From 994e712162af1d568a1751c32626478f2c613cc2 Mon Sep 17 00:00:00 2001
From: Michal Nazarewicz <mina86@mina86.com>
Date: Mon, 16 Jan 2023 17:56:01 +0100
Subject: [PATCH 001/685] Implement DoubleEnded and ExactSize for Take<Repeat>
 and Take<RepeatWith>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Repeat iterator always returns the same element and behaves the same way
backwards and forwards.  Take iterator can trivially implement backwards
iteration over Repeat inner iterator by simply doing forwards iteration.

DoubleEndedIterator is not currently implemented for Take<Repeat<T>>
because Repeat doesn’t implement ExactSizeIterator which is a required
bound on DEI implementation for Take.

Similarly, since Repeat is an infinite iterator which never stops, Take
can trivially know how many elements it’s going to return.  This allows
implementing ExactSizeIterator on Take<Repeat<T>>.

While at it, observe that ExactSizeIterator can also be implemented for
Take<RepeatWhile<F>> so add that implementation too.  Since in contrast
to Repeat, RepeatWhile doesn’t guarante to always return the same value,
DoubleEndedIterator isn’t implemented.

Those changes render core::iter::repeat_n somewhat redundant.

Issue: https://github.com/rust-lang/rust/issues/104434
Issue: https://github.com/rust-lang/rust/issues/104729
---
 library/core/src/iter/adapters/take.rs   | 57 +++++++++++++++
 library/core/tests/iter/adapters/take.rs | 90 ++++++++++++++++++++++++
 2 files changed, 147 insertions(+)

diff --git a/library/core/src/iter/adapters/take.rs b/library/core/src/iter/adapters/take.rs
index 297dd0acaddc1..4c8f9fe16da0f 100644
--- a/library/core/src/iter/adapters/take.rs
+++ b/library/core/src/iter/adapters/take.rs
@@ -317,3 +317,60 @@ impl<I: Iterator + TrustedRandomAccess> SpecTake for Take<I> {
         }
     }
 }
+
+#[stable(feature = "exact_size_take_repeat", since = "CURRENT_RUSTC_VERSION")]
+impl<T: Clone> DoubleEndedIterator for Take<crate::iter::Repeat<T>> {
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.next()
+    }
+
+    #[inline]
+    fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
+        self.nth(n)
+    }
+
+    #[inline]
+    fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R
+    where
+        Self: Sized,
+        Fold: FnMut(Acc, Self::Item) -> R,
+        R: Try<Output = Acc>,
+    {
+        self.try_fold(init, fold)
+    }
+
+    #[inline]
+    fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc
+    where
+        Self: Sized,
+        Fold: FnMut(Acc, Self::Item) -> Acc,
+    {
+        self.fold(init, fold)
+    }
+
+    #[inline]
+    #[rustc_inherit_overflow_checks]
+    fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+        self.advance_by(n)
+    }
+}
+
+// Note: It may be tempting to impl DoubleEndedIterator for Take<RepeatWith>.
+// One must fight that temptation since such implementation wouldn’t be correct
+// because we have no way to return value of nth invocation of repeater followed
+// by n-1st without remembering all results.
+
+#[stable(feature = "exact_size_take_repeat", since = "CURRENT_RUSTC_VERSION")]
+impl<T: Clone> ExactSizeIterator for Take<crate::iter::Repeat<T>> {
+    fn len(&self) -> usize {
+        self.n
+    }
+}
+
+#[stable(feature = "exact_size_take_repeat", since = "CURRENT_RUSTC_VERSION")]
+impl<F: FnMut() -> A, A> ExactSizeIterator for Take<crate::iter::RepeatWith<F>> {
+    fn len(&self) -> usize {
+        self.n
+    }
+}
diff --git a/library/core/tests/iter/adapters/take.rs b/library/core/tests/iter/adapters/take.rs
index 39afa2cbfcaf2..65a8a93b4a916 100644
--- a/library/core/tests/iter/adapters/take.rs
+++ b/library/core/tests/iter/adapters/take.rs
@@ -170,3 +170,93 @@ fn test_byref_take_consumed_items() {
     assert_eq!(count, 70);
     assert_eq!(inner, 90..90);
 }
+
+#[test]
+fn test_exact_size_take_repeat() {
+    let mut iter = core::iter::repeat(42).take(40);
+    assert_eq!((40, Some(40)), iter.size_hint());
+    assert_eq!(40, iter.len());
+
+    assert_eq!(Some(42), iter.next());
+    assert_eq!((39, Some(39)), iter.size_hint());
+    assert_eq!(39, iter.len());
+
+    assert_eq!(Some(42), iter.next_back());
+    assert_eq!((38, Some(38)), iter.size_hint());
+    assert_eq!(38, iter.len());
+
+    assert_eq!(Some(42), iter.nth(3));
+    assert_eq!((34, Some(34)), iter.size_hint());
+    assert_eq!(34, iter.len());
+
+    assert_eq!(Some(42), iter.nth_back(3));
+    assert_eq!((30, Some(30)), iter.size_hint());
+    assert_eq!(30, iter.len());
+
+    assert_eq!(Ok(()), iter.advance_by(10));
+    assert_eq!((20, Some(20)), iter.size_hint());
+    assert_eq!(20, iter.len());
+
+    assert_eq!(Ok(()), iter.advance_back_by(10));
+    assert_eq!((10, Some(10)), iter.size_hint());
+    assert_eq!(10, iter.len());
+}
+
+#[test]
+fn test_exact_size_take_repeat_with() {
+    let mut counter = 0;
+    let mut iter = core::iter::repeat_with(move || {
+        counter += 1;
+        counter
+    })
+    .take(40);
+    assert_eq!((40, Some(40)), iter.size_hint());
+    assert_eq!(40, iter.len());
+
+    assert_eq!(Some(1), iter.next());
+    assert_eq!((39, Some(39)), iter.size_hint());
+    assert_eq!(39, iter.len());
+
+    assert_eq!(Some(5), iter.nth(3));
+    assert_eq!((35, Some(35)), iter.size_hint());
+    assert_eq!(35, iter.len());
+
+    assert_eq!(Ok(()), iter.advance_by(10));
+    assert_eq!((25, Some(25)), iter.size_hint());
+    assert_eq!(25, iter.len());
+
+    assert_eq!(Some(16), iter.next());
+    assert_eq!((24, Some(24)), iter.size_hint());
+    assert_eq!(24, iter.len());
+}
+
+// This is https://github.com/rust-lang/rust/issues/104729 with all uses of
+// repeat(0) were replaced by repeat(0).take(20).
+#[test]
+fn test_reverse_on_zip() {
+    let vec_1 = [1; 10];
+
+    let zipped_iter = vec_1.iter().copied().zip(core::iter::repeat(0).take(20));
+
+    // Forward
+    for (one, zero) in zipped_iter {
+        assert_eq!((1, 0), (one, zero));
+    }
+
+    let rev_vec_iter = vec_1.iter().rev();
+    let rev_repeat_iter = std::iter::repeat(0).take(20).rev();
+
+    // Manual reversed zip
+    let rev_zipped_iter = rev_vec_iter.zip(rev_repeat_iter);
+
+    for (&one, zero) in rev_zipped_iter {
+        assert_eq!((1, 0), (one, zero));
+    }
+
+    let zipped_iter = vec_1.iter().zip(core::iter::repeat(0).take(20));
+
+    // Cannot call rev here for automatic reversed zip constuction
+    for (&one, zero) in zipped_iter.rev() {
+        assert_eq!((1, 0), (one, zero));
+    }
+}

From 07481b9e90df0860519043b54e07529003e74814 Mon Sep 17 00:00:00 2001
From: bohan <bohan-zhang@foxmail.com>
Date: Fri, 5 Jul 2024 00:59:58 +0800
Subject: [PATCH 002/685] use old ctx if has same expand environment during
 decode span

---
 compiler/rustc_span/src/hygiene.rs |  8 +++++++
 tests/incremental/decl_macro.rs    | 34 ++++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+)
 create mode 100644 tests/incremental/decl_macro.rs

diff --git a/compiler/rustc_span/src/hygiene.rs b/compiler/rustc_span/src/hygiene.rs
index 483e32c645393..7e6acc0b9fba9 100644
--- a/compiler/rustc_span/src/hygiene.rs
+++ b/compiler/rustc_span/src/hygiene.rs
@@ -1413,6 +1413,14 @@ pub fn decode_syntax_context<D: Decoder, F: FnOnce(&mut D, u32) -> SyntaxContext
 
     // Overwrite the dummy data with our decoded SyntaxContextData
     HygieneData::with(|hygiene_data| {
+        if let Some(old) = hygiene_data.syntax_context_data.get(raw_id as usize)
+            && old.outer_expn == ctxt_data.outer_expn
+            && old.outer_transparency == ctxt_data.outer_transparency
+            && old.parent == ctxt_data.parent
+        {
+            ctxt_data = old.clone();
+        }
+
         let dummy = std::mem::replace(
             &mut hygiene_data.syntax_context_data[ctxt.as_u32() as usize],
             ctxt_data,
diff --git a/tests/incremental/decl_macro.rs b/tests/incremental/decl_macro.rs
new file mode 100644
index 0000000000000..74810ae422749
--- /dev/null
+++ b/tests/incremental/decl_macro.rs
@@ -0,0 +1,34 @@
+//@ revisions: rpass1 rpass2
+
+// issue#112680
+
+#![feature(decl_macro)]
+
+pub trait T {
+    type Key;
+    fn index_from_key(key: Self::Key) -> usize;
+}
+
+pub macro m($key_ty:ident, $val_ty:ident) {
+    struct $key_ty {
+        inner: usize,
+    }
+
+    impl T for $val_ty {
+        type Key = $key_ty;
+
+        fn index_from_key(key: Self::Key) -> usize {
+            key.inner
+        }
+    }
+}
+
+m!(TestId, Test);
+
+#[cfg(rpass1)]
+struct Test(u32);
+
+#[cfg(rpass2)]
+struct Test;
+
+fn main() {}

From df27dfa0eae8a14d69e5006334bb06d84ba050b7 Mon Sep 17 00:00:00 2001
From: Mikhail Zabaluev <mikhail.zabaluev@gmail.com>
Date: Fri, 22 Mar 2024 16:50:48 +0200
Subject: [PATCH 003/685] Optimize integer pow by removing exit branch

The branch at the end of the `pow` implementations is redundant
with multiplication code already present in the loop. By rotating
the exit check, this branch can be largely removed, improving code size
and instruction cache coherence.
---
 library/core/src/num/int_macros.rs  | 61 ++++++++++++---------------
 library/core/src/num/uint_macros.rs | 64 ++++++++++++-----------------
 2 files changed, 52 insertions(+), 73 deletions(-)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index d40e02352a1d0..6ed0eb07e48d8 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1495,18 +1495,17 @@ macro_rules! int_impl {
             let mut base = self;
             let mut acc: Self = 1;
 
-            while exp > 1 {
+            loop {
                 if (exp & 1) == 1 {
                     acc = try_opt!(acc.checked_mul(base));
+                    // since exp!=0, finally the exp must be 1.
+                    if exp == 1 {
+                        return Some(acc);
+                    }
                 }
                 exp /= 2;
                 base = try_opt!(base.checked_mul(base));
             }
-            // since exp!=0, finally the exp must be 1.
-            // Deal with the final bit of the exponent separately, since
-            // squaring the base afterwards is not necessary and may cause a
-            // needless overflow.
-            acc.checked_mul(base)
         }
 
         /// Strict exponentiation. Computes `self.pow(exp)`, panicking if
@@ -1546,18 +1545,17 @@ macro_rules! int_impl {
             let mut base = self;
             let mut acc: Self = 1;
 
-            while exp > 1 {
+            loop {
                 if (exp & 1) == 1 {
                     acc = acc.strict_mul(base);
+                    // since exp!=0, finally the exp must be 1.
+                    if exp == 1 {
+                        return acc;
+                    }
                 }
                 exp /= 2;
                 base = base.strict_mul(base);
             }
-            // since exp!=0, finally the exp must be 1.
-            // Deal with the final bit of the exponent separately, since
-            // squaring the base afterwards is not necessary and may cause a
-            // needless overflow.
-            acc.strict_mul(base)
         }
 
         /// Returns the square root of the number, rounded down.
@@ -2181,19 +2179,17 @@ macro_rules! int_impl {
             let mut base = self;
             let mut acc: Self = 1;
 
-            while exp > 1 {
+            loop {
                 if (exp & 1) == 1 {
                     acc = acc.wrapping_mul(base);
+                    // since exp!=0, finally the exp must be 1.
+                    if exp == 1 {
+                        return acc;
+                    }
                 }
                 exp /= 2;
                 base = base.wrapping_mul(base);
             }
-
-            // since exp!=0, finally the exp must be 1.
-            // Deal with the final bit of the exponent separately, since
-            // squaring the base afterwards is not necessary and may cause a
-            // needless overflow.
-            acc.wrapping_mul(base)
         }
 
         /// Calculates `self` + `rhs`
@@ -2687,9 +2683,14 @@ macro_rules! int_impl {
             // Scratch space for storing results of overflowing_mul.
             let mut r;
 
-            while exp > 1 {
+            loop {
                 if (exp & 1) == 1 {
                     r = acc.overflowing_mul(base);
+                    // since exp!=0, finally the exp must be 1.
+                    if exp == 1 {
+                        r.1 |= overflown;
+                        return r;
+                    }
                     acc = r.0;
                     overflown |= r.1;
                 }
@@ -2698,14 +2699,6 @@ macro_rules! int_impl {
                 base = r.0;
                 overflown |= r.1;
             }
-
-            // since exp!=0, finally the exp must be 1.
-            // Deal with the final bit of the exponent separately, since
-            // squaring the base afterwards is not necessary and may cause a
-            // needless overflow.
-            r = acc.overflowing_mul(base);
-            r.1 |= overflown;
-            r
         }
 
         /// Raises self to the power of `exp`, using exponentiation by squaring.
@@ -2732,19 +2725,17 @@ macro_rules! int_impl {
             let mut base = self;
             let mut acc = 1;
 
-            while exp > 1 {
+            loop {
                 if (exp & 1) == 1 {
                     acc = acc * base;
+                    // since exp!=0, finally the exp must be 1.
+                    if exp == 1 {
+                        return acc;
+                    }
                 }
                 exp /= 2;
                 base = base * base;
             }
-
-            // since exp!=0, finally the exp must be 1.
-            // Deal with the final bit of the exponent separately, since
-            // squaring the base afterwards is not necessary and may cause a
-            // needless overflow.
-            acc * base
         }
 
         /// Returns the square root of the number, rounded down.
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index ad72c29758bd7..b272a9d901bf4 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1534,20 +1534,17 @@ macro_rules! uint_impl {
             let mut base = self;
             let mut acc: Self = 1;
 
-            while exp > 1 {
+            loop {
                 if (exp & 1) == 1 {
                     acc = try_opt!(acc.checked_mul(base));
+                    // since exp!=0, finally the exp must be 1.
+                    if exp == 1 {
+                        return Some(acc);
+                    }
                 }
                 exp /= 2;
                 base = try_opt!(base.checked_mul(base));
             }
-
-            // since exp!=0, finally the exp must be 1.
-            // Deal with the final bit of the exponent separately, since
-            // squaring the base afterwards is not necessary and may cause a
-            // needless overflow.
-
-            acc.checked_mul(base)
         }
 
         /// Strict exponentiation. Computes `self.pow(exp)`, panicking if
@@ -1587,18 +1584,17 @@ macro_rules! uint_impl {
             let mut base = self;
             let mut acc: Self = 1;
 
-            while exp > 1 {
+            loop {
                 if (exp & 1) == 1 {
                     acc = acc.strict_mul(base);
+                    // since exp!=0, finally the exp must be 1.
+                    if exp == 1 {
+                        return acc;
+                    }
                 }
                 exp /= 2;
                 base = base.strict_mul(base);
             }
-            // since exp!=0, finally the exp must be 1.
-            // Deal with the final bit of the exponent separately, since
-            // squaring the base afterwards is not necessary and may cause a
-            // needless overflow.
-            acc.strict_mul(base)
         }
 
         /// Saturating integer addition. Computes `self + rhs`, saturating at
@@ -2059,19 +2055,17 @@ macro_rules! uint_impl {
             let mut base = self;
             let mut acc: Self = 1;
 
-            while exp > 1 {
+            loop {
                 if (exp & 1) == 1 {
                     acc = acc.wrapping_mul(base);
+                    // since exp!=0, finally the exp must be 1.
+                    if exp == 1 {
+                        return acc;
+                    }
                 }
                 exp /= 2;
                 base = base.wrapping_mul(base);
             }
-
-            // since exp!=0, finally the exp must be 1.
-            // Deal with the final bit of the exponent separately, since
-            // squaring the base afterwards is not necessary and may cause a
-            // needless overflow.
-            acc.wrapping_mul(base)
         }
 
         /// Calculates `self` + `rhs`
@@ -2516,9 +2510,14 @@ macro_rules! uint_impl {
             // Scratch space for storing results of overflowing_mul.
             let mut r;
 
-            while exp > 1 {
+            loop {
                 if (exp & 1) == 1 {
                     r = acc.overflowing_mul(base);
+                    // since exp!=0, finally the exp must be 1.
+                    if exp == 1 {
+                        r.1 |= overflown;
+                        return r;
+                    }
                     acc = r.0;
                     overflown |= r.1;
                 }
@@ -2527,15 +2526,6 @@ macro_rules! uint_impl {
                 base = r.0;
                 overflown |= r.1;
             }
-
-            // since exp!=0, finally the exp must be 1.
-            // Deal with the final bit of the exponent separately, since
-            // squaring the base afterwards is not necessary and may cause a
-            // needless overflow.
-            r = acc.overflowing_mul(base);
-            r.1 |= overflown;
-
-            r
         }
 
         /// Raises self to the power of `exp`, using exponentiation by squaring.
@@ -2560,19 +2550,17 @@ macro_rules! uint_impl {
             let mut base = self;
             let mut acc = 1;
 
-            while exp > 1 {
+            loop {
                 if (exp & 1) == 1 {
                     acc = acc * base;
+                    // since exp!=0, finally the exp must be 1.
+                    if exp == 1 {
+                        return acc;
+                    }
                 }
                 exp /= 2;
                 base = base * base;
             }
-
-            // since exp!=0, finally the exp must be 1.
-            // Deal with the final bit of the exponent separately, since
-            // squaring the base afterwards is not necessary and may cause a
-            // needless overflow.
-            acc * base
         }
 
         /// Returns the square root of the number, rounded down.

From 1faa1018c7ddd2f505904b0f71255afa5ae1bbe7 Mon Sep 17 00:00:00 2001
From: Mikhail Zabaluev <mikhail.zabaluev@gmail.com>
Date: Fri, 12 Jul 2024 00:54:26 +0300
Subject: [PATCH 004/685] Explicitly unroll integer pow for small exponents

The newly optimized loop has introduced a regression in the case
when pow is called with a small constant exponent. LLVM is no longer
able to unroll the loop and the generated code is larger and slower
than what's expected in tests.

Match and handle small exponent values separately by branching out
to an explicit multiplication sequence for that exponent.
Powers larger than 6 need more than three multiplications, so these
cases are less likely to benefit from this optimization, also such
constant exponents are less likely to be used in practice.
For uses with a non-constant exponent, this might also provide
a performance benefit if the exponent is small and does not vary
between successive calls, so the same match arm tends to be taken as
a predicted branch.
---
 library/core/src/num/int_macros.rs  | 62 ++++++++++++++++++++++++++---
 library/core/src/num/uint_macros.rs | 62 ++++++++++++++++++++++++++---
 2 files changed, 112 insertions(+), 12 deletions(-)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 6ed0eb07e48d8..d1bb5a6ef478a 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -2173,10 +2173,35 @@ macro_rules! int_impl {
                       without modifying the original"]
         #[inline]
         pub const fn wrapping_pow(self, mut exp: u32) -> Self {
-            if exp == 0 {
-                return 1;
-            }
             let mut base = self;
+
+            // Unroll multiplications for small exponent values.
+            // This gives the optimizer a way to efficiently inline call sites
+            // for the most common use cases with constant exponents.
+            // Currently, LLVM is unable to unroll the loop below.
+            match exp {
+                0 => return 1,
+                1 => return base,
+                2 => return base.wrapping_mul(base),
+                3 => {
+                    let squared = base.wrapping_mul(base);
+                    return squared.wrapping_mul(base);
+                }
+                4 => {
+                    let squared = base.wrapping_mul(base);
+                    return squared.wrapping_mul(squared);
+                }
+                5 => {
+                    let squared = base.wrapping_mul(base);
+                    return squared.wrapping_mul(squared).wrapping_mul(base);
+                }
+                6 => {
+                    let cubed = base.wrapping_mul(base).wrapping_mul(base);
+                    return cubed.wrapping_mul(cubed);
+                }
+                _ => {}
+            }
+
             let mut acc: Self = 1;
 
             loop {
@@ -2719,10 +2744,35 @@ macro_rules! int_impl {
         #[inline]
         #[rustc_inherit_overflow_checks]
         pub const fn pow(self, mut exp: u32) -> Self {
-            if exp == 0 {
-                return 1;
-            }
             let mut base = self;
+
+            // Unroll multiplications for small exponent values.
+            // This gives the optimizer a way to efficiently inline call sites
+            // for the most common use cases with constant exponents.
+            // Currently, LLVM is unable to unroll the loop below.
+            match exp {
+                0 => return 1,
+                1 => return base,
+                2 => return base * base,
+                3 => {
+                    let squared = base * base;
+                    return squared * base;
+                }
+                4 => {
+                    let squared = base * base;
+                    return squared * squared;
+                }
+                5 => {
+                    let squared = base * base;
+                    return squared * squared * base;
+                }
+                6 => {
+                    let cubed = base * base * base;
+                    return cubed * cubed;
+                }
+                _ => {}
+            }
+
             let mut acc = 1;
 
             loop {
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index b272a9d901bf4..6e5d37f8163ea 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -2049,10 +2049,35 @@ macro_rules! uint_impl {
                       without modifying the original"]
         #[inline]
         pub const fn wrapping_pow(self, mut exp: u32) -> Self {
-            if exp == 0 {
-                return 1;
-            }
             let mut base = self;
+
+            // Unroll multiplications for small exponent values.
+            // This gives the optimizer a way to efficiently inline call sites
+            // for the most common use cases with constant exponents.
+            // Currently, LLVM is unable to unroll the loop below.
+            match exp {
+                0 => return 1,
+                1 => return base,
+                2 => return base.wrapping_mul(base),
+                3 => {
+                    let squared = base.wrapping_mul(base);
+                    return squared.wrapping_mul(base);
+                }
+                4 => {
+                    let squared = base.wrapping_mul(base);
+                    return squared.wrapping_mul(squared);
+                }
+                5 => {
+                    let squared = base.wrapping_mul(base);
+                    return squared.wrapping_mul(squared).wrapping_mul(base);
+                }
+                6 => {
+                    let cubed = base.wrapping_mul(base).wrapping_mul(base);
+                    return cubed.wrapping_mul(cubed);
+                }
+                _ => {}
+            }
+
             let mut acc: Self = 1;
 
             loop {
@@ -2544,10 +2569,35 @@ macro_rules! uint_impl {
         #[inline]
         #[rustc_inherit_overflow_checks]
         pub const fn pow(self, mut exp: u32) -> Self {
-            if exp == 0 {
-                return 1;
-            }
             let mut base = self;
+
+            // Unroll multiplications for small exponent values.
+            // This gives the optimizer a way to efficiently inline call sites
+            // for the most common use cases with constant exponents.
+            // Currently, LLVM is unable to unroll the loop below.
+            match exp {
+                0 => return 1,
+                1 => return base,
+                2 => return base * base,
+                3 => {
+                    let squared = base * base;
+                    return squared * base;
+                }
+                4 => {
+                    let squared = base * base;
+                    return squared * squared;
+                }
+                5 => {
+                    let squared = base * base;
+                    return squared * squared * base;
+                }
+                6 => {
+                    let cubed = base * base * base;
+                    return cubed * cubed;
+                }
+                _ => {}
+            }
+
             let mut acc = 1;
 
             loop {

From 2f235343529c39bdab47704ec9620d6784eeeb6d Mon Sep 17 00:00:00 2001
From: Mikhail Zabaluev <mikhail.zabaluev@gmail.com>
Date: Fri, 12 Jul 2024 22:54:08 +0300
Subject: [PATCH 005/685] Use is_val_statically_known to optimize pow

In the dynamic exponent case, it's preferred to not increase code size,
so use solely the loop-based implementation there.
This shows about 4% penalty in the variable exponent benchmarks
on x86_64.
---
 library/core/src/lib.rs             |   1 +
 library/core/src/num/int_macros.rs  | 108 ++++++++++++++++------------
 library/core/src/num/uint_macros.rs | 108 ++++++++++++++++------------
 3 files changed, 125 insertions(+), 92 deletions(-)

diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 0f82f01e57a71..ede95e3b2ca9b 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -170,6 +170,7 @@
 #![feature(internal_impls_macro)]
 #![feature(ip)]
 #![feature(is_ascii_octdigit)]
+#![feature(is_val_statically_known)]
 #![feature(isqrt)]
 #![feature(link_cfg)]
 #![feature(offset_of_enum)]
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index d1bb5a6ef478a..be0e6a2a03b70 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -2172,35 +2172,43 @@ macro_rules! int_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
+        #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn wrapping_pow(self, mut exp: u32) -> Self {
             let mut base = self;
 
-            // Unroll multiplications for small exponent values.
-            // This gives the optimizer a way to efficiently inline call sites
-            // for the most common use cases with constant exponents.
-            // Currently, LLVM is unable to unroll the loop below.
-            match exp {
-                0 => return 1,
-                1 => return base,
-                2 => return base.wrapping_mul(base),
-                3 => {
-                    let squared = base.wrapping_mul(base);
-                    return squared.wrapping_mul(base);
-                }
-                4 => {
-                    let squared = base.wrapping_mul(base);
-                    return squared.wrapping_mul(squared);
-                }
-                5 => {
-                    let squared = base.wrapping_mul(base);
-                    return squared.wrapping_mul(squared).wrapping_mul(base);
+            if intrinsics::is_val_statically_known(exp) {
+                // Unroll multiplications for small exponent values.
+                // This gives the optimizer a way to efficiently inline call sites
+                // for the most common use cases with constant exponents.
+                // Currently, LLVM is unable to unroll the loop below.
+                match exp {
+                    0 => return 1,
+                    1 => return base,
+                    2 => return base.wrapping_mul(base),
+                    3 => {
+                        let squared = base.wrapping_mul(base);
+                        return squared.wrapping_mul(base);
+                    }
+                    4 => {
+                        let squared = base.wrapping_mul(base);
+                        return squared.wrapping_mul(squared);
+                    }
+                    5 => {
+                        let squared = base.wrapping_mul(base);
+                        return squared.wrapping_mul(squared).wrapping_mul(base);
+                    }
+                    6 => {
+                        let cubed = base.wrapping_mul(base).wrapping_mul(base);
+                        return cubed.wrapping_mul(cubed);
+                    }
+                    _ => {}
                 }
-                6 => {
-                    let cubed = base.wrapping_mul(base).wrapping_mul(base);
-                    return cubed.wrapping_mul(cubed);
+            } else {
+                if exp == 0 {
+                    return 1;
                 }
-                _ => {}
             }
+            debug_assert!(exp != 0);
 
             let mut acc: Self = 1;
 
@@ -2743,35 +2751,43 @@ macro_rules! int_impl {
                       without modifying the original"]
         #[inline]
         #[rustc_inherit_overflow_checks]
+        #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn pow(self, mut exp: u32) -> Self {
             let mut base = self;
 
-            // Unroll multiplications for small exponent values.
-            // This gives the optimizer a way to efficiently inline call sites
-            // for the most common use cases with constant exponents.
-            // Currently, LLVM is unable to unroll the loop below.
-            match exp {
-                0 => return 1,
-                1 => return base,
-                2 => return base * base,
-                3 => {
-                    let squared = base * base;
-                    return squared * base;
-                }
-                4 => {
-                    let squared = base * base;
-                    return squared * squared;
-                }
-                5 => {
-                    let squared = base * base;
-                    return squared * squared * base;
+            if intrinsics::is_val_statically_known(exp) {
+                // Unroll multiplications for small exponent values.
+                // This gives the optimizer a way to efficiently inline call sites
+                // for the most common use cases with constant exponents.
+                // Currently, LLVM is unable to unroll the loop below.
+                match exp {
+                    0 => return 1,
+                    1 => return base,
+                    2 => return base * base,
+                    3 => {
+                        let squared = base * base;
+                        return squared * base;
+                    }
+                    4 => {
+                        let squared = base * base;
+                        return squared * squared;
+                    }
+                    5 => {
+                        let squared = base * base;
+                        return squared * squared * base;
+                    }
+                    6 => {
+                        let cubed = base * base * base;
+                        return cubed * cubed;
+                    }
+                    _ => {}
                 }
-                6 => {
-                    let cubed = base * base * base;
-                    return cubed * cubed;
+            } else {
+                if exp == 0 {
+                    return 1;
                 }
-                _ => {}
             }
+            debug_assert!(exp != 0);
 
             let mut acc = 1;
 
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 6e5d37f8163ea..24352593fca3d 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -2048,35 +2048,43 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
+        #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn wrapping_pow(self, mut exp: u32) -> Self {
             let mut base = self;
 
-            // Unroll multiplications for small exponent values.
-            // This gives the optimizer a way to efficiently inline call sites
-            // for the most common use cases with constant exponents.
-            // Currently, LLVM is unable to unroll the loop below.
-            match exp {
-                0 => return 1,
-                1 => return base,
-                2 => return base.wrapping_mul(base),
-                3 => {
-                    let squared = base.wrapping_mul(base);
-                    return squared.wrapping_mul(base);
-                }
-                4 => {
-                    let squared = base.wrapping_mul(base);
-                    return squared.wrapping_mul(squared);
-                }
-                5 => {
-                    let squared = base.wrapping_mul(base);
-                    return squared.wrapping_mul(squared).wrapping_mul(base);
+            if intrinsics::is_val_statically_known(exp) {
+                // Unroll multiplications for small exponent values.
+                // This gives the optimizer a way to efficiently inline call sites
+                // for the most common use cases with constant exponents.
+                // Currently, LLVM is unable to unroll the loop below.
+                match exp {
+                    0 => return 1,
+                    1 => return base,
+                    2 => return base.wrapping_mul(base),
+                    3 => {
+                        let squared = base.wrapping_mul(base);
+                        return squared.wrapping_mul(base);
+                    }
+                    4 => {
+                        let squared = base.wrapping_mul(base);
+                        return squared.wrapping_mul(squared);
+                    }
+                    5 => {
+                        let squared = base.wrapping_mul(base);
+                        return squared.wrapping_mul(squared).wrapping_mul(base);
+                    }
+                    6 => {
+                        let cubed = base.wrapping_mul(base).wrapping_mul(base);
+                        return cubed.wrapping_mul(cubed);
+                    }
+                    _ => {}
                 }
-                6 => {
-                    let cubed = base.wrapping_mul(base).wrapping_mul(base);
-                    return cubed.wrapping_mul(cubed);
+            } else {
+                if exp == 0 {
+                    return 1;
                 }
-                _ => {}
             }
+            debug_assert!(exp != 0);
 
             let mut acc: Self = 1;
 
@@ -2568,35 +2576,43 @@ macro_rules! uint_impl {
                       without modifying the original"]
         #[inline]
         #[rustc_inherit_overflow_checks]
+        #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn pow(self, mut exp: u32) -> Self {
             let mut base = self;
 
-            // Unroll multiplications for small exponent values.
-            // This gives the optimizer a way to efficiently inline call sites
-            // for the most common use cases with constant exponents.
-            // Currently, LLVM is unable to unroll the loop below.
-            match exp {
-                0 => return 1,
-                1 => return base,
-                2 => return base * base,
-                3 => {
-                    let squared = base * base;
-                    return squared * base;
-                }
-                4 => {
-                    let squared = base * base;
-                    return squared * squared;
-                }
-                5 => {
-                    let squared = base * base;
-                    return squared * squared * base;
+            if intrinsics::is_val_statically_known(exp) {
+                // Unroll multiplications for small exponent values.
+                // This gives the optimizer a way to efficiently inline call sites
+                // for the most common use cases with constant exponents.
+                // Currently, LLVM is unable to unroll the loop below.
+                match exp {
+                    0 => return 1,
+                    1 => return base,
+                    2 => return base * base,
+                    3 => {
+                        let squared = base * base;
+                        return squared * base;
+                    }
+                    4 => {
+                        let squared = base * base;
+                        return squared * squared;
+                    }
+                    5 => {
+                        let squared = base * base;
+                        return squared * squared * base;
+                    }
+                    6 => {
+                        let cubed = base * base * base;
+                        return cubed * cubed;
+                    }
+                    _ => {}
                 }
-                6 => {
-                    let cubed = base * base * base;
-                    return cubed * cubed;
+            } else {
+                if exp == 0 {
+                    return 1;
                 }
-                _ => {}
             }
+            debug_assert!(exp != 0);
 
             let mut acc = 1;
 

From 89f3064e344dd1ea2046c05e070fbc3a4ee7f7f7 Mon Sep 17 00:00:00 2001
From: Josef Schlehofer <pepe.schlehofer@gmail.com>
Date: Tue, 9 Aug 2022 01:28:42 +0200
Subject: [PATCH 006/685] Add powerpc-unknown-linux-muslspe compile target

This is almost identical to already existing targets:
- powerpc_unknown_linux_musl.rs
- powerpc_unknown_linux_gnuspe.rs

It has support for PowerPC SPE (muslspe), which
can be used with GCC version up to 8. It is useful for Freescale or IBM
cores like e500.

This was verified to be working with OpenWrt build system for CZ.NIC's
Turris 1.x routers, which are using Freescale P2020, e500v2, so add it as
a Tier 3 target.
---
 compiler/rustc_target/src/spec/mod.rs         |  1 +
 .../targets/powerpc_unknown_linux_muslspe.rs  | 28 ++++++++++++++++
 src/doc/rustc/src/SUMMARY.md                  |  1 +
 src/doc/rustc/src/platform-support.md         |  1 +
 .../powerpc-unknown-linux-muslspe.md          | 32 +++++++++++++++++++
 tests/assembly/targets/targets-elf.rs         |  3 ++
 6 files changed, 66 insertions(+)
 create mode 100644 compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs
 create mode 100644 src/doc/rustc/src/platform-support/powerpc-unknown-linux-muslspe.md

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 607eeac7ccdc3..e5ffc94d083ce 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1558,6 +1558,7 @@ supported_targets! {
     ("powerpc-unknown-linux-gnu", powerpc_unknown_linux_gnu),
     ("powerpc-unknown-linux-gnuspe", powerpc_unknown_linux_gnuspe),
     ("powerpc-unknown-linux-musl", powerpc_unknown_linux_musl),
+    ("powerpc-unknown-linux-muslspe", powerpc_unknown_linux_muslspe),
     ("powerpc64-ibm-aix", powerpc64_ibm_aix),
     ("powerpc64-unknown-linux-gnu", powerpc64_unknown_linux_gnu),
     ("powerpc64-unknown-linux-musl", powerpc64_unknown_linux_musl),
diff --git a/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs
new file mode 100644
index 0000000000000..d19015729ec19
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/powerpc_unknown_linux_muslspe.rs
@@ -0,0 +1,28 @@
+use crate::abi::Endian;
+use crate::spec::{base, Cc, LinkerFlavor, Lld, StackProbeType, Target, TargetOptions};
+
+pub fn target() -> Target {
+    let mut base = base::linux_musl::opts();
+    base.add_pre_link_args(LinkerFlavor::Gnu(Cc::Yes, Lld::No), &["-mspe"]);
+    base.max_atomic_width = Some(32);
+    base.stack_probes = StackProbeType::Inline;
+
+    Target {
+        llvm_target: "powerpc-unknown-linux-muslspe".into(),
+        metadata: crate::spec::TargetMetadata {
+            description: Some("PowerPC SPE Linux with musl".into()),
+            tier: Some(3),
+            host_tools: Some(false),
+            std: Some(true),
+        },
+        pointer_width: 32,
+        data_layout: "E-m:e-p:32:32-Fn32-i64:64-n32".into(),
+        arch: "powerpc".into(),
+        options: TargetOptions {
+            abi: "spe".into(),
+            endian: Endian::Big,
+            mcount: "_mcount".into(),
+            ..base
+        },
+    }
+}
diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 1a8ff931f0177..e5883cb971491 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -61,6 +61,7 @@
     - [mipsisa\*r6\*-unknown-linux-gnu\*](platform-support/mips-release-6.md)
     - [nvptx64-nvidia-cuda](platform-support/nvptx64-nvidia-cuda.md)
     - [powerpc-unknown-openbsd](platform-support/powerpc-unknown-openbsd.md)
+    - [powerpc-unknown-linux-muslspe](platform-support/powerpc-unknown-linux-muslspe.md)
     - [powerpc64-ibm-aix](platform-support/aix.md)
     - [riscv32im-risc0-zkvm-elf](platform-support/riscv32im-risc0-zkvm-elf.md)
     - [riscv32imac-unknown-xous-elf](platform-support/riscv32imac-unknown-xous-elf.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index 370dbed50fa1a..57187bbe902a4 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -331,6 +331,7 @@ target | std | host | notes
 `msp430-none-elf` | * |  | 16-bit MSP430 microcontrollers
 `powerpc-unknown-linux-gnuspe` | ✓ |  | PowerPC SPE Linux
 `powerpc-unknown-linux-musl` | ? |  | PowerPC Linux with musl 1.2.3
+[`powerpc-unknown-linux-muslspe`](platform-support/powerpc-unknown-linux-muslspe.md) | ? |  | PowerPC SPE Linux
 [`powerpc-unknown-netbsd`](platform-support/netbsd.md) | ✓ | ✓ | NetBSD 32-bit powerpc systems
 [`powerpc-unknown-openbsd`](platform-support/powerpc-unknown-openbsd.md) | * |  |
 `powerpc-wrs-vxworks-spe` | ? |  |
diff --git a/src/doc/rustc/src/platform-support/powerpc-unknown-linux-muslspe.md b/src/doc/rustc/src/platform-support/powerpc-unknown-linux-muslspe.md
new file mode 100644
index 0000000000000..4c416b5192994
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/powerpc-unknown-linux-muslspe.md
@@ -0,0 +1,32 @@
+# powerpc-unknown-linux-muslspe
+
+**Tier: 3**
+
+This target is very similar to already existing ones like `powerpc_unknown_linux_musl` and `powerpc_unknown_linux_gnuspe`.
+This one has PowerPC SPE support for musl. Unfortunately, the last supported gcc version with PowerPC SPE is 8.4.0.
+
+## Target maintainers
+
+- [@BKPepe](https://github.com/BKPepe)
+
+## Requirements
+
+This target is cross-compiled. There is no support for `std`. There is no
+default allocator, but it's possible to use `alloc` by supplying an allocator.
+
+This target generated binaries in the ELF format.
+
+## Building the target
+
+This target was tested and used within the `OpenWrt` build system for CZ.NIC Turris 1.x routers using Freescale P2020.
+
+## Building Rust programs
+
+Rust does not yet ship pre-compiled artifacts for this target. To compile for
+this target, you will either need to build Rust with the target enabled (see
+"Building the target" above), or build your own copy of `core` by using
+`build-std` or similar.
+
+## Testing
+
+This is a cross-compiled target and there is no support to run rustc test suite.
diff --git a/tests/assembly/targets/targets-elf.rs b/tests/assembly/targets/targets-elf.rs
index 32cce3839dc26..59ee0d47bba08 100644
--- a/tests/assembly/targets/targets-elf.rs
+++ b/tests/assembly/targets/targets-elf.rs
@@ -345,6 +345,9 @@
 //@ revisions: powerpc_unknown_linux_musl
 //@ [powerpc_unknown_linux_musl] compile-flags: --target powerpc-unknown-linux-musl
 //@ [powerpc_unknown_linux_musl] needs-llvm-components: powerpc
+//@ revisions: powerpc_unknown_linux_muslspe
+//@ [powerpc_unknown_linux_muslspe] compile-flags: --target powerpc-unknown-linux-muslspe
+//@ [powerpc_unknown_linux_muslspe] needs-llvm-components: powerpc
 //@ revisions: powerpc_unknown_netbsd
 //@ [powerpc_unknown_netbsd] compile-flags: --target powerpc-unknown-netbsd
 //@ [powerpc_unknown_netbsd] needs-llvm-components: powerpc

From 68fb25e2eb4898551037a62b753bc9702f868fe3 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Thu, 18 Jul 2024 20:32:08 -0400
Subject: [PATCH 007/685] Make use of raw strings in `core::fmt::builders`

There are quite a few uses of escaped quotes. Turn these into raw
strings within documentation and tests to make things easier to read.
---
 library/core/src/fmt/builders.rs   | 24 +++++-----
 library/core/tests/fmt/builders.rs | 74 +++++++++++++++---------------
 2 files changed, 49 insertions(+), 49 deletions(-)

diff --git a/library/core/src/fmt/builders.rs b/library/core/src/fmt/builders.rs
index 4ccb585862cdf..944f7c0850706 100644
--- a/library/core/src/fmt/builders.rs
+++ b/library/core/src/fmt/builders.rs
@@ -78,7 +78,7 @@ impl fmt::Write for PadAdapter<'_, '_> {
 ///
 /// assert_eq!(
 ///     format!("{:?}", Foo { bar: 10, baz: "Hello World".to_string() }),
-///     "Foo { bar: 10, baz: \"Hello World\" }",
+///     r#"Foo { bar: 10, baz: "Hello World" }"#,
 /// );
 /// ```
 #[must_use = "must eventually call `finish()` on Debug builders"]
@@ -125,7 +125,7 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
     ///
     /// assert_eq!(
     ///     format!("{:?}", Bar { bar: 10, another: "Hello World".to_string() }),
-    ///     "Bar { bar: 10, another: \"Hello World\", nonexistent_field: 1 }",
+    ///     r#"Bar { bar: 10, another: "Hello World", nonexistent_field: 1 }"#,
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
@@ -237,7 +237,7 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
     ///
     /// assert_eq!(
     ///     format!("{:?}", Bar { bar: 10, baz: "Hello World".to_string() }),
-    ///     "Bar { bar: 10, baz: \"Hello World\" }",
+    ///     r#"Bar { bar: 10, baz: "Hello World" }"#,
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
@@ -280,7 +280,7 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
 ///
 /// assert_eq!(
 ///     format!("{:?}", Foo(10, "Hello World".to_string())),
-///     "Foo(10, \"Hello World\")",
+///     r#"Foo(10, "Hello World")"#,
 /// );
 /// ```
 #[must_use = "must eventually call `finish()` on Debug builders"]
@@ -322,7 +322,7 @@ impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
     ///
     /// assert_eq!(
     ///     format!("{:?}", Foo(10, "Hello World".to_string())),
-    ///     "Foo(10, \"Hello World\")",
+    ///     r#"Foo(10, "Hello World")"#,
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
@@ -381,7 +381,7 @@ impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
     ///
     /// assert_eq!(
     ///     format!("{:?}", Foo(10, "Hello World".to_string())),
-    ///     "Foo(10, \"Hello World\")",
+    ///     r#"Foo(10, "Hello World")"#,
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
@@ -747,7 +747,7 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> {
 ///
 /// assert_eq!(
 ///     format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
-///     "{\"A\": 10, \"B\": 11}",
+///     r#"{"A": 10, "B": 11}"#,
 /// );
 /// ```
 #[must_use = "must eventually call `finish()` on Debug builders"]
@@ -787,7 +787,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     ///
     /// assert_eq!(
     ///     format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
-    ///     "{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
+    ///     r#"{"whole": [("A", 10), ("B", 11)]}"#,
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
@@ -823,7 +823,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     ///
     /// assert_eq!(
     ///     format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
-    ///     "{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
+    ///     r#"{"whole": [("A", 10), ("B", 11)]}"#,
     /// );
     /// ```
     #[stable(feature = "debug_map_key_value", since = "1.42.0")]
@@ -899,7 +899,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     ///
     /// assert_eq!(
     ///     format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
-    ///     "{\"whole\": [(\"A\", 10), (\"B\", 11)]}",
+    ///     r#"{"whole": [("A", 10), ("B", 11)]}"#,
     /// );
     /// ```
     #[stable(feature = "debug_map_key_value", since = "1.42.0")]
@@ -957,7 +957,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     ///
     /// assert_eq!(
     ///     format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
-    ///     "{\"A\": 10, \"B\": 11}",
+    ///     r#"{"A": 10, "B": 11}"#,
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
@@ -997,7 +997,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
     ///
     /// assert_eq!(
     ///     format!("{:?}", Foo(vec![("A".to_string(), 10), ("B".to_string(), 11)])),
-    ///     "{\"A\": 10, \"B\": 11}",
+    ///     r#"{"A": 10, "B": 11}"#,
     /// );
     /// ```
     #[stable(feature = "debug_builders", since = "1.2.0")]
diff --git a/library/core/tests/fmt/builders.rs b/library/core/tests/fmt/builders.rs
index 2bdc334b7c027..7b73f13815107 100644
--- a/library/core/tests/fmt/builders.rs
+++ b/library/core/tests/fmt/builders.rs
@@ -79,23 +79,23 @@ mod debug_struct {
         }
 
         assert_eq!(
-            "Bar { foo: Foo { bar: true, baz: 10/20 }, hello: \"world\" }",
+            r#"Bar { foo: Foo { bar: true, baz: 10/20 }, hello: "world" }"#,
             format!("{Bar:?}")
         );
         assert_eq!(
-            "Bar {
+            r#"Bar {
     foo: Foo {
         bar: true,
         baz: 10/20,
     },
-    hello: \"world\",
-}",
+    hello: "world",
+}"#,
             format!("{Bar:#?}")
         );
     }
 
     #[test]
-    fn test_only_non_exhaustive() {
+    fn test_empty_non_exhaustive() {
         struct Foo;
 
         impl fmt::Debug for Foo {
@@ -157,19 +157,19 @@ mod debug_struct {
         }
 
         assert_eq!(
-            "Bar { foo: Foo { bar: true, baz: 10/20, .. }, hello: \"world\", .. }",
+            r#"Bar { foo: Foo { bar: true, baz: 10/20, .. }, hello: "world", .. }"#,
             format!("{Bar:?}")
         );
         assert_eq!(
-            "Bar {
+            r#"Bar {
     foo: Foo {
         bar: true,
         baz: 10/20,
         ..
     },
-    hello: \"world\",
+    hello: "world",
     ..
-}",
+}"#,
             format!("{Bar:#?}")
         );
     }
@@ -249,15 +249,15 @@ mod debug_tuple {
             }
         }
 
-        assert_eq!("Bar(Foo(true, 10/20), \"world\")", format!("{Bar:?}"));
+        assert_eq!(r#"Bar(Foo(true, 10/20), "world")"#, format!("{Bar:?}"));
         assert_eq!(
-            "Bar(
+            r#"Bar(
     Foo(
         true,
         10/20,
     ),
-    \"world\",
-)",
+    "world",
+)"#,
             format!("{Bar:#?}")
         );
     }
@@ -301,11 +301,11 @@ mod debug_map {
         assert_eq!(format!("{Entry:?}"), format!("{KeyValue:?}"));
         assert_eq!(format!("{Entry:#?}"), format!("{KeyValue:#?}"));
 
-        assert_eq!("{\"bar\": true}", format!("{Entry:?}"));
+        assert_eq!(r#"{"bar": true}"#, format!("{Entry:?}"));
         assert_eq!(
-            "{
-    \"bar\": true,
-}",
+            r#"{
+    "bar": true,
+}"#,
             format!("{Entry:#?}")
         );
     }
@@ -339,12 +339,12 @@ mod debug_map {
         assert_eq!(format!("{Entry:?}"), format!("{KeyValue:?}"));
         assert_eq!(format!("{Entry:#?}"), format!("{KeyValue:#?}"));
 
-        assert_eq!("{\"bar\": true, 10: 10/20}", format!("{Entry:?}"));
+        assert_eq!(r#"{"bar": true, 10: 10/20}"#, format!("{Entry:?}"));
         assert_eq!(
-            "{
-    \"bar\": true,
+            r#"{
+    "bar": true,
     10: 10/20,
-}",
+}"#,
             format!("{Entry:#?}")
         );
     }
@@ -371,21 +371,21 @@ mod debug_map {
         }
 
         assert_eq!(
-            "{\"foo\": {\"bar\": true, 10: 10/20}, \
-                    {\"bar\": true, 10: 10/20}: \"world\"}",
+            r#"{"foo": {"bar": true, 10: 10/20}, \
+                    {"bar": true, 10: 10/20}: "world"}"#,
             format!("{Bar:?}")
         );
         assert_eq!(
-            "{
-    \"foo\": {
-        \"bar\": true,
+            r#"{
+    "foo": {
+        "bar": true,
         10: 10/20,
     },
     {
-        \"bar\": true,
+        "bar": true,
         10: 10/20,
-    }: \"world\",
-}",
+    }: "world",
+}"#,
             format!("{Bar:#?}")
         );
     }
@@ -547,15 +547,15 @@ mod debug_set {
             }
         }
 
-        assert_eq!("{{true, 10/20}, \"world\"}", format!("{Bar:?}"));
+        assert_eq!(r#"{{true, 10/20}, "world"}"#, format!("{Bar:?}"));
         assert_eq!(
-            "{
+            r#"{
     {
         true,
         10/20,
     },
-    \"world\",
-}",
+    "world",
+}"#,
             format!("{Bar:#?}")
         );
     }
@@ -635,15 +635,15 @@ mod debug_list {
             }
         }
 
-        assert_eq!("[[true, 10/20], \"world\"]", format!("{Bar:?}"));
+        assert_eq!(r#"[[true, 10/20], "world"]"#, format!("{Bar:?}"));
         assert_eq!(
-            "[
+            r#"[
     [
         true,
         10/20,
     ],
-    \"world\",
-]",
+    "world",
+]"#,
             format!("{Bar:#?}")
         );
     }

From 827970ebe9fcce27ada9f71977895666f56032be Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Thu, 18 Jul 2024 20:33:22 -0400
Subject: [PATCH 008/685] Implement `debug_more_non_exhaustive`

Add a `.finish_non_exhaustive()` method to `DebugTuple`, `DebugSet`,
`DebugList`, and `DebugMap`. This indicates that the structures have
remaining items with `..`.

This implements the ACP at
<https://github.com/rust-lang/libs-team/issues/248>.
---
 library/core/src/fmt/builders.rs   | 200 ++++++++++++++++++
 library/core/tests/fmt/builders.rs | 322 ++++++++++++++++++++++++++++-
 library/core/tests/lib.rs          |   1 +
 3 files changed, 521 insertions(+), 2 deletions(-)

diff --git a/library/core/src/fmt/builders.rs b/library/core/src/fmt/builders.rs
index 944f7c0850706..1d04320831df3 100644
--- a/library/core/src/fmt/builders.rs
+++ b/library/core/src/fmt/builders.rs
@@ -360,6 +360,51 @@ impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
         self
     }
 
+    /// Marks the tuple struct as non-exhaustive, indicating to the reader that there are some
+    /// other fields that are not shown in the debug representation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(debug_more_non_exhaustive)]
+    ///
+    /// use std::fmt;
+    ///
+    /// struct Foo(i32, String);
+    ///
+    /// impl fmt::Debug for Foo {
+    ///     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         fmt.debug_tuple("Foo")
+    ///            .field(&self.0)
+    ///            .finish_non_exhaustive() // Show that some other field(s) exist.
+    ///     }
+    /// }
+    ///
+    /// assert_eq!(
+    ///     format!("{:?}", Foo(10, "secret!".to_owned())),
+    ///     "Foo(10, ..)",
+    /// );
+    /// ```
+    #[unstable(feature = "debug_more_non_exhaustive", issue = "127942")]
+    pub fn finish_non_exhaustive(&mut self) -> fmt::Result {
+        self.result = self.result.and_then(|_| {
+            if self.fields > 0 {
+                if self.is_pretty() {
+                    let mut slot = None;
+                    let mut state = Default::default();
+                    let mut writer = PadAdapter::wrap(self.fmt, &mut slot, &mut state);
+                    writer.write_str("..\n")?;
+                    self.fmt.write_str(")")
+                } else {
+                    self.fmt.write_str(", ..)")
+                }
+            } else {
+                self.fmt.write_str("(..)")
+            }
+        });
+        self.result
+    }
+
     /// Finishes output and returns any error encountered.
     ///
     /// # Examples
@@ -554,6 +599,56 @@ impl<'a, 'b: 'a> DebugSet<'a, 'b> {
         self
     }
 
+    /// Marks the set as non-exhaustive, indicating to the reader that there are some other
+    /// elements that are not shown in the debug representation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(debug_more_non_exhaustive)]
+    ///
+    /// use std::fmt;
+    ///
+    /// struct Foo(Vec<i32>);
+    ///
+    /// impl fmt::Debug for Foo {
+    ///     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         // Print at most two elements, abbreviate the rest
+    ///         let mut f = fmt.debug_set();
+    ///         let mut f = f.entries(self.0.iter().take(2));
+    ///         if self.0.len() > 2 {
+    ///             f.finish_non_exhaustive()
+    ///         } else {
+    ///             f.finish()
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// assert_eq!(
+    ///     format!("{:?}", Foo(vec![1, 2, 3, 4])),
+    ///     "{1, 2, ..}",
+    /// );
+    /// ```
+    #[unstable(feature = "debug_more_non_exhaustive", issue = "127942")]
+    pub fn finish_non_exhaustive(&mut self) -> fmt::Result {
+        self.inner.result = self.inner.result.and_then(|_| {
+            if self.inner.has_fields {
+                if self.inner.is_pretty() {
+                    let mut slot = None;
+                    let mut state = Default::default();
+                    let mut writer = PadAdapter::wrap(self.inner.fmt, &mut slot, &mut state);
+                    writer.write_str("..\n")?;
+                    self.inner.fmt.write_str("}")
+                } else {
+                    self.inner.fmt.write_str(", ..}")
+                }
+            } else {
+                self.inner.fmt.write_str("..}")
+            }
+        });
+        self.inner.result
+    }
+
     /// Finishes output and returns any error encountered.
     ///
     /// # Examples
@@ -697,6 +792,55 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> {
         self
     }
 
+    /// Marks the list as non-exhaustive, indicating to the reader that there are some other
+    /// elements that are not shown in the debug representation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(debug_more_non_exhaustive)]
+    ///
+    /// use std::fmt;
+    ///
+    /// struct Foo(Vec<i32>);
+    ///
+    /// impl fmt::Debug for Foo {
+    ///     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         // Print at most two elements, abbreviate the rest
+    ///         let mut f = fmt.debug_list();
+    ///         let mut f = f.entries(self.0.iter().take(2));
+    ///         if self.0.len() > 2 {
+    ///             f.finish_non_exhaustive()
+    ///         } else {
+    ///             f.finish()
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// assert_eq!(
+    ///     format!("{:?}", Foo(vec![1, 2, 3, 4])),
+    ///     "[1, 2, ..]",
+    /// );
+    /// ```
+    #[unstable(feature = "debug_more_non_exhaustive", issue = "127942")]
+    pub fn finish_non_exhaustive(&mut self) -> fmt::Result {
+        self.inner.result.and_then(|_| {
+            if self.inner.has_fields {
+                if self.inner.is_pretty() {
+                    let mut slot = None;
+                    let mut state = Default::default();
+                    let mut writer = PadAdapter::wrap(self.inner.fmt, &mut slot, &mut state);
+                    writer.write_str("..\n")?;
+                    self.inner.fmt.write_str("]")
+                } else {
+                    self.inner.fmt.write_str(", ..]")
+                }
+            } else {
+                self.inner.fmt.write_str("..]")
+            }
+        })
+    }
+
     /// Finishes output and returns any error encountered.
     ///
     /// # Examples
@@ -973,6 +1117,62 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
         self
     }
 
+    /// Marks the map as non-exhaustive, indicating to the reader that there are some other
+    /// entries that are not shown in the debug representation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(debug_more_non_exhaustive)]
+    ///
+    /// use std::fmt;
+    ///
+    /// struct Foo(Vec<(String, i32)>);
+    ///
+    /// impl fmt::Debug for Foo {
+    ///     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+    ///         // Print at most two elements, abbreviate the rest
+    ///         let mut f = fmt.debug_map();
+    ///         let mut f = f.entries(self.0.iter().take(2).map(|&(ref k, ref v)| (k, v)));
+    ///         if self.0.len() > 2 {
+    ///             f.finish_non_exhaustive()
+    ///         } else {
+    ///             f.finish()
+    ///         }
+    ///     }
+    /// }
+    ///
+    /// assert_eq!(
+    ///     format!("{:?}", Foo(vec![
+    ///         ("A".to_string(), 10),
+    ///         ("B".to_string(), 11),
+    ///         ("C".to_string(), 12),
+    ///     ])),
+    ///     r#"{"A": 10, "B": 11, ..}"#,
+    /// );
+    /// ```
+    #[unstable(feature = "debug_more_non_exhaustive", issue = "127942")]
+    pub fn finish_non_exhaustive(&mut self) -> fmt::Result {
+        self.result = self.result.and_then(|_| {
+            assert!(!self.has_key, "attempted to finish a map with a partial entry");
+
+            if self.has_fields {
+                if self.is_pretty() {
+                    let mut slot = None;
+                    let mut state = Default::default();
+                    let mut writer = PadAdapter::wrap(self.fmt, &mut slot, &mut state);
+                    writer.write_str("..\n")?;
+                    self.fmt.write_str("}")
+                } else {
+                    self.fmt.write_str(", ..}")
+                }
+            } else {
+                self.fmt.write_str("..}")
+            }
+        });
+        self.result
+    }
+
     /// Finishes output and returns any error encountered.
     ///
     /// # Panics
diff --git a/library/core/tests/fmt/builders.rs b/library/core/tests/fmt/builders.rs
index 7b73f13815107..ba4801f5912b8 100644
--- a/library/core/tests/fmt/builders.rs
+++ b/library/core/tests/fmt/builders.rs
@@ -257,6 +257,80 @@ mod debug_tuple {
         10/20,
     ),
     "world",
+)"#,
+            format!("{Bar:#?}")
+        );
+    }
+
+    #[test]
+    fn test_empty_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_tuple("Foo").finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!("Foo(..)", format!("{Foo:?}"));
+        assert_eq!("Foo(..)", format!("{Foo:#?}"));
+    }
+
+    #[test]
+    fn test_multiple_and_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_tuple("Foo")
+                    .field(&true)
+                    .field(&format_args!("{}/{}", 10, 20))
+                    .finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!("Foo(true, 10/20, ..)", format!("{Foo:?}"));
+        assert_eq!(
+            "Foo(
+    true,
+    10/20,
+    ..
+)",
+            format!("{Foo:#?}")
+        );
+    }
+
+    #[test]
+    fn test_nested_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_tuple("Foo")
+                    .field(&true)
+                    .field(&format_args!("{}/{}", 10, 20))
+                    .finish_non_exhaustive()
+            }
+        }
+
+        struct Bar;
+
+        impl fmt::Debug for Bar {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_tuple("Bar").field(&Foo).field(&"world").finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!(r#"Bar(Foo(true, 10/20, ..), "world", ..)"#, format!("{Bar:?}"));
+        assert_eq!(
+            r#"Bar(
+    Foo(
+        true,
+        10/20,
+        ..
+    ),
+    "world",
+    ..
 )"#,
             format!("{Bar:#?}")
         );
@@ -371,8 +445,7 @@ mod debug_map {
         }
 
         assert_eq!(
-            r#"{"foo": {"bar": true, 10: 10/20}, \
-                    {"bar": true, 10: 10/20}: "world"}"#,
+            r#"{"foo": {"bar": true, 10: 10/20}, {"bar": true, 10: 10/20}: "world"}"#,
             format!("{Bar:?}")
         );
         assert_eq!(
@@ -471,6 +544,103 @@ mod debug_map {
 
         let _ = format!("{Foo:?}");
     }
+
+    #[test]
+    fn test_empty_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_map().finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!("{..}", format!("{Foo:?}"));
+        assert_eq!("{..}", format!("{Foo:#?}"));
+    }
+
+    #[test]
+    fn test_multiple_and_non_exhaustive() {
+        struct Entry;
+
+        impl fmt::Debug for Entry {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_map()
+                    .entry(&"bar", &true)
+                    .entry(&10, &format_args!("{}/{}", 10, 20))
+                    .finish_non_exhaustive()
+            }
+        }
+
+        struct KeyValue;
+
+        impl fmt::Debug for KeyValue {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_map()
+                    .key(&"bar")
+                    .value(&true)
+                    .key(&10)
+                    .value(&format_args!("{}/{}", 10, 20))
+                    .finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!(format!("{Entry:?}"), format!("{KeyValue:?}"));
+        assert_eq!(format!("{Entry:#?}"), format!("{KeyValue:#?}"));
+
+        assert_eq!(r#"{"bar": true, 10: 10/20, ..}"#, format!("{Entry:?}"));
+        assert_eq!(
+            r#"{
+    "bar": true,
+    10: 10/20,
+    ..
+}"#,
+            format!("{Entry:#?}")
+        );
+    }
+
+    #[test]
+    fn test_nested_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_map()
+                    .entry(&"bar", &true)
+                    .entry(&10, &format_args!("{}/{}", 10, 20))
+                    .finish_non_exhaustive()
+            }
+        }
+
+        struct Bar;
+
+        impl fmt::Debug for Bar {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_map().entry(&"foo", &Foo).entry(&Foo, &"world").finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!(
+            r#"{"foo": {"bar": true, 10: 10/20, ..}, {"bar": true, 10: 10/20, ..}: "world", ..}"#,
+            format!("{Bar:?}")
+        );
+        assert_eq!(
+            r#"{
+    "foo": {
+        "bar": true,
+        10: 10/20,
+        ..
+    },
+    {
+        "bar": true,
+        10: 10/20,
+        ..
+    }: "world",
+    ..
+}"#,
+            format!("{Bar:#?}")
+        );
+    }
 }
 
 mod debug_set {
@@ -555,6 +725,80 @@ mod debug_set {
         10/20,
     },
     "world",
+}"#,
+            format!("{Bar:#?}")
+        );
+    }
+
+    #[test]
+    fn test_empty_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_set().finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!("{..}", format!("{Foo:?}"));
+        assert_eq!("{..}", format!("{Foo:#?}"));
+    }
+
+    #[test]
+    fn test_multiple_and_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_set()
+                    .entry(&true)
+                    .entry(&format_args!("{}/{}", 10, 20))
+                    .finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!("{true, 10/20, ..}", format!("{Foo:?}"));
+        assert_eq!(
+            "{
+    true,
+    10/20,
+    ..
+}",
+            format!("{Foo:#?}")
+        );
+    }
+
+    #[test]
+    fn test_nested_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_set()
+                    .entry(&true)
+                    .entry(&format_args!("{}/{}", 10, 20))
+                    .finish_non_exhaustive()
+            }
+        }
+
+        struct Bar;
+
+        impl fmt::Debug for Bar {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_set().entry(&Foo).entry(&"world").finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!(r#"{{true, 10/20, ..}, "world", ..}"#, format!("{Bar:?}"));
+        assert_eq!(
+            r#"{
+    {
+        true,
+        10/20,
+        ..
+    },
+    "world",
+    ..
 }"#,
             format!("{Bar:#?}")
         );
@@ -643,6 +887,80 @@ mod debug_list {
         10/20,
     ],
     "world",
+]"#,
+            format!("{Bar:#?}")
+        );
+    }
+
+    #[test]
+    fn test_empty_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_list().finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!("[..]", format!("{Foo:?}"));
+        assert_eq!("[..]", format!("{Foo:#?}"));
+    }
+
+    #[test]
+    fn test_multiple_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_list()
+                    .entry(&true)
+                    .entry(&format_args!("{}/{}", 10, 20))
+                    .finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!("[true, 10/20, ..]", format!("{Foo:?}"));
+        assert_eq!(
+            "[
+    true,
+    10/20,
+    ..
+]",
+            format!("{Foo:#?}")
+        );
+    }
+
+    #[test]
+    fn test_nested_non_exhaustive() {
+        struct Foo;
+
+        impl fmt::Debug for Foo {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_list()
+                    .entry(&true)
+                    .entry(&format_args!("{}/{}", 10, 20))
+                    .finish_non_exhaustive()
+            }
+        }
+
+        struct Bar;
+
+        impl fmt::Debug for Bar {
+            fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt.debug_list().entry(&Foo).entry(&"world").finish_non_exhaustive()
+            }
+        }
+
+        assert_eq!(r#"[[true, 10/20, ..], "world", ..]"#, format!("{Bar:?}"));
+        assert_eq!(
+            r#"[
+    [
+        true,
+        10/20,
+        ..
+    ],
+    "world",
+    ..
 ]"#,
             format!("{Bar:#?}")
         );
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index 83a615fcd8be3..0f6ba7e4c66cb 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -29,6 +29,7 @@
 #![feature(core_io_borrowed_buf)]
 #![feature(core_private_bignum)]
 #![feature(core_private_diy_float)]
+#![feature(debug_more_non_exhaustive)]
 #![feature(dec2flt)]
 #![feature(duration_consts_float)]
 #![feature(duration_constants)]

From b18c7d85a92011bcc094b33e6a3c646a3cfca8f3 Mon Sep 17 00:00:00 2001
From: Ian Jackson <ijackson@chiark.greenend.org.uk>
Date: Mon, 22 Jul 2024 17:34:29 +0100
Subject: [PATCH 009/685] Docs for Waker and LocalWaker: Add cross-refs in
 comment

---
 library/core/src/task/wake.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/library/core/src/task/wake.rs b/library/core/src/task/wake.rs
index 86a965f68e085..4582bf9f42245 100644
--- a/library/core/src/task/wake.rs
+++ b/library/core/src/task/wake.rs
@@ -531,6 +531,10 @@ impl Waker {
 
     /// Returns a reference to a `Waker` that does nothing when used.
     ///
+    // Note!  Much of the documentation for this method is duplicated
+    // in the docs for `LocalWaker::noop`.
+    // If you edit it, consider editing the other copy too.
+    //
     /// This is mostly useful for writing tests that need a [`Context`] to poll
     /// some futures, but are not expecting those futures to wake the waker or
     /// do not need to do anything specific if it happens.
@@ -784,6 +788,10 @@ impl LocalWaker {
 
     /// Creates a new `LocalWaker` that does nothing when `wake` is called.
     ///
+    // Note!  Much of the documentation for this method is duplicated
+    // in the docs for `Waker::noop`.
+    // If you edit it, consider editing the other copy too.
+    //
     /// This is mostly useful for writing tests that need a [`Context`] to poll
     /// some futures, but are not expecting those futures to wake the waker or
     /// do not need to do anything specific if it happens.

From c404406a87412d50604893d8c347744195ce2dea Mon Sep 17 00:00:00 2001
From: Ian Jackson <ijackson@chiark.greenend.org.uk>
Date: Mon, 22 Jul 2024 17:35:11 +0100
Subject: [PATCH 010/685] LocalWaker docs: Make long-ago omitted but probably
 intended changes

In 6f8a944ba4311cbcf5922132721095c226c6fbab, titled

  Change return type of unstable `Waker::noop()` from `Waker` to `&Waker`.

the summary line for Waker was changed:

  -    /// Creates a new `Waker` that does nothing when `wake` is called.
  +    /// Returns a reference to a `Waker` that does nothing when used.

and the sentence about clone was added.

LocalWaker's docs were not changed, even though the types were, but
there is no explanation for why not.  It seems like it was simply a
slip induced by the clone-and-hack.
---
 library/core/src/task/wake.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/library/core/src/task/wake.rs b/library/core/src/task/wake.rs
index 4582bf9f42245..baa8a956f8af1 100644
--- a/library/core/src/task/wake.rs
+++ b/library/core/src/task/wake.rs
@@ -786,7 +786,7 @@ impl LocalWaker {
         Self { waker }
     }
 
-    /// Creates a new `LocalWaker` that does nothing when `wake` is called.
+    /// Returns a reference to a `LocalWaker` that does nothing when used.
     ///
     // Note!  Much of the documentation for this method is duplicated
     // in the docs for `Waker::noop`.
@@ -796,6 +796,8 @@ impl LocalWaker {
     /// some futures, but are not expecting those futures to wake the waker or
     /// do not need to do anything specific if it happens.
     ///
+    /// If an owned `LocalWaker` is needed, `clone()` this one.
+    ///
     /// # Examples
     ///
     /// ```

From b4b991e66f0a1fd0e517ed7f038129350a7ad6ce Mon Sep 17 00:00:00 2001
From: surechen <chenshuo17@huawei.com>
Date: Tue, 23 Jul 2024 10:24:45 +0800
Subject: [PATCH 011/685] Suggest adding Result return type for associated
 method in E0277.

For following:

```rust
struct A;
impl A {
    fn test4(&self) {
        let mut _file = File::create("foo.txt")?;
        //~^ ERROR the `?` operator can only be used in a method
    }
```
Suggest:

```rust
impl A {
    fn test4(&self) -> Result<(), Box<dyn std::error::Error>> {
        let mut _file = File::create("foo.txt")?;
        //~^ ERROR the `?` operator can only be used in a method

    Ok(())
    }
}
```

For #125997
---
 .../src/error_reporting/traits/suggestions.rs | 41 +++++++++++++++---
 ...turn-from-residual-sugg-issue-125997.fixed | 19 ++++++++
 .../return-from-residual-sugg-issue-125997.rs | 15 +++++++
 ...urn-from-residual-sugg-issue-125997.stderr | 43 ++++++++++++++++++-
 4 files changed, 111 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index 885216e62165e..9b949323a360a 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -4612,6 +4612,9 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         })
     }
 
+    // For E0277 when use `?` operator, suggest adding
+    // a suitable return type in `FnSig`, and a default
+    // return value at the end of the function's body.
     pub(super) fn suggest_add_result_as_return_type(
         &self,
         obligation: &PredicateObligation<'tcx>,
@@ -4622,19 +4625,47 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             return;
         }
 
+        // Only suggest for local function and associated method,
+        // because this suggest adding both return type in
+        // the `FnSig` and a default return value in the body, so it
+        // is not suitable for foreign function without a local body,
+        // and neighter for trait method which may be also implemented
+        // in other place, so shouldn't change it's FnSig.
+        fn choose_suggest_items<'tcx, 'hir>(
+            tcx: TyCtxt<'tcx>,
+            node: hir::Node<'hir>,
+        ) -> Option<(&'hir hir::FnDecl<'hir>, hir::BodyId)> {
+            match node {
+                hir::Node::Item(item) if let hir::ItemKind::Fn(sig, _, body_id) = item.kind => {
+                    Some((sig.decl, body_id))
+                }
+                hir::Node::ImplItem(item)
+                    if let hir::ImplItemKind::Fn(sig, body_id) = item.kind =>
+                {
+                    let parent = tcx.parent_hir_node(item.hir_id());
+                    if let hir::Node::Item(item) = parent
+                        && let hir::ItemKind::Impl(imp) = item.kind
+                        && imp.of_trait.is_none()
+                    {
+                        return Some((sig.decl, body_id));
+                    }
+                    None
+                }
+                _ => None,
+            }
+        }
+
         let node = self.tcx.hir_node_by_def_id(obligation.cause.body_id);
-        if let hir::Node::Item(item) = node
-            && let hir::ItemKind::Fn(sig, _, body_id) = item.kind
-            && let hir::FnRetTy::DefaultReturn(ret_span) = sig.decl.output
+        if let Some((fn_decl, body_id)) = choose_suggest_items(self.tcx, node)
+            && let hir::FnRetTy::DefaultReturn(ret_span) = fn_decl.output
             && self.tcx.is_diagnostic_item(sym::FromResidual, trait_pred.def_id())
             && trait_pred.skip_binder().trait_ref.args.type_at(0).is_unit()
             && let ty::Adt(def, _) = trait_pred.skip_binder().trait_ref.args.type_at(1).kind()
             && self.tcx.is_diagnostic_item(sym::Result, def.did())
         {
-            let body = self.tcx.hir().body(body_id);
             let mut sugg_spans =
                 vec![(ret_span, " -> Result<(), Box<dyn std::error::Error>>".to_string())];
-
+            let body = self.tcx.hir().body(body_id);
             if let hir::ExprKind::Block(b, _) = body.value.kind
                 && b.expr.is_none()
             {
diff --git a/tests/ui/return/return-from-residual-sugg-issue-125997.fixed b/tests/ui/return/return-from-residual-sugg-issue-125997.fixed
index b2eca69aeb902..a5a133998259b 100644
--- a/tests/ui/return/return-from-residual-sugg-issue-125997.fixed
+++ b/tests/ui/return/return-from-residual-sugg-issue-125997.fixed
@@ -33,6 +33,25 @@ macro_rules! mac {
     };
 }
 
+struct A;
+
+impl A {
+    fn test4(&self) -> Result<(), Box<dyn std::error::Error>> {
+        let mut _file = File::create("foo.txt")?;
+        //~^ ERROR the `?` operator can only be used in a method
+    
+    Ok(())
+}
+
+    fn test5(&self) -> Result<(), Box<dyn std::error::Error>> {
+        let mut _file = File::create("foo.txt")?;
+        //~^ ERROR the `?` operator can only be used in a method
+        println!();
+    
+    Ok(())
+}
+}
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut _file = File::create("foo.txt")?;
     //~^ ERROR the `?` operator can only be used in a function
diff --git a/tests/ui/return/return-from-residual-sugg-issue-125997.rs b/tests/ui/return/return-from-residual-sugg-issue-125997.rs
index dd8550a388b86..30ca27eae45ef 100644
--- a/tests/ui/return/return-from-residual-sugg-issue-125997.rs
+++ b/tests/ui/return/return-from-residual-sugg-issue-125997.rs
@@ -27,6 +27,21 @@ macro_rules! mac {
     };
 }
 
+struct A;
+
+impl A {
+    fn test4(&self) {
+        let mut _file = File::create("foo.txt")?;
+        //~^ ERROR the `?` operator can only be used in a method
+    }
+
+    fn test5(&self) {
+        let mut _file = File::create("foo.txt")?;
+        //~^ ERROR the `?` operator can only be used in a method
+        println!();
+    }
+}
+
 fn main() {
     let mut _file = File::create("foo.txt")?;
     //~^ ERROR the `?` operator can only be used in a function
diff --git a/tests/ui/return/return-from-residual-sugg-issue-125997.stderr b/tests/ui/return/return-from-residual-sugg-issue-125997.stderr
index ef938f0213dfb..a59f38c2ec644 100644
--- a/tests/ui/return/return-from-residual-sugg-issue-125997.stderr
+++ b/tests/ui/return/return-from-residual-sugg-issue-125997.stderr
@@ -37,8 +37,47 @@ LL +     Ok(())
 LL + }
    |
 
+error[E0277]: the `?` operator can only be used in a method that returns `Result` or `Option` (or another type that implements `FromResidual`)
+  --> $DIR/return-from-residual-sugg-issue-125997.rs:34:48
+   |
+LL |     fn test4(&self) {
+   |     --------------- this function should return `Result` or `Option` to accept `?`
+LL |         let mut _file = File::create("foo.txt")?;
+   |                                                ^ cannot use the `?` operator in a method that returns `()`
+   |
+   = help: the trait `FromResidual<Result<Infallible, std::io::Error>>` is not implemented for `()`
+help: consider adding return type
+   |
+LL ~     fn test4(&self) -> Result<(), Box<dyn std::error::Error>> {
+LL |         let mut _file = File::create("foo.txt")?;
+LL |
+LL ~     
+LL +     Ok(())
+LL + }
+   |
+
+error[E0277]: the `?` operator can only be used in a method that returns `Result` or `Option` (or another type that implements `FromResidual`)
+  --> $DIR/return-from-residual-sugg-issue-125997.rs:39:48
+   |
+LL |     fn test5(&self) {
+   |     --------------- this function should return `Result` or `Option` to accept `?`
+LL |         let mut _file = File::create("foo.txt")?;
+   |                                                ^ cannot use the `?` operator in a method that returns `()`
+   |
+   = help: the trait `FromResidual<Result<Infallible, std::io::Error>>` is not implemented for `()`
+help: consider adding return type
+   |
+LL ~     fn test5(&self) -> Result<(), Box<dyn std::error::Error>> {
+LL |         let mut _file = File::create("foo.txt")?;
+LL |
+LL |         println!();
+LL ~     
+LL +     Ok(())
+LL + }
+   |
+
 error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
-  --> $DIR/return-from-residual-sugg-issue-125997.rs:31:44
+  --> $DIR/return-from-residual-sugg-issue-125997.rs:46:44
    |
 LL | fn main() {
    | --------- this function should return `Result` or `Option` to accept `?`
@@ -81,6 +120,6 @@ LL +     Ok(())
 LL + }
    |
 
-error: aborting due to 4 previous errors
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0277`.

From 2c166f4f55f4b3062f907e8a72cff56a98978e58 Mon Sep 17 00:00:00 2001
From: Neven Villani <vanille@crans.org>
Date: Thu, 18 Jul 2024 13:32:24 +0200
Subject: [PATCH 012/685] Make unused states of Reserved unrepresentable

---
 .../src/borrow_tracker/tree_borrows/mod.rs    |  25 ++-
 .../src/borrow_tracker/tree_borrows/perms.rs  | 182 +++++++++++-------
 .../borrow_tracker/tree_borrows/tree/tests.rs |  35 +++-
 .../reserved/cell-protected-write.stderr      |  10 +-
 .../reserved/int-protected-write.stderr       |  10 +-
 .../tree_borrows/cell-alternate-writes.stderr |   2 +-
 .../pass/tree_borrows/end-of-protector.stderr |  22 +--
 .../tests/pass/tree_borrows/formatting.stderr |   2 +-
 .../pass/tree_borrows/reborrow-is-read.stderr |   2 +-
 .../tests/pass/tree_borrows/reserved.stderr   |  34 ++--
 .../pass/tree_borrows/unique.default.stderr   |   4 +-
 .../pass/tree_borrows/unique.uniq.stderr      |   4 +-
 .../tree_borrows/vec_unique.default.stderr    |   2 +-
 13 files changed, 200 insertions(+), 134 deletions(-)

diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
index 123d4b407fb4c..7871dbe16b340 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -1,10 +1,6 @@
 use rustc_middle::{
     mir::{Mutability, RetagKind},
-    ty::{
-        self,
-        layout::{HasParamEnv, HasTyCtxt},
-        Ty,
-    },
+    ty::{self, layout::HasParamEnv, Ty},
 };
 use rustc_span::def_id::DefId;
 use rustc_target::abi::{Abi, Size};
@@ -146,10 +142,9 @@ impl<'tcx> NewPermission {
         // interior mutability and protectors interact poorly.
         // To eliminate the case of Protected Reserved IM we override interior mutability
         // in the case of a protected reference: protected references are always considered
-        // "freeze".
+        // "freeze" in their reservation phase.
         let initial_state = match mutability {
-            Mutability::Mut if ty_is_unpin =>
-                Permission::new_reserved(ty_is_freeze || is_protected),
+            Mutability::Mut if ty_is_unpin => Permission::new_reserved(ty_is_freeze, is_protected),
             Mutability::Not if ty_is_freeze => Permission::new_frozen(),
             // Raw pointers never enter this function so they are not handled.
             // However raw pointers are not the only pointers that take the parent
@@ -176,10 +171,12 @@ impl<'tcx> NewPermission {
             // Regular `Unpin` box, give it `noalias` but only a weak protector
             // because it is valid to deallocate it within the function.
             let ty_is_freeze = ty.is_freeze(*cx.tcx, cx.param_env());
+            let protected = kind == RetagKind::FnEntry;
+            let initial_state = Permission::new_reserved(ty_is_freeze, protected);
             Self {
                 zero_size,
-                initial_state: Permission::new_reserved(ty_is_freeze),
-                protector: (kind == RetagKind::FnEntry).then_some(ProtectorKind::WeakProtector),
+                initial_state,
+                protector: protected.then_some(ProtectorKind::WeakProtector),
             }
         })
     }
@@ -521,11 +518,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn tb_protect_place(&mut self, place: &MPlaceTy<'tcx>) -> InterpResult<'tcx, MPlaceTy<'tcx>> {
         let this = self.eval_context_mut();
 
+        // Note: if we were to inline `new_reserved` below we would find out that
+        // `ty_is_freeze` is eventually unused because it appears in a `ty_is_freeze || true`.
+        // We are nevertheless including it here for clarity.
+        let ty_is_freeze = place.layout.ty.is_freeze(*this.tcx, this.param_env());
         // Retag it. With protection! That is the entire point.
         let new_perm = NewPermission {
-            initial_state: Permission::new_reserved(
-                place.layout.ty.is_freeze(this.tcx(), this.param_env()),
-            ),
+            initial_state: Permission::new_reserved(ty_is_freeze, /* protected */ true),
             zero_size: false,
             protector: Some(ProtectorKind::StrongProtector),
         };
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs
index 8e23257b6c006..5461edb51d3af 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/perms.rs
@@ -8,10 +8,16 @@ use crate::AccessKind;
 /// The activation states of a pointer.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 enum PermissionPriv {
-    /// represents: a local reference that has not yet been written to;
-    /// allows: child reads, foreign reads, foreign writes if type is freeze;
+    /// represents: a local mutable reference that has not yet been written to;
+    /// allows: child reads, foreign reads;
     /// affected by: child writes (becomes Active),
-    /// rejects: foreign writes (Disabled, except if type is not freeze).
+    /// rejects: foreign writes (Disabled).
+    ///
+    /// `ReservedFrz` is mostly for types that are `Freeze` (no interior mutability).
+    /// If the type has interior mutability, see `ReservedIM` instead.
+    /// (Note: since the discovery of `tests/fail/tree_borrows/reservedim_spurious_write.rs`,
+    /// we also use `ReservedFreeze` for mutable references that were retagged with a protector
+    /// independently of interior mutability)
     ///
     /// special case: behaves differently when protected, which is where `conflicted`
     /// is relevant
@@ -22,12 +28,12 @@ enum PermissionPriv {
     /// - foreign-read then child-write is UB due to `conflicted`,
     /// - child-write then foreign-read is UB since child-write will activate and then
     ///   foreign-read disables a protected `Active`, which is UB.
-    ///
-    /// Note: since the discovery of `tests/fail/tree_borrows/reservedim_spurious_write.rs`,
-    /// `ty_is_freeze` does not strictly mean that the type has no interior mutability,
-    /// it could be an interior mutable type that lost its interior mutability privileges
-    /// when retagged with a protector.
-    Reserved { ty_is_freeze: bool, conflicted: bool },
+    ReservedFrz { conflicted: bool },
+    /// Alternative version of `ReservedFrz` made for types with interior mutability.
+    /// allows: child reads, foreign reads, foreign writes (extra);
+    /// affected by: child writes (becomes Active);
+    /// rejects: nothing.
+    ReservedIM,
     /// represents: a unique pointer;
     /// allows: child reads, child writes;
     /// rejects: foreign reads (Frozen), foreign writes (Disabled).
@@ -59,17 +65,14 @@ impl PartialOrd for PermissionPriv {
             (_, Frozen) => Less,
             (Active, _) => Greater,
             (_, Active) => Less,
-            (
-                Reserved { ty_is_freeze: f1, conflicted: c1 },
-                Reserved { ty_is_freeze: f2, conflicted: c2 },
-            ) => {
-                // No transition ever changes `ty_is_freeze`.
-                if f1 != f2 {
-                    return None;
-                }
+            (ReservedIM, ReservedIM) => Equal,
+            (ReservedFrz { conflicted: c1 }, ReservedFrz { conflicted: c2 }) => {
                 // `bool` is ordered such that `false <= true`, so this works as intended.
                 c1.cmp(c2)
             }
+            // Versions of `Reserved` with different interior mutability are incomparable with each
+            // other.
+            (ReservedIM, ReservedFrz { .. }) | (ReservedFrz { .. }, ReservedIM) => return None,
         })
     }
 }
@@ -77,7 +80,12 @@ impl PartialOrd for PermissionPriv {
 impl PermissionPriv {
     /// Check if `self` can be the initial state of a pointer.
     fn is_initial(&self) -> bool {
-        matches!(self, Reserved { conflicted: false, .. } | Frozen)
+        matches!(self, ReservedFrz { conflicted: false } | Frozen | ReservedIM)
+    }
+
+    /// Reject `ReservedIM` that cannot exist in the presence of a protector.
+    fn compatible_with_protector(&self) -> bool {
+        !matches!(self, ReservedIM)
     }
 }
 
@@ -93,7 +101,7 @@ mod transition {
             Disabled => return None,
             // The inner data `ty_is_freeze` of `Reserved` is always irrelevant for Read
             // accesses, since the data is not being mutated. Hence the `{ .. }`.
-            readable @ (Reserved { .. } | Active | Frozen) => readable,
+            readable @ (ReservedFrz { .. } | ReservedIM | Active | Frozen) => readable,
         })
     }
 
@@ -109,11 +117,16 @@ mod transition {
 
             // Someone else read. To make sure we won't write before function exit,
             // we set the "conflicted" flag, which will disallow writes while we are protected.
-            Reserved { ty_is_freeze, .. } if protected =>
-                Reserved { ty_is_freeze, conflicted: true },
+            ReservedFrz { .. } if protected => ReservedFrz { conflicted: true },
             // Before activation and without protectors, foreign reads are fine.
             // That's the entire point of 2-phase borrows.
-            res @ Reserved { .. } => res,
+            res @ (ReservedFrz { .. } | ReservedIM) => {
+                // Even though we haven't checked `ReservedIM if protected` separately,
+                // it is a state that cannot occur because under a protector we only
+                // create `ReservedFrz` never `ReservedIM`.
+                assert!(!protected);
+                res
+            }
             Active =>
                 if protected {
                     // We wrote, someone else reads -- that's bad.
@@ -134,10 +147,10 @@ mod transition {
             // If the `conflicted` flag is set, then there was a foreign read during
             // the function call that is still ongoing (still `protected`),
             // this is UB (`noalias` violation).
-            Reserved { conflicted: true, .. } if protected => return None,
+            ReservedFrz { conflicted: true } if protected => return None,
             // A write always activates the 2-phase borrow, even with interior
             // mutability
-            Reserved { .. } | Active => Active,
+            ReservedFrz { .. } | ReservedIM | Active => Active,
             Frozen | Disabled => return None,
         })
     }
@@ -145,15 +158,15 @@ mod transition {
     /// A non-child node was write-accessed: this makes everything `Disabled` except for
     /// non-protected interior mutable `Reserved` which stay the same.
     fn foreign_write(state: PermissionPriv, protected: bool) -> Option<PermissionPriv> {
+        // There is no explicit dependency on `protected`, but recall that interior mutable
+        // types receive a `ReservedFrz` instead of `ReservedIM` when retagged under a protector,
+        // so the result of this function does indirectly depend on (past) protector status.
         Some(match state {
-            // FIXME: since the fix related to reservedim_spurious_write, it is now possible
-            // to express these transitions of the state machine without an explicit dependency
-            // on `protected`: because `ty_is_freeze: false` implies `!protected` then
-            // the line handling `Reserved { .. } if protected` could be deleted.
-            // This will however require optimizations to the exhaustive tests because
-            // fewer initial conditions are valid.
-            Reserved { .. } if protected => Disabled,
-            res @ Reserved { ty_is_freeze: false, .. } => res,
+            res @ ReservedIM => {
+                // We can never create a `ReservedIM` under a protector, only `ReservedFrz`.
+                assert!(!protected);
+                res
+            }
             _ => Disabled,
         })
     }
@@ -208,9 +221,23 @@ impl Permission {
         Self { inner: Active }
     }
 
-    /// Default initial permission of a reborrowed mutable reference.
-    pub fn new_reserved(ty_is_freeze: bool) -> Self {
-        Self { inner: Reserved { ty_is_freeze, conflicted: false } }
+    /// Default initial permission of a reborrowed mutable reference that is either
+    /// protected or not interior mutable.
+    fn new_reserved_frz() -> Self {
+        Self { inner: ReservedFrz { conflicted: false } }
+    }
+
+    /// Default initial permission of an unprotected interior mutable reference.
+    fn new_reserved_im() -> Self {
+        Self { inner: ReservedIM }
+    }
+
+    /// Wrapper around `new_reserved_frz` and `new_reserved_im` that decides
+    /// which to call based on the interior mutability and the retag kind (whether there
+    /// is a protector is relevant because being protected takes priority over being
+    /// interior mutable)
+    pub fn new_reserved(ty_is_freeze: bool, protected: bool) -> Self {
+        if ty_is_freeze || protected { Self::new_reserved_frz() } else { Self::new_reserved_im() }
     }
 
     /// Default initial permission of a reborrowed shared reference.
@@ -224,6 +251,11 @@ impl Permission {
         Self { inner: Disabled }
     }
 
+    /// Reject `ReservedIM` that cannot exist in the presence of a protector.
+    pub fn compatible_with_protector(&self) -> bool {
+        self.inner.compatible_with_protector()
+    }
+
     /// Apply the transition to the inner PermissionPriv.
     pub fn perform_access(
         kind: AccessKind,
@@ -279,12 +311,9 @@ pub mod diagnostics {
                 f,
                 "{}",
                 match self {
-                    Reserved { ty_is_freeze: true, conflicted: false } => "Reserved",
-                    Reserved { ty_is_freeze: true, conflicted: true } => "Reserved (conflicted)",
-                    Reserved { ty_is_freeze: false, conflicted: false } =>
-                        "Reserved (interior mutable)",
-                    Reserved { ty_is_freeze: false, conflicted: true } =>
-                        "Reserved (interior mutable, conflicted)",
+                    ReservedFrz { conflicted: false } => "Reserved",
+                    ReservedFrz { conflicted: true } => "Reserved (conflicted)",
+                    ReservedIM => "Reserved (interior mutable)",
                     Active => "Active",
                     Frozen => "Frozen",
                     Disabled => "Disabled",
@@ -312,10 +341,9 @@ pub mod diagnostics {
             // and also as `diagnostics::DisplayFmtPermission.uninit` otherwise
             // alignment will be incorrect.
             match self.inner {
-                Reserved { ty_is_freeze: true, conflicted: false } => "Rs  ",
-                Reserved { ty_is_freeze: true, conflicted: true } => "RsC ",
-                Reserved { ty_is_freeze: false, conflicted: false } => "RsM ",
-                Reserved { ty_is_freeze: false, conflicted: true } => "RsCM",
+                ReservedFrz { conflicted: false } => "Res ",
+                ReservedFrz { conflicted: true } => "ResC",
+                ReservedIM => "ReIM",
                 Active => "Act ",
                 Frozen => "Frz ",
                 Disabled => "Dis ",
@@ -325,13 +353,14 @@ pub mod diagnostics {
 
     impl PermTransition {
         /// Readable explanation of the consequences of an event.
-        /// Fits in the sentence "This accessed caused {trans.summary()}".
+        /// Fits in the sentence "This transition corresponds to {trans.summary()}".
         pub fn summary(&self) -> &'static str {
             assert!(self.is_possible());
+            assert!(!self.is_noop());
             match (self.from, self.to) {
                 (_, Active) => "the first write to a 2-phase borrowed mutable reference",
                 (_, Frozen) => "a loss of write permissions",
-                (Reserved { conflicted: false, .. }, Reserved { conflicted: true, .. }) =>
+                (ReservedFrz { conflicted: false }, ReservedFrz { conflicted: true }) =>
                     "a temporary loss of write permissions until function exit",
                 (Frozen, Disabled) => "a loss of read permissions",
                 (_, Disabled) => "a loss of read and write permissions",
@@ -380,28 +409,33 @@ pub mod diagnostics {
                         (Frozen, Frozen) => true,
                         (Active, Frozen) => true,
                         (Disabled, Disabled) => true,
-                        (Reserved { conflicted: true, .. }, Reserved { conflicted: true, .. }) =>
-                            true,
+                        (
+                            ReservedFrz { conflicted: true, .. },
+                            ReservedFrz { conflicted: true, .. },
+                        ) => true,
                         // A pointer being `Disabled` is a strictly stronger source of
                         // errors than it being `Frozen`. If we try to access a `Disabled`,
                         // then where it became `Frozen` (or `Active` or `Reserved`) is the least
                         // of our concerns for now.
-                        (Reserved { conflicted: true, .. } | Active | Frozen, Disabled) => false,
-                        (Reserved { conflicted: true, .. }, Frozen) => false,
+                        (ReservedFrz { conflicted: true } | Active | Frozen, Disabled) => false,
+                        (ReservedFrz { conflicted: true }, Frozen) => false,
 
                         // `Active` and `Reserved` have all permissions, so a
                         // `ChildAccessForbidden(Reserved | Active)` can never exist.
-                        (_, Active) | (_, Reserved { conflicted: false, .. }) =>
+                        (_, Active) | (_, ReservedFrz { conflicted: false }) =>
                             unreachable!("this permission cannot cause an error"),
-                        // No transition has `Reserved(conflicted=false)` as its `.to` unless it's a noop.
-                        (Reserved { conflicted: false, .. }, _) =>
+                        // No transition has `Reserved { conflicted: false }` or `ReservedIM`
+                        // as its `.to` unless it's a noop.
+                        (ReservedFrz { conflicted: false } | ReservedIM, _) =>
                             unreachable!("self is a noop transition"),
                         // All transitions produced in normal executions (using `apply_access`)
                         // change permissions in the order `Reserved -> Active -> Frozen -> Disabled`.
                         // We assume that the error was triggered on the same location that
                         // the transition `self` applies to, so permissions found must be increasing
                         // in the order `self.from < self.to <= insufficient.inner`
-                        (Active | Frozen | Disabled, Reserved { .. }) | (Disabled, Frozen) =>
+                        (Active | Frozen | Disabled, ReservedFrz { .. } | ReservedIM)
+                        | (Disabled, Frozen)
+                        | (ReservedFrz { .. }, ReservedIM) =>
                             unreachable!("permissions between self and err must be increasing"),
                     }
                 }
@@ -415,8 +449,10 @@ pub mod diagnostics {
                         // conflicted.
                         (Active, Active) => true,
                         (Frozen, Frozen) => true,
-                        (Reserved { conflicted: true, .. }, Reserved { conflicted: true, .. }) =>
-                            true,
+                        (
+                            ReservedFrz { conflicted: true, .. },
+                            ReservedFrz { conflicted: true, .. },
+                        ) => true,
                         // If the error is a transition `Frozen -> Disabled`, then we don't really
                         // care whether before that was `Reserved -> Active -> Frozen` or
                         // `Frozen` directly.
@@ -429,23 +465,23 @@ pub mod diagnostics {
                         //   -> Reserved { conflicted: true }` is inexistant or irrelevant,
                         // and so is the `Reserved { conflicted: false } -> Active`
                         (Active, Frozen) => false,
-                        (Reserved { conflicted: true, .. }, _) => false,
+                        (ReservedFrz { conflicted: true }, _) => false,
 
                         (_, Disabled) =>
                             unreachable!(
                                 "permission that results in Disabled should not itself be Disabled in the first place"
                             ),
-                        // No transition has `Reserved { conflicted: false }` as its `.to`
+                        // No transition has `Reserved { conflicted: false }` or `ReservedIM` as its `.to`
                         // unless it's a noop.
-                        (Reserved { conflicted: false, .. }, _) =>
+                        (ReservedFrz { conflicted: false } | ReservedIM, _) =>
                             unreachable!("self is a noop transition"),
 
                         // Permissions only evolve in the order `Reserved -> Active -> Frozen -> Disabled`,
                         // so permissions found must be increasing in the order
                         // `self.from < self.to <= forbidden.from < forbidden.to`.
-                        (Disabled, Reserved { .. } | Active | Frozen)
-                        | (Frozen, Reserved { .. } | Active)
-                        | (Active, Reserved { .. }) =>
+                        (Disabled, ReservedFrz { .. } | ReservedIM | Active | Frozen)
+                        | (Frozen, ReservedFrz { .. } | ReservedIM | Active)
+                        | (Active, ReservedFrz { .. } | ReservedIM) =>
                             unreachable!("permissions between self and err must be increasing"),
                     }
                 }
@@ -466,9 +502,9 @@ pub mod diagnostics {
 
 #[cfg(test)]
 impl Permission {
-    pub fn is_reserved_with_conflicted(&self, expected_conflicted: bool) -> bool {
+    pub fn is_reserved_frz_with_conflicted(&self, expected_conflicted: bool) -> bool {
         match self.inner {
-            Reserved { conflicted, .. } => conflicted == expected_conflicted,
+            ReservedFrz { conflicted } => conflicted == expected_conflicted,
             _ => false,
         }
     }
@@ -482,10 +518,9 @@ mod propagation_optimization_checks {
     impl Exhaustive for PermissionPriv {
         fn exhaustive() -> Box<dyn Iterator<Item = Self>> {
             Box::new(
-                vec![Active, Frozen, Disabled].into_iter().chain(
-                    <[bool; 2]>::exhaustive()
-                        .map(|[ty_is_freeze, conflicted]| Reserved { ty_is_freeze, conflicted }),
-                ),
+                vec![Active, Frozen, Disabled, ReservedIM]
+                    .into_iter()
+                    .chain(<bool>::exhaustive().map(|conflicted| ReservedFrz { conflicted })),
             )
         }
     }
@@ -525,6 +560,9 @@ mod propagation_optimization_checks {
                 // We thus eliminate from this test and all other tests
                 // the case where the tag is initially unprotected and later becomes protected.
                 precondition!(old_protected || !new_protected);
+                if old_protected {
+                    precondition!(old.compatible_with_protector());
+                }
                 for (access, rel_pos) in <(AccessKind, AccessRelatedness)>::exhaustive() {
                     if let Some(new) = perform_access(access, rel_pos, old, old_protected) {
                         assert_eq!(
@@ -546,6 +584,9 @@ mod propagation_optimization_checks {
         for old in PermissionPriv::exhaustive() {
             for [old_protected, new_protected] in <[bool; 2]>::exhaustive() {
                 precondition!(old_protected || !new_protected);
+                if old_protected {
+                    precondition!(old.compatible_with_protector());
+                }
                 for rel_pos in AccessRelatedness::exhaustive() {
                     precondition!(rel_pos.is_foreign());
                     if let Some(new) = perform_access(old_access, rel_pos, old, old_protected) {
@@ -570,6 +611,9 @@ mod propagation_optimization_checks {
                 reach.insert((start, start));
                 for (access, rel) in <(AccessKind, AccessRelatedness)>::exhaustive() {
                     for prot in bool::exhaustive() {
+                        if prot {
+                            precondition!(start.compatible_with_protector());
+                        }
                         if let Some(end) = transition::perform_access(access, rel, start, prot) {
                             reach.insert((start, end));
                         }
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/tree/tests.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/tree/tests.rs
index 73717014e8995..654419c099d3c 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/tree/tests.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/tree/tests.rs
@@ -14,6 +14,15 @@ impl Exhaustive for LocationState {
     }
 }
 
+impl LocationState {
+    /// Ensure that the current internal state can exist at the same time as a protector.
+    /// In practice this only eliminates `ReservedIM` that is never used in the presence
+    /// of a protector (we instead emit `ReservedFrz` on retag).
+    pub fn compatible_with_protector(&self) -> bool {
+        self.permission.compatible_with_protector()
+    }
+}
+
 #[test]
 #[rustfmt::skip]
 // Exhaustive check that for any starting configuration loc,
@@ -30,6 +39,9 @@ fn all_read_accesses_commute() {
         // so the two read accesses occur under the same protector.
         for protected in bool::exhaustive() {
             for loc in LocationState::exhaustive() {
+                if protected {
+                    precondition!(loc.compatible_with_protector());
+                }
                 // Apply 1 then 2. Failure here means that there is UB in the source
                 // and we skip the check in the target.
                 let mut loc12 = loc;
@@ -61,8 +73,8 @@ fn protected_enforces_noalias() {
         // We want to check pairs of accesses where one is foreign and one is not.
         precondition!(rel1.is_foreign() != rel2.is_foreign());
         for [kind1, kind2] in <[AccessKind; 2]>::exhaustive() {
-            for mut state in LocationState::exhaustive() {
-                let protected = true;
+            let protected = true;
+            for mut state in LocationState::exhaustive().filter(|s| s.compatible_with_protector()) {
                 precondition!(state.perform_access(kind1, rel1, protected).is_ok());
                 precondition!(state.perform_access(kind2, rel2, protected).is_ok());
                 // If these were both allowed, it must have been two reads.
@@ -387,6 +399,9 @@ mod spurious_read {
 
         fn retag_y(self, new_y: LocStateProt) -> Result<Self, ()> {
             assert!(new_y.is_initial());
+            if new_y.prot && !new_y.state.compatible_with_protector() {
+                return Err(());
+            }
             // `xy_rel` changes to "mutually foreign" now: `y` can no longer be a parent of `x`.
             Self { y: new_y, xy_rel: RelPosXY::MutuallyForeign, ..self }
                 .read_if_initialized(PtrSelector::Y)
@@ -511,7 +526,7 @@ mod spurious_read {
     }
 
     #[test]
-    // `Reserved(aliased=false)` and `Reserved(aliased=true)` are properly indistinguishable
+    // `Reserved { conflicted: false }` and `Reserved { conflicted: true }` are properly indistinguishable
     // under the conditions where we want to insert a spurious read.
     fn reserved_aliased_protected_indistinguishable() {
         let source = LocStateProtPair {
@@ -521,14 +536,16 @@ mod spurious_read {
                 prot: true,
             },
             y: LocStateProt {
-                state: LocationState::new_uninit(Permission::new_reserved(false)),
+                state: LocationState::new_uninit(Permission::new_reserved(
+                    /* freeze */ true, /* protected */ true,
+                )),
                 prot: true,
             },
         };
         let acc = TestAccess { ptr: PtrSelector::X, kind: AccessKind::Read };
         let target = source.clone().perform_test_access(&acc).unwrap();
-        assert!(source.y.state.permission.is_reserved_with_conflicted(false));
-        assert!(target.y.state.permission.is_reserved_with_conflicted(true));
+        assert!(source.y.state.permission.is_reserved_frz_with_conflicted(false));
+        assert!(target.y.state.permission.is_reserved_frz_with_conflicted(true));
         assert!(!source.distinguishable::<(), ()>(&target))
     }
 
@@ -563,7 +580,13 @@ mod spurious_read {
                     precondition!(x_retag_perm.initialized);
                     // And `x` just got retagged, so it must be initial.
                     precondition!(x_retag_perm.permission.is_initial());
+                    // As stated earlier, `x` is always protected in the patterns we consider here.
+                    precondition!(x_retag_perm.compatible_with_protector());
                     for y_protected in bool::exhaustive() {
+                        // Finally `y` that is optionally protected must have a compatible permission.
+                        if y_protected {
+                            precondition!(y_current_perm.compatible_with_protector());
+                        }
                         v.push(Pattern { xy_rel, x_retag_perm, y_current_perm, y_protected });
                     }
                 }
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 ce9a5b7f15865..133a50938f281 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
@@ -2,11 +2,11 @@
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| RsM |      └─┬──<TAG=base>
-| RsM |        ├─┬──<TAG=x>
-| RsM |        │ └─┬──<TAG=caller:x>
-| Rs  |        │   └────<TAG=callee:x> Strongly protected
-| RsM |        └────<TAG=y, callee:y, caller:y>
+| ReIM|      └─┬──<TAG=base>
+| ReIM|        ├─┬──<TAG=x>
+| ReIM|        │ └─┬──<TAG=caller:x>
+| Res |        │   └────<TAG=callee:x> Strongly protected
+| ReIM|        └────<TAG=y, callee:y, caller:y>
 ──────────────────────────────────────────────────
 error: Undefined Behavior: write access through <TAG> (y, callee:y, caller:y) at ALLOC[0x0] is forbidden
   --> $DIR/cell-protected-write.rs:LL:CC
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 41559587bda33..a4dc123979edf 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
@@ -2,11 +2,11 @@
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| Rs  |      └─┬──<TAG=n>
-| Rs  |        ├─┬──<TAG=x>
-| Rs  |        │ └─┬──<TAG=caller:x>
-| Rs  |        │   └────<TAG=callee:x> Strongly protected
-| Rs  |        └────<TAG=y, callee:y, caller:y>
+| Res |      └─┬──<TAG=n>
+| Res |        ├─┬──<TAG=x>
+| Res |        │ └─┬──<TAG=caller:x>
+| Res |        │   └────<TAG=callee:x> Strongly protected
+| Res |        └────<TAG=y, callee:y, caller:y>
 ──────────────────────────────────────────────────
 error: Undefined Behavior: write access through <TAG> (y, callee:y, caller:y) at ALLOC[0x0] is forbidden
   --> $DIR/int-protected-write.rs:LL:CC
diff --git a/src/tools/miri/tests/pass/tree_borrows/cell-alternate-writes.stderr b/src/tools/miri/tests/pass/tree_borrows/cell-alternate-writes.stderr
index 57caa09c88836..d13e9ad0215bc 100644
--- a/src/tools/miri/tests/pass/tree_borrows/cell-alternate-writes.stderr
+++ b/src/tools/miri/tests/pass/tree_borrows/cell-alternate-writes.stderr
@@ -2,7 +2,7 @@
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| RsM |      └────<TAG=data, x, y>
+| ReIM|      └────<TAG=data, x, y>
 ──────────────────────────────────────────────────
 ──────────────────────────────────────────────────
 Warning: this tree is indicative only. Some tags may have been hidden.
diff --git a/src/tools/miri/tests/pass/tree_borrows/end-of-protector.stderr b/src/tools/miri/tests/pass/tree_borrows/end-of-protector.stderr
index 69b8a17dc5e12..4d77d96776d31 100644
--- a/src/tools/miri/tests/pass/tree_borrows/end-of-protector.stderr
+++ b/src/tools/miri/tests/pass/tree_borrows/end-of-protector.stderr
@@ -2,27 +2,27 @@
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| Rs  |      └─┬──<TAG=data>
-| Rs  |        └────<TAG=x>
+| Res |      └─┬──<TAG=data>
+| Res |        └────<TAG=x>
 ──────────────────────────────────────────────────
 ──────────────────────────────────────────────────
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| Rs  |      └─┬──<TAG=data>
-| Rs  |        └─┬──<TAG=x>
-| Rs  |          └─┬──<TAG=caller:x>
-| Rs  |            └────<TAG=callee:x> Strongly protected
+| Res |      └─┬──<TAG=data>
+| Res |        └─┬──<TAG=x>
+| Res |          └─┬──<TAG=caller:x>
+| Res |            └────<TAG=callee:x> Strongly protected
 ──────────────────────────────────────────────────
 ──────────────────────────────────────────────────
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| Rs  |      └─┬──<TAG=data>
-| Rs  |        ├─┬──<TAG=x>
-| Rs  |        │ └─┬──<TAG=caller:x>
-| Rs  |        │   └────<TAG=callee:x>
-| Rs  |        └────<TAG=y>
+| Res |      └─┬──<TAG=data>
+| Res |        ├─┬──<TAG=x>
+| Res |        │ └─┬──<TAG=caller:x>
+| Res |        │   └────<TAG=callee:x>
+| Res |        └────<TAG=y>
 ──────────────────────────────────────────────────
 ──────────────────────────────────────────────────
 Warning: this tree is indicative only. Some tags may have been hidden.
diff --git a/src/tools/miri/tests/pass/tree_borrows/formatting.stderr b/src/tools/miri/tests/pass/tree_borrows/formatting.stderr
index 235ab68fe0178..29f99034bab5c 100644
--- a/src/tools/miri/tests/pass/tree_borrows/formatting.stderr
+++ b/src/tools/miri/tests/pass/tree_borrows/formatting.stderr
@@ -2,7 +2,7 @@
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1..   2..  10..  11.. 100.. 101..1000..1001..1024
 | Act | Act | Act | Act | Act | Act | Act | Act | Act |    └─┬──<TAG=root of the allocation>
-| Rs  | Act | Rs  | Act | Rs  | Act | Rs  | Act | Rs  |      └─┬──<TAG=data, data>
+| Res | Act | Res | Act | Res | Act | Res | Act | Res |      └─┬──<TAG=data, data>
 |-----| Act |-----|?Dis |-----|?Dis |-----|?Dis |-----|        ├────<TAG=data[1]>
 |-----|-----|-----| Act |-----|?Dis |-----|?Dis |-----|        ├────<TAG=data[10]>
 |-----|-----|-----|-----|-----| Frz |-----|?Dis |-----|        ├────<TAG=data[100]>
diff --git a/src/tools/miri/tests/pass/tree_borrows/reborrow-is-read.stderr b/src/tools/miri/tests/pass/tree_borrows/reborrow-is-read.stderr
index f09aa52f1a10a..d589a06211182 100644
--- a/src/tools/miri/tests/pass/tree_borrows/reborrow-is-read.stderr
+++ b/src/tools/miri/tests/pass/tree_borrows/reborrow-is-read.stderr
@@ -11,5 +11,5 @@ Warning: this tree is indicative only. Some tags may have been hidden.
 | Act |    └─┬──<TAG=root of the allocation>
 | Act |      └─┬──<TAG=parent>
 | Frz |        ├────<TAG=x>
-| Rs  |        └────<TAG=y>
+| Res |        └────<TAG=y>
 ──────────────────────────────────────────────────
diff --git a/src/tools/miri/tests/pass/tree_borrows/reserved.stderr b/src/tools/miri/tests/pass/tree_borrows/reserved.stderr
index d149a4065f92b..be90382640b4a 100644
--- a/src/tools/miri/tests/pass/tree_borrows/reserved.stderr
+++ b/src/tools/miri/tests/pass/tree_borrows/reserved.stderr
@@ -3,20 +3,20 @@
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| RsM |      └─┬──<TAG=base>
-| RsM |        ├─┬──<TAG=x>
-| RsM |        │ └─┬──<TAG=caller:x>
-| RsC |        │   └────<TAG=callee:x>
-| RsM |        └────<TAG=y, caller:y, callee:y>
+| ReIM|      └─┬──<TAG=base>
+| ReIM|        ├─┬──<TAG=x>
+| ReIM|        │ └─┬──<TAG=caller:x>
+| ResC|        │   └────<TAG=callee:x>
+| ReIM|        └────<TAG=y, caller:y, callee:y>
 ──────────────────────────────────────────────────
 [interior mut] Foreign Read: Re* -> Re*
 ──────────────────────────────────────────────────
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   8
 | Act |    └─┬──<TAG=root of the allocation>
-| RsM |      └─┬──<TAG=base>
-| RsM |        ├────<TAG=x>
-| RsM |        └────<TAG=y>
+| ReIM|      └─┬──<TAG=base>
+| ReIM|        ├────<TAG=x>
+| ReIM|        └────<TAG=y>
 ──────────────────────────────────────────────────
 [interior mut] Foreign Write: Re* -> Re*
 ──────────────────────────────────────────────────
@@ -24,7 +24,7 @@ Warning: this tree is indicative only. Some tags may have been hidden.
 0..   8
 | Act |    └─┬──<TAG=root of the allocation>
 | Act |      └─┬──<TAG=base>
-| RsM |        ├────<TAG=x>
+| ReIM|        ├────<TAG=x>
 | Act |        └────<TAG=y>
 ──────────────────────────────────────────────────
 [protected] Foreign Read: Res -> Frz
@@ -32,20 +32,20 @@ Warning: this tree is indicative only. Some tags may have been hidden.
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| Rs  |      └─┬──<TAG=base>
-| Rs  |        ├─┬──<TAG=x>
-| Rs  |        │ └─┬──<TAG=caller:x>
-| RsC |        │   └────<TAG=callee:x>
-| Rs  |        └────<TAG=y, caller:y, callee:y>
+| Res |      └─┬──<TAG=base>
+| Res |        ├─┬──<TAG=x>
+| Res |        │ └─┬──<TAG=caller:x>
+| ResC|        │   └────<TAG=callee:x>
+| Res |        └────<TAG=y, caller:y, callee:y>
 ──────────────────────────────────────────────────
 [] Foreign Read: Res -> Res
 ──────────────────────────────────────────────────
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| Rs  |      └─┬──<TAG=base>
-| Rs  |        ├────<TAG=x>
-| Rs  |        └────<TAG=y>
+| Res |      └─┬──<TAG=base>
+| Res |        ├────<TAG=x>
+| Res |        └────<TAG=y>
 ──────────────────────────────────────────────────
 [] Foreign Write: Res -> Dis
 ──────────────────────────────────────────────────
diff --git a/src/tools/miri/tests/pass/tree_borrows/unique.default.stderr b/src/tools/miri/tests/pass/tree_borrows/unique.default.stderr
index 6e774e5014d41..6098c855bde72 100644
--- a/src/tools/miri/tests/pass/tree_borrows/unique.default.stderr
+++ b/src/tools/miri/tests/pass/tree_borrows/unique.default.stderr
@@ -2,8 +2,8 @@
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| Rs  |      └─┬──<TAG=base>
-| Rs  |        └────<TAG=raw, uniq, uniq>
+| Res |      └─┬──<TAG=base>
+| Res |        └────<TAG=raw, uniq, uniq>
 ──────────────────────────────────────────────────
 ──────────────────────────────────────────────────
 Warning: this tree is indicative only. Some tags may have been hidden.
diff --git a/src/tools/miri/tests/pass/tree_borrows/unique.uniq.stderr b/src/tools/miri/tests/pass/tree_borrows/unique.uniq.stderr
index 26d9ad2ad3838..960c7e216e1d0 100644
--- a/src/tools/miri/tests/pass/tree_borrows/unique.uniq.stderr
+++ b/src/tools/miri/tests/pass/tree_borrows/unique.uniq.stderr
@@ -2,8 +2,8 @@
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   1
 | Act |    └─┬──<TAG=root of the allocation>
-| Rs  |      └─┬──<TAG=base>
-| Rs  |        └─┬──<TAG=raw>
+| Res |      └─┬──<TAG=base>
+| Res |        └─┬──<TAG=raw>
 |-----|          └────<TAG=uniq, uniq>
 ──────────────────────────────────────────────────
 ──────────────────────────────────────────────────
diff --git a/src/tools/miri/tests/pass/tree_borrows/vec_unique.default.stderr b/src/tools/miri/tests/pass/tree_borrows/vec_unique.default.stderr
index f63aa1f683497..254eba061f45d 100644
--- a/src/tools/miri/tests/pass/tree_borrows/vec_unique.default.stderr
+++ b/src/tools/miri/tests/pass/tree_borrows/vec_unique.default.stderr
@@ -2,5 +2,5 @@
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   2
 | Act |    └─┬──<TAG=root of the allocation>
-| Rs  |      └────<TAG=base.as_ptr(), base.as_ptr(), raw_parts.0, reconstructed.as_ptr(), reconstructed.as_ptr()>
+| Res |      └────<TAG=base.as_ptr(), base.as_ptr(), raw_parts.0, reconstructed.as_ptr(), reconstructed.as_ptr()>
 ──────────────────────────────────────────────────

From 7643ea5b9c241019ecabb29b3d1eb30450dc2412 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 24 Jul 2024 15:14:41 -0400
Subject: [PATCH 013/685] create a new section on pointer to reference
 conversion

also start deduplicating the docs that are getting moved to this
section.
---
 library/core/src/ptr/mod.rs     | 24 ++++++++++++++++++++
 library/core/src/ptr/mut_ptr.rs | 40 ++++-----------------------------
 2 files changed, 28 insertions(+), 36 deletions(-)

diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index f2247e83ec5c5..683f1d57f2259 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -56,6 +56,30 @@
 //! has size 0, i.e., even if memory is not actually touched. Consider using
 //! [`NonNull::dangling`] in such cases.
 //!
+//! ## Pointer to reference conversion
+//! When converting a pointer to a reference using `&*`, there are several
+//! rules that must be followed:
+//! * The pointer must be properly aligned.
+//!
+//! * It must be "dereferenceable" in the sense defined above
+//!
+//! * The pointer must point to an initialized instance of `T`.
+//!
+//! * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
+//!   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
+//!   In particular, while this reference exists, the memory the pointer points to must
+//!   not get accessed (read or written) through any other pointer.
+//!
+//! If a pointer follows all of these rules, it is said to be
+//! *convertable to a reference*.
+//!
+//! These apply even if the result is unused!
+//! (The part about being initialized is not yet fully decided, but until
+//! it is, the only safe approach is to ensure that they are indeed initialized.)
+//!
+//! An example of the implications of the above rules is that an expression such
+//! as `unsafe { &*(0 as *const u8) }` is Immediate Undefined Behavior.
+//!
 //! ## Allocated object
 //!
 //! An *allocated object* is a subset of program memory which is addressable
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
index 904d6c62dcf1e..c88b356ec743c 100644
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -247,24 +247,7 @@ impl<T: ?Sized> *mut T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * The pointer must point to an initialized instance of `T`.
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get mutated (except inside `UnsafeCell`).
-    ///
-    /// This applies even if the result of this method is unused!
-    /// (The part about being initialized is not yet fully decided, but until
-    /// it is, the only safe approach is to ensure that they are indeed initialized.)
-    ///
-    /// [the module documentation]: crate::ptr#safety
+    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
     /// # Examples
     ///
@@ -609,25 +592,10 @@ impl<T: ?Sized> *mut T {
     ///
     /// # Safety
     ///
-    /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * The pointer must point to an initialized instance of `T`.
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get accessed (read or written) through any other pointer.
+    /// When calling this method, you have to ensure that *either*
+    /// the pointer is null *or*
+    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
-    /// This applies even if the result of this method is unused!
-    /// (The part about being initialized is not yet fully decided, but until
-    /// it is, the only safe approach is to ensure that they are indeed initialized.)
-    ///
-    /// [the module documentation]: crate::ptr#safety
     ///
     /// # Examples
     ///

From 1073f97ed8ed11bad047fc0b647ed99b98afb7ca Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Wed, 24 Jul 2024 16:36:33 -0400
Subject: [PATCH 014/685] remove duplicate explanations of the ptr to ref
 conversion rules

---
 library/core/src/ptr/const_ptr.rs | 54 ++---------------------
 library/core/src/ptr/mod.rs       | 34 ++++++++++----
 library/core/src/ptr/mut_ptr.rs   | 73 ++++---------------------------
 library/core/src/ptr/non_null.rs  | 72 +++++-------------------------
 4 files changed, 50 insertions(+), 183 deletions(-)

diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs
index 3e7933e9eec86..8b9f7b57d0053 100644
--- a/library/core/src/ptr/const_ptr.rs
+++ b/library/core/src/ptr/const_ptr.rs
@@ -239,24 +239,7 @@ impl<T: ?Sized> *const T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * The pointer must point to an initialized instance of `T`.
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get mutated (except inside `UnsafeCell`).
-    ///
-    /// This applies even if the result of this method is unused!
-    /// (The part about being initialized is not yet fully decided, but until
-    /// it is, the only safe approach is to ensure that they are indeed initialized.)
-    ///
-    /// [the module documentation]: crate::ptr#safety
+    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
     /// # Examples
     ///
@@ -302,24 +285,8 @@ impl<T: ?Sized> *const T {
     ///
     /// # Safety
     ///
-    /// When calling this method, you have to ensure that all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * The pointer must point to an initialized instance of `T`.
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get mutated (except inside `UnsafeCell`).
-    ///
-    /// This applies even if the result of this method is unused!
-    /// (The part about being initialized is not yet fully decided, but until
-    /// it is, the only safe approach is to ensure that they are indeed initialized.)
-    ///
-    /// [the module documentation]: crate::ptr#safety
+    /// When calling this method, you have to ensure that
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
     /// # Examples
     ///
@@ -350,20 +317,7 @@ impl<T: ?Sized> *const T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get mutated (except inside `UnsafeCell`).
-    ///
-    /// This applies even if the result of this method is unused!
-    ///
-    /// [the module documentation]: crate::ptr#safety
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
     /// # Examples
     ///
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 683f1d57f2259..591705a69fdee 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -57,21 +57,39 @@
 //! [`NonNull::dangling`] in such cases.
 //!
 //! ## Pointer to reference conversion
-//! When converting a pointer to a reference using `&*`, there are several
-//! rules that must be followed:
+//! When converting a pointer to a reference `&T` using `&*`,
+//! there are several rules that must be followed:
+//!
 //! * The pointer must be properly aligned.
 //!
-//! * It must be "dereferenceable" in the sense defined above
+// some microprocessors may use address 0 for an interrupt vector.
+// users of these microprocessors must always read/write address 0 through
+// a raw pointer, not a reference.
+//! * It must be non-null.
+//!
+//! * It must be "dereferenceable" in the sense defined above.
 //!
-//! * The pointer must point to an initialized instance of `T`.
+//! * The pointer must point to a valid instance of `T`.
+//!   This means that the created reference can only refer to
+//!   uninitialized memory through careful use of `MaybeUninit`.
 //!
-//! * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-//!   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-//!   In particular, while this reference exists, the memory the pointer points to must
-//!   not get accessed (read or written) through any other pointer.
+//! * You must enforce Rust's aliasing rules, since the lifetime of the
+//!   created reference is arbitrarily chosen,
+//!   and does not necessarily reflect the actual lifetime of the data.
+//!   In particular, while this reference exists,
+//!   the memory the pointer points to must
+//!   not get accessed (read or written) through any raw pointer,
+//!   except for data inside an `UnsafeCell`
+// ^ previous documentation was somewhat unclear on if modifications through
+// an UnsafeCell are safe even if they would seemingly violate the exclusivity
+// of a mut ref.
 //!
 //! If a pointer follows all of these rules, it is said to be
 //! *convertable to a reference*.
+// ^ we use this term instead of saying that the produced reference must
+// be valid, as the validity of a reference is easily confused for the
+// validity of the thing it refers to, and while the two concepts are
+// closly related, they are not identical.
 //!
 //! These apply even if the result is unused!
 //! (The part about being initialized is not yet fully decided, but until
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
index c88b356ec743c..fb393ffadd5cd 100644
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -296,24 +296,7 @@ impl<T: ?Sized> *mut T {
     ///
     /// # Safety
     ///
-    /// When calling this method, you have to ensure that all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * The pointer must point to an initialized instance of `T`.
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get mutated (except inside `UnsafeCell`).
-    ///
-    /// This applies even if the result of this method is unused!
-    /// (The part about being initialized is not yet fully decided, but until
-    /// it is, the only safe approach is to ensure that they are indeed initialized.)
-    ///
-    /// [the module documentation]: crate::ptr#safety
+    /// When calling this method, you have to ensure that the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
     /// # Examples
     ///
@@ -347,20 +330,9 @@ impl<T: ?Sized> *mut T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get mutated (except inside `UnsafeCell`).
-    ///
-    /// This applies even if the result of this method is unused!
-    ///
-    /// [the module documentation]: crate::ptr#safety
+    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion).
+    /// Note that because the created reference is to `MaybeUninit<T>`, the
+    /// source pointer can point to uninitialized memory.
     ///
     /// # Examples
     ///
@@ -594,7 +566,7 @@ impl<T: ?Sized> *mut T {
     ///
     /// When calling this method, you have to ensure that *either*
     /// the pointer is null *or*
-    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
     ///
     /// # Examples
@@ -643,24 +615,8 @@ impl<T: ?Sized> *mut T {
     ///
     /// # Safety
     ///
-    /// When calling this method, you have to ensure that all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * The pointer must point to an initialized instance of `T`.
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get mutated (except inside `UnsafeCell`).
-    ///
-    /// This applies even if the result of this method is unused!
-    /// (The part about being initialized is not yet fully decided, but until
-    /// it is, the only safe approach is to ensure that they are indeed initialized.)
-    ///
-    /// [the module documentation]: crate::ptr#safety
+    /// When calling this method, you have to ensure that
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
     /// # Examples
     ///
@@ -695,20 +651,7 @@ impl<T: ?Sized> *mut T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get accessed (read or written) through any other pointer.
-    ///
-    /// This applies even if the result of this method is unused!
-    ///
-    /// [the module documentation]: crate::ptr#safety
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
     #[inline]
     #[unstable(feature = "ptr_as_uninit", issue = "75402")]
     #[rustc_const_unstable(feature = "const_ptr_as_ref", issue = "91822")]
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index 796c85d0cacc7..1e1cf780c28f0 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -128,20 +128,10 @@ impl<T: Sized> NonNull<T> {
     ///
     /// # Safety
     ///
-    /// When calling this method, you have to ensure that all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get mutated (except inside `UnsafeCell`).
-    ///
-    /// This applies even if the result of this method is unused!
-    ///
-    /// [the module documentation]: crate::ptr#safety
+    /// When calling this method, you have to ensure that
+    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion).
+    /// Note that because the created reference is to `MaybeUninit<T>`, the
+    /// source pointer can point to uninitialized memory.
     #[inline]
     #[must_use]
     #[unstable(feature = "ptr_as_uninit", issue = "75402")]
@@ -162,20 +152,10 @@ impl<T: Sized> NonNull<T> {
     ///
     /// # Safety
     ///
-    /// When calling this method, you have to ensure that all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get accessed (read or written) through any other pointer.
-    ///
-    /// This applies even if the result of this method is unused!
-    ///
-    /// [the module documentation]: crate::ptr#safety
+    /// When calling this method, you have to ensure that
+    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion).
+    /// Note that because the created reference is to `MaybeUninit<T>`, the
+    /// source pointer can point to uninitialized memory.
     #[inline]
     #[must_use]
     #[unstable(feature = "ptr_as_uninit", issue = "75402")]
@@ -361,22 +341,8 @@ impl<T: ?Sized> NonNull<T> {
     ///
     /// # Safety
     ///
-    /// When calling this method, you have to ensure that all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * The pointer must point to an initialized instance of `T`.
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get mutated (except inside `UnsafeCell`).
-    ///
-    /// This applies even if the result of this method is unused!
-    /// (The part about being initialized is not yet fully decided, but until
-    /// it is, the only safe approach is to ensure that they are indeed initialized.)
+    /// When calling this method, you have to ensure that
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
     /// # Examples
     ///
@@ -412,22 +378,8 @@ impl<T: ?Sized> NonNull<T> {
     ///
     /// # Safety
     ///
-    /// When calling this method, you have to ensure that all of the following is true:
-    ///
-    /// * The pointer must be properly aligned.
-    ///
-    /// * It must be "dereferenceable" in the sense defined in [the module documentation].
-    ///
-    /// * The pointer must point to an initialized instance of `T`.
-    ///
-    /// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
-    ///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
-    ///   In particular, while this reference exists, the memory the pointer points to must
-    ///   not get accessed (read or written) through any other pointer.
-    ///
-    /// This applies even if the result of this method is unused!
-    /// (The part about being initialized is not yet fully decided, but until
-    /// it is, the only safe approach is to ensure that they are indeed initialized.)
+    /// When calling this method, you have to ensure that
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
     /// # Examples
     ///
     /// ```

From 3877a7bcf3176740b49c94a137b233e88ce0a401 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 25 Jul 2024 11:53:07 -0400
Subject: [PATCH 015/685] clarify interactions with MaybeUninit and UnsafeCell

---
 library/core/src/ptr/mod.rs | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 591705a69fdee..b2fb365d22745 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -69,9 +69,12 @@
 //!
 //! * It must be "dereferenceable" in the sense defined above.
 //!
-//! * The pointer must point to a valid instance of `T`.
+//! * The pointer must point to a valid value of type `T`.
 //!   This means that the created reference can only refer to
-//!   uninitialized memory through careful use of `MaybeUninit`.
+//!   uninitialized memory through careful use of `MaybeUninit`,
+//!   or if the uninitialized memory is entirly contained within
+//!   padding bytes, since
+//!   [padding has the same validity invariant as `MaybeUninit`][ucg-pad].
 //!
 //! * You must enforce Rust's aliasing rules, since the lifetime of the
 //!   created reference is arbitrarily chosen,
@@ -79,10 +82,9 @@
 //!   In particular, while this reference exists,
 //!   the memory the pointer points to must
 //!   not get accessed (read or written) through any raw pointer,
-//!   except for data inside an `UnsafeCell`
-// ^ previous documentation was somewhat unclear on if modifications through
-// an UnsafeCell are safe even if they would seemingly violate the exclusivity
-// of a mut ref.
+//!   except for data inside an `UnsafeCell`.
+//!   Note that aliased writes are always UB for mutable references,
+//!   even if they only modify `UnsafeCell` data.
 //!
 //! If a pointer follows all of these rules, it is said to be
 //! *convertable to a reference*.
@@ -98,6 +100,8 @@
 //! An example of the implications of the above rules is that an expression such
 //! as `unsafe { &*(0 as *const u8) }` is Immediate Undefined Behavior.
 //!
+//! [ucgpad]: https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#padding
+//!
 //! ## Allocated object
 //!
 //! An *allocated object* is a subset of program memory which is addressable

From 760c3fab4f0acff98ee32f05a0726c88e11fe814 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 26 Jul 2024 11:12:35 +0200
Subject: [PATCH 016/685] Fix case where `doc_markdown` is triggered on words
 ending with "ified"

---
 clippy_lints/src/doc/markdown.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/clippy_lints/src/doc/markdown.rs b/clippy_lints/src/doc/markdown.rs
index 41c0bcd55adca..237badb3f233c 100644
--- a/clippy_lints/src/doc/markdown.rs
+++ b/clippy_lints/src/doc/markdown.rs
@@ -92,6 +92,10 @@ fn check_word(cx: &LateContext<'_>, word: &str, span: Span, code_level: isize, b
             && matches!(prefix.chars().last(), Some('S' | 'X'))
         {
             prefix
+        } else if let Some(prefix) = s.strip_suffix("ified")
+            && prefix.chars().all(|c| c.is_ascii_uppercase())
+        {
+            prefix
         } else {
             s.strip_suffix('s').unwrap_or(s)
         };

From 88506a9147172ff233f820451982e9514aee3476 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Fri, 26 Jul 2024 11:12:59 +0200
Subject: [PATCH 017/685] Add regression test for #13097

---
 tests/ui/doc/doc_markdown-issue_13097.fixed  | 13 +++++++++++++
 tests/ui/doc/doc_markdown-issue_13097.rs     | 13 +++++++++++++
 tests/ui/doc/doc_markdown-issue_13097.stderr | 18 ++++++++++++++++++
 3 files changed, 44 insertions(+)
 create mode 100644 tests/ui/doc/doc_markdown-issue_13097.fixed
 create mode 100644 tests/ui/doc/doc_markdown-issue_13097.rs
 create mode 100644 tests/ui/doc/doc_markdown-issue_13097.stderr

diff --git a/tests/ui/doc/doc_markdown-issue_13097.fixed b/tests/ui/doc/doc_markdown-issue_13097.fixed
new file mode 100644
index 0000000000000..fb0f40b34a4b8
--- /dev/null
+++ b/tests/ui/doc/doc_markdown-issue_13097.fixed
@@ -0,0 +1,13 @@
+// This test checks that words starting with capital letters and ending with "ified" don't
+// trigger the lint.
+
+#![deny(clippy::doc_markdown)]
+
+pub enum OutputFormat {
+    /// `HumaNified`
+    //~^ ERROR: item in documentation is missing backticks
+    Plain,
+    // Should not warn!
+    /// JSONified console output
+    Json,
+}
diff --git a/tests/ui/doc/doc_markdown-issue_13097.rs b/tests/ui/doc/doc_markdown-issue_13097.rs
new file mode 100644
index 0000000000000..8c1e1a3cd6c24
--- /dev/null
+++ b/tests/ui/doc/doc_markdown-issue_13097.rs
@@ -0,0 +1,13 @@
+// This test checks that words starting with capital letters and ending with "ified" don't
+// trigger the lint.
+
+#![deny(clippy::doc_markdown)]
+
+pub enum OutputFormat {
+    /// HumaNified
+    //~^ ERROR: item in documentation is missing backticks
+    Plain,
+    // Should not warn!
+    /// JSONified console output
+    Json,
+}
diff --git a/tests/ui/doc/doc_markdown-issue_13097.stderr b/tests/ui/doc/doc_markdown-issue_13097.stderr
new file mode 100644
index 0000000000000..ae68a767ec930
--- /dev/null
+++ b/tests/ui/doc/doc_markdown-issue_13097.stderr
@@ -0,0 +1,18 @@
+error: item in documentation is missing backticks
+  --> tests/ui/doc/doc_markdown-issue_13097.rs:7:9
+   |
+LL |     /// HumaNified
+   |         ^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> tests/ui/doc/doc_markdown-issue_13097.rs:4:9
+   |
+LL | #![deny(clippy::doc_markdown)]
+   |         ^^^^^^^^^^^^^^^^^^^^
+help: try
+   |
+LL |     /// `HumaNified`
+   |         ~~~~~~~~~~~~
+
+error: aborting due to 1 previous error
+

From 855a9d1377a2da3e4566de9adb8b783295a771dd Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Mon, 24 Jun 2024 18:42:23 +0200
Subject: [PATCH 018/685] Add new `too_long_first_doc_paragraph` first
 paragraph lint

---
 CHANGELOG.md                                  |   1 +
 clippy_lints/src/declared_lints.rs            |   1 +
 clippy_lints/src/doc/mod.rs                   | 113 +++++++++++++-----
 .../src/doc/too_long_first_doc_paragraph.rs   |  85 +++++++++++++
 .../ui/too_long_first_doc_paragraph-fix.fixed |   8 ++
 tests/ui/too_long_first_doc_paragraph-fix.rs  |   7 ++
 .../too_long_first_doc_paragraph-fix.stderr   |  19 +++
 tests/ui/too_long_first_doc_paragraph.rs      |  47 ++++++++
 tests/ui/too_long_first_doc_paragraph.stderr  |  22 ++++
 9 files changed, 270 insertions(+), 33 deletions(-)
 create mode 100644 clippy_lints/src/doc/too_long_first_doc_paragraph.rs
 create mode 100644 tests/ui/too_long_first_doc_paragraph-fix.fixed
 create mode 100644 tests/ui/too_long_first_doc_paragraph-fix.rs
 create mode 100644 tests/ui/too_long_first_doc_paragraph-fix.stderr
 create mode 100644 tests/ui/too_long_first_doc_paragraph.rs
 create mode 100644 tests/ui/too_long_first_doc_paragraph.stderr

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 60c03b03d9be3..ca70da5bb5170 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5913,6 +5913,7 @@ Released 2018-09-13
 [`to_string_in_format_args`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_in_format_args
 [`to_string_trait_impl`]: https://rust-lang.github.io/rust-clippy/master/index.html#to_string_trait_impl
 [`todo`]: https://rust-lang.github.io/rust-clippy/master/index.html#todo
+[`too_long_first_doc_paragraph`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_long_first_doc_paragraph
 [`too_many_arguments`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
 [`too_many_lines`]: https://rust-lang.github.io/rust-clippy/master/index.html#too_many_lines
 [`toplevel_ref_arg`]: https://rust-lang.github.io/rust-clippy/master/index.html#toplevel_ref_arg
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 69f9eb6842bcd..2933a65a71f58 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -148,6 +148,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::doc::NEEDLESS_DOCTEST_MAIN_INFO,
     crate::doc::SUSPICIOUS_DOC_COMMENTS_INFO,
     crate::doc::TEST_ATTR_IN_DOCTEST_INFO,
+    crate::doc::TOO_LONG_FIRST_DOC_PARAGRAPH_INFO,
     crate::doc::UNNECESSARY_SAFETY_DOC_INFO,
     crate::double_parens::DOUBLE_PARENS_INFO,
     crate::drop_forget_ref::DROP_NON_DROP_INFO,
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 5b6a5b08aa94c..5e9fb0162bf80 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -1,4 +1,6 @@
 mod lazy_continuation;
+mod too_long_first_doc_paragraph;
+
 use clippy_config::Conf;
 use clippy_utils::attrs::is_doc_hidden;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
@@ -422,6 +424,38 @@ declare_clippy_lint! {
     "require every line of a paragraph to be indented and marked"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks if the first line in the documentation of items listed in module page is too long.
+    ///
+    /// ### Why is this bad?
+    /// Documentation will show the first paragraph of the doscstring in the summary page of a
+    /// module, so having a nice, short summary in the first paragraph is part of writing good docs.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// /// A very short summary.
+    /// /// A much longer explanation that goes into a lot more detail about
+    /// /// how the thing works, possibly with doclinks and so one,
+    /// /// and probably spanning a many rows.
+    /// struct Foo {}
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// /// A very short summary.
+    /// ///
+    /// /// A much longer explanation that goes into a lot more detail about
+    /// /// how the thing works, possibly with doclinks and so one,
+    /// /// and probably spanning a many rows.
+    /// struct Foo {}
+    /// ```
+    #[clippy::version = "1.81.0"]
+    pub TOO_LONG_FIRST_DOC_PARAGRAPH,
+    style,
+    "ensure that the first line of a documentation paragraph isn't too long"
+}
+
+#[derive(Clone)]
 pub struct Documentation {
     valid_idents: &'static FxHashSet<String>,
     check_private_items: bool,
@@ -448,6 +482,7 @@ impl_lint_pass!(Documentation => [
     SUSPICIOUS_DOC_COMMENTS,
     EMPTY_DOCS,
     DOC_LAZY_CONTINUATION,
+    TOO_LONG_FIRST_DOC_PARAGRAPH,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Documentation {
@@ -457,39 +492,44 @@ impl<'tcx> LateLintPass<'tcx> for Documentation {
         };
 
         match cx.tcx.hir_node(cx.last_node_with_lint_attrs) {
-            Node::Item(item) => match item.kind {
-                ItemKind::Fn(sig, _, body_id) => {
-                    if !(is_entrypoint_fn(cx, item.owner_id.to_def_id()) || in_external_macro(cx.tcx.sess, item.span)) {
-                        let body = cx.tcx.hir().body(body_id);
-
-                        let panic_info = FindPanicUnwrap::find_span(cx, cx.tcx.typeck(item.owner_id), body.value);
-                        missing_headers::check(
+            Node::Item(item) => {
+                too_long_first_doc_paragraph::check(cx, attrs, item.kind, headers.first_paragraph_len);
+                match item.kind {
+                    ItemKind::Fn(sig, _, body_id) => {
+                        if !(is_entrypoint_fn(cx, item.owner_id.to_def_id())
+                            || in_external_macro(cx.tcx.sess, item.span))
+                        {
+                            let body = cx.tcx.hir().body(body_id);
+
+                            let panic_info = FindPanicUnwrap::find_span(cx, cx.tcx.typeck(item.owner_id), body.value);
+                            missing_headers::check(
+                                cx,
+                                item.owner_id,
+                                sig,
+                                headers,
+                                Some(body_id),
+                                panic_info,
+                                self.check_private_items,
+                            );
+                        }
+                    },
+                    ItemKind::Trait(_, unsafety, ..) => match (headers.safety, unsafety) {
+                        (false, Safety::Unsafe) => span_lint(
                             cx,
-                            item.owner_id,
-                            sig,
-                            headers,
-                            Some(body_id),
-                            panic_info,
-                            self.check_private_items,
-                        );
-                    }
-                },
-                ItemKind::Trait(_, unsafety, ..) => match (headers.safety, unsafety) {
-                    (false, Safety::Unsafe) => span_lint(
-                        cx,
-                        MISSING_SAFETY_DOC,
-                        cx.tcx.def_span(item.owner_id),
-                        "docs for unsafe trait missing `# Safety` section",
-                    ),
-                    (true, Safety::Safe) => span_lint(
-                        cx,
-                        UNNECESSARY_SAFETY_DOC,
-                        cx.tcx.def_span(item.owner_id),
-                        "docs for safe trait have unnecessary `# Safety` section",
-                    ),
+                            MISSING_SAFETY_DOC,
+                            cx.tcx.def_span(item.owner_id),
+                            "docs for unsafe trait missing `# Safety` section",
+                        ),
+                        (true, Safety::Safe) => span_lint(
+                            cx,
+                            UNNECESSARY_SAFETY_DOC,
+                            cx.tcx.def_span(item.owner_id),
+                            "docs for safe trait have unnecessary `# Safety` section",
+                        ),
+                        _ => (),
+                    },
                     _ => (),
-                },
-                _ => (),
+                }
             },
             Node::TraitItem(trait_item) => {
                 if let TraitItemKind::Fn(sig, ..) = trait_item.kind
@@ -547,6 +587,7 @@ struct DocHeaders {
     safety: bool,
     errors: bool,
     panics: bool,
+    first_paragraph_len: usize,
 }
 
 /// Does some pre-processing on raw, desugared `#[doc]` attributes such as parsing them and
@@ -586,8 +627,9 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         acc
     });
     doc.pop();
+    let doc = doc.trim();
 
-    if doc.trim().is_empty() {
+    if doc.is_empty() {
         if let Some(span) = span_of_fragments(&fragments) {
             span_lint_and_help(
                 cx,
@@ -611,7 +653,7 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         cx,
         valid_idents,
         parser.into_offset_iter(),
-        &doc,
+        doc,
         Fragments {
             fragments: &fragments,
             doc: &doc,
@@ -653,6 +695,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
     let mut paragraph_range = 0..0;
     let mut code_level = 0;
     let mut blockquote_level = 0;
+    let mut is_first_paragraph = true;
 
     let mut containers = Vec::new();
 
@@ -720,6 +763,10 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                 }
                 ticks_unbalanced = false;
                 paragraph_range = range;
+                if is_first_paragraph {
+                    headers.first_paragraph_len = doc[paragraph_range.clone()].chars().count();
+                    is_first_paragraph = false;
+                }
             },
             End(TagEnd::Heading(_) | TagEnd::Paragraph | TagEnd::Item) => {
                 if let End(TagEnd::Heading(_)) = event {
diff --git a/clippy_lints/src/doc/too_long_first_doc_paragraph.rs b/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
new file mode 100644
index 0000000000000..a5a58b444011a
--- /dev/null
+++ b/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
@@ -0,0 +1,85 @@
+use rustc_ast::ast::Attribute;
+use rustc_errors::Applicability;
+use rustc_hir::ItemKind;
+use rustc_lint::LateContext;
+
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::source::snippet_opt;
+
+use super::TOO_LONG_FIRST_DOC_PARAGRAPH;
+
+pub(super) fn check(
+    cx: &LateContext<'_>,
+    attrs: &[Attribute],
+    item_kind: ItemKind<'_>,
+    mut first_paragraph_len: usize,
+) {
+    if first_paragraph_len <= 100
+        || !matches!(
+            item_kind,
+            ItemKind::Static(..)
+                | ItemKind::Const(..)
+                | ItemKind::Fn(..)
+                | ItemKind::Macro(..)
+                | ItemKind::Mod(..)
+                | ItemKind::TyAlias(..)
+                | ItemKind::Enum(..)
+                | ItemKind::Struct(..)
+                | ItemKind::Union(..)
+                | ItemKind::Trait(..)
+                | ItemKind::TraitAlias(..)
+        )
+    {
+        return;
+    }
+    let mut spans = Vec::new();
+    let mut should_suggest_empty_doc = false;
+
+    for attr in attrs {
+        if let Some(doc) = attr.doc_str() {
+            spans.push(attr.span);
+            let doc = doc.as_str();
+            let doc = doc.trim();
+            if spans.len() == 1 {
+                // We make this suggestion only if the first doc line ends with a punctuation
+                // because if might just need to add an empty line with `///`.
+                should_suggest_empty_doc = doc.ends_with('.') || doc.ends_with('!') || doc.ends_with('?');
+            }
+            let len = doc.chars().count();
+            if len >= first_paragraph_len {
+                break;
+            }
+            first_paragraph_len -= len;
+        }
+    }
+
+    let &[first_span, .., last_span] = spans.as_slice() else { return };
+
+    if should_suggest_empty_doc
+        && let Some(second_span) = spans.get(1)
+        && let new_span = first_span.with_hi(second_span.lo()).with_lo(first_span.hi())
+        && let Some(snippet) = snippet_opt(cx, new_span)
+    {
+        span_lint_and_then(
+            cx,
+            TOO_LONG_FIRST_DOC_PARAGRAPH,
+            first_span.with_hi(last_span.lo()),
+            "first doc comment paragraph is too long",
+            |diag| {
+                diag.span_suggestion(
+                    new_span,
+                    "add",
+                    format!("{snippet}///\n"),
+                    Applicability::MachineApplicable,
+                );
+            },
+        );
+        return;
+    }
+    span_lint(
+        cx,
+        TOO_LONG_FIRST_DOC_PARAGRAPH,
+        first_span.with_hi(last_span.lo()),
+        "first doc comment paragraph is too long",
+    );
+}
diff --git a/tests/ui/too_long_first_doc_paragraph-fix.fixed b/tests/ui/too_long_first_doc_paragraph-fix.fixed
new file mode 100644
index 0000000000000..b3f66f5279384
--- /dev/null
+++ b/tests/ui/too_long_first_doc_paragraph-fix.fixed
@@ -0,0 +1,8 @@
+#![warn(clippy::too_long_first_doc_paragraph)]
+
+/// A very short summary.
+///
+/// A much longer explanation that goes into a lot more detail about
+/// how the thing works, possibly with doclinks and so one,
+/// and probably spanning a many rows.
+struct Foo;
diff --git a/tests/ui/too_long_first_doc_paragraph-fix.rs b/tests/ui/too_long_first_doc_paragraph-fix.rs
new file mode 100644
index 0000000000000..f0ece9523de4b
--- /dev/null
+++ b/tests/ui/too_long_first_doc_paragraph-fix.rs
@@ -0,0 +1,7 @@
+#![warn(clippy::too_long_first_doc_paragraph)]
+
+/// A very short summary.
+/// A much longer explanation that goes into a lot more detail about
+/// how the thing works, possibly with doclinks and so one,
+/// and probably spanning a many rows.
+struct Foo;
diff --git a/tests/ui/too_long_first_doc_paragraph-fix.stderr b/tests/ui/too_long_first_doc_paragraph-fix.stderr
new file mode 100644
index 0000000000000..00949f405d538
--- /dev/null
+++ b/tests/ui/too_long_first_doc_paragraph-fix.stderr
@@ -0,0 +1,19 @@
+error: first doc comment paragraph is too long
+  --> tests/ui/too_long_first_doc_paragraph-fix.rs:3:1
+   |
+LL | / /// A very short summary.
+LL | | /// A much longer explanation that goes into a lot more detail about
+LL | | /// how the thing works, possibly with doclinks and so one,
+LL | | /// and probably spanning a many rows.
+   | |_
+   |
+   = note: `-D clippy::too-long-first-doc-paragraph` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::too_long_first_doc_paragraph)]`
+help: add an empty line
+   |
+LL ~ /// A very short summary.
+LL + ///
+   |
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/too_long_first_doc_paragraph.rs b/tests/ui/too_long_first_doc_paragraph.rs
new file mode 100644
index 0000000000000..88a8f6d38310d
--- /dev/null
+++ b/tests/ui/too_long_first_doc_paragraph.rs
@@ -0,0 +1,47 @@
+//@no-rustfix
+
+#![warn(clippy::too_long_first_doc_paragraph)]
+
+/// Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
+/// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
+/// gravida non lacinia at, rhoncus eu lacus.
+pub struct Bar;
+
+// Should not warn! (not an item visible on mod page)
+/// Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
+/// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
+/// gravida non lacinia at, rhoncus eu lacus.
+impl Bar {}
+
+// Should not warn! (less than 80 characters)
+/// Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+///
+/// Nunc turpis nunc, lacinia
+/// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
+/// gravida non lacinia at, rhoncus eu lacus.
+enum Enum {
+    A,
+}
+
+/// Lorem
+/// ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
+/// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
+/// gravida non lacinia at, rhoncus eu lacus.
+union Union {
+    a: u8,
+    b: u8,
+}
+
+// Should not warn! (title)
+/// # bla
+/// Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
+/// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
+/// gravida non lacinia at, rhoncus eu lacus.
+union Union2 {
+    a: u8,
+    b: u8,
+}
+
+fn main() {
+    // test code goes here
+}
diff --git a/tests/ui/too_long_first_doc_paragraph.stderr b/tests/ui/too_long_first_doc_paragraph.stderr
new file mode 100644
index 0000000000000..7f48e5cf884e6
--- /dev/null
+++ b/tests/ui/too_long_first_doc_paragraph.stderr
@@ -0,0 +1,22 @@
+error: first doc comment paragraph is too long
+  --> tests/ui/too_long_first_doc_paragraph.rs:5:1
+   |
+LL | / /// Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
+LL | | /// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
+LL | | /// gravida non lacinia at, rhoncus eu lacus.
+   | |_
+   |
+   = note: `-D clippy::too-long-first-doc-paragraph` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::too_long_first_doc_paragraph)]`
+
+error: first doc comment paragraph is too long
+  --> tests/ui/too_long_first_doc_paragraph.rs:26:1
+   |
+LL | / /// Lorem
+LL | | /// ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
+LL | | /// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
+LL | | /// gravida non lacinia at, rhoncus eu lacus.
+   | |_
+
+error: aborting due to 2 previous errors
+

From f455587feec19b459c5eb75c9dc1995b93bb24f6 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 9 Jul 2024 16:00:06 +0200
Subject: [PATCH 019/685] Set the limit of characters to 200 and don't run the
 lint on private items unless config allows it

---
 clippy_lints/src/doc/mod.rs                     | 13 +++++++++----
 .../src/doc/too_long_first_doc_paragraph.rs     | 17 +++++++++++------
 tests/ui/too_long_first_doc_paragraph-fix.fixed |  5 +++--
 tests/ui/too_long_first_doc_paragraph-fix.rs    |  5 +++--
 .../ui/too_long_first_doc_paragraph-fix.stderr  |  3 ++-
 tests/ui/too_long_first_doc_paragraph.rs        | 12 +++++++++---
 6 files changed, 37 insertions(+), 18 deletions(-)

diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 5e9fb0162bf80..6debcd9b6a0f1 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -493,7 +493,13 @@ impl<'tcx> LateLintPass<'tcx> for Documentation {
 
         match cx.tcx.hir_node(cx.last_node_with_lint_attrs) {
             Node::Item(item) => {
-                too_long_first_doc_paragraph::check(cx, attrs, item.kind, headers.first_paragraph_len);
+                too_long_first_doc_paragraph::check(
+                    cx,
+                    item,
+                    attrs,
+                    headers.first_paragraph_len,
+                    self.check_private_items,
+                );
                 match item.kind {
                     ItemKind::Fn(sig, _, body_id) => {
                         if !(is_entrypoint_fn(cx, item.owner_id.to_def_id())
@@ -627,9 +633,8 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         acc
     });
     doc.pop();
-    let doc = doc.trim();
 
-    if doc.is_empty() {
+    if doc.trim().is_empty() {
         if let Some(span) = span_of_fragments(&fragments) {
             span_lint_and_help(
                 cx,
@@ -653,7 +658,7 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         cx,
         valid_idents,
         parser.into_offset_iter(),
-        doc,
+        &doc,
         Fragments {
             fragments: &fragments,
             doc: &doc,
diff --git a/clippy_lints/src/doc/too_long_first_doc_paragraph.rs b/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
index a5a58b444011a..a1b714b7d0020 100644
--- a/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
+++ b/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
@@ -1,6 +1,6 @@
 use rustc_ast::ast::Attribute;
 use rustc_errors::Applicability;
-use rustc_hir::ItemKind;
+use rustc_hir::{Item, ItemKind};
 use rustc_lint::LateContext;
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
@@ -10,13 +10,17 @@ use super::TOO_LONG_FIRST_DOC_PARAGRAPH;
 
 pub(super) fn check(
     cx: &LateContext<'_>,
+    item: &Item<'_>,
     attrs: &[Attribute],
-    item_kind: ItemKind<'_>,
     mut first_paragraph_len: usize,
+    check_private_items: bool,
 ) {
-    if first_paragraph_len <= 100
+    if !check_private_items && !cx.effective_visibilities.is_exported(item.owner_id.def_id) {
+        return;
+    }
+    if first_paragraph_len <= 200
         || !matches!(
-            item_kind,
+            item.kind,
             ItemKind::Static(..)
                 | ItemKind::Const(..)
                 | ItemKind::Fn(..)
@@ -32,6 +36,7 @@ pub(super) fn check(
     {
         return;
     }
+
     let mut spans = Vec::new();
     let mut should_suggest_empty_doc = false;
 
@@ -42,7 +47,7 @@ pub(super) fn check(
             let doc = doc.trim();
             if spans.len() == 1 {
                 // We make this suggestion only if the first doc line ends with a punctuation
-                // because if might just need to add an empty line with `///`.
+                // because it might just need to add an empty line with `///`.
                 should_suggest_empty_doc = doc.ends_with('.') || doc.ends_with('!') || doc.ends_with('?');
             }
             let len = doc.chars().count();
@@ -68,7 +73,7 @@ pub(super) fn check(
             |diag| {
                 diag.span_suggestion(
                     new_span,
-                    "add",
+                    "add an empty line",
                     format!("{snippet}///\n"),
                     Applicability::MachineApplicable,
                 );
diff --git a/tests/ui/too_long_first_doc_paragraph-fix.fixed b/tests/ui/too_long_first_doc_paragraph-fix.fixed
index b3f66f5279384..d4a0cdf3447f1 100644
--- a/tests/ui/too_long_first_doc_paragraph-fix.fixed
+++ b/tests/ui/too_long_first_doc_paragraph-fix.fixed
@@ -4,5 +4,6 @@
 ///
 /// A much longer explanation that goes into a lot more detail about
 /// how the thing works, possibly with doclinks and so one,
-/// and probably spanning a many rows.
-struct Foo;
+/// and probably spanning a many rows. Blablabla, it needs to be over
+/// 200 characters so I needed to write something longeeeeeeer.
+pub struct Foo;
diff --git a/tests/ui/too_long_first_doc_paragraph-fix.rs b/tests/ui/too_long_first_doc_paragraph-fix.rs
index f0ece9523de4b..5a3b6c42a328b 100644
--- a/tests/ui/too_long_first_doc_paragraph-fix.rs
+++ b/tests/ui/too_long_first_doc_paragraph-fix.rs
@@ -3,5 +3,6 @@
 /// A very short summary.
 /// A much longer explanation that goes into a lot more detail about
 /// how the thing works, possibly with doclinks and so one,
-/// and probably spanning a many rows.
-struct Foo;
+/// and probably spanning a many rows. Blablabla, it needs to be over
+/// 200 characters so I needed to write something longeeeeeeer.
+pub struct Foo;
diff --git a/tests/ui/too_long_first_doc_paragraph-fix.stderr b/tests/ui/too_long_first_doc_paragraph-fix.stderr
index 00949f405d538..6403265a39c54 100644
--- a/tests/ui/too_long_first_doc_paragraph-fix.stderr
+++ b/tests/ui/too_long_first_doc_paragraph-fix.stderr
@@ -4,7 +4,8 @@ error: first doc comment paragraph is too long
 LL | / /// A very short summary.
 LL | | /// A much longer explanation that goes into a lot more detail about
 LL | | /// how the thing works, possibly with doclinks and so one,
-LL | | /// and probably spanning a many rows.
+LL | | /// and probably spanning a many rows. Blablabla, it needs to be over
+LL | | /// 200 characters so I needed to write something longeeeeeeer.
    | |_
    |
    = note: `-D clippy::too-long-first-doc-paragraph` implied by `-D warnings`
diff --git a/tests/ui/too_long_first_doc_paragraph.rs b/tests/ui/too_long_first_doc_paragraph.rs
index 88a8f6d38310d..1042249c5b7bd 100644
--- a/tests/ui/too_long_first_doc_paragraph.rs
+++ b/tests/ui/too_long_first_doc_paragraph.rs
@@ -19,7 +19,7 @@ impl Bar {}
 /// Nunc turpis nunc, lacinia
 /// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
 /// gravida non lacinia at, rhoncus eu lacus.
-enum Enum {
+pub enum Enum {
     A,
 }
 
@@ -27,7 +27,7 @@ enum Enum {
 /// ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
 /// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
 /// gravida non lacinia at, rhoncus eu lacus.
-union Union {
+pub union Union {
     a: u8,
     b: u8,
 }
@@ -37,11 +37,17 @@ union Union {
 /// Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
 /// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
 /// gravida non lacinia at, rhoncus eu lacus.
-union Union2 {
+pub union Union2 {
     a: u8,
     b: u8,
 }
 
+// Should not warn! (not public)
+/// Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
+/// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
+/// gravida non lacinia at, rhoncus eu lacus.
+fn f() {}
+
 fn main() {
     // test code goes here
 }

From 4969960a9c0a9ac4e8bbe0083124186eb5159028 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 9 Jul 2024 16:29:39 +0200
Subject: [PATCH 020/685] Fix dogfood lints

---
 .../src/doc/too_long_first_doc_paragraph.rs   |  4 +++-
 clippy_utils/src/lib.rs                       | 21 ++++++++++++-------
 clippy_utils/src/macros.rs                    |  9 ++++----
 clippy_utils/src/source.rs                    | 14 +++++++------
 clippy_utils/src/ty.rs                        | 20 +++++++++++-------
 5 files changed, 42 insertions(+), 26 deletions(-)

diff --git a/clippy_lints/src/doc/too_long_first_doc_paragraph.rs b/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
index a1b714b7d0020..45ec392d55380 100644
--- a/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
+++ b/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
@@ -58,7 +58,9 @@ pub(super) fn check(
         }
     }
 
-    let &[first_span, .., last_span] = spans.as_slice() else { return };
+    let &[first_span, .., last_span] = spans.as_slice() else {
+        return;
+    };
 
     if should_suggest_empty_doc
         && let Some(second_span) = spans.get(1)
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1d5f1a2a2bb13..7d613a50665f4 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -150,6 +150,7 @@ macro_rules! extract_msrv_attr {
 
 /// If the given expression is a local binding, find the initializer expression.
 /// If that initializer expression is another local binding, find its initializer again.
+///
 /// This process repeats as long as possible (but usually no more than once). Initializer
 /// expressions with adjustments are ignored. If this is not desired, use [`find_binding_init`]
 /// instead.
@@ -180,6 +181,7 @@ pub fn expr_or_init<'a, 'b, 'tcx: 'b>(cx: &LateContext<'tcx>, mut expr: &'a Expr
 }
 
 /// Finds the initializer expression for a local binding. Returns `None` if the binding is mutable.
+///
 /// By only considering immutable bindings, we guarantee that the returned expression represents the
 /// value of the binding wherever it is referenced.
 ///
@@ -428,12 +430,12 @@ pub fn qpath_generic_tys<'tcx>(qpath: &QPath<'tcx>) -> impl Iterator<Item = &'tc
         })
 }
 
-/// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
+/// THIS METHOD IS DEPRECATED. Matches a `QPath` against a slice of segment string literals.
+///
+/// This method is deprecated and will eventually be removed since it does not match against the
 /// entire path or resolved `DefId`. Prefer using `match_def_path`. Consider getting a `DefId` from
 /// `QPath::Resolved.1.res.opt_def_id()`.
 ///
-/// Matches a `QPath` against a slice of segment string literals.
-///
 /// There is also `match_path` if you are dealing with a `rustc_hir::Path` instead of a
 /// `rustc_hir::QPath`.
 ///
@@ -482,12 +484,12 @@ pub fn is_path_diagnostic_item<'tcx>(
     path_def_id(cx, maybe_path).map_or(false, |id| cx.tcx.is_diagnostic_item(diag_item, id))
 }
 
-/// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
+/// THIS METHOD IS DEPRECATED. Matches a `Path` against a slice of segment string literals.
+///
+/// This method is deprecated and will eventually be removed since it does not match against the
 /// entire path or resolved `DefId`. Prefer using `match_def_path`. Consider getting a `DefId` from
 /// `QPath::Resolved.1.res.opt_def_id()`.
 ///
-/// Matches a `Path` against a slice of segment string literals.
-///
 /// There is also `match_qpath` if you are dealing with a `rustc_hir::QPath` instead of a
 /// `rustc_hir::Path`.
 ///
@@ -903,6 +905,7 @@ pub fn is_default_equivalent_call(cx: &LateContext<'_>, repl_func: &Expr<'_>) ->
 }
 
 /// Returns true if the expr is equal to `Default::default()` of it's type when evaluated.
+///
 /// It doesn't cover all cases, for example indirect function calls (some of std
 /// functions are supported) but it is the best we have.
 pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
@@ -1059,6 +1062,7 @@ impl std::ops::BitOrAssign for CaptureKind {
 }
 
 /// Given an expression referencing a local, determines how it would be captured in a closure.
+///
 /// Note as this will walk up to parent expressions until the capture can be determined it should
 /// only be used while making a closure somewhere a value is consumed. e.g. a block, match arm, or
 /// function argument (other than a receiver).
@@ -2361,8 +2365,9 @@ pub fn fn_def_id_with_node_args<'tcx>(
 }
 
 /// Returns `Option<String>` where String is a textual representation of the type encapsulated in
-/// the slice iff the given expression is a slice of primitives (as defined in the
-/// `is_recursively_primitive_type` function) and `None` otherwise.
+/// the slice iff the given expression is a slice of primitives.
+///
+/// (As defined in the `is_recursively_primitive_type` function.) Returns `None` otherwise.
 pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
     let expr_type = cx.typeck_results().expr_ty_adjusted(expr);
     let expr_kind = expr_type.kind();
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 455239cc37f35..3c85eb1296e1f 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -150,10 +150,11 @@ pub fn first_node_macro_backtrace(cx: &LateContext<'_>, node: &impl HirNode) ->
 }
 
 /// If `node` is the "first node" in a macro expansion, returns `Some` with the `ExpnId` of the
-/// macro call site (i.e. the parent of the macro expansion). This generally means that `node`
-/// is the outermost node of an entire macro expansion, but there are some caveats noted below.
-/// This is useful for finding macro calls while visiting the HIR without processing the macro call
-/// at every node within its expansion.
+/// macro call site (i.e. the parent of the macro expansion).
+///
+/// This generally means that `node` is the outermost node of an entire macro expansion, but there
+/// are some caveats noted below. This is useful for finding macro calls while visiting the HIR
+/// without processing the macro call at every node within its expansion.
 ///
 /// If you already have immediate access to the parent node, it is simpler to
 /// just check the context of that span directly (e.g. `parent.span.from_expansion()`).
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 496c8f5b55373..924cdf1b8735c 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -527,9 +527,10 @@ pub fn snippet_block_with_context<'a>(
     (reindent_multiline(snip, true, indent), from_macro)
 }
 
-/// Same as `snippet_with_applicability`, but first walks the span up to the given context. This
-/// will result in the macro call, rather than the expansion, if the span is from a child context.
-/// If the span is not from a child context, it will be used directly instead.
+/// Same as `snippet_with_applicability`, but first walks the span up to the given context.
+///
+/// This will result in the macro call, rather than the expansion, if the span is from a child
+/// context. If the span is not from a child context, it will be used directly instead.
 ///
 /// e.g. Given the expression `&vec![]`, getting a snippet from the span for `vec![]` as a HIR node
 /// would result in `box []`. If given the context of the address of expression, this function will
@@ -572,9 +573,10 @@ fn snippet_with_context_sess<'a>(
 }
 
 /// Walks the span up to the target context, thereby returning the macro call site if the span is
-/// inside a macro expansion, or the original span if it is not. Note this will return `None` in the
-/// case of the span being in a macro expansion, but the target context is from expanding a macro
-/// argument.
+/// inside a macro expansion, or the original span if it is not.
+///
+/// Note this will return `None` in the case of the span being in a macro expansion, but the target
+/// context is from expanding a macro argument.
 ///
 /// Given the following
 ///
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 812fb647fdab6..de5ae484834cc 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -160,8 +160,10 @@ pub fn get_type_diagnostic_name(cx: &LateContext<'_>, ty: Ty<'_>) -> Option<Symb
 }
 
 /// Returns true if `ty` is a type on which calling `Clone` through a function instead of
-/// as a method, such as `Arc::clone()` is considered idiomatic. Lints should avoid suggesting to
-/// replace instances of `ty::Clone()` by `.clone()` for objects of those types.
+/// as a method, such as `Arc::clone()` is considered idiomatic.
+///
+/// Lints should avoid suggesting to replace instances of `ty::Clone()` by `.clone()` for objects
+/// of those types.
 pub fn should_call_clone_as_function(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
     matches!(
         get_type_diagnostic_name(cx, ty),
@@ -398,8 +400,10 @@ fn is_normalizable_helper<'tcx>(
 }
 
 /// Returns `true` if the given type is a non aggregate primitive (a `bool` or `char`, any
-/// integer or floating-point number type). For checking aggregation of primitive types (e.g.
-/// tuples and slices of primitive type) see `is_recursively_primitive_type`
+/// integer or floating-point number type).
+///
+/// For checking aggregation of primitive types (e.g. tuples and slices of primitive type) see
+/// `is_recursively_primitive_type`
 pub fn is_non_aggregate_primitive_type(ty: Ty<'_>) -> bool {
     matches!(ty.kind(), ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_))
 }
@@ -476,9 +480,10 @@ pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
     }
 }
 
-/// Checks if the drop order for a type matters. Some std types implement drop solely to
-/// deallocate memory. For these types, and composites containing them, changing the drop order
-/// won't result in any observable side effects.
+/// Checks if the drop order for a type matters.
+///
+/// Some std types implement drop solely to deallocate memory. For these types, and composites
+/// containing them, changing the drop order won't result in any observable side effects.
 pub fn needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     fn needs_ordered_drop_inner<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, seen: &mut FxHashSet<Ty<'tcx>>) -> bool {
         if !seen.insert(ty) {
@@ -1324,6 +1329,7 @@ pub fn deref_chain<'cx, 'tcx>(cx: &'cx LateContext<'tcx>, ty: Ty<'tcx>) -> impl
 }
 
 /// Checks if a Ty<'_> has some inherent method Symbol.
+///
 /// This does not look for impls in the type's `Deref::Target` type.
 /// If you need this, you should wrap this call in `clippy_utils::ty::deref_chain().any(...)`.
 pub fn get_adt_inherent_method<'a>(cx: &'a LateContext<'_>, ty: Ty<'_>, method_name: Symbol) -> Option<&'a AssocItem> {

From 3c6e5ef4ae20c7439a2bc951ef349c59954412c6 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 21 Jul 2024 17:29:32 +0200
Subject: [PATCH 021/685] Add comment explaining what the matching items are
 for `TOO_LONG_FIRST_DOC_PARAGRAPH` lint

---
 clippy_lints/src/doc/too_long_first_doc_paragraph.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/clippy_lints/src/doc/too_long_first_doc_paragraph.rs b/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
index 45ec392d55380..a47cba64b28e5 100644
--- a/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
+++ b/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
@@ -21,6 +21,8 @@ pub(super) fn check(
     if first_paragraph_len <= 200
         || !matches!(
             item.kind,
+            // This is the list of items which can be documented AND are displayed on the module
+            // page. So associated items or impl blocks are not part of this list.
             ItemKind::Static(..)
                 | ItemKind::Const(..)
                 | ItemKind::Fn(..)

From 0b87af9d4f7c6faa9e89496609f016dc3e3977e1 Mon Sep 17 00:00:00 2001
From: Mrmaxmeier <Mrmaxmeier@gmail.com>
Date: Sat, 27 Apr 2024 23:14:36 +0200
Subject: [PATCH 022/685] Add `-Z embed-source=yes` to embed source code in
 DWARF debug info

---
 .../src/debuginfo/metadata.rs                 |  9 +++++++
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   |  2 ++
 compiler/rustc_interface/src/tests.rs         |  1 +
 .../rustc_llvm/llvm-wrapper/RustWrapper.cpp   |  9 +++++--
 compiler/rustc_session/messages.ftl           |  6 +++++
 compiler/rustc_session/src/errors.rs          | 14 +++++++++++
 compiler/rustc_session/src/options.rs         |  2 ++
 compiler/rustc_session/src/session.rs         | 25 +++++++++++++++++--
 .../src/compiler-flags/embed-source.md        | 12 +++++++++
 9 files changed, 76 insertions(+), 4 deletions(-)
 create mode 100644 src/doc/unstable-book/src/compiler-flags/embed-source.md

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index ad63858861261..701ea62b21a7d 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -629,6 +629,9 @@ pub fn file_metadata<'ll>(cx: &CodegenCx<'ll, '_>, source_file: &SourceFile) ->
         };
         let hash_value = hex_encode(source_file.src_hash.hash_bytes());
 
+        let source =
+            cx.sess().opts.unstable_opts.embed_source.then_some(()).and(source_file.src.as_ref());
+
         unsafe {
             llvm::LLVMRustDIBuilderCreateFile(
                 DIB(cx),
@@ -639,6 +642,8 @@ pub fn file_metadata<'ll>(cx: &CodegenCx<'ll, '_>, source_file: &SourceFile) ->
                 hash_kind,
                 hash_value.as_ptr().cast(),
                 hash_value.len(),
+                source.map_or(ptr::null(), |x| x.as_ptr().cast()),
+                source.map_or(0, |x| x.len()),
             )
         }
     }
@@ -659,6 +664,8 @@ pub fn unknown_file_metadata<'ll>(cx: &CodegenCx<'ll, '_>) -> &'ll DIFile {
             llvm::ChecksumKind::None,
             hash_value.as_ptr().cast(),
             hash_value.len(),
+            ptr::null(),
+            0,
         )
     })
 }
@@ -943,6 +950,8 @@ pub fn build_compile_unit_di_node<'ll, 'tcx>(
             llvm::ChecksumKind::None,
             ptr::null(),
             0,
+            ptr::null(),
+            0,
         );
 
         let unit_metadata = llvm::LLVMRustDIBuilderCreateCompileUnit(
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index c8e0e075eeabc..faa675b66c8a1 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1853,6 +1853,8 @@ extern "C" {
         CSKind: ChecksumKind,
         Checksum: *const c_char,
         ChecksumLen: size_t,
+        Source: *const c_char,
+        SourceLen: size_t,
     ) -> &'a DIFile;
 
     pub fn LLVMRustDIBuilderCreateSubroutineType<'a>(
diff --git a/compiler/rustc_interface/src/tests.rs b/compiler/rustc_interface/src/tests.rs
index ce3b2f77f210a..c4704e38ce6fa 100644
--- a/compiler/rustc_interface/src/tests.rs
+++ b/compiler/rustc_interface/src/tests.rs
@@ -773,6 +773,7 @@ fn test_unstable_options_tracking_hash() {
     tracked!(direct_access_external_data, Some(true));
     tracked!(dual_proc_macros, true);
     tracked!(dwarf_version, Some(5));
+    tracked!(embed_source, true);
     tracked!(emit_thin_lto, false);
     tracked!(export_executable_symbols, true);
     tracked!(fewer_names, Some(true));
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index 4cdd8af1008c0..6e700c31e6763 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -901,14 +901,19 @@ extern "C" LLVMMetadataRef
 LLVMRustDIBuilderCreateFile(LLVMRustDIBuilderRef Builder, const char *Filename,
                             size_t FilenameLen, const char *Directory,
                             size_t DirectoryLen, LLVMRustChecksumKind CSKind,
-                            const char *Checksum, size_t ChecksumLen) {
+                            const char *Checksum, size_t ChecksumLen,
+                            const char *Source, size_t SourceLen) {
 
   std::optional<DIFile::ChecksumKind> llvmCSKind = fromRust(CSKind);
   std::optional<DIFile::ChecksumInfo<StringRef>> CSInfo{};
   if (llvmCSKind)
     CSInfo.emplace(*llvmCSKind, StringRef{Checksum, ChecksumLen});
+  std::optional<StringRef> oSource{};
+  if (Source)
+    oSource = StringRef(Source, SourceLen);
   return wrap(Builder->createFile(StringRef(Filename, FilenameLen),
-                                  StringRef(Directory, DirectoryLen), CSInfo));
+                                  StringRef(Directory, DirectoryLen), CSInfo,
+                                  oSource));
 }
 
 extern "C" LLVMMetadataRef
diff --git a/compiler/rustc_session/messages.ftl b/compiler/rustc_session/messages.ftl
index b84280a3ccf3f..afd5360c81194 100644
--- a/compiler/rustc_session/messages.ftl
+++ b/compiler/rustc_session/messages.ftl
@@ -14,6 +14,12 @@ session_crate_name_empty = crate name must not be empty
 
 session_crate_name_invalid = crate names cannot start with a `-`, but `{$s}` has a leading hyphen
 
+session_embed_source_insufficient_dwarf_version = `-Zembed-source=y` requires at least `-Z dwarf-version=5` but DWARF version is {$dwarf_version}
+
+session_embed_source_requires_debug_info = `-Zembed-source=y` requires debug information to be enabled
+
+session_embed_source_requires_llvm_backend = `-Zembed-source=y` is only supported on the LLVM codegen backend
+
 session_expr_parentheses_needed = parentheses are required to parse this as an expression
 
 session_failed_to_create_profiler = failed to create profiler: {$err}
diff --git a/compiler/rustc_session/src/errors.rs b/compiler/rustc_session/src/errors.rs
index 5cc54a5855bbe..f708109b87a0c 100644
--- a/compiler/rustc_session/src/errors.rs
+++ b/compiler/rustc_session/src/errors.rs
@@ -165,6 +165,20 @@ pub(crate) struct UnsupportedDwarfVersion {
     pub(crate) dwarf_version: u32,
 }
 
+#[derive(Diagnostic)]
+#[diag(session_embed_source_insufficient_dwarf_version)]
+pub(crate) struct EmbedSourceInsufficientDwarfVersion {
+    pub(crate) dwarf_version: u32,
+}
+
+#[derive(Diagnostic)]
+#[diag(session_embed_source_requires_debug_info)]
+pub(crate) struct EmbedSourceRequiresDebugInfo;
+
+#[derive(Diagnostic)]
+#[diag(session_embed_source_requires_llvm_backend)]
+pub(crate) struct EmbedSourceRequiresLLVMBackend;
+
 #[derive(Diagnostic)]
 #[diag(session_target_stack_protector_not_supported)]
 pub(crate) struct StackProtectorNotSupportedForTarget<'a> {
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
index bf54aae1cfeb0..13aac6669fe4f 100644
--- a/compiler/rustc_session/src/options.rs
+++ b/compiler/rustc_session/src/options.rs
@@ -1708,6 +1708,8 @@ options! {
         them only if an error has not been emitted"),
     ehcont_guard: bool = (false, parse_bool, [TRACKED],
         "generate Windows EHCont Guard tables"),
+    embed_source: bool = (false, parse_bool, [TRACKED],
+        "embed source text in DWARF debug sections (default: no)"),
     emit_stack_sizes: bool = (false, parse_bool, [UNTRACKED],
         "emit a section containing stack size metadata (default: no)"),
     emit_thin_lto: bool = (true, parse_bool, [TRACKED],
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index be67baf57f6dc..634f3684b51aa 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -37,8 +37,9 @@ use rustc_target::spec::{
 use crate::code_stats::CodeStats;
 pub use crate::code_stats::{DataTypeKind, FieldInfo, FieldKind, SizeKind, VariantInfo};
 use crate::config::{
-    self, CoverageLevel, CrateType, ErrorOutputType, FunctionReturn, Input, InstrumentCoverage,
-    OptLevel, OutFileName, OutputType, RemapPathScopeComponents, SwitchWithOptPath,
+    self, CoverageLevel, CrateType, DebugInfo, ErrorOutputType, FunctionReturn, Input,
+    InstrumentCoverage, OptLevel, OutFileName, OutputType, RemapPathScopeComponents,
+    SwitchWithOptPath,
 };
 use crate::parse::{add_feature_diagnostics, ParseSess};
 use crate::search_paths::{PathKind, SearchPath};
@@ -1300,6 +1301,26 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
             .emit_err(errors::SplitDebugInfoUnstablePlatform { debuginfo: sess.split_debuginfo() });
     }
 
+    if sess.opts.unstable_opts.embed_source {
+        let dwarf_version =
+            sess.opts.unstable_opts.dwarf_version.unwrap_or(sess.target.default_dwarf_version);
+
+        let uses_llvm_backend =
+            matches!(sess.opts.unstable_opts.codegen_backend.as_deref(), None | Some("llvm"));
+
+        if dwarf_version < 5 {
+            sess.dcx().emit_warn(errors::EmbedSourceInsufficientDwarfVersion { dwarf_version });
+        }
+
+        if sess.opts.debuginfo == DebugInfo::None {
+            sess.dcx().emit_warn(errors::EmbedSourceRequiresDebugInfo);
+        }
+
+        if !uses_llvm_backend {
+            sess.dcx().emit_warn(errors::EmbedSourceRequiresLLVMBackend);
+        }
+    }
+
     if sess.opts.unstable_opts.instrument_xray.is_some() && !sess.target.options.supports_xray {
         sess.dcx().emit_err(errors::InstrumentationNotSupported { us: "XRay".to_string() });
     }
diff --git a/src/doc/unstable-book/src/compiler-flags/embed-source.md b/src/doc/unstable-book/src/compiler-flags/embed-source.md
new file mode 100644
index 0000000000000..01a11e3779712
--- /dev/null
+++ b/src/doc/unstable-book/src/compiler-flags/embed-source.md
@@ -0,0 +1,12 @@
+# `embed-source`
+
+This flag controls whether the compiler embeds the program source code text into
+the object debug information section. It takes one of the following values:
+
+* `y`, `yes`, `on` or `true`: put source code in debug info.
+* `n`, `no`, `off`, `false` or no value: omit source code from debug info (the default).
+
+This flag is ignored in configurations that don't emit DWARF debug information
+and is ignored on non-LLVM backends. `-Z embed-source` requires DWARFv5. Use
+`-Z dwarf-version=5` to control the compiler's DWARF target version and `-g` to
+enable debug info generation.

From 608901b9c07d7d2f3e2803378c4f0cc07c61bc36 Mon Sep 17 00:00:00 2001
From: Mrmaxmeier <Mrmaxmeier@gmail.com>
Date: Tue, 16 Jul 2024 20:50:28 +0200
Subject: [PATCH 023/685] Add run-make test for -Zembed-source=yes

---
 tests/run-make/embed-source-dwarf/main.rs  |  2 +
 tests/run-make/embed-source-dwarf/rmake.rs | 70 ++++++++++++++++++++++
 2 files changed, 72 insertions(+)
 create mode 100644 tests/run-make/embed-source-dwarf/main.rs
 create mode 100644 tests/run-make/embed-source-dwarf/rmake.rs

diff --git a/tests/run-make/embed-source-dwarf/main.rs b/tests/run-make/embed-source-dwarf/main.rs
new file mode 100644
index 0000000000000..c80af84f41415
--- /dev/null
+++ b/tests/run-make/embed-source-dwarf/main.rs
@@ -0,0 +1,2 @@
+// hello
+fn main() {}
diff --git a/tests/run-make/embed-source-dwarf/rmake.rs b/tests/run-make/embed-source-dwarf/rmake.rs
new file mode 100644
index 0000000000000..06d550121b0de
--- /dev/null
+++ b/tests/run-make/embed-source-dwarf/rmake.rs
@@ -0,0 +1,70 @@
+//@ ignore-windows
+//@ ignore-apple
+
+// LLVM 17's embed-source implementation requires that source code is attached
+// for all files in the output DWARF debug info. This restriction was lifted in
+// LLVM 18 (87e22bdd2bd6d77d782f9d64b3e3ae5bdcd5080d).
+//@ min-llvm-version: 18
+
+// This test should be replaced with one in tests/debuginfo once we can easily
+// tell via GDB or LLDB if debuginfo contains source code. Cheap tricks in LLDB
+// like setting an invalid source map path don't appear to work, maybe this'll
+// become easier once GDB supports DWARFv6?
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::rc::Rc;
+
+use gimli::{AttributeValue, EndianRcSlice, Reader, RunTimeEndian};
+use object::{Object, ObjectSection};
+use run_make_support::{gimli, object, rfs, rustc};
+
+fn main() {
+    let output = PathBuf::from("embed-source-main");
+    rustc()
+        .input("main.rs")
+        .output(&output)
+        .arg("-g")
+        .arg("-Zembed-source=yes")
+        .arg("-Zdwarf-version=5")
+        .run();
+    let output = rfs::read(output);
+    let obj = object::File::parse(output.as_slice()).unwrap();
+    let endian = if obj.is_little_endian() { RunTimeEndian::Little } else { RunTimeEndian::Big };
+    let dwarf = gimli::Dwarf::load(|section| -> Result<_, ()> {
+        let data = obj.section_by_name(section.name()).map(|s| s.uncompressed_data().unwrap());
+        Ok(EndianRcSlice::new(Rc::from(data.unwrap_or_default().as_ref()), endian))
+    })
+    .unwrap();
+
+    let mut sources = HashMap::new();
+
+    let mut iter = dwarf.units();
+    while let Some(header) = iter.next().unwrap() {
+        let unit = dwarf.unit(header).unwrap();
+        let unit = unit.unit_ref(&dwarf);
+
+        if let Some(program) = &unit.line_program {
+            let header = program.header();
+            for file in header.file_names() {
+                if let Some(source) = file.source() {
+                    let path = unit
+                        .attr_string(file.path_name())
+                        .unwrap()
+                        .to_string_lossy()
+                        .unwrap()
+                        .to_string();
+                    let source =
+                        unit.attr_string(source).unwrap().to_string_lossy().unwrap().to_string();
+                    if !source.is_empty() {
+                        sources.insert(path, source);
+                    }
+                }
+            }
+        }
+    }
+
+    dbg!(&sources);
+    assert_eq!(sources.len(), 1);
+    assert_eq!(sources.get("main.rs").unwrap(), "// hello\nfn main() {}\n");
+}

From ec921db289ea87fd4030cb7f8a70f6ba3a31c2c7 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sun, 23 Jun 2024 22:11:35 +0300
Subject: [PATCH 024/685] impl CloneToUninit for str and CStr

---
 library/core/src/clone.rs   | 21 +++++++++++++++++++
 library/core/tests/clone.rs | 40 +++++++++++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+)

diff --git a/library/core/src/clone.rs b/library/core/src/clone.rs
index 76a89eaaff86e..409fd2746f588 100644
--- a/library/core/src/clone.rs
+++ b/library/core/src/clone.rs
@@ -346,6 +346,27 @@ unsafe impl<T: Copy> CloneToUninit for [T] {
     }
 }
 
+#[unstable(feature = "clone_to_uninit", issue = "126799")]
+unsafe impl CloneToUninit for str {
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_uninit(&self, dst: *mut Self) {
+        // SAFETY: str is just a [u8] with UTF-8 invariant
+        unsafe { self.as_bytes().clone_to_uninit(dst as *mut [u8]) }
+    }
+}
+
+#[unstable(feature = "clone_to_uninit", issue = "126799")]
+unsafe impl CloneToUninit for crate::ffi::CStr {
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_uninit(&self, dst: *mut Self) {
+        // SAFETY: For now, CStr is just a #[repr(trasnsparent)] [c_char] with some invariants.
+        // And we can cast [c_char] to [u8] on all supported platforms (see: to_bytes_with_nul).
+        // The pointer metadata properly preserves the length (NUL included).
+        // See: `cstr_metadata_is_length_with_nul` in tests.
+        unsafe { self.to_bytes_with_nul().clone_to_uninit(dst as *mut [u8]) }
+    }
+}
+
 /// Ownership of a collection of values stored in a non-owned `[MaybeUninit<T>]`, some of which
 /// are not yet initialized. This is sort of like a `Vec` that doesn't own its allocation.
 /// Its responsibility is to provide cleanup on unwind by dropping the values that *are*
diff --git a/library/core/tests/clone.rs b/library/core/tests/clone.rs
index b7130f16f8795..71a328733b7c4 100644
--- a/library/core/tests/clone.rs
+++ b/library/core/tests/clone.rs
@@ -1,5 +1,7 @@
 use core::clone::CloneToUninit;
+use core::ffi::CStr;
 use core::mem::MaybeUninit;
+use core::ptr;
 
 #[test]
 #[allow(suspicious_double_ref_op)]
@@ -81,3 +83,41 @@ fn test_clone_to_uninit_slice_drops_on_panic() {
     drop(a);
     assert_eq!(COUNTER.load(Relaxed), 0);
 }
+
+#[test]
+fn test_clone_to_uninit_str() {
+    let a = "hello";
+
+    let mut storage: MaybeUninit<[u8; 5]> = MaybeUninit::uninit();
+    unsafe { a.clone_to_uninit(storage.as_mut_ptr() as *mut [u8] as *mut str) };
+    assert_eq!(a.as_bytes(), unsafe { storage.assume_init() }.as_slice());
+
+    let mut b: Box<str> = "world".into();
+    assert_eq!(a.len(), b.len());
+    assert_ne!(a, &*b);
+    unsafe { a.clone_to_uninit(ptr::from_mut::<str>(&mut b)) };
+    assert_eq!(a, &*b);
+}
+
+#[test]
+fn test_clone_to_uninit_cstr() {
+    let a = c"hello";
+
+    let mut storage: MaybeUninit<[u8; 6]> = MaybeUninit::uninit();
+    unsafe { a.clone_to_uninit(storage.as_mut_ptr() as *mut [u8] as *mut CStr) };
+    assert_eq!(a.to_bytes_with_nul(), unsafe { storage.assume_init() }.as_slice());
+
+    let mut b: Box<CStr> = c"world".into();
+    assert_eq!(a.count_bytes(), b.count_bytes());
+    assert_ne!(a, &*b);
+    unsafe { a.clone_to_uninit(ptr::from_mut::<CStr>(&mut b)) };
+    assert_eq!(a, &*b);
+}
+
+#[test]
+fn cstr_metadata_is_length_with_nul() {
+    let s: &CStr = c"abcdef";
+    let p: *const CStr = ptr::from_ref(s);
+    let bytes: *const [u8] = p as *const [u8];
+    assert_eq!(s.to_bytes_with_nul().len(), bytes.len());
+}

From afabc583f7f646d45f506263a1c331383ebdc252 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sun, 23 Jun 2024 23:05:10 +0300
Subject: [PATCH 025/685] impl CloneToUninit for Path and OsStr

---
 library/std/src/ffi/os_str.rs       | 12 ++++++++++++
 library/std/src/ffi/os_str/tests.rs | 17 +++++++++++++++++
 library/std/src/lib.rs              |  1 +
 library/std/src/path.rs             | 11 +++++++++++
 library/std/src/path/tests.rs       | 19 +++++++++++++++++++
 library/std/src/sys/os_str/bytes.rs | 12 ++++++++++++
 library/std/src/sys/os_str/wtf8.rs  | 12 ++++++++++++
 library/std/src/sys_common/wtf8.rs  | 11 +++++++++++
 8 files changed, 95 insertions(+)

diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs
index a501bcc98cf38..f68ea3c562a5e 100644
--- a/library/std/src/ffi/os_str.rs
+++ b/library/std/src/ffi/os_str.rs
@@ -3,10 +3,13 @@
 #[cfg(test)]
 mod tests;
 
+use core::clone::CloneToUninit;
+
 use crate::borrow::{Borrow, Cow};
 use crate::collections::TryReserveError;
 use crate::hash::{Hash, Hasher};
 use crate::ops::{self, Range};
+use crate::ptr::addr_of_mut;
 use crate::rc::Rc;
 use crate::str::FromStr;
 use crate::sync::Arc;
@@ -1261,6 +1264,15 @@ impl Clone for Box<OsStr> {
     }
 }
 
+#[unstable(feature = "clone_to_uninit", issue = "126799")]
+unsafe impl CloneToUninit for OsStr {
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_uninit(&self, dst: *mut Self) {
+        // SAFETY: we're just a wrapper around a platform-specific Slice
+        unsafe { self.inner.clone_to_uninit(addr_of_mut!((*dst).inner)) }
+    }
+}
+
 #[stable(feature = "shared_from_slice2", since = "1.24.0")]
 impl From<OsString> for Arc<OsStr> {
     /// Converts an [`OsString`] into an <code>[Arc]<[OsStr]></code> by moving the [`OsString`]
diff --git a/library/std/src/ffi/os_str/tests.rs b/library/std/src/ffi/os_str/tests.rs
index 5b39b9e34d8c7..67147934b4db3 100644
--- a/library/std/src/ffi/os_str/tests.rs
+++ b/library/std/src/ffi/os_str/tests.rs
@@ -1,4 +1,6 @@
 use super::*;
+use crate::mem::MaybeUninit;
+use crate::ptr;
 
 #[test]
 fn test_os_string_with_capacity() {
@@ -286,3 +288,18 @@ fn slice_surrogate_edge() {
     assert_eq!(post_crab.slice_encoded_bytes(..4), "🦀");
     assert_eq!(post_crab.slice_encoded_bytes(4..), surrogate);
 }
+
+#[test]
+fn clone_to_uninit() {
+    let a = OsStr::new("hello.txt");
+
+    let mut storage = vec![MaybeUninit::<u8>::uninit(); size_of_val::<OsStr>(a)];
+    unsafe { a.clone_to_uninit(ptr::from_mut::<[_]>(storage.as_mut_slice()) as *mut OsStr) };
+    assert_eq!(a.as_encoded_bytes(), unsafe { MaybeUninit::slice_assume_init_ref(&storage) });
+
+    let mut b: Box<OsStr> = OsStr::new("world.exe").into();
+    assert_eq!(size_of_val::<OsStr>(a), size_of_val::<OsStr>(&b));
+    assert_ne!(a, &*b);
+    unsafe { a.clone_to_uninit(ptr::from_mut::<OsStr>(&mut b)) };
+    assert_eq!(a, &*b);
+}
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index ee6f5a6f3c0d5..5cc6376a32d72 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -323,6 +323,7 @@
 // tidy-alphabetical-start
 #![feature(c_str_module)]
 #![feature(char_internals)]
+#![feature(clone_to_uninit)]
 #![feature(core_intrinsics)]
 #![feature(core_io_borrowed_buf)]
 #![feature(duration_constants)]
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 80163667636ae..d6c78883f2804 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -70,6 +70,8 @@
 #[cfg(test)]
 mod tests;
 
+use core::clone::CloneToUninit;
+
 use crate::borrow::{Borrow, Cow};
 use crate::collections::TryReserveError;
 use crate::error::Error;
@@ -3109,6 +3111,15 @@ impl Path {
     }
 }
 
+#[unstable(feature = "clone_to_uninit", issue = "126799")]
+unsafe impl CloneToUninit for Path {
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_uninit(&self, dst: *mut Self) {
+        // SAFETY: Path is just a wrapper around OsStr
+        unsafe { self.inner.clone_to_uninit(core::ptr::addr_of_mut!((*dst).inner)) }
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl AsRef<OsStr> for Path {
     #[inline]
diff --git a/library/std/src/path/tests.rs b/library/std/src/path/tests.rs
index a12e42cba0c5c..6436872087d6c 100644
--- a/library/std/src/path/tests.rs
+++ b/library/std/src/path/tests.rs
@@ -3,6 +3,8 @@ use core::hint::black_box;
 use super::*;
 use crate::collections::{BTreeSet, HashSet};
 use crate::hash::DefaultHasher;
+use crate::mem::MaybeUninit;
+use crate::ptr;
 
 #[allow(unknown_lints, unused_macro_rules)]
 macro_rules! t (
@@ -2054,3 +2056,20 @@ fn bench_hash_path_long(b: &mut test::Bencher) {
 
     black_box(hasher.finish());
 }
+
+#[test]
+fn clone_to_uninit() {
+    let a = Path::new("hello.txt");
+
+    let mut storage = vec![MaybeUninit::<u8>::uninit(); size_of_val::<Path>(a)];
+    unsafe { a.clone_to_uninit(ptr::from_mut::<[_]>(storage.as_mut_slice()) as *mut Path) };
+    assert_eq!(a.as_os_str().as_encoded_bytes(), unsafe {
+        MaybeUninit::slice_assume_init_ref(&storage)
+    });
+
+    let mut b: Box<Path> = Path::new("world.exe").into();
+    assert_eq!(size_of_val::<Path>(a), size_of_val::<Path>(&b));
+    assert_ne!(a, &*b);
+    unsafe { a.clone_to_uninit(ptr::from_mut::<Path>(&mut b)) };
+    assert_eq!(a, &*b);
+}
diff --git a/library/std/src/sys/os_str/bytes.rs b/library/std/src/sys/os_str/bytes.rs
index 0f8bd6453528e..8529207366e93 100644
--- a/library/std/src/sys/os_str/bytes.rs
+++ b/library/std/src/sys/os_str/bytes.rs
@@ -1,6 +1,9 @@
 //! The underlying OsString/OsStr implementation on Unix and many other
 //! systems: just a `Vec<u8>`/`[u8]`.
 
+use core::clone::CloneToUninit;
+use core::ptr::addr_of_mut;
+
 use crate::borrow::Cow;
 use crate::collections::TryReserveError;
 use crate::fmt::Write;
@@ -345,3 +348,12 @@ impl Slice {
         self.inner.eq_ignore_ascii_case(&other.inner)
     }
 }
+
+#[unstable(feature = "clone_to_uninit", issue = "126799")]
+unsafe impl CloneToUninit for Slice {
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_uninit(&self, dst: *mut Self) {
+        // SAFETY: we're just a wrapper around [u8]
+        unsafe { self.inner.clone_to_uninit(addr_of_mut!((*dst).inner)) }
+    }
+}
diff --git a/library/std/src/sys/os_str/wtf8.rs b/library/std/src/sys/os_str/wtf8.rs
index ed975ba58b5e2..e5755a4b87443 100644
--- a/library/std/src/sys/os_str/wtf8.rs
+++ b/library/std/src/sys/os_str/wtf8.rs
@@ -1,5 +1,8 @@
 //! The underlying OsString/OsStr implementation on Windows is a
 //! wrapper around the "WTF-8" encoding; see the `wtf8` module for more.
+use core::clone::CloneToUninit;
+use core::ptr::addr_of_mut;
+
 use crate::borrow::Cow;
 use crate::collections::TryReserveError;
 use crate::rc::Rc;
@@ -268,3 +271,12 @@ impl Slice {
         self.inner.eq_ignore_ascii_case(&other.inner)
     }
 }
+
+#[unstable(feature = "clone_to_uninit", issue = "126799")]
+unsafe impl CloneToUninit for Slice {
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_uninit(&self, dst: *mut Self) {
+        // SAFETY: we're just a wrapper around Wtf8
+        unsafe { self.inner.clone_to_uninit(addr_of_mut!((*dst).inner)) }
+    }
+}
diff --git a/library/std/src/sys_common/wtf8.rs b/library/std/src/sys_common/wtf8.rs
index 277c9506febbb..2bdeff78ddfd6 100644
--- a/library/std/src/sys_common/wtf8.rs
+++ b/library/std/src/sys_common/wtf8.rs
@@ -19,12 +19,14 @@
 mod tests;
 
 use core::char::{encode_utf16_raw, encode_utf8_raw};
+use core::clone::CloneToUninit;
 use core::str::next_code_point;
 
 use crate::borrow::Cow;
 use crate::collections::TryReserveError;
 use crate::hash::{Hash, Hasher};
 use crate::iter::FusedIterator;
+use crate::ptr::addr_of_mut;
 use crate::rc::Rc;
 use crate::sync::Arc;
 use crate::sys_common::AsInner;
@@ -1046,3 +1048,12 @@ impl Hash for Wtf8 {
         0xfeu8.hash(state)
     }
 }
+
+#[unstable(feature = "clone_to_uninit", issue = "126799")]
+unsafe impl CloneToUninit for Wtf8 {
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_to_uninit(&self, dst: *mut Self) {
+        // SAFETY: we're just a wrapper around [u8]
+        unsafe { self.bytes.clone_to_uninit(addr_of_mut!((*dst).bytes)) }
+    }
+}

From dbc13fb309f3a1539e8bb1cdeeb5fbb2e3eaaa43 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Mon, 24 Jun 2024 18:09:27 +0300
Subject: [PATCH 026/685] Sparkle some attributes over `CloneToUninit` stuff

---
 library/core/src/clone.rs           | 7 +++++++
 library/std/src/ffi/os_str.rs       | 1 +
 library/std/src/path.rs             | 1 +
 library/std/src/sys/os_str/bytes.rs | 1 +
 library/std/src/sys/os_str/wtf8.rs  | 1 +
 library/std/src/sys_common/wtf8.rs  | 1 +
 6 files changed, 12 insertions(+)

diff --git a/library/core/src/clone.rs b/library/core/src/clone.rs
index 409fd2746f588..88f7990c017df 100644
--- a/library/core/src/clone.rs
+++ b/library/core/src/clone.rs
@@ -272,6 +272,7 @@ pub unsafe trait CloneToUninit {
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl<T: Clone> CloneToUninit for T {
+    #[inline]
     default unsafe fn clone_to_uninit(&self, dst: *mut Self) {
         // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of
         // ptr::write().
@@ -285,8 +286,10 @@ unsafe impl<T: Clone> CloneToUninit for T {
 
 // Specialized implementation for types that are [`Copy`], not just [`Clone`],
 // and can therefore be copied bitwise.
+#[doc(hidden)]
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl<T: Copy> CloneToUninit for T {
+    #[inline]
     unsafe fn clone_to_uninit(&self, dst: *mut Self) {
         // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of
         // ptr::copy_nonoverlapping().
@@ -298,6 +301,7 @@ unsafe impl<T: Copy> CloneToUninit for T {
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl<T: Clone> CloneToUninit for [T] {
+    #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     default unsafe fn clone_to_uninit(&self, dst: *mut Self) {
         let len = self.len();
@@ -326,8 +330,10 @@ unsafe impl<T: Clone> CloneToUninit for [T] {
     }
 }
 
+#[doc(hidden)]
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl<T: Copy> CloneToUninit for [T] {
+    #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dst: *mut Self) {
         let len = self.len();
@@ -348,6 +354,7 @@ unsafe impl<T: Copy> CloneToUninit for [T] {
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl CloneToUninit for str {
+    #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dst: *mut Self) {
         // SAFETY: str is just a [u8] with UTF-8 invariant
diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs
index f68ea3c562a5e..918eec2d0d8ef 100644
--- a/library/std/src/ffi/os_str.rs
+++ b/library/std/src/ffi/os_str.rs
@@ -1266,6 +1266,7 @@ impl Clone for Box<OsStr> {
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl CloneToUninit for OsStr {
+    #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dst: *mut Self) {
         // SAFETY: we're just a wrapper around a platform-specific Slice
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index d6c78883f2804..9eaa0e01c2c00 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -3113,6 +3113,7 @@ impl Path {
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl CloneToUninit for Path {
+    #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dst: *mut Self) {
         // SAFETY: Path is just a wrapper around OsStr
diff --git a/library/std/src/sys/os_str/bytes.rs b/library/std/src/sys/os_str/bytes.rs
index 8529207366e93..992767211d083 100644
--- a/library/std/src/sys/os_str/bytes.rs
+++ b/library/std/src/sys/os_str/bytes.rs
@@ -351,6 +351,7 @@ impl Slice {
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl CloneToUninit for Slice {
+    #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dst: *mut Self) {
         // SAFETY: we're just a wrapper around [u8]
diff --git a/library/std/src/sys/os_str/wtf8.rs b/library/std/src/sys/os_str/wtf8.rs
index e5755a4b87443..433237aa6e7bf 100644
--- a/library/std/src/sys/os_str/wtf8.rs
+++ b/library/std/src/sys/os_str/wtf8.rs
@@ -274,6 +274,7 @@ impl Slice {
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl CloneToUninit for Slice {
+    #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dst: *mut Self) {
         // SAFETY: we're just a wrapper around Wtf8
diff --git a/library/std/src/sys_common/wtf8.rs b/library/std/src/sys_common/wtf8.rs
index 2bdeff78ddfd6..063451ad54e1c 100644
--- a/library/std/src/sys_common/wtf8.rs
+++ b/library/std/src/sys_common/wtf8.rs
@@ -1051,6 +1051,7 @@ impl Hash for Wtf8 {
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl CloneToUninit for Wtf8 {
+    #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dst: *mut Self) {
         // SAFETY: we're just a wrapper around [u8]

From 110c273f4fb40c318be59a557ba90314fbbc42a6 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Wed, 26 Jun 2024 02:22:07 +0300
Subject: [PATCH 027/685] CloneToUninit: use a private specialization trait

and move implementation details into a submodule
---
 library/core/src/clone.rs        | 123 ++---------------------------
 library/core/src/clone/uninit.rs | 128 +++++++++++++++++++++++++++++++
 2 files changed, 134 insertions(+), 117 deletions(-)
 create mode 100644 library/core/src/clone/uninit.rs

diff --git a/library/core/src/clone.rs b/library/core/src/clone.rs
index 88f7990c017df..2150463067205 100644
--- a/library/core/src/clone.rs
+++ b/library/core/src/clone.rs
@@ -36,8 +36,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use crate::mem::{self, MaybeUninit};
-use crate::ptr;
+mod uninit;
 
 /// A common trait for the ability to explicitly duplicate an object.
 ///
@@ -248,7 +247,7 @@ pub unsafe trait CloneToUninit {
     /// * `dst` must be properly aligned.
     /// * `dst` must have the same [pointer metadata] (slice length or `dyn` vtable) as `self`.
     ///
-    /// [valid]: ptr#safety
+    /// [valid]: crate::ptr#safety
     /// [pointer metadata]: crate::ptr::metadata()
     ///
     /// # Panics
@@ -272,83 +271,20 @@ pub unsafe trait CloneToUninit {
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl<T: Clone> CloneToUninit for T {
-    #[inline]
-    default unsafe fn clone_to_uninit(&self, dst: *mut Self) {
-        // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of
-        // ptr::write().
-        unsafe {
-            // We hope the optimizer will figure out to create the cloned value in-place,
-            // skipping ever storing it on the stack and the copy to the destination.
-            ptr::write(dst, self.clone());
-        }
-    }
-}
-
-// Specialized implementation for types that are [`Copy`], not just [`Clone`],
-// and can therefore be copied bitwise.
-#[doc(hidden)]
-#[unstable(feature = "clone_to_uninit", issue = "126799")]
-unsafe impl<T: Copy> CloneToUninit for T {
     #[inline]
     unsafe fn clone_to_uninit(&self, dst: *mut Self) {
-        // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of
-        // ptr::copy_nonoverlapping().
-        unsafe {
-            ptr::copy_nonoverlapping(self, dst, 1);
-        }
+        // SAFETY: we're calling a specialization with the same contract
+        unsafe { <T as self::uninit::CopySpec>::clone_one(self, dst) }
     }
 }
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
 unsafe impl<T: Clone> CloneToUninit for [T] {
-    #[inline]
-    #[cfg_attr(debug_assertions, track_caller)]
-    default unsafe fn clone_to_uninit(&self, dst: *mut Self) {
-        let len = self.len();
-        // This is the most likely mistake to make, so check it as a debug assertion.
-        debug_assert_eq!(
-            len,
-            dst.len(),
-            "clone_to_uninit() source and destination must have equal lengths",
-        );
-
-        // SAFETY: The produced `&mut` is valid because:
-        // * The caller is obligated to provide a pointer which is valid for writes.
-        // * All bytes pointed to are in MaybeUninit, so we don't care about the memory's
-        //   initialization status.
-        let uninit_ref = unsafe { &mut *(dst as *mut [MaybeUninit<T>]) };
-
-        // Copy the elements
-        let mut initializing = InitializingSlice::from_fully_uninit(uninit_ref);
-        for element_ref in self.iter() {
-            // If the clone() panics, `initializing` will take care of the cleanup.
-            initializing.push(element_ref.clone());
-        }
-        // If we reach here, then the entire slice is initialized, and we've satisfied our
-        // responsibilities to the caller. Disarm the cleanup guard by forgetting it.
-        mem::forget(initializing);
-    }
-}
-
-#[doc(hidden)]
-#[unstable(feature = "clone_to_uninit", issue = "126799")]
-unsafe impl<T: Copy> CloneToUninit for [T] {
     #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dst: *mut Self) {
-        let len = self.len();
-        // This is the most likely mistake to make, so check it as a debug assertion.
-        debug_assert_eq!(
-            len,
-            dst.len(),
-            "clone_to_uninit() source and destination must have equal lengths",
-        );
-
-        // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of
-        // ptr::copy_nonoverlapping().
-        unsafe {
-            ptr::copy_nonoverlapping(self.as_ptr(), dst.as_mut_ptr(), len);
-        }
+        // SAFETY: we're calling a specialization with the same contract
+        unsafe { <T as self::uninit::CopySpec>::clone_slice(self, dst) }
     }
 }
 
@@ -374,53 +310,6 @@ unsafe impl CloneToUninit for crate::ffi::CStr {
     }
 }
 
-/// Ownership of a collection of values stored in a non-owned `[MaybeUninit<T>]`, some of which
-/// are not yet initialized. This is sort of like a `Vec` that doesn't own its allocation.
-/// Its responsibility is to provide cleanup on unwind by dropping the values that *are*
-/// initialized, unless disarmed by forgetting.
-///
-/// This is a helper for `impl<T: Clone> CloneToUninit for [T]`.
-struct InitializingSlice<'a, T> {
-    data: &'a mut [MaybeUninit<T>],
-    /// Number of elements of `*self.data` that are initialized.
-    initialized_len: usize,
-}
-
-impl<'a, T> InitializingSlice<'a, T> {
-    #[inline]
-    fn from_fully_uninit(data: &'a mut [MaybeUninit<T>]) -> Self {
-        Self { data, initialized_len: 0 }
-    }
-
-    /// Push a value onto the end of the initialized part of the slice.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the slice is already fully initialized.
-    #[inline]
-    fn push(&mut self, value: T) {
-        MaybeUninit::write(&mut self.data[self.initialized_len], value);
-        self.initialized_len += 1;
-    }
-}
-
-impl<'a, T> Drop for InitializingSlice<'a, T> {
-    #[cold] // will only be invoked on unwind
-    fn drop(&mut self) {
-        let initialized_slice = ptr::slice_from_raw_parts_mut(
-            MaybeUninit::slice_as_mut_ptr(self.data),
-            self.initialized_len,
-        );
-        // SAFETY:
-        // * the pointer is valid because it was made from a mutable reference
-        // * `initialized_len` counts the initialized elements as an invariant of this type,
-        //   so each of the pointed-to elements is initialized and may be dropped.
-        unsafe {
-            ptr::drop_in_place::<[T]>(initialized_slice);
-        }
-    }
-}
-
 /// Implementations of `Clone` for primitive types.
 ///
 /// Implementations that cannot be described in Rust
diff --git a/library/core/src/clone/uninit.rs b/library/core/src/clone/uninit.rs
new file mode 100644
index 0000000000000..8b738bec796de
--- /dev/null
+++ b/library/core/src/clone/uninit.rs
@@ -0,0 +1,128 @@
+use crate::mem::{self, MaybeUninit};
+use crate::ptr;
+
+/// Private specialization trait used by CloneToUninit, as per
+/// [the dev guide](https://std-dev-guide.rust-lang.org/policy/specialization.html).
+pub(super) unsafe trait CopySpec: Clone {
+    unsafe fn clone_one(src: &Self, dst: *mut Self);
+    unsafe fn clone_slice(src: &[Self], dst: *mut [Self]);
+}
+
+unsafe impl<T: Clone> CopySpec for T {
+    #[inline]
+    default unsafe fn clone_one(src: &Self, dst: *mut Self) {
+        // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of
+        // ptr::write().
+        unsafe {
+            // We hope the optimizer will figure out to create the cloned value in-place,
+            // skipping ever storing it on the stack and the copy to the destination.
+            ptr::write(dst, src.clone());
+        }
+    }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    default unsafe fn clone_slice(src: &[Self], dst: *mut [Self]) {
+        let len = src.len();
+        // This is the most likely mistake to make, so check it as a debug assertion.
+        debug_assert_eq!(
+            len,
+            dst.len(),
+            "clone_to_uninit() source and destination must have equal lengths",
+        );
+
+        // SAFETY: The produced `&mut` is valid because:
+        // * The caller is obligated to provide a pointer which is valid for writes.
+        // * All bytes pointed to are in MaybeUninit, so we don't care about the memory's
+        //   initialization status.
+        let uninit_ref = unsafe { &mut *(dst as *mut [MaybeUninit<T>]) };
+
+        // Copy the elements
+        let mut initializing = InitializingSlice::from_fully_uninit(uninit_ref);
+        for element_ref in src {
+            // If the clone() panics, `initializing` will take care of the cleanup.
+            initializing.push(element_ref.clone());
+        }
+        // If we reach here, then the entire slice is initialized, and we've satisfied our
+        // responsibilities to the caller. Disarm the cleanup guard by forgetting it.
+        mem::forget(initializing);
+    }
+}
+
+// Specialized implementation for types that are [`Copy`], not just [`Clone`],
+// and can therefore be copied bitwise.
+unsafe impl<T: Copy> CopySpec for T {
+    #[inline]
+    unsafe fn clone_one(src: &Self, dst: *mut Self) {
+        // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of
+        // ptr::copy_nonoverlapping().
+        unsafe {
+            ptr::copy_nonoverlapping(src, dst, 1);
+        }
+    }
+
+    #[inline]
+    #[cfg_attr(debug_assertions, track_caller)]
+    unsafe fn clone_slice(src: &[Self], dst: *mut [Self]) {
+        let len = src.len();
+        // This is the most likely mistake to make, so check it as a debug assertion.
+        debug_assert_eq!(
+            len,
+            dst.len(),
+            "clone_to_uninit() source and destination must have equal lengths",
+        );
+
+        // SAFETY: The safety conditions of clone_to_uninit() are a superset of those of
+        // ptr::copy_nonoverlapping().
+        unsafe {
+            ptr::copy_nonoverlapping(src.as_ptr(), dst.as_mut_ptr(), len);
+        }
+    }
+}
+
+/// Ownership of a collection of values stored in a non-owned `[MaybeUninit<T>]`, some of which
+/// are not yet initialized. This is sort of like a `Vec` that doesn't own its allocation.
+/// Its responsibility is to provide cleanup on unwind by dropping the values that *are*
+/// initialized, unless disarmed by forgetting.
+///
+/// This is a helper for `impl<T: Clone> CloneToUninit for [T]`.
+struct InitializingSlice<'a, T> {
+    data: &'a mut [MaybeUninit<T>],
+    /// Number of elements of `*self.data` that are initialized.
+    initialized_len: usize,
+}
+
+impl<'a, T> InitializingSlice<'a, T> {
+    #[inline]
+    fn from_fully_uninit(data: &'a mut [MaybeUninit<T>]) -> Self {
+        Self { data, initialized_len: 0 }
+    }
+
+    /// Push a value onto the end of the initialized part of the slice.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the slice is already fully initialized.
+    #[inline]
+    fn push(&mut self, value: T) {
+        MaybeUninit::write(&mut self.data[self.initialized_len], value);
+        self.initialized_len += 1;
+    }
+}
+
+impl<'a, T> Drop for InitializingSlice<'a, T> {
+    #[cold] // will only be invoked on unwind
+    fn drop(&mut self) {
+        let initialized_slice = ptr::slice_from_raw_parts_mut(
+            MaybeUninit::slice_as_mut_ptr(self.data),
+            self.initialized_len,
+        );
+        // SAFETY:
+        // * the pointer is valid because it was made from a mutable reference
+        // * `initialized_len` counts the initialized elements as an invariant of this type,
+        //   so each of the pointed-to elements is initialized and may be dropped.
+        unsafe {
+            ptr::drop_in_place::<[T]>(initialized_slice);
+        }
+    }
+}

From b7e7975dedb42edf3ba1b53708950db34c31c182 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 30 Jul 2024 16:01:36 +0200
Subject: [PATCH 028/685] Move style into its file

---
 .github/deploy.sh        |   1 +
 util/gh-pages/index.html | 366 +--------------------------------------
 util/gh-pages/style.css  | 364 ++++++++++++++++++++++++++++++++++++++
 3 files changed, 366 insertions(+), 365 deletions(-)
 create mode 100644 util/gh-pages/style.css

diff --git a/.github/deploy.sh b/.github/deploy.sh
index 5a59f94ec918b..d937661c0f828 100644
--- a/.github/deploy.sh
+++ b/.github/deploy.sh
@@ -10,6 +10,7 @@ mkdir out/master/
 cp util/gh-pages/index.html out/master
 cp util/gh-pages/script.js out/master
 cp util/gh-pages/lints.json out/master
+cp util/gh-pages/style.css out/master
 
 if [[ -n $TAG_NAME ]]; then
   echo "Save the doc for the current tag ($TAG_NAME) and point stable/ to it"
diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index 7f271ac838597..267354cc8bfc6 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -23,371 +23,7 @@
     <link id="styleHighlight" rel="stylesheet" href="https://rust-lang.github.io/mdBook/highlight.css">
     <link id="styleNight" rel="stylesheet" href="https://rust-lang.github.io/mdBook/tomorrow-night.css" disabled="true">
     <link id="styleAyu" rel="stylesheet" href="https://rust-lang.github.io/mdBook/ayu-highlight.css" disabled="true">
-    <style>
-        blockquote { font-size: 1em; }
-        [ng\:cloak], [ng-cloak], [data-ng-cloak], [x-ng-cloak], .ng-cloak, .x-ng-cloak { display: none !important; }
-
-        .dropdown-menu {
-            color: var(--fg);
-            background: var(--theme-popup-bg);
-            border: 1px solid var(--theme-popup-border);
-        }
-
-        .dropdown-menu .divider {
-            background-color: var(--theme-popup-border);
-        }
-
-        .dropdown-menu .checkbox {
-            display: block;
-            white-space: nowrap;
-            margin: 0;
-        }
-        .dropdown-menu .checkbox label {
-            padding: 3px 20px;
-            width: 100%;
-        }
-
-        .dropdown-menu .checkbox input {
-            position: relative;
-            margin: 0 0.5rem 0;
-            padding: 0;
-        }
-
-        .dropdown-menu .checkbox:hover {
-            background-color: var(--theme-hover);
-        }
-
-        div.panel div.panel-body button {
-            background: var(--searchbar-bg);
-            color: var(--searchbar-fg);
-            border-color: var(--theme-popup-border);
-        }
-
-        div.panel div.panel-body button:hover {
-            box-shadow: 0 0 3px var(--searchbar-shadow-color);
-        }
-
-        div.panel div.panel-body  button.open {
-            filter: brightness(90%);
-        }
-
-        .dropdown-toggle .badge {
-            background-color: #777;
-        }
-
-        .panel-heading { cursor: pointer; }
-
-        .panel-title { display: flex; flex-wrap: wrap;}
-        .panel-title .label { display: inline-block; }
-
-        .panel-title-name { flex: 1; min-width: 400px;}
-        .panel-title-name span { vertical-align: bottom; }
-
-        .panel .panel-title-name .anchor { display: none; }
-        .panel:hover .panel-title-name .anchor { display: inline;}
-
-        .search-control {
-            margin-top: 15px;
-        }
-
-        @media (min-width: 992px) {
-            .search-control {
-                margin-top: 0;
-            }
-        }
-
-        @media (min-width: 405px) {
-            #upper-filters {
-                display: flex;
-                flex-wrap: wrap;
-            }
-        }
-
-        @media (max-width: 430px) {
-            /* Turn the version filter list to the left */
-            #version-filter-selector {
-                right: 0;
-                left: auto;
-            }
-        }
-
-        @media (max-width: 412px) {
-            #upper-filters,
-            .panel-body .search-control  {
-                padding-right: 8px;
-                padding-left: 8px;
-            }
-        }
-
-        .label {
-            padding-top: 0.3em;
-            padding-bottom: 0.3em;
-        }
-
-        .label-lint-group {
-            min-width: 8em;
-        }
-        .label-lint-level {
-            min-width: 4em;
-        }
-
-        .label-lint-level-allow {
-            background-color: #5cb85c;
-        }
-        .label-lint-level-warn {
-            background-color: #f0ad4e;
-        }
-        .label-lint-level-deny {
-            background-color: #d9534f;
-        }
-        .label-lint-level-none {
-            background-color: #777777;
-            opacity: 0.5;
-        }
-
-        .label-group-deprecated {
-            opacity: 0.5;
-        }
-
-        .label-doc-folding {
-            color: #000;
-            background-color: #fff;
-            border: 1px solid var(--theme-popup-border);
-        }
-        .label-doc-folding:hover {
-            background-color: #e6e6e6;
-        }
-
-        .lint-doc-md > h3 {
-            border-top: 1px solid var(--theme-popup-border);
-            padding: 10px 15px;
-            margin: 0 -15px;
-            font-size: 18px;
-        }
-        .lint-doc-md > h3:first-child {
-            border-top: none;
-            padding-top: 0px;
-        }
-
-        @media (max-width:749px) {
-            .lint-additional-info-container {
-                display: flex;
-                flex-flow: column;
-            }
-            .lint-additional-info-item + .lint-additional-info-item {
-                border-top: 1px solid var(--theme-popup-border);
-            }
-        }
-        @media (min-width:750px) {
-            .lint-additional-info-container {
-                display: flex;
-                flex-flow: row;
-            }
-            .lint-additional-info-item + .lint-additional-info-item {
-                border-left: 1px solid var(--theme-popup-border);
-            }
-        }
-
-        .lint-additional-info-item {
-            display: inline-flex;
-            min-width: 200px;
-            flex-grow: 1;
-            padding: 9px 5px 5px 15px;
-        }
-
-        .label-applicability {
-            background-color: #777777;
-            margin: auto 5px;
-        }
-
-        .label-version {
-            background-color: #777777;
-            margin: auto 5px;
-            font-family: monospace;
-        }
-
-        details {
-            border-radius: 4px;
-            padding: .5em .5em 0;
-        }
-
-        code {
-            white-space: pre !important;
-        }
-
-        summary {
-            font-weight: bold;
-            margin: -.5em -.5em 0;
-            padding: .5em;
-            display: revert;
-        }
-
-        details[open] {
-            padding: .5em;
-        }
-    </style>
-    <style>
-        /* Expanding the mdBoom theme*/
-        .light {
-            --inline-code-bg: #f6f7f6;
-        }
-        .rust {
-            --inline-code-bg: #f6f7f6;
-        }
-        .coal {
-            --inline-code-bg: #1d1f21;
-        }
-        .navy {
-            --inline-code-bg: #1d1f21;
-        }
-        .ayu {
-            --inline-code-bg: #191f26;
-        }
-
-        .theme-dropdown {
-            position: absolute;
-            margin: 0.7em;
-            z-index: 10;
-        }
-
-        /* Applying the mdBook theme */
-        .theme-icon {
-            text-align: center;
-            width: 2em;
-            height: 2em;
-            line-height: 2em;
-            border: solid 1px var(--icons);
-            border-radius: 5px;
-            user-select: none;
-            cursor: pointer;
-        }
-        .theme-icon:hover {
-            background: var(--theme-hover);
-        }
-        .theme-choice {
-            display: none;
-            list-style: none;
-            border: 1px solid var(--theme-popup-border);
-            border-radius: 5px;
-            color: var(--fg);
-            background: var(--theme-popup-bg);
-            padding: 0 0;
-            overflow: hidden;
-        }
-
-        .theme-dropdown.open .theme-choice {
-            display: block;
-        }
-
-        .theme-choice > li {
-            padding: 5px 10px;
-            font-size: 0.8em;
-            user-select: none;
-            cursor: pointer;
-        }
-
-        .theme-choice > li:hover {
-            background: var(--theme-hover);
-        }
-
-        .alert {
-            color: var(--fg);
-            background: var(--theme-hover);
-            border: 1px solid var(--theme-popup-border);
-        }
-        .page-header {
-            border-color: var(--theme-popup-border);
-        }
-        .panel-default > .panel-heading {
-            background: var(--theme-hover);
-            color: var(--fg);
-            border: 1px solid var(--theme-popup-border);
-        }
-        .panel-default > .panel-heading:hover {
-            filter: brightness(90%);
-        }
-        .list-group-item {
-            background: 0%;
-            border: 1px solid var(--theme-popup-border);
-        }
-        .panel, pre, hr {
-            background: var(--bg);
-            border: 1px solid var(--theme-popup-border);
-        }
-
-        #version-filter-selector .checkbox {
-            display: flex;
-        }
-
-        #version-filter {
-            min-width: available;
-        }
-
-        #version-filter li label {
-            padding-right: 0;
-            width: 35%;
-        }
-
-        .version-filter-input {
-            height: 60%;
-            width: 30%;
-            text-align: center;
-            border: none;
-            border-bottom: 1px solid #000000;
-        }
-
-        #filter-label, .filter-clear {
-            background: var(--searchbar-bg);
-            color: var(--searchbar-fg);
-            border-color: var(--theme-popup-border);
-            filter: brightness(95%);
-        }
-        #filter-label:hover, .filter-clear:hover {
-            filter: brightness(90%);
-        }
-        .filter-input {
-            background: var(--searchbar-bg);
-            color: var(--searchbar-fg);
-            border-color: var(--theme-popup-border);
-        }
-
-        .filter-input::-webkit-input-placeholder,
-        .filter-input::-moz-placeholder {
-            color: var(--searchbar-fg);
-            opacity: 30%;
-        }
-
-        .expansion-group {
-            margin-top: 15px;
-            padding: 0px 8px;
-            display: flex;
-            flex-wrap: nowrap;
-        }
-
-        @media (min-width: 992px) {
-            .expansion-group {
-                margin-top: 0;
-                padding: 0px 15px;
-            }
-        }
-
-        .expansion-control {
-            width: 50%;
-        }
-
-        :not(pre) > code {
-            color: var(--inline-code-color);
-            background-color: var(--inline-code-bg);
-        }
-        html {
-            scrollbar-color: var(--scrollbar) var(--bg);
-        }
-        body {
-            background: var(--bg);
-            color: var(--fg);
-        }
-
-    </style>
+    <link rel="stylesheet" href="style.css">
 </head>
 <body ng-app="clippy" ng-controller="lintList">
     <div theme-dropdown class="theme-dropdown">
diff --git a/util/gh-pages/style.css b/util/gh-pages/style.css
new file mode 100644
index 0000000000000..f9feb0ba13ae3
--- /dev/null
+++ b/util/gh-pages/style.css
@@ -0,0 +1,364 @@
+blockquote { font-size: 1em; }
+
+[ng\:cloak], [ng-cloak], [data-ng-cloak], [x-ng-cloak], .ng-cloak, .x-ng-cloak {
+    display: none !important;
+}
+
+.dropdown-menu {
+    color: var(--fg);
+    background: var(--theme-popup-bg);
+    border: 1px solid var(--theme-popup-border);
+}
+
+.dropdown-menu .divider {
+    background-color: var(--theme-popup-border);
+}
+
+.dropdown-menu .checkbox {
+    display: block;
+    white-space: nowrap;
+    margin: 0;
+}
+.dropdown-menu .checkbox label {
+    padding: 3px 20px;
+    width: 100%;
+}
+
+.dropdown-menu .checkbox input {
+    position: relative;
+    margin: 0 0.5rem 0;
+    padding: 0;
+}
+
+.dropdown-menu .checkbox:hover {
+    background-color: var(--theme-hover);
+}
+
+div.panel div.panel-body button {
+    background: var(--searchbar-bg);
+    color: var(--searchbar-fg);
+    border-color: var(--theme-popup-border);
+}
+
+div.panel div.panel-body button:hover {
+    box-shadow: 0 0 3px var(--searchbar-shadow-color);
+}
+
+div.panel div.panel-body  button.open {
+    filter: brightness(90%);
+}
+
+.dropdown-toggle .badge {
+    background-color: #777;
+}
+
+.panel-heading { cursor: pointer; }
+
+.panel-title { display: flex; flex-wrap: wrap;}
+.panel-title .label { display: inline-block; }
+
+.panel-title-name { flex: 1; min-width: 400px;}
+.panel-title-name span { vertical-align: bottom; }
+
+.panel .panel-title-name .anchor { display: none; }
+.panel:hover .panel-title-name .anchor { display: inline;}
+
+.search-control {
+    margin-top: 15px;
+}
+
+@media (min-width: 992px) {
+    .search-control {
+        margin-top: 0;
+    }
+}
+
+@media (min-width: 405px) {
+    #upper-filters {
+        display: flex;
+        flex-wrap: wrap;
+    }
+}
+
+@media (max-width: 430px) {
+    /* Turn the version filter list to the left */
+    #version-filter-selector {
+        right: 0;
+        left: auto;
+    }
+}
+
+@media (max-width: 412px) {
+    #upper-filters,
+    .panel-body .search-control  {
+        padding-right: 8px;
+        padding-left: 8px;
+    }
+}
+
+.label {
+    padding-top: 0.3em;
+    padding-bottom: 0.3em;
+}
+
+.label-lint-group {
+    min-width: 8em;
+}
+.label-lint-level {
+    min-width: 4em;
+}
+
+.label-lint-level-allow {
+    background-color: #5cb85c;
+}
+.label-lint-level-warn {
+    background-color: #f0ad4e;
+}
+.label-lint-level-deny {
+    background-color: #d9534f;
+}
+.label-lint-level-none {
+    background-color: #777777;
+    opacity: 0.5;
+}
+
+.label-group-deprecated {
+    opacity: 0.5;
+}
+
+.label-doc-folding {
+    color: #000;
+    background-color: #fff;
+    border: 1px solid var(--theme-popup-border);
+}
+.label-doc-folding:hover {
+    background-color: #e6e6e6;
+}
+
+.lint-doc-md > h3 {
+    border-top: 1px solid var(--theme-popup-border);
+    padding: 10px 15px;
+    margin: 0 -15px;
+    font-size: 18px;
+}
+.lint-doc-md > h3:first-child {
+    border-top: none;
+    padding-top: 0px;
+}
+
+@media (max-width:749px) {
+    .lint-additional-info-container {
+        display: flex;
+        flex-flow: column;
+    }
+    .lint-additional-info-item + .lint-additional-info-item {
+        border-top: 1px solid var(--theme-popup-border);
+    }
+}
+@media (min-width:750px) {
+    .lint-additional-info-container {
+        display: flex;
+        flex-flow: row;
+    }
+    .lint-additional-info-item + .lint-additional-info-item {
+        border-left: 1px solid var(--theme-popup-border);
+    }
+}
+
+.lint-additional-info-item {
+    display: inline-flex;
+    min-width: 200px;
+    flex-grow: 1;
+    padding: 9px 5px 5px 15px;
+}
+
+.label-applicability {
+    background-color: #777777;
+    margin: auto 5px;
+}
+
+.label-version {
+    background-color: #777777;
+    margin: auto 5px;
+    font-family: monospace;
+}
+
+details {
+    border-radius: 4px;
+    padding: .5em .5em 0;
+}
+
+code {
+    white-space: pre !important;
+}
+
+summary {
+    font-weight: bold;
+    margin: -.5em -.5em 0;
+    padding: .5em;
+    display: revert;
+}
+
+details[open] {
+    padding: .5em;
+}
+
+/* Expanding the mdBook theme*/
+.light {
+    --inline-code-bg: #f6f7f6;
+}
+.rust {
+    --inline-code-bg: #f6f7f6;
+}
+.coal {
+    --inline-code-bg: #1d1f21;
+}
+.navy {
+    --inline-code-bg: #1d1f21;
+}
+.ayu {
+    --inline-code-bg: #191f26;
+}
+
+.theme-dropdown {
+    position: absolute;
+    margin: 0.7em;
+    z-index: 10;
+}
+
+/* Applying the mdBook theme */
+.theme-icon {
+    text-align: center;
+    width: 2em;
+    height: 2em;
+    line-height: 2em;
+    border: solid 1px var(--icons);
+    border-radius: 5px;
+    user-select: none;
+    cursor: pointer;
+}
+.theme-icon:hover {
+    background: var(--theme-hover);
+}
+.theme-choice {
+    display: none;
+    list-style: none;
+    border: 1px solid var(--theme-popup-border);
+    border-radius: 5px;
+    color: var(--fg);
+    background: var(--theme-popup-bg);
+    padding: 0 0;
+    overflow: hidden;
+}
+
+.theme-dropdown.open .theme-choice {
+    display: block;
+}
+
+.theme-choice > li {
+    padding: 5px 10px;
+    font-size: 0.8em;
+    user-select: none;
+    cursor: pointer;
+}
+
+.theme-choice > li:hover {
+    background: var(--theme-hover);
+}
+
+.alert {
+    color: var(--fg);
+    background: var(--theme-hover);
+    border: 1px solid var(--theme-popup-border);
+}
+.page-header {
+    border-color: var(--theme-popup-border);
+}
+.panel-default > .panel-heading {
+    background: var(--theme-hover);
+    color: var(--fg);
+    border: 1px solid var(--theme-popup-border);
+}
+.panel-default > .panel-heading:hover {
+    filter: brightness(90%);
+}
+.list-group-item {
+    background: 0%;
+    border: 1px solid var(--theme-popup-border);
+}
+.panel, pre, hr {
+    background: var(--bg);
+    border: 1px solid var(--theme-popup-border);
+}
+
+#version-filter-selector .checkbox {
+    display: flex;
+}
+
+#version-filter {
+    min-width: available;
+}
+
+#version-filter li label {
+    padding-right: 0;
+    width: 35%;
+}
+
+.version-filter-input {
+    height: 60%;
+    width: 30%;
+    text-align: center;
+    border: none;
+    border-bottom: 1px solid #000000;
+}
+
+#filter-label, .filter-clear {
+    background: var(--searchbar-bg);
+    color: var(--searchbar-fg);
+    border-color: var(--theme-popup-border);
+    filter: brightness(95%);
+}
+#filter-label:hover, .filter-clear:hover {
+    filter: brightness(90%);
+}
+.filter-input {
+    background: var(--searchbar-bg);
+    color: var(--searchbar-fg);
+    border-color: var(--theme-popup-border);
+}
+
+.filter-input::-webkit-input-placeholder,
+.filter-input::-moz-placeholder {
+    color: var(--searchbar-fg);
+    opacity: 30%;
+}
+
+.expansion-group {
+    margin-top: 15px;
+    padding: 0px 8px;
+    display: flex;
+    flex-wrap: nowrap;
+}
+
+@media (min-width: 992px) {
+    .expansion-group {
+        margin-top: 0;
+        padding: 0px 15px;
+    }
+}
+
+.expansion-control {
+    width: 50%;
+}
+
+:not(pre) > code {
+    color: var(--inline-code-color);
+    background-color: var(--inline-code-bg);
+}
+html {
+    scrollbar-color: var(--scrollbar) var(--bg);
+}
+body {
+    background: var(--bg);
+    color: var(--fg);
+}

From 7c5209121d52411d95bca199124d35ab3300ce9d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 30 Jul 2024 17:31:42 +0200
Subject: [PATCH 029/685] Add new settings menu

---
 util/gh-pages/index.html | 27 ++++++++++++++++----
 util/gh-pages/script.js  | 45 ++++++++++++++++++++++++++++++----
 util/gh-pages/style.css  | 53 ++++++++++++++++++++++++++++++++++++----
 3 files changed, 110 insertions(+), 15 deletions(-)

diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index 267354cc8bfc6..12c9608f6f5f7 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -26,11 +26,28 @@
     <link rel="stylesheet" href="style.css">
 </head>
 <body ng-app="clippy" ng-controller="lintList">
-    <div theme-dropdown class="theme-dropdown">
-        <div id="theme-icon" class="theme-icon">&#128396;</div>
-        <ul id="theme-menu" class="theme-choice">
-            <li id="{{id}}" ng-repeat="(id, name) in themes" ng-click="selectTheme(id)">{{name}}</li>
-        </ul>
+    <div id="settings">
+        <div theme-dropdown class="theme-dropdown">
+            <div class="menu-container">
+                <div id="theme-icon" class="theme-icon">&#128396;</div>
+                <ul id="theme-menu" class="theme-choice">
+                    <li id="{{id}}" ng-repeat="(id, name) in themes" ng-click="selectTheme(id)">{{name}}</li>
+                </ul>
+            </div>
+        </div>
+        <div settings-dropdown class="settings-dropdown">
+            <div class="menu-container">
+                <div id="settings-icon" class="settings-icon"></div>
+                <ul id="settings-menu" class="settings-choice">
+                    <li>
+                        <label>
+                            <input type="checkbox" id="disable-shortcuts" onchange="changeSetting(this)">
+                            <span>Disable keyboard shortcuts</span>
+                        </label>
+                    </li>
+                </ul>
+            </div>
+        </div>
     </div>
 
     <div class="container">
diff --git a/util/gh-pages/script.js b/util/gh-pages/script.js
index ed1e090e1b540..f072327bc340f 100644
--- a/util/gh-pages/script.js
+++ b/util/gh-pages/script.js
@@ -68,6 +68,24 @@
                 }
             }
         })
+        .directive('settingsDropdown', function ($document) {
+            return {
+                restrict: 'A',
+                link: function ($scope, $element, $attr) {
+                    $element.bind('click', function () {
+                        $element.toggleClass('open');
+                        $element.addClass('open-recent');
+                    });
+
+                    $document.bind('click', function () {
+                        if (!$element.hasClass('open-recent')) {
+                            $element.removeClass('open');
+                        }
+                        $element.removeClass('open-recent');
+                    })
+                }
+            }
+        })
         .directive('filterDropdown', function ($document) {
             return {
                 restrict: 'A',
@@ -537,6 +555,16 @@ function getQueryVariable(variable) {
     }
 }
 
+function storeValue(settingName, value) {
+    try {
+        localStorage.setItem(`clippy-lint-list-${settingName}`, value);
+    } catch (e) { }
+}
+
+function loadValue(settingName) {
+    return localStorage.getItem(`clippy-lint-list-${settingName}`);
+}
+
 function setTheme(theme, store) {
     let enableHighlight = false;
     let enableNight = false;
@@ -569,14 +597,12 @@ function setTheme(theme, store) {
     document.getElementById("styleAyu").disabled = !enableAyu;
 
     if (store) {
-        try {
-            localStorage.setItem('clippy-lint-list-theme', theme);
-        } catch (e) { }
+        storeValue("theme", theme);
     }
 }
 
 function handleShortcut(ev) {
-    if (ev.ctrlKey || ev.altKey || ev.metaKey) {
+    if (ev.ctrlKey || ev.altKey || ev.metaKey || disableShortcuts) {
         return;
     }
 
@@ -601,11 +627,20 @@ function handleShortcut(ev) {
 document.addEventListener("keypress", handleShortcut);
 document.addEventListener("keydown", handleShortcut);
 
+function changeSetting(elem) {
+    if (elem.id === "disable-shortcuts") {
+        disableShortcuts = elem.checked;
+        storeValue(elem.id, elem.checked);
+    }
+}
+
 // loading the theme after the initial load
 const prefersDark = window.matchMedia("(prefers-color-scheme: dark)");
-const theme = localStorage.getItem('clippy-lint-list-theme');
+const theme = loadValue('theme');
 if (prefersDark.matches && !theme) {
     setTheme("coal", false);
 } else {
     setTheme(theme, false);
 }
+let disableShortcuts = loadValue('disable-shortcuts') === "true";
+document.getElementById("disable-shortcuts").checked = disableShortcuts;
diff --git a/util/gh-pages/style.css b/util/gh-pages/style.css
index f9feb0ba13ae3..4ad8b502dd82f 100644
--- a/util/gh-pages/style.css
+++ b/util/gh-pages/style.css
@@ -220,14 +220,20 @@ details[open] {
     --inline-code-bg: #191f26;
 }
 
-.theme-dropdown {
+#settings {
     position: absolute;
     margin: 0.7em;
     z-index: 10;
+    display: flex;
+}
+
+.menu-container {
+    position: relative;
+    width: 28px;
 }
 
 /* Applying the mdBook theme */
-.theme-icon {
+.theme-icon, .settings-icon {
     text-align: center;
     width: 2em;
     height: 2em;
@@ -237,10 +243,10 @@ details[open] {
     user-select: none;
     cursor: pointer;
 }
-.theme-icon:hover {
+.theme-icon:hover, .settings-icon:hover {
     background: var(--theme-hover);
 }
-.theme-choice {
+.theme-choice, .settings-choice {
     display: none;
     list-style: none;
     border: 1px solid var(--theme-popup-border);
@@ -249,9 +255,46 @@ details[open] {
     background: var(--theme-popup-bg);
     padding: 0 0;
     overflow: hidden;
+    position: absolute;
+}
+
+.settings-dropdown {
+    margin-left: 4px;
+}
+
+.settings-icon::before {
+    /* Wheel <https://www.svgrepo.com/svg/384069/settings-cog-gear> */
+    content: url('data:image/svg+xml,<svg width="18" height="18" viewBox="0 0 12 12" \
+enable-background="new 0 0 12 12" xmlns="http://www.w3.org/2000/svg">\
+<path d="M10.25,6c0-0.1243286-0.0261841-0.241333-0.0366211-0.362915l1.6077881-1.5545654l\
+-1.25-2.1650391  c0,0-1.2674561,0.3625488-2.1323853,0.6099854c-0.2034912-0.1431885-0.421875\
+-0.2639771-0.6494751-0.3701782L7.25,0h-2.5 c0,0-0.3214111,1.2857666-0.5393066,2.1572876\
+C3.9830933,2.2634888,3.7647095,2.3842773,3.5612183,2.5274658L1.428833,1.9174805 \
+l-1.25,2.1650391c0,0,0.9641113,0.9321899,1.6077881,1.5545654C1.7761841,5.758667,\
+1.75,5.8756714,1.75,6  s0.0261841,0.241333,0.0366211,0.362915L0.178833,7.9174805l1.25,\
+2.1650391l2.1323853-0.6099854  c0.2034912,0.1432495,0.421875,0.2639771,0.6494751,0.3701782\
+L4.75,12h2.5l0.5393066-2.1572876  c0.2276001-0.1062012,0.4459839-0.2269287,0.6494751\
+-0.3701782l2.1323853,0.6099854l1.25-2.1650391L10.2133789,6.362915  C10.2238159,6.241333,\
+10.25,6.1243286,10.25,6z M6,7.5C5.1715698,7.5,4.5,6.8284302,4.5,6S5.1715698,4.5,6,4.5S7.5\
+,5.1715698,7.5,6  S6.8284302,7.5,6,7.5z" fill="black"/></svg>');
+  width: 18px;
+  height: 18px;
+  display: block;
+  filter: invert(0.7);
+  padding-left: 4px;
+  padding-top: 3px;
+}
+
+.settings-choice {
+    padding: 4px;
+    width: 212px;
+}
+
+.settings-choice label {
+    cursor: pointer;
 }
 
-.theme-dropdown.open .theme-choice {
+.theme-dropdown.open .theme-choice, .settings-dropdown.open .settings-choice {
     display: block;
 }
 

From 8bf5a8332244dfc57cbd608ece30929ff44b7316 Mon Sep 17 00:00:00 2001
From: alexey semenyuk <alexsemenyuk88@gmail.com>
Date: Tue, 30 Jul 2024 22:34:56 +0500
Subject: [PATCH 030/685] Fix example

---
 clippy_lints/src/unused_io_amount.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/unused_io_amount.rs b/clippy_lints/src/unused_io_amount.rs
index 448946bd66d51..cfc4ea46bdb2b 100644
--- a/clippy_lints/src/unused_io_amount.rs
+++ b/clippy_lints/src/unused_io_amount.rs
@@ -34,11 +34,18 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// use std::io;
     /// fn foo<W: io::Write>(w: &mut W) -> io::Result<()> {
-    ///     // must be `w.write_all(b"foo")?;`
     ///     w.write(b"foo")?;
     ///     Ok(())
     /// }
     /// ```
+    /// Use instead:
+    /// ```rust,ignore
+    /// use std::io;
+    /// fn foo<W: io::Write>(w: &mut W) -> io::Result<()> {
+    ///     w.write_all(b"foo")?;
+    ///     Ok(())
+    /// }
+    /// ```
     #[clippy::version = "pre 1.29.0"]
     pub UNUSED_IO_AMOUNT,
     correctness,

From e65a48efd9b711281c70667c5392de70a9e1f7c3 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 1 Aug 2024 11:59:47 -0700
Subject: [PATCH 031/685] Document WebAssembly target feature expectations

This commit is a result of the discussion on #128475 and incorporates
parts of #109807 as well. This is all done as a new page of
documentation for the `wasm32-unknown-unknown` target which previously
did not exist. This new page goes into details about the preexisting
target and additionally documents the expectations for WebAssembly
features and code generation.

The tl;dr is that LLVM will enable features over time after most engines
have had support for awhile. Compiling without features requires
`-Ctarget-cpu=mvp` to rustc plus `-Zbuild-std` to Cargo.

Closes #109807
Closes #128475
---
 src/doc/rustc/src/platform-support.md         |   2 +-
 .../wasm32-unknown-unknown.md                 | 154 ++++++++++++++++++
 .../src/platform-support/wasm32-wasip1.md     |   7 +
 .../src/platform-support/wasm32-wasip2.md     |   7 +
 4 files changed, 169 insertions(+), 1 deletion(-)
 create mode 100644 src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md

diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index cbb338f481172..1fb7d2d150385 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -190,7 +190,7 @@ target | std | notes
 [`thumbv8m.main-none-eabi`](platform-support/thumbv8m.main-none-eabi.md) | * | Bare Armv8-M Mainline
 [`thumbv8m.main-none-eabihf`](platform-support/thumbv8m.main-none-eabi.md) | * | Bare Armv8-M Mainline, hardfloat
 `wasm32-unknown-emscripten` | ✓ | WebAssembly via Emscripten
-`wasm32-unknown-unknown` | ✓ | WebAssembly
+[`wasm32-unknown-unknown`](platform-support/wasm32-unknown-unknown.md) | ✓ | WebAssembly
 `wasm32-wasi` | ✓ | WebAssembly with WASI (undergoing a [rename to `wasm32-wasip1`][wasi-rename])
 [`wasm32-wasip1`](platform-support/wasm32-wasip1.md) | ✓ | WebAssembly with WASI
 [`wasm32-wasip1-threads`](platform-support/wasm32-wasip1-threads.md) | ✓ | WebAssembly with WASI Preview 1 and threads
diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
new file mode 100644
index 0000000000000..03126eaa50cbb
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -0,0 +1,154 @@
+# `wasm32-unknown-unknown`
+
+**Tier: 2**
+
+The `wasm32-unknown-unknown` target is a WebAssembly compilation target which
+does not import any functions from the host for the standard library. This is
+the "minimal" WebAssembly in the sense of making the fewest assumptions about
+the host environment. This target is often used when compiling to the web or
+JavaScript environments as there is not standard for what functions can be
+imported on the web. This target can also be useful for creating minimal or
+bare-bones WebAssembly binaries.
+
+The `wasm32-unknown-unknown` target has support for the Rust standard library
+but many parts of the standard library do not work and return errors. For
+example `println!` does nothing, `std::fs` always return errors, and
+`std::thread::spawn` will panic. There is no means by which this can be
+overridden. For a WebAssembly target that more fully supports the standard
+library see the [`wasm32-wasip1`](./wasm32-wasip1.md) or
+[`wasm32-wasip2`](./wasm32-wasip2.md) targets.
+
+The `wasm32-unknown-unknown` target has full support for the `core` and `alloc`
+crates. It additionally supports the `HashMap` type in the `std` crate, although
+hash maps are not randomized like they are on other platforms.
+
+One existing user of this target (please feel free to edit and expand this list
+too) is the [`wasm-bindgen` project](https://github.com/rustwasm/wasm-bindgen)
+which facilitates Rust code interoperating with JavaScript code. Note, though,
+that not all uses of `wasm32-unknown-unknown` are using JavaScript and the web.
+
+## Target maintainers
+
+When this target was added to the compiler platform-specific documentation here
+was not maintained at that time. This means that the list below is not
+exhaustive and there are more interested parties in this target. That being
+said since when this document was last updated those interested in maintaining
+this target are:
+
+- Alex Crichton, https://github.com/alexcrichton
+
+## Requirements
+
+This target is cross-compiled. The target includes support for `std` itself,
+but as mentioned above many pieces of functionality that require an operating
+system do not work and will return errors.
+
+This target currently has no equivalent in C/C++. There is no C/C++ toolchain
+for this target. While interop is theoretically possible it's recommended to
+instead use one of:
+
+* `wasm32-unknown-emscripten` - for web-based use cases the Emscripten
+  toolchain is typically chosen for running C/C++.
+* [`wasm32-wasip1`](./wasm32-wasip1.md) - the wasi-sdk toolchain is used to
+  compile C/C++ on this target and can interop with Rust code. WASI works on
+  the web so far as there's no blocker, but an implementation of WASI APIs
+  must be either chosen or reimplemented.
+
+This target has no build requirements beyond what's in-tree in the Rust
+repository. Linking binaries requires LLD to be enabled for the `wasm-ld`
+driver. This target uses the `dlmalloc` crate as the default global allocator.
+
+## Building the target
+
+Building this target can be done by:
+
+* Configure the `wasm32-unknown-unknown` target to get built.
+* Configure LLD to be built.
+* Ensure the `WebAssembly` target backend is not disabled in LLVM.
+
+These are all controlled through `config.toml` options. It should be possible
+to build this target on any platform.
+
+## Building Rust programs
+
+Rust programs can be compiled by adding this target via rustup:
+
+```sh
+$ rustup target add wasm32-unknown-unknown
+```
+
+and then compiling with the target:
+
+```sh
+$ rustc foo.rs --target wasm32-unknown-unknown
+$ file foo.wasm
+```
+
+## Cross-compilation
+
+This target can be cross-compiled from any hosts.
+
+## Testing
+
+This target is not tested in CI for the rust-lang/rust repository. Many tests
+must be disabled to run on this target and failures are non-obvious because
+println doesn't work in the standard library. It's recommended to test the
+`wasm32-wasip1` target instead for WebAssembly compatibility.
+
+## Conditionally compiling code
+
+It's recommended to conditionally compile code for this target with:
+
+```text
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+```
+
+Note that there is no way to tell via `#[cfg]` whether code will be running on
+the web or not.
+
+## Enabled WebAssembly features
+
+WebAssembly is an evolving standard which adds new features such as new
+instructions over time. This target's default set of supported WebAssembly
+features will additionally change over time. The `wasm32-unknown-unknown` target
+inherits the default settings of LLVM which typically matches the default
+settings of Emscripten as well.
+
+Changes to WebAssembly go through a [proposals process][proposals] but reaching
+the final stage (stage 5) does not automatically mean that the feature will be
+enabled in LLVM and Rust by default. At this time the general guidance is that
+features must be present in most engines for a "good chunk of time" before
+they're enabled in LLVM by default. There is currently not exact number of
+months or engines that are required to enable features by default.
+
+[proposals]: https://github.com/WebAssembly/proposals
+
+If you're compiling WebAssembly code for an engine that does not support a
+feature in LLVM's default feature set then the feature must be disabled at
+compile time. Note, though, that enabled features may be used in the standard
+library or precompiled libraries shipped via rustup. This means that not only
+does your own code need to be compiled with the correct set of flags but the
+Rust standard library additionally must be recompiled.
+
+Compiling all code for the initial release of WebAssembly looks like:
+
+```sh
+$ export RUSTFLAG=-Ctarget-cpu=mvp
+$ cargo +nightly build -Zbuild-std=panic_abort,std --target wasm32-unknown-unknown
+```
+
+Here the `mvp` "cpu" is a placeholder in LLVM for disabling all supported
+features by default. Cargo's `-Zbuild-std` feature, a Nightly Rust feature, is
+then used to recompile the standard library in addition to your own code. This
+will produce a binary that uses only the original WebAssembly features by
+default and no proposals since its inception.
+
+To enable individual features it can be done with `-Ctarget-feature=+foo`.
+Available features can be found through:
+
+```sh
+$ rustc -Ctarget-feature=help --target wasm32-unknown-unknown
+```
+
+You'll need to consult your WebAssembly engine's documentation to learn more
+about the supported WebAssembly features the engine has.
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip1.md b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
index fb70bbdc2b403..7a7cac9aeeb1e 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip1.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
@@ -132,3 +132,10 @@ It's recommended to conditionally compile code for this target with:
 
 Note that the `target_env = "p1"` condition first appeared in Rust 1.80. Prior
 to Rust 1.80 the `target_env` condition was not set.
+
+## Enabled WebAssembly features
+
+The default set of WebAssembly features enabled for compilation is currently the
+same across all WebAssembly targets. For more information on WebAssembly
+features see the documentation for
+[`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md)
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip2.md b/src/doc/rustc/src/platform-support/wasm32-wasip2.md
index 1e53fbc178e2e..e4ef65bcfec55 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip2.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip2.md
@@ -61,3 +61,10 @@ It's recommended to conditionally compile code for this target with:
 ```text
 #[cfg(all(target_os = "wasi", target_env = "p2"))]
 ```
+
+## Enabled WebAssembly features
+
+The default set of WebAssembly features enabled for compilation is currently the
+same across all WebAssembly targets. For more information on WebAssembly
+features see the documentation for
+[`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md)

From dea3846edc94ac2b840458594b2772f0c960e329 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 1 Aug 2024 12:16:42 -0700
Subject: [PATCH 032/685] Review comments

---
 .../src/platform-support/wasm32-unknown-unknown.md  | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
index 03126eaa50cbb..85915cf90a9c3 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -6,7 +6,7 @@ The `wasm32-unknown-unknown` target is a WebAssembly compilation target which
 does not import any functions from the host for the standard library. This is
 the "minimal" WebAssembly in the sense of making the fewest assumptions about
 the host environment. This target is often used when compiling to the web or
-JavaScript environments as there is not standard for what functions can be
+JavaScript environments as there is no standard for what functions can be
 imported on the web. This target can also be useful for creating minimal or
 bare-bones WebAssembly binaries.
 
@@ -86,13 +86,13 @@ $ file foo.wasm
 
 ## Cross-compilation
 
-This target can be cross-compiled from any hosts.
+This target can be cross-compiled from any host.
 
 ## Testing
 
 This target is not tested in CI for the rust-lang/rust repository. Many tests
 must be disabled to run on this target and failures are non-obvious because
-println doesn't work in the standard library. It's recommended to test the
+`println!` doesn't work in the standard library. It's recommended to test the
 `wasm32-wasip1` target instead for WebAssembly compatibility.
 
 ## Conditionally compiling code
@@ -118,7 +118,7 @@ Changes to WebAssembly go through a [proposals process][proposals] but reaching
 the final stage (stage 5) does not automatically mean that the feature will be
 enabled in LLVM and Rust by default. At this time the general guidance is that
 features must be present in most engines for a "good chunk of time" before
-they're enabled in LLVM by default. There is currently not exact number of
+they're enabled in LLVM by default. There is currently no exact number of
 months or engines that are required to enable features by default.
 
 [proposals]: https://github.com/WebAssembly/proposals
@@ -144,7 +144,8 @@ will produce a binary that uses only the original WebAssembly features by
 default and no proposals since its inception.
 
 To enable individual features it can be done with `-Ctarget-feature=+foo`.
-Available features can be found through:
+Available features for Rust code itself are documented in the [reference] and
+can also be found through:
 
 ```sh
 $ rustc -Ctarget-feature=help --target wasm32-unknown-unknown
@@ -152,3 +153,5 @@ $ rustc -Ctarget-feature=help --target wasm32-unknown-unknown
 
 You'll need to consult your WebAssembly engine's documentation to learn more
 about the supported WebAssembly features the engine has.
+
+[reference]: https://doc.rust-lang.org/reference/attributes/codegen.html#wasm32-or-wasm64

From 927633cae4eec359901523d8fa9a962749c89560 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 1 Aug 2024 12:20:44 -0700
Subject: [PATCH 033/685] Add a note about libraries and `#[target_feature]`

---
 .../wasm32-unknown-unknown.md                 | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
index 85915cf90a9c3..2bd50f6e6db8c 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -155,3 +155,36 @@ You'll need to consult your WebAssembly engine's documentation to learn more
 about the supported WebAssembly features the engine has.
 
 [reference]: https://doc.rust-lang.org/reference/attributes/codegen.html#wasm32-or-wasm64
+
+Note that it is still possible for Rust crates and libraries to enable
+WebAssembly features on a per-function level. This means that the build
+command above may not be sufficent to disable all WebAssembly features. If the
+final binary still has SIMD instructions, for example, the function in question
+will need to be found and the crate in question will likely contain something
+like:
+
+```rust
+#[target_feature(enable = "simd128")]
+fn foo() {
+    // ...
+}
+```
+
+In this situation there is no compiler flag to disable emission of SIMD
+instructions and the crate must instead be modified to not include this function
+at compile time either by default or through a Cargo feature. For crate authors
+it's recommended to avoid `#[target_feature(enable = "...")]` except where
+necessary and instead use:
+
+```rust
+#[cfg(target_feature = "simd128")]
+fn foo() {
+    // ...
+}
+```
+
+That is to say instead of enabling target features it's recommended to
+conditionally compile code instead. This is notably different to the way native
+platforms such as x86\_64 work, and this is due to the fact that WebAssembly
+binaries must only contain code the engine understands. Native binaries work so
+long as the CPU doesn't execute unknown code dynamically at runtime.

From cfe3ea65d29dbed12cf5466b51dbeb094a3729f1 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 1 Aug 2024 13:13:19 -0700
Subject: [PATCH 034/685] Add new page to SUMMARY.md

---
 src/doc/rustc/src/SUMMARY.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 08460af15d4c7..c5622a5e14e20 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -78,6 +78,7 @@
     - [wasm32-wasip1](platform-support/wasm32-wasip1.md)
     - [wasm32-wasip1-threads](platform-support/wasm32-wasip1-threads.md)
     - [wasm32-wasip2](platform-support/wasm32-wasip2.md)
+    - [wasm32-unknown-unknown](platform-support/wasm32-unknown-unknown.md)
     - [wasm64-unknown-unknown](platform-support/wasm64-unknown-unknown.md)
     - [\*-win7-windows-msvc](platform-support/win7-windows-msvc.md)
     - [x86_64-fortanix-unknown-sgx](platform-support/x86_64-fortanix-unknown-sgx.md)

From ce7f1b77f400bbf42e2ca9628dec087c1a2605c5 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 1 Aug 2024 14:33:04 -0700
Subject: [PATCH 035/685] Ignore two new doc blocks in testing

---
 src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
index 2bd50f6e6db8c..a4b547bd1fff1 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -163,7 +163,7 @@ final binary still has SIMD instructions, for example, the function in question
 will need to be found and the crate in question will likely contain something
 like:
 
-```rust
+```rust,ignore
 #[target_feature(enable = "simd128")]
 fn foo() {
     // ...
@@ -176,7 +176,7 @@ at compile time either by default or through a Cargo feature. For crate authors
 it's recommended to avoid `#[target_feature(enable = "...")]` except where
 necessary and instead use:
 
-```rust
+```rust,ignore
 #[cfg(target_feature = "simd128")]
 fn foo() {
     // ...

From b6f65a4b224ec74918ecc5e02527c72e75a18f89 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 1 Aug 2024 14:36:55 -0700
Subject: [PATCH 036/685] Document on-by-default features

---
 .../rustc/src/platform-support/wasm32-unknown-unknown.md  | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
index a4b547bd1fff1..5de80fea6bf76 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -123,6 +123,14 @@ months or engines that are required to enable features by default.
 
 [proposals]: https://github.com/WebAssembly/proposals
 
+As of the time of this writing the proposals that are enabled by default (the
+`generic` CPU in LLVM terminology) are:
+
+* `multivalue`
+* `mutable-globals`
+* `reference-types`
+* `sign-ext`
+
 If you're compiling WebAssembly code for an engine that does not support a
 feature in LLVM's default feature set then the feature must be disabled at
 compile time. Note, though, that enabled features may be used in the standard

From a5082ef5a8de1296d5d623b4a76711f2e3176e26 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 1 Aug 2024 15:02:32 -0700
Subject: [PATCH 037/685] Appease tidy

---
 src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
index 5de80fea6bf76..1c2894e3a7390 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -171,7 +171,7 @@ final binary still has SIMD instructions, for example, the function in question
 will need to be found and the crate in question will likely contain something
 like:
 
-```rust,ignore
+```rust,ignore (not-always-compiled-to-wasm)
 #[target_feature(enable = "simd128")]
 fn foo() {
     // ...
@@ -184,7 +184,7 @@ at compile time either by default or through a Cargo feature. For crate authors
 it's recommended to avoid `#[target_feature(enable = "...")]` except where
 necessary and instead use:
 
-```rust,ignore
+```rust,ignore (not-always-compiled-to-wasm)
 #[cfg(target_feature = "simd128")]
 fn foo() {
     // ...

From b1493ba5194fcc5cfe4f6315db288e4e18509110 Mon Sep 17 00:00:00 2001
From: beetrees <b@beetr.ee>
Date: Sat, 1 Jun 2024 12:25:16 +0100
Subject: [PATCH 038/685] Move ZST ABI handling to `rustc_target`

---
 compiler/rustc_target/src/abi/call/mod.rs     | 13 +++-
 compiler/rustc_target/src/abi/call/powerpc.rs | 20 +++--
 compiler/rustc_target/src/abi/call/s390x.rs   | 18 +++--
 compiler/rustc_target/src/abi/call/sparc64.rs | 12 ++-
 .../rustc_target/src/abi/call/x86_win64.rs    | 10 ++-
 compiler/rustc_ty_utils/src/abi.rs            | 27 +------
 src/tools/compiletest/src/command-list.rs     |  5 ++
 tests/ui/abi/c-zst.other-linux.stderr         | 67 ++++++++++++++++
 tests/ui/abi/c-zst.other.stderr               | 67 ++++++++++++++++
 tests/ui/abi/c-zst.powerpc-linux.stderr       | 78 +++++++++++++++++++
 tests/ui/abi/c-zst.rs                         | 27 +++++++
 tests/ui/abi/c-zst.s390x-linux.stderr         | 78 +++++++++++++++++++
 tests/ui/abi/c-zst.sparc64-linux.stderr       | 78 +++++++++++++++++++
 .../ui/abi/c-zst.x86_64-pc-windows-gnu.stderr | 78 +++++++++++++++++++
 tests/ui/abi/sysv64-zst.rs                    |  8 ++
 tests/ui/abi/sysv64-zst.stderr                | 67 ++++++++++++++++
 tests/ui/abi/win64-zst.other.stderr           | 67 ++++++++++++++++
 tests/ui/abi/win64-zst.rs                     | 11 +++
 tests/ui/abi/win64-zst.windows-gnu.stderr     | 78 +++++++++++++++++++
 19 files changed, 766 insertions(+), 43 deletions(-)
 create mode 100644 tests/ui/abi/c-zst.other-linux.stderr
 create mode 100644 tests/ui/abi/c-zst.other.stderr
 create mode 100644 tests/ui/abi/c-zst.powerpc-linux.stderr
 create mode 100644 tests/ui/abi/c-zst.rs
 create mode 100644 tests/ui/abi/c-zst.s390x-linux.stderr
 create mode 100644 tests/ui/abi/c-zst.sparc64-linux.stderr
 create mode 100644 tests/ui/abi/c-zst.x86_64-pc-windows-gnu.stderr
 create mode 100644 tests/ui/abi/sysv64-zst.rs
 create mode 100644 tests/ui/abi/sysv64-zst.stderr
 create mode 100644 tests/ui/abi/win64-zst.other.stderr
 create mode 100644 tests/ui/abi/win64-zst.rs
 create mode 100644 tests/ui/abi/win64-zst.windows-gnu.stderr

diff --git a/compiler/rustc_target/src/abi/call/mod.rs b/compiler/rustc_target/src/abi/call/mod.rs
index 5bfc528dffc83..25e4d70945b2c 100644
--- a/compiler/rustc_target/src/abi/call/mod.rs
+++ b/compiler/rustc_target/src/abi/call/mod.rs
@@ -642,7 +642,7 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
     pub fn make_indirect(&mut self) {
         match self.mode {
             PassMode::Direct(_) | PassMode::Pair(_, _) => {
-                self.mode = Self::indirect_pass_mode(&self.layout);
+                self.make_indirect_force();
             }
             PassMode::Indirect { attrs: _, meta_attrs: _, on_stack: false } => {
                 // already indirect
@@ -652,6 +652,11 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
         }
     }
 
+    /// Same as make_indirect, but doesn't check the current `PassMode`.
+    pub fn make_indirect_force(&mut self) {
+        self.mode = Self::indirect_pass_mode(&self.layout);
+    }
+
     /// Pass this argument indirectly, by placing it at a fixed stack offset.
     /// This corresponds to the `byval` LLVM argument attribute.
     /// This is only valid for sized arguments.
@@ -871,10 +876,10 @@ impl<'a, Ty> FnAbi<'a, Ty> {
             }
             "x86_64" => match abi {
                 spec::abi::Abi::SysV64 { .. } => x86_64::compute_abi_info(cx, self),
-                spec::abi::Abi::Win64 { .. } => x86_win64::compute_abi_info(self),
+                spec::abi::Abi::Win64 { .. } => x86_win64::compute_abi_info(cx, self),
                 _ => {
                     if cx.target_spec().is_like_windows {
-                        x86_win64::compute_abi_info(self)
+                        x86_win64::compute_abi_info(cx, self)
                     } else {
                         x86_64::compute_abi_info(cx, self)
                     }
@@ -898,7 +903,7 @@ impl<'a, Ty> FnAbi<'a, Ty> {
             "csky" => csky::compute_abi_info(self),
             "mips" | "mips32r6" => mips::compute_abi_info(cx, self),
             "mips64" | "mips64r6" => mips64::compute_abi_info(cx, self),
-            "powerpc" => powerpc::compute_abi_info(self),
+            "powerpc" => powerpc::compute_abi_info(cx, self),
             "powerpc64" => powerpc64::compute_abi_info(cx, self),
             "s390x" => s390x::compute_abi_info(cx, self),
             "msp430" => msp430::compute_abi_info(self),
diff --git a/compiler/rustc_target/src/abi/call/powerpc.rs b/compiler/rustc_target/src/abi/call/powerpc.rs
index 70c32db0a871b..cb80d64c94304 100644
--- a/compiler/rustc_target/src/abi/call/powerpc.rs
+++ b/compiler/rustc_target/src/abi/call/powerpc.rs
@@ -1,4 +1,5 @@
 use crate::abi::call::{ArgAbi, FnAbi};
+use crate::spec::HasTargetSpec;
 
 fn classify_ret<Ty>(ret: &mut ArgAbi<'_, Ty>) {
     if ret.layout.is_aggregate() {
@@ -8,7 +9,17 @@ fn classify_ret<Ty>(ret: &mut ArgAbi<'_, Ty>) {
     }
 }
 
-fn classify_arg<Ty>(arg: &mut ArgAbi<'_, Ty>) {
+fn classify_arg<Ty>(cx: &impl HasTargetSpec, arg: &mut ArgAbi<'_, Ty>) {
+    if arg.is_ignore() {
+        // powerpc-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs.
+        if cx.target_spec().os == "linux"
+            && matches!(&*cx.target_spec().env, "gnu" | "musl" | "uclibc")
+            && arg.layout.is_zst()
+        {
+            arg.make_indirect_force();
+        }
+        return;
+    }
     if arg.layout.is_aggregate() {
         arg.make_indirect();
     } else {
@@ -16,15 +27,12 @@ fn classify_arg<Ty>(arg: &mut ArgAbi<'_, Ty>) {
     }
 }
 
-pub fn compute_abi_info<Ty>(fn_abi: &mut FnAbi<'_, Ty>) {
+pub fn compute_abi_info<Ty>(cx: &impl HasTargetSpec, fn_abi: &mut FnAbi<'_, Ty>) {
     if !fn_abi.ret.is_ignore() {
         classify_ret(&mut fn_abi.ret);
     }
 
     for arg in fn_abi.args.iter_mut() {
-        if arg.is_ignore() {
-            continue;
-        }
-        classify_arg(arg);
+        classify_arg(cx, arg);
     }
 }
diff --git a/compiler/rustc_target/src/abi/call/s390x.rs b/compiler/rustc_target/src/abi/call/s390x.rs
index 1a2191082d5de..7dcbb3e4a9e9b 100644
--- a/compiler/rustc_target/src/abi/call/s390x.rs
+++ b/compiler/rustc_target/src/abi/call/s390x.rs
@@ -3,6 +3,7 @@
 
 use crate::abi::call::{ArgAbi, FnAbi, Reg};
 use crate::abi::{HasDataLayout, TyAbiInterface};
+use crate::spec::HasTargetSpec;
 
 fn classify_ret<Ty>(ret: &mut ArgAbi<'_, Ty>) {
     if !ret.layout.is_aggregate() && ret.layout.size.bits() <= 64 {
@@ -15,12 +16,22 @@ fn classify_ret<Ty>(ret: &mut ArgAbi<'_, Ty>) {
 fn classify_arg<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>)
 where
     Ty: TyAbiInterface<'a, C> + Copy,
-    C: HasDataLayout,
+    C: HasDataLayout + HasTargetSpec,
 {
     if !arg.layout.is_sized() {
         // Not touching this...
         return;
     }
+    if arg.is_ignore() {
+        // s390x-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs.
+        if cx.target_spec().os == "linux"
+            && matches!(&*cx.target_spec().env, "gnu" | "musl" | "uclibc")
+            && arg.layout.is_zst()
+        {
+            arg.make_indirect_force();
+        }
+        return;
+    }
     if !arg.layout.is_aggregate() && arg.layout.size.bits() <= 64 {
         arg.extend_integer_width_to(64);
         return;
@@ -46,16 +57,13 @@ where
 pub fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
 where
     Ty: TyAbiInterface<'a, C> + Copy,
-    C: HasDataLayout,
+    C: HasDataLayout + HasTargetSpec,
 {
     if !fn_abi.ret.is_ignore() {
         classify_ret(&mut fn_abi.ret);
     }
 
     for arg in fn_abi.args.iter_mut() {
-        if arg.is_ignore() {
-            continue;
-        }
         classify_arg(cx, arg);
     }
 }
diff --git a/compiler/rustc_target/src/abi/call/sparc64.rs b/compiler/rustc_target/src/abi/call/sparc64.rs
index c0952130e0410..3b2bf9b3187f1 100644
--- a/compiler/rustc_target/src/abi/call/sparc64.rs
+++ b/compiler/rustc_target/src/abi/call/sparc64.rs
@@ -4,6 +4,7 @@ use crate::abi::call::{
     ArgAbi, ArgAttribute, ArgAttributes, ArgExtension, CastTarget, FnAbi, Reg, Uniform,
 };
 use crate::abi::{self, HasDataLayout, Scalar, Size, TyAbiInterface, TyAndLayout};
+use crate::spec::HasTargetSpec;
 
 #[derive(Clone, Debug)]
 pub struct Sdata {
@@ -211,7 +212,7 @@ where
 pub fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
 where
     Ty: TyAbiInterface<'a, C> + Copy,
-    C: HasDataLayout,
+    C: HasDataLayout + HasTargetSpec,
 {
     if !fn_abi.ret.is_ignore() {
         classify_arg(cx, &mut fn_abi.ret, Size::from_bytes(32));
@@ -219,7 +220,14 @@ where
 
     for arg in fn_abi.args.iter_mut() {
         if arg.is_ignore() {
-            continue;
+            // sparc64-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs.
+            if cx.target_spec().os == "linux"
+                && matches!(&*cx.target_spec().env, "gnu" | "musl" | "uclibc")
+                && arg.layout.is_zst()
+            {
+                arg.make_indirect_force();
+            }
+            return;
         }
         classify_arg(cx, arg, Size::from_bytes(16));
     }
diff --git a/compiler/rustc_target/src/abi/call/x86_win64.rs b/compiler/rustc_target/src/abi/call/x86_win64.rs
index 4e19460bd28c2..6ca01cf84eaa4 100644
--- a/compiler/rustc_target/src/abi/call/x86_win64.rs
+++ b/compiler/rustc_target/src/abi/call/x86_win64.rs
@@ -1,9 +1,10 @@
 use crate::abi::call::{ArgAbi, FnAbi, Reg};
 use crate::abi::{Abi, Float, Primitive};
+use crate::spec::HasTargetSpec;
 
 // Win64 ABI: https://docs.microsoft.com/en-us/cpp/build/parameter-passing
 
-pub fn compute_abi_info<Ty>(fn_abi: &mut FnAbi<'_, Ty>) {
+pub fn compute_abi_info<Ty>(cx: &impl HasTargetSpec, fn_abi: &mut FnAbi<'_, Ty>) {
     let fixup = |a: &mut ArgAbi<'_, Ty>| {
         match a.layout.abi {
             Abi::Uninhabited | Abi::Aggregate { sized: false } => {}
@@ -37,6 +38,13 @@ pub fn compute_abi_info<Ty>(fn_abi: &mut FnAbi<'_, Ty>) {
     }
     for arg in fn_abi.args.iter_mut() {
         if arg.is_ignore() {
+            // x86_64-pc-windows-gnu doesn't ignore ZSTs.
+            if cx.target_spec().os == "windows"
+                && cx.target_spec().env == "gnu"
+                && arg.layout.is_zst()
+            {
+                arg.make_indirect_force();
+            }
             continue;
         }
         fixup(arg);
diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index f1675f80717f0..464d03e4b35f2 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -584,7 +584,7 @@ fn fn_abi_new_uncached<'tcx>(
     let conv = conv_from_spec_abi(cx.tcx(), sig.abi, sig.c_variadic);
 
     let mut inputs = sig.inputs();
-    let extra_args = if sig.abi == RustCall {
+    let extra_args = if sig.abi == SpecAbi::RustCall {
         assert!(!sig.c_variadic && extra_args.is_empty());
 
         if let Some(input) = sig.inputs().last() {
@@ -608,18 +608,6 @@ fn fn_abi_new_uncached<'tcx>(
         extra_args
     };
 
-    let target = &cx.tcx.sess.target;
-    let target_env_gnu_like = matches!(&target.env[..], "gnu" | "musl" | "uclibc");
-    let win_x64_gnu = target.os == "windows" && target.arch == "x86_64" && target.env == "gnu";
-    let linux_s390x_gnu_like =
-        target.os == "linux" && target.arch == "s390x" && target_env_gnu_like;
-    let linux_sparc64_gnu_like =
-        target.os == "linux" && target.arch == "sparc64" && target_env_gnu_like;
-    let linux_powerpc_gnu_like =
-        target.os == "linux" && target.arch == "powerpc" && target_env_gnu_like;
-    use SpecAbi::*;
-    let rust_abi = matches!(sig.abi, RustIntrinsic | Rust | RustCall);
-
     let is_drop_in_place =
         fn_def_id.is_some() && fn_def_id == cx.tcx.lang_items().drop_in_place_fn();
 
@@ -659,18 +647,7 @@ fn fn_abi_new_uncached<'tcx>(
         });
 
         if arg.layout.is_zst() {
-            // For some forsaken reason, x86_64-pc-windows-gnu
-            // doesn't ignore zero-sized struct arguments.
-            // The same is true for {s390x,sparc64,powerpc}-unknown-linux-{gnu,musl,uclibc}.
-            if is_return
-                || rust_abi
-                || (!win_x64_gnu
-                    && !linux_s390x_gnu_like
-                    && !linux_sparc64_gnu_like
-                    && !linux_powerpc_gnu_like)
-            {
-                arg.mode = PassMode::Ignore;
-            }
+            arg.mode = PassMode::Ignore;
         }
 
         Ok(arg)
diff --git a/src/tools/compiletest/src/command-list.rs b/src/tools/compiletest/src/command-list.rs
index 288f90ea12399..a405cd486c713 100644
--- a/src/tools/compiletest/src/command-list.rs
+++ b/src/tools/compiletest/src/command-list.rs
@@ -91,10 +91,12 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "ignore-nvptx64-nvidia-cuda",
     "ignore-openbsd",
     "ignore-pass",
+    "ignore-powerpc",
     "ignore-remote",
     "ignore-riscv64",
     "ignore-s390x",
     "ignore-sgx",
+    "ignore-sparc64",
     "ignore-spirv",
     "ignore-stable",
     "ignore-stage1",
@@ -122,6 +124,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "ignore-x86",
     "ignore-x86_64",
     "ignore-x86_64-apple-darwin",
+    "ignore-x86_64-pc-windows-gnu",
     "ignore-x86_64-unknown-linux-gnu",
     "incremental",
     "known-bug",
@@ -189,7 +192,9 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "only-msvc",
     "only-nightly",
     "only-nvptx64",
+    "only-powerpc",
     "only-riscv64",
+    "only-s390x",
     "only-sparc",
     "only-sparc64",
     "only-stable",
diff --git a/tests/ui/abi/c-zst.other-linux.stderr b/tests/ui/abi/c-zst.other-linux.stderr
new file mode 100644
index 0000000000000..5a656e6ea66e0
--- /dev/null
+++ b/tests/ui/abi/c-zst.other-linux.stderr
@@ -0,0 +1,67 @@
+error: fn_abi_of(pass_zst) = FnAbi {
+           args: [
+               ArgAbi {
+                   layout: TyAndLayout {
+                       ty: (),
+                       layout: Layout {
+                           size: Size(0 bytes),
+                           align: AbiAndPrefAlign {
+                               abi: $SOME_ALIGN,
+                               pref: $SOME_ALIGN,
+                           },
+                           abi: Aggregate {
+                               sized: true,
+                           },
+                           fields: Arbitrary {
+                               offsets: [],
+                               memory_index: [],
+                           },
+                           largest_niche: None,
+                           variants: Single {
+                               index: 0,
+                           },
+                           max_repr_align: None,
+                           unadjusted_abi_align: $SOME_ALIGN,
+                       },
+                   },
+                   mode: Ignore,
+               },
+           ],
+           ret: ArgAbi {
+               layout: TyAndLayout {
+                   ty: (),
+                   layout: Layout {
+                       size: Size(0 bytes),
+                       align: AbiAndPrefAlign {
+                           abi: $SOME_ALIGN,
+                           pref: $SOME_ALIGN,
+                       },
+                       abi: Aggregate {
+                           sized: true,
+                       },
+                       fields: Arbitrary {
+                           offsets: [],
+                           memory_index: [],
+                       },
+                       largest_niche: None,
+                       variants: Single {
+                           index: 0,
+                       },
+                       max_repr_align: None,
+                       unadjusted_abi_align: $SOME_ALIGN,
+                   },
+               },
+               mode: Ignore,
+           },
+           c_variadic: false,
+           fixed_count: 1,
+           conv: C,
+           can_unwind: false,
+       }
+  --> $DIR/c-zst.rs:27:1
+   |
+LL | extern "C" fn pass_zst(_: ()) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/abi/c-zst.other.stderr b/tests/ui/abi/c-zst.other.stderr
new file mode 100644
index 0000000000000..5a656e6ea66e0
--- /dev/null
+++ b/tests/ui/abi/c-zst.other.stderr
@@ -0,0 +1,67 @@
+error: fn_abi_of(pass_zst) = FnAbi {
+           args: [
+               ArgAbi {
+                   layout: TyAndLayout {
+                       ty: (),
+                       layout: Layout {
+                           size: Size(0 bytes),
+                           align: AbiAndPrefAlign {
+                               abi: $SOME_ALIGN,
+                               pref: $SOME_ALIGN,
+                           },
+                           abi: Aggregate {
+                               sized: true,
+                           },
+                           fields: Arbitrary {
+                               offsets: [],
+                               memory_index: [],
+                           },
+                           largest_niche: None,
+                           variants: Single {
+                               index: 0,
+                           },
+                           max_repr_align: None,
+                           unadjusted_abi_align: $SOME_ALIGN,
+                       },
+                   },
+                   mode: Ignore,
+               },
+           ],
+           ret: ArgAbi {
+               layout: TyAndLayout {
+                   ty: (),
+                   layout: Layout {
+                       size: Size(0 bytes),
+                       align: AbiAndPrefAlign {
+                           abi: $SOME_ALIGN,
+                           pref: $SOME_ALIGN,
+                       },
+                       abi: Aggregate {
+                           sized: true,
+                       },
+                       fields: Arbitrary {
+                           offsets: [],
+                           memory_index: [],
+                       },
+                       largest_niche: None,
+                       variants: Single {
+                           index: 0,
+                       },
+                       max_repr_align: None,
+                       unadjusted_abi_align: $SOME_ALIGN,
+                   },
+               },
+               mode: Ignore,
+           },
+           c_variadic: false,
+           fixed_count: 1,
+           conv: C,
+           can_unwind: false,
+       }
+  --> $DIR/c-zst.rs:27:1
+   |
+LL | extern "C" fn pass_zst(_: ()) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/abi/c-zst.powerpc-linux.stderr b/tests/ui/abi/c-zst.powerpc-linux.stderr
new file mode 100644
index 0000000000000..ba9738050d87d
--- /dev/null
+++ b/tests/ui/abi/c-zst.powerpc-linux.stderr
@@ -0,0 +1,78 @@
+error: fn_abi_of(pass_zst) = FnAbi {
+           args: [
+               ArgAbi {
+                   layout: TyAndLayout {
+                       ty: (),
+                       layout: Layout {
+                           size: Size(0 bytes),
+                           align: AbiAndPrefAlign {
+                               abi: $SOME_ALIGN,
+                               pref: $SOME_ALIGN,
+                           },
+                           abi: Aggregate {
+                               sized: true,
+                           },
+                           fields: Arbitrary {
+                               offsets: [],
+                               memory_index: [],
+                           },
+                           largest_niche: None,
+                           variants: Single {
+                               index: 0,
+                           },
+                           max_repr_align: None,
+                           unadjusted_abi_align: $SOME_ALIGN,
+                       },
+                   },
+                   mode: Indirect {
+                       attrs: ArgAttributes {
+                           regular: NoAlias | NoCapture | NonNull | NoUndef,
+                           arg_ext: None,
+                           pointee_size: Size(0 bytes),
+                           pointee_align: Some(
+                               Align(1 bytes),
+                           ),
+                       },
+                       meta_attrs: None,
+                       on_stack: false,
+                   },
+               },
+           ],
+           ret: ArgAbi {
+               layout: TyAndLayout {
+                   ty: (),
+                   layout: Layout {
+                       size: Size(0 bytes),
+                       align: AbiAndPrefAlign {
+                           abi: $SOME_ALIGN,
+                           pref: $SOME_ALIGN,
+                       },
+                       abi: Aggregate {
+                           sized: true,
+                       },
+                       fields: Arbitrary {
+                           offsets: [],
+                           memory_index: [],
+                       },
+                       largest_niche: None,
+                       variants: Single {
+                           index: 0,
+                       },
+                       max_repr_align: None,
+                       unadjusted_abi_align: $SOME_ALIGN,
+                   },
+               },
+               mode: Ignore,
+           },
+           c_variadic: false,
+           fixed_count: 1,
+           conv: C,
+           can_unwind: false,
+       }
+  --> $DIR/c-zst.rs:27:1
+   |
+LL | extern "C" fn pass_zst(_: ()) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/abi/c-zst.rs b/tests/ui/abi/c-zst.rs
new file mode 100644
index 0000000000000..0cfd653b37e87
--- /dev/null
+++ b/tests/ui/abi/c-zst.rs
@@ -0,0 +1,27 @@
+//@ revisions: other other-linux x86_64-pc-windows-gnu s390x-linux sparc64-linux powerpc-linux
+//@ normalize-stderr-test: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
+// ZSTs are only not ignored when the target_env is "gnu", "musl" or "uclibc". However, Rust does
+// not currently support any other target_env on these architectures.
+
+// Ignore the ZST revisions
+//@[other] ignore-x86_64-pc-windows-gnu
+//@[other] ignore-linux
+//@[other-linux] only-linux
+//@[other-linux] ignore-s390x
+//@[other-linux] ignore-sparc64
+//@[other-linux] ignore-powerpc
+
+// Pass the ZST indirectly revisions
+//@[x86_64-pc-windows-gnu] only-x86_64-pc-windows-gnu
+//@[s390x-linux] only-s390x
+//@[s390x-linux] only-linux
+//@[sparc64-linux] only-sparc64
+//@[sparc64-linux] only-linux
+//@[powerpc-linux] only-powerpc
+//@[powerpc-linux] only-linux
+
+#![feature(rustc_attrs)]
+#![crate_type = "lib"]
+
+#[rustc_abi(debug)]
+extern "C" fn pass_zst(_: ()) {} //~ ERROR: fn_abi
diff --git a/tests/ui/abi/c-zst.s390x-linux.stderr b/tests/ui/abi/c-zst.s390x-linux.stderr
new file mode 100644
index 0000000000000..ba9738050d87d
--- /dev/null
+++ b/tests/ui/abi/c-zst.s390x-linux.stderr
@@ -0,0 +1,78 @@
+error: fn_abi_of(pass_zst) = FnAbi {
+           args: [
+               ArgAbi {
+                   layout: TyAndLayout {
+                       ty: (),
+                       layout: Layout {
+                           size: Size(0 bytes),
+                           align: AbiAndPrefAlign {
+                               abi: $SOME_ALIGN,
+                               pref: $SOME_ALIGN,
+                           },
+                           abi: Aggregate {
+                               sized: true,
+                           },
+                           fields: Arbitrary {
+                               offsets: [],
+                               memory_index: [],
+                           },
+                           largest_niche: None,
+                           variants: Single {
+                               index: 0,
+                           },
+                           max_repr_align: None,
+                           unadjusted_abi_align: $SOME_ALIGN,
+                       },
+                   },
+                   mode: Indirect {
+                       attrs: ArgAttributes {
+                           regular: NoAlias | NoCapture | NonNull | NoUndef,
+                           arg_ext: None,
+                           pointee_size: Size(0 bytes),
+                           pointee_align: Some(
+                               Align(1 bytes),
+                           ),
+                       },
+                       meta_attrs: None,
+                       on_stack: false,
+                   },
+               },
+           ],
+           ret: ArgAbi {
+               layout: TyAndLayout {
+                   ty: (),
+                   layout: Layout {
+                       size: Size(0 bytes),
+                       align: AbiAndPrefAlign {
+                           abi: $SOME_ALIGN,
+                           pref: $SOME_ALIGN,
+                       },
+                       abi: Aggregate {
+                           sized: true,
+                       },
+                       fields: Arbitrary {
+                           offsets: [],
+                           memory_index: [],
+                       },
+                       largest_niche: None,
+                       variants: Single {
+                           index: 0,
+                       },
+                       max_repr_align: None,
+                       unadjusted_abi_align: $SOME_ALIGN,
+                   },
+               },
+               mode: Ignore,
+           },
+           c_variadic: false,
+           fixed_count: 1,
+           conv: C,
+           can_unwind: false,
+       }
+  --> $DIR/c-zst.rs:27:1
+   |
+LL | extern "C" fn pass_zst(_: ()) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/abi/c-zst.sparc64-linux.stderr b/tests/ui/abi/c-zst.sparc64-linux.stderr
new file mode 100644
index 0000000000000..ba9738050d87d
--- /dev/null
+++ b/tests/ui/abi/c-zst.sparc64-linux.stderr
@@ -0,0 +1,78 @@
+error: fn_abi_of(pass_zst) = FnAbi {
+           args: [
+               ArgAbi {
+                   layout: TyAndLayout {
+                       ty: (),
+                       layout: Layout {
+                           size: Size(0 bytes),
+                           align: AbiAndPrefAlign {
+                               abi: $SOME_ALIGN,
+                               pref: $SOME_ALIGN,
+                           },
+                           abi: Aggregate {
+                               sized: true,
+                           },
+                           fields: Arbitrary {
+                               offsets: [],
+                               memory_index: [],
+                           },
+                           largest_niche: None,
+                           variants: Single {
+                               index: 0,
+                           },
+                           max_repr_align: None,
+                           unadjusted_abi_align: $SOME_ALIGN,
+                       },
+                   },
+                   mode: Indirect {
+                       attrs: ArgAttributes {
+                           regular: NoAlias | NoCapture | NonNull | NoUndef,
+                           arg_ext: None,
+                           pointee_size: Size(0 bytes),
+                           pointee_align: Some(
+                               Align(1 bytes),
+                           ),
+                       },
+                       meta_attrs: None,
+                       on_stack: false,
+                   },
+               },
+           ],
+           ret: ArgAbi {
+               layout: TyAndLayout {
+                   ty: (),
+                   layout: Layout {
+                       size: Size(0 bytes),
+                       align: AbiAndPrefAlign {
+                           abi: $SOME_ALIGN,
+                           pref: $SOME_ALIGN,
+                       },
+                       abi: Aggregate {
+                           sized: true,
+                       },
+                       fields: Arbitrary {
+                           offsets: [],
+                           memory_index: [],
+                       },
+                       largest_niche: None,
+                       variants: Single {
+                           index: 0,
+                       },
+                       max_repr_align: None,
+                       unadjusted_abi_align: $SOME_ALIGN,
+                   },
+               },
+               mode: Ignore,
+           },
+           c_variadic: false,
+           fixed_count: 1,
+           conv: C,
+           can_unwind: false,
+       }
+  --> $DIR/c-zst.rs:27:1
+   |
+LL | extern "C" fn pass_zst(_: ()) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/abi/c-zst.x86_64-pc-windows-gnu.stderr b/tests/ui/abi/c-zst.x86_64-pc-windows-gnu.stderr
new file mode 100644
index 0000000000000..ba9738050d87d
--- /dev/null
+++ b/tests/ui/abi/c-zst.x86_64-pc-windows-gnu.stderr
@@ -0,0 +1,78 @@
+error: fn_abi_of(pass_zst) = FnAbi {
+           args: [
+               ArgAbi {
+                   layout: TyAndLayout {
+                       ty: (),
+                       layout: Layout {
+                           size: Size(0 bytes),
+                           align: AbiAndPrefAlign {
+                               abi: $SOME_ALIGN,
+                               pref: $SOME_ALIGN,
+                           },
+                           abi: Aggregate {
+                               sized: true,
+                           },
+                           fields: Arbitrary {
+                               offsets: [],
+                               memory_index: [],
+                           },
+                           largest_niche: None,
+                           variants: Single {
+                               index: 0,
+                           },
+                           max_repr_align: None,
+                           unadjusted_abi_align: $SOME_ALIGN,
+                       },
+                   },
+                   mode: Indirect {
+                       attrs: ArgAttributes {
+                           regular: NoAlias | NoCapture | NonNull | NoUndef,
+                           arg_ext: None,
+                           pointee_size: Size(0 bytes),
+                           pointee_align: Some(
+                               Align(1 bytes),
+                           ),
+                       },
+                       meta_attrs: None,
+                       on_stack: false,
+                   },
+               },
+           ],
+           ret: ArgAbi {
+               layout: TyAndLayout {
+                   ty: (),
+                   layout: Layout {
+                       size: Size(0 bytes),
+                       align: AbiAndPrefAlign {
+                           abi: $SOME_ALIGN,
+                           pref: $SOME_ALIGN,
+                       },
+                       abi: Aggregate {
+                           sized: true,
+                       },
+                       fields: Arbitrary {
+                           offsets: [],
+                           memory_index: [],
+                       },
+                       largest_niche: None,
+                       variants: Single {
+                           index: 0,
+                       },
+                       max_repr_align: None,
+                       unadjusted_abi_align: $SOME_ALIGN,
+                   },
+               },
+               mode: Ignore,
+           },
+           c_variadic: false,
+           fixed_count: 1,
+           conv: C,
+           can_unwind: false,
+       }
+  --> $DIR/c-zst.rs:27:1
+   |
+LL | extern "C" fn pass_zst(_: ()) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/abi/sysv64-zst.rs b/tests/ui/abi/sysv64-zst.rs
new file mode 100644
index 0000000000000..6f4497e77a181
--- /dev/null
+++ b/tests/ui/abi/sysv64-zst.rs
@@ -0,0 +1,8 @@
+//@ only-x86_64
+//@ normalize-stderr-test: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
+
+#![feature(rustc_attrs)]
+#![crate_type = "lib"]
+
+#[rustc_abi(debug)]
+extern "sysv64" fn pass_zst(_: ()) {} //~ ERROR: fn_abi
diff --git a/tests/ui/abi/sysv64-zst.stderr b/tests/ui/abi/sysv64-zst.stderr
new file mode 100644
index 0000000000000..8b0b84dfa0699
--- /dev/null
+++ b/tests/ui/abi/sysv64-zst.stderr
@@ -0,0 +1,67 @@
+error: fn_abi_of(pass_zst) = FnAbi {
+           args: [
+               ArgAbi {
+                   layout: TyAndLayout {
+                       ty: (),
+                       layout: Layout {
+                           size: Size(0 bytes),
+                           align: AbiAndPrefAlign {
+                               abi: $SOME_ALIGN,
+                               pref: $SOME_ALIGN,
+                           },
+                           abi: Aggregate {
+                               sized: true,
+                           },
+                           fields: Arbitrary {
+                               offsets: [],
+                               memory_index: [],
+                           },
+                           largest_niche: None,
+                           variants: Single {
+                               index: 0,
+                           },
+                           max_repr_align: None,
+                           unadjusted_abi_align: $SOME_ALIGN,
+                       },
+                   },
+                   mode: Ignore,
+               },
+           ],
+           ret: ArgAbi {
+               layout: TyAndLayout {
+                   ty: (),
+                   layout: Layout {
+                       size: Size(0 bytes),
+                       align: AbiAndPrefAlign {
+                           abi: $SOME_ALIGN,
+                           pref: $SOME_ALIGN,
+                       },
+                       abi: Aggregate {
+                           sized: true,
+                       },
+                       fields: Arbitrary {
+                           offsets: [],
+                           memory_index: [],
+                       },
+                       largest_niche: None,
+                       variants: Single {
+                           index: 0,
+                       },
+                       max_repr_align: None,
+                       unadjusted_abi_align: $SOME_ALIGN,
+                   },
+               },
+               mode: Ignore,
+           },
+           c_variadic: false,
+           fixed_count: 1,
+           conv: X86_64SysV,
+           can_unwind: false,
+       }
+  --> $DIR/sysv64-zst.rs:8:1
+   |
+LL | extern "sysv64" fn pass_zst(_: ()) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/abi/win64-zst.other.stderr b/tests/ui/abi/win64-zst.other.stderr
new file mode 100644
index 0000000000000..15db141cb5748
--- /dev/null
+++ b/tests/ui/abi/win64-zst.other.stderr
@@ -0,0 +1,67 @@
+error: fn_abi_of(pass_zst) = FnAbi {
+           args: [
+               ArgAbi {
+                   layout: TyAndLayout {
+                       ty: (),
+                       layout: Layout {
+                           size: Size(0 bytes),
+                           align: AbiAndPrefAlign {
+                               abi: $SOME_ALIGN,
+                               pref: $SOME_ALIGN,
+                           },
+                           abi: Aggregate {
+                               sized: true,
+                           },
+                           fields: Arbitrary {
+                               offsets: [],
+                               memory_index: [],
+                           },
+                           largest_niche: None,
+                           variants: Single {
+                               index: 0,
+                           },
+                           max_repr_align: None,
+                           unadjusted_abi_align: $SOME_ALIGN,
+                       },
+                   },
+                   mode: Ignore,
+               },
+           ],
+           ret: ArgAbi {
+               layout: TyAndLayout {
+                   ty: (),
+                   layout: Layout {
+                       size: Size(0 bytes),
+                       align: AbiAndPrefAlign {
+                           abi: $SOME_ALIGN,
+                           pref: $SOME_ALIGN,
+                       },
+                       abi: Aggregate {
+                           sized: true,
+                       },
+                       fields: Arbitrary {
+                           offsets: [],
+                           memory_index: [],
+                       },
+                       largest_niche: None,
+                       variants: Single {
+                           index: 0,
+                       },
+                       max_repr_align: None,
+                       unadjusted_abi_align: $SOME_ALIGN,
+                   },
+               },
+               mode: Ignore,
+           },
+           c_variadic: false,
+           fixed_count: 1,
+           conv: X86_64Win64,
+           can_unwind: false,
+       }
+  --> $DIR/win64-zst.rs:11:1
+   |
+LL | extern "win64" fn pass_zst(_: ()) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/abi/win64-zst.rs b/tests/ui/abi/win64-zst.rs
new file mode 100644
index 0000000000000..cae32795e16e7
--- /dev/null
+++ b/tests/ui/abi/win64-zst.rs
@@ -0,0 +1,11 @@
+//@ only-x86_64
+//@ revisions: other windows-gnu
+//@ normalize-stderr-test: "(abi|pref|unadjusted_abi_align): Align\([1-8] bytes\)" -> "$1: $$SOME_ALIGN"
+//@[other] ignore-windows-gnu
+//@[windows-gnu] only-windows-gnu
+
+#![feature(rustc_attrs)]
+#![crate_type = "lib"]
+
+#[rustc_abi(debug)]
+extern "win64" fn pass_zst(_: ()) {} //~ ERROR: fn_abi
diff --git a/tests/ui/abi/win64-zst.windows-gnu.stderr b/tests/ui/abi/win64-zst.windows-gnu.stderr
new file mode 100644
index 0000000000000..7773e0aa2b572
--- /dev/null
+++ b/tests/ui/abi/win64-zst.windows-gnu.stderr
@@ -0,0 +1,78 @@
+error: fn_abi_of(pass_zst) = FnAbi {
+           args: [
+               ArgAbi {
+                   layout: TyAndLayout {
+                       ty: (),
+                       layout: Layout {
+                           size: Size(0 bytes),
+                           align: AbiAndPrefAlign {
+                               abi: $SOME_ALIGN,
+                               pref: $SOME_ALIGN,
+                           },
+                           abi: Aggregate {
+                               sized: true,
+                           },
+                           fields: Arbitrary {
+                               offsets: [],
+                               memory_index: [],
+                           },
+                           largest_niche: None,
+                           variants: Single {
+                               index: 0,
+                           },
+                           max_repr_align: None,
+                           unadjusted_abi_align: $SOME_ALIGN,
+                       },
+                   },
+                   mode: Indirect {
+                       attrs: ArgAttributes {
+                           regular: NoAlias | NoCapture | NonNull | NoUndef,
+                           arg_ext: None,
+                           pointee_size: Size(0 bytes),
+                           pointee_align: Some(
+                               Align(1 bytes),
+                           ),
+                       },
+                       meta_attrs: None,
+                       on_stack: false,
+                   },
+               },
+           ],
+           ret: ArgAbi {
+               layout: TyAndLayout {
+                   ty: (),
+                   layout: Layout {
+                       size: Size(0 bytes),
+                       align: AbiAndPrefAlign {
+                           abi: $SOME_ALIGN,
+                           pref: $SOME_ALIGN,
+                       },
+                       abi: Aggregate {
+                           sized: true,
+                       },
+                       fields: Arbitrary {
+                           offsets: [],
+                           memory_index: [],
+                       },
+                       largest_niche: None,
+                       variants: Single {
+                           index: 0,
+                       },
+                       max_repr_align: None,
+                       unadjusted_abi_align: $SOME_ALIGN,
+                   },
+               },
+               mode: Ignore,
+           },
+           c_variadic: false,
+           fixed_count: 1,
+           conv: X86_64Win64,
+           can_unwind: false,
+       }
+  --> $DIR/win64-zst.rs:11:1
+   |
+LL | extern "win64" fn pass_zst(_: ()) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+

From 06197ef3c111fad0498d30b631a141de1aed2843 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Fri, 2 Aug 2024 06:59:45 -0700
Subject: [PATCH 039/685] Review comments

---
 .../src/platform-support/wasm32-unknown-unknown.md |  4 ++--
 .../src/platform-support/wasm32-wasip1-threads.md  | 14 ++++++++++++++
 .../rustc/src/platform-support/wasm32-wasip1.md    |  5 ++---
 .../rustc/src/platform-support/wasm32-wasip2.md    |  5 ++---
 4 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
index 1c2894e3a7390..ee37e5e90cfb4 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -141,7 +141,7 @@ Rust standard library additionally must be recompiled.
 Compiling all code for the initial release of WebAssembly looks like:
 
 ```sh
-$ export RUSTFLAG=-Ctarget-cpu=mvp
+$ export RUSTFLAGS=-Ctarget-cpu=mvp
 $ cargo +nightly build -Zbuild-std=panic_abort,std --target wasm32-unknown-unknown
 ```
 
@@ -166,7 +166,7 @@ about the supported WebAssembly features the engine has.
 
 Note that it is still possible for Rust crates and libraries to enable
 WebAssembly features on a per-function level. This means that the build
-command above may not be sufficent to disable all WebAssembly features. If the
+command above may not be sufficient to disable all WebAssembly features. If the
 final binary still has SIMD instructions, for example, the function in question
 will need to be found and the crate in question will likely contain something
 like:
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md b/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md
index c3eda26ca8ef9..aafb64e6778c2 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md
@@ -162,3 +162,17 @@ It's recommended to conditionally compile code for this target with:
 Prior to Rust 1.80 the `target_env = "p1"` key was not set. Currently the
 `target_feature = "atomics"` is Nightly-only. Note that the precise `#[cfg]`
 necessary to detect this target may change as the target becomes more stable.
+
+## Enabled WebAssembly features
+
+The default set of WebAssembly features enabled for compilation is similar to
+[`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md) but two more features
+are included:
+
+* `bulk-memory`
+* `atomics`
+
+For more information about features see the documentation for
+[`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md), but note that the
+`mvp` CPU in LLVM does not support this target as it's required that
+`bulk-memory`, `atomics`, and `mutable-globals` are all enabled.
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip1.md b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
index 7a7cac9aeeb1e..103cb38be09b0 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip1.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
@@ -136,6 +136,5 @@ to Rust 1.80 the `target_env` condition was not set.
 ## Enabled WebAssembly features
 
 The default set of WebAssembly features enabled for compilation is currently the
-same across all WebAssembly targets. For more information on WebAssembly
-features see the documentation for
-[`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md)
+same as [`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md). See the
+documentation there for more information.
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip2.md b/src/doc/rustc/src/platform-support/wasm32-wasip2.md
index e4ef65bcfec55..7d22e9e60d5ad 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip2.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip2.md
@@ -65,6 +65,5 @@ It's recommended to conditionally compile code for this target with:
 ## Enabled WebAssembly features
 
 The default set of WebAssembly features enabled for compilation is currently the
-same across all WebAssembly targets. For more information on WebAssembly
-features see the documentation for
-[`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md)
+same as [`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md). See the
+documentation there for more information.

From 22aa104bce457e7d70b05d7a32cdf09f25ac06b1 Mon Sep 17 00:00:00 2001
From: yukang <moorekang@gmail.com>
Date: Fri, 2 Aug 2024 00:28:57 +0800
Subject: [PATCH 040/685] don't suggest turning crate-level attributes into
 outer style

---
 compiler/rustc_ast/src/ast.rs                 | 11 ++++++
 compiler/rustc_parse/src/parser/attr.rs       | 38 +++++++++++++------
 compiler/rustc_parse/src/parser/stmt.rs       |  5 +++
 tests/ui/delegation/inner-attr.stderr         |  5 ---
 .../attribute/attr-stmt-expr-attr-bad.stderr  | 15 --------
 tests/ui/parser/attribute/attr.stderr         |  5 ---
 .../inner-attr-after-doc-comment.stderr       |  5 ---
 tests/ui/parser/inner-attr.stderr             |  5 ---
 .../isgg-invalid-outer-attttr-issue-127930.rs | 10 +++++
 ...g-invalid-outer-attttr-issue-127930.stderr | 12 ++++++
 tests/ui/parser/issues/issue-30318.fixed      |  2 +-
 tests/ui/parser/issues/issue-30318.rs         |  2 +-
 tests/ui/parser/issues/issue-30318.stderr     |  8 ++--
 13 files changed, 70 insertions(+), 53 deletions(-)
 create mode 100644 tests/ui/parser/issues/isgg-invalid-outer-attttr-issue-127930.rs
 create mode 100644 tests/ui/parser/issues/isgg-invalid-outer-attttr-issue-127930.stderr

diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index fc1af3fc3dd11..0c81c0f4c93e1 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -2898,6 +2898,17 @@ pub struct AttrItem {
     pub tokens: Option<LazyAttrTokenStream>,
 }
 
+impl AttrItem {
+    pub fn is_valid_for_outer_style(&self) -> bool {
+        self.path == sym::cfg_attr
+            || self.path == sym::cfg
+            || self.path == sym::forbid
+            || self.path == sym::warn
+            || self.path == sym::allow
+            || self.path == sym::deny
+    }
+}
+
 /// `TraitRef`s appear in impls.
 ///
 /// Resolution maps each `TraitRef`'s `ref_id` to its defining trait; that's all
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index 12b9414d1f760..7b64a60960b5e 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -67,6 +67,7 @@ impl<'a> Parser<'a> {
                             token::CommentKind::Line => OuterAttributeType::DocComment,
                             token::CommentKind::Block => OuterAttributeType::DocBlockComment,
                         },
+                        true,
                     ) {
                         err.note(fluent::parse_note);
                         err.span_suggestion_verbose(
@@ -130,7 +131,11 @@ impl<'a> Parser<'a> {
 
             // Emit error if inner attribute is encountered and forbidden.
             if style == ast::AttrStyle::Inner {
-                this.error_on_forbidden_inner_attr(attr_sp, inner_parse_policy);
+                this.error_on_forbidden_inner_attr(
+                    attr_sp,
+                    inner_parse_policy,
+                    item.is_valid_for_outer_style(),
+                );
             }
 
             Ok(attr::mk_attr_from_item(&self.psess.attr_id_generator, item, None, style, attr_sp))
@@ -142,6 +147,7 @@ impl<'a> Parser<'a> {
         err: &mut Diag<'_>,
         span: Span,
         attr_type: OuterAttributeType,
+        suggest_to_outer: bool,
     ) -> Option<Span> {
         let mut snapshot = self.create_snapshot_for_diagnostic();
         let lo = span.lo()
@@ -176,16 +182,18 @@ impl<'a> Parser<'a> {
                 // FIXME(#100717)
                 err.arg("item", item.kind.descr());
                 err.span_label(item.span, fluent::parse_label_does_not_annotate_this);
-                err.span_suggestion_verbose(
-                    replacement_span,
-                    fluent::parse_sugg_change_inner_to_outer,
-                    match attr_type {
-                        OuterAttributeType::Attribute => "",
-                        OuterAttributeType::DocBlockComment => "*",
-                        OuterAttributeType::DocComment => "/",
-                    },
-                    rustc_errors::Applicability::MachineApplicable,
-                );
+                if suggest_to_outer {
+                    err.span_suggestion_verbose(
+                        replacement_span,
+                        fluent::parse_sugg_change_inner_to_outer,
+                        match attr_type {
+                            OuterAttributeType::Attribute => "",
+                            OuterAttributeType::DocBlockComment => "*",
+                            OuterAttributeType::DocComment => "/",
+                        },
+                        rustc_errors::Applicability::MachineApplicable,
+                    );
+                }
                 return None;
             }
             Err(item_err) => {
@@ -196,7 +204,12 @@ impl<'a> Parser<'a> {
         Some(replacement_span)
     }
 
-    pub(super) fn error_on_forbidden_inner_attr(&self, attr_sp: Span, policy: InnerAttrPolicy) {
+    pub(super) fn error_on_forbidden_inner_attr(
+        &self,
+        attr_sp: Span,
+        policy: InnerAttrPolicy,
+        suggest_to_outer: bool,
+    ) {
         if let InnerAttrPolicy::Forbidden(reason) = policy {
             let mut diag = match reason.as_ref().copied() {
                 Some(InnerAttrForbiddenReason::AfterOuterDocComment { prev_doc_comment_span }) => {
@@ -230,6 +243,7 @@ impl<'a> Parser<'a> {
                     &mut diag,
                     attr_sp,
                     OuterAttributeType::Attribute,
+                    suggest_to_outer,
                 )
                 .is_some()
             {
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index 7b0daaa14335f..fe8fbeea4767e 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -439,11 +439,16 @@ impl<'a> Parser<'a> {
     pub fn parse_block(&mut self) -> PResult<'a, P<Block>> {
         let (attrs, block) = self.parse_inner_attrs_and_block()?;
         if let [.., last] = &*attrs {
+            let suggest_to_outer = match &last.kind {
+                ast::AttrKind::Normal(attr) => attr.item.is_valid_for_outer_style(),
+                _ => false,
+            };
             self.error_on_forbidden_inner_attr(
                 last.span,
                 super::attr::InnerAttrPolicy::Forbidden(Some(
                     InnerAttrForbiddenReason::InCodeBlock,
                 )),
+                suggest_to_outer,
             );
         }
         Ok(block)
diff --git a/tests/ui/delegation/inner-attr.stderr b/tests/ui/delegation/inner-attr.stderr
index f3b53e331ad88..257ab760ffc1a 100644
--- a/tests/ui/delegation/inner-attr.stderr
+++ b/tests/ui/delegation/inner-attr.stderr
@@ -8,11 +8,6 @@ LL | fn main() {}
    | ------------ the inner attribute doesn't annotate this function
    |
    = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
-help: to annotate the function, change the attribute from inner to outer style
-   |
-LL - reuse a as b { #![rustc_dummy] self }
-LL + reuse a as b { #[rustc_dummy] self }
-   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/attribute/attr-stmt-expr-attr-bad.stderr b/tests/ui/parser/attribute/attr-stmt-expr-attr-bad.stderr
index 1ba130e20b578..bd860841b8060 100644
--- a/tests/ui/parser/attribute/attr-stmt-expr-attr-bad.stderr
+++ b/tests/ui/parser/attribute/attr-stmt-expr-attr-bad.stderr
@@ -359,11 +359,6 @@ LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!(); }
    |                        previous outer attribute
    |
    = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
-help: to annotate the item macro invocation, change the attribute from inner to outer style
-   |
-LL - #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!(); }
-LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo!(); }
-   |
 
 error: an inner attribute is not permitted following an outer attribute
   --> $DIR/attr-stmt-expr-attr-bad.rs:77:32
@@ -375,11 +370,6 @@ LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo![]; }
    |                        previous outer attribute
    |
    = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
-help: to annotate the item macro invocation, change the attribute from inner to outer style
-   |
-LL - #[cfg(FALSE)] fn s() { #[attr] #![attr] foo![]; }
-LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo![]; }
-   |
 
 error: an inner attribute is not permitted following an outer attribute
   --> $DIR/attr-stmt-expr-attr-bad.rs:79:32
@@ -391,11 +381,6 @@ LL | #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!{}; }
    |                        previous outer attribute
    |
    = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
-help: to annotate the item macro invocation, change the attribute from inner to outer style
-   |
-LL - #[cfg(FALSE)] fn s() { #[attr] #![attr] foo!{}; }
-LL + #[cfg(FALSE)] fn s() { #[attr] #[attr] foo!{}; }
-   |
 
 error[E0586]: inclusive range with no end
   --> $DIR/attr-stmt-expr-attr-bad.rs:85:35
diff --git a/tests/ui/parser/attribute/attr.stderr b/tests/ui/parser/attribute/attr.stderr
index 2e0b16efb6cea..a79a5246c2a9a 100644
--- a/tests/ui/parser/attribute/attr.stderr
+++ b/tests/ui/parser/attribute/attr.stderr
@@ -7,11 +7,6 @@ LL | fn foo() {}
    | ----------- the inner attribute doesn't annotate this function
    |
    = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
-help: to annotate the function, change the attribute from inner to outer style
-   |
-LL - #![lang = "foo"]
-LL + #[lang = "foo"]
-   |
 
 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 6dbc0fd93fd42..f087c2e4d6540 100644
--- a/tests/ui/parser/inner-attr-after-doc-comment.stderr
+++ b/tests/ui/parser/inner-attr-after-doc-comment.stderr
@@ -13,11 +13,6 @@ LL |   fn main() {}
    |   ------------ the inner attribute doesn't annotate this function
    |
    = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
-help: to annotate the function, change the attribute from inner to outer style
-   |
-LL - #![recursion_limit="100"]
-LL + #[recursion_limit="100"]
-   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/inner-attr.stderr b/tests/ui/parser/inner-attr.stderr
index 57ca164fc15a2..18a82ea4c3856 100644
--- a/tests/ui/parser/inner-attr.stderr
+++ b/tests/ui/parser/inner-attr.stderr
@@ -10,11 +10,6 @@ LL | fn main() {}
    | ------------ the inner attribute doesn't annotate this function
    |
    = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
-help: to annotate the function, change the attribute from inner to outer style
-   |
-LL - #![recursion_limit="100"]
-LL + #[recursion_limit="100"]
-   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/parser/issues/isgg-invalid-outer-attttr-issue-127930.rs b/tests/ui/parser/issues/isgg-invalid-outer-attttr-issue-127930.rs
new file mode 100644
index 0000000000000..26541a89a565a
--- /dev/null
+++ b/tests/ui/parser/issues/isgg-invalid-outer-attttr-issue-127930.rs
@@ -0,0 +1,10 @@
+#![allow(dead_code)]
+fn foo() {}
+
+#![feature(iter_array_chunks)] //~ ERROR an inner attribute is not permitted in this context
+fn bar() {}
+
+fn main() {
+    foo();
+    bar();
+}
diff --git a/tests/ui/parser/issues/isgg-invalid-outer-attttr-issue-127930.stderr b/tests/ui/parser/issues/isgg-invalid-outer-attttr-issue-127930.stderr
new file mode 100644
index 0000000000000..d6daa21e7418d
--- /dev/null
+++ b/tests/ui/parser/issues/isgg-invalid-outer-attttr-issue-127930.stderr
@@ -0,0 +1,12 @@
+error: an inner attribute is not permitted in this context
+  --> $DIR/isgg-invalid-outer-attttr-issue-127930.rs:4:1
+   |
+LL | #![feature(iter_array_chunks)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | fn bar() {}
+   | ----------- the inner attribute doesn't annotate this function
+   |
+   = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/parser/issues/issue-30318.fixed b/tests/ui/parser/issues/issue-30318.fixed
index d1661be519393..d4720834746fc 100644
--- a/tests/ui/parser/issues/issue-30318.fixed
+++ b/tests/ui/parser/issues/issue-30318.fixed
@@ -6,7 +6,7 @@ fn foo() { }
 //~^ ERROR expected outer doc comment
 fn bar() { } //~ NOTE the inner doc comment doesn't annotate this function
 
-#[test] //~ ERROR an inner attribute is not permitted in this context
+#[cfg(test)] //~ ERROR an inner attribute is not permitted in this context
 fn baz() { } //~ NOTE the inner attribute doesn't annotate this function
 //~^^ NOTE inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually
 
diff --git a/tests/ui/parser/issues/issue-30318.rs b/tests/ui/parser/issues/issue-30318.rs
index 6f055cd4f7e95..0555379836ac9 100644
--- a/tests/ui/parser/issues/issue-30318.rs
+++ b/tests/ui/parser/issues/issue-30318.rs
@@ -6,7 +6,7 @@ fn foo() { }
 //~^ ERROR expected outer doc comment
 fn bar() { } //~ NOTE the inner doc comment doesn't annotate this function
 
-#![test] //~ ERROR an inner attribute is not permitted in this context
+#![cfg(test)] //~ ERROR an inner attribute is not permitted in this context
 fn baz() { } //~ NOTE the inner attribute doesn't annotate this function
 //~^^ NOTE inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually
 
diff --git a/tests/ui/parser/issues/issue-30318.stderr b/tests/ui/parser/issues/issue-30318.stderr
index c441a92abad92..56bc200db1d3a 100644
--- a/tests/ui/parser/issues/issue-30318.stderr
+++ b/tests/ui/parser/issues/issue-30318.stderr
@@ -15,16 +15,16 @@ LL | /// Misplaced comment...
 error: an inner attribute is not permitted in this context
   --> $DIR/issue-30318.rs:9:1
    |
-LL | #![test]
-   | ^^^^^^^^
+LL | #![cfg(test)]
+   | ^^^^^^^^^^^^^
 LL | fn baz() { }
    | ------------ the inner attribute doesn't annotate this function
    |
    = note: inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files
 help: to annotate the function, change the attribute from inner to outer style
    |
-LL - #![test]
-LL + #[test]
+LL - #![cfg(test)]
+LL + #[cfg(test)]
    |
 
 error[E0753]: expected outer doc comment

From 5364cbea80f0e9b251151f40aa67592b0827759e Mon Sep 17 00:00:00 2001
From: rzvxa <rzvxa@protonmail.com>
Date: Sat, 3 Aug 2024 22:52:22 +0330
Subject: [PATCH 041/685] Respect allow inconsistent_struct_constructor on the
 type definition

---
 .../src/inconsistent_struct_constructor.rs    |  4 ++++
 .../ui/inconsistent_struct_constructor.fixed  | 21 +++++++++++++++++++
 tests/ui/inconsistent_struct_constructor.rs   | 21 +++++++++++++++++++
 .../ui/inconsistent_struct_constructor.stderr |  4 ++--
 4 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index 5b0aadf35c62d..da289225509bf 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -1,4 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::is_lint_allowed;
 use clippy_utils::source::snippet;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
@@ -71,6 +72,9 @@ impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
             && let ty = cx.typeck_results().expr_ty(expr)
             && let Some(adt_def) = ty.ty_adt_def()
             && adt_def.is_struct()
+            && let Some(local_def_id) = adt_def.did().as_local()
+            && let ty_hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id)
+            && !is_lint_allowed(cx, INCONSISTENT_STRUCT_CONSTRUCTOR, ty_hir_id)
             && let Some(variant) = adt_def.variants().iter().next()
         {
             let mut def_order_map = FxHashMap::default();
diff --git a/tests/ui/inconsistent_struct_constructor.fixed b/tests/ui/inconsistent_struct_constructor.fixed
index 5778f8f526f86..4c324587c96fa 100644
--- a/tests/ui/inconsistent_struct_constructor.fixed
+++ b/tests/ui/inconsistent_struct_constructor.fixed
@@ -15,6 +15,14 @@ struct Foo {
     z: i32,
 }
 
+#[derive(Default)]
+#[allow(clippy::inconsistent_struct_constructor)]
+struct Bar {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
 mod without_base {
     use super::Foo;
 
@@ -70,4 +78,17 @@ mod with_base {
     }
 }
 
+mod with_allow_ty_def {
+    use super::Bar;
+
+    fn test() {
+        let x = 1;
+        let y = 1;
+        let z = 1;
+
+        // Should NOT lint because `Bar` is defined with `#[allow(clippy::inconsistent_struct_constructor)]`
+        Bar { y, x, z };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/inconsistent_struct_constructor.rs b/tests/ui/inconsistent_struct_constructor.rs
index 9efaf0689342f..d49f236b9b07b 100644
--- a/tests/ui/inconsistent_struct_constructor.rs
+++ b/tests/ui/inconsistent_struct_constructor.rs
@@ -15,6 +15,14 @@ struct Foo {
     z: i32,
 }
 
+#[derive(Default)]
+#[allow(clippy::inconsistent_struct_constructor)]
+struct Bar {
+    x: i32,
+    y: i32,
+    z: i32,
+}
+
 mod without_base {
     use super::Foo;
 
@@ -74,4 +82,17 @@ mod with_base {
     }
 }
 
+mod with_allow_ty_def {
+    use super::Bar;
+
+    fn test() {
+        let x = 1;
+        let y = 1;
+        let z = 1;
+
+        // Should NOT lint because `Bar` is defined with `#[allow(clippy::inconsistent_struct_constructor)]`
+        Bar { y, x, z };
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/inconsistent_struct_constructor.stderr b/tests/ui/inconsistent_struct_constructor.stderr
index 1192271f911fd..97bb7c789a720 100644
--- a/tests/ui/inconsistent_struct_constructor.stderr
+++ b/tests/ui/inconsistent_struct_constructor.stderr
@@ -1,5 +1,5 @@
 error: struct constructor field order is inconsistent with struct definition field order
-  --> tests/ui/inconsistent_struct_constructor.rs:28:9
+  --> tests/ui/inconsistent_struct_constructor.rs:36:9
    |
 LL |         Foo { y, x, z };
    |         ^^^^^^^^^^^^^^^ help: try: `Foo { x, y, z }`
@@ -8,7 +8,7 @@ LL |         Foo { y, x, z };
    = help: to override `-D warnings` add `#[allow(clippy::inconsistent_struct_constructor)]`
 
 error: struct constructor field order is inconsistent with struct definition field order
-  --> tests/ui/inconsistent_struct_constructor.rs:55:9
+  --> tests/ui/inconsistent_struct_constructor.rs:63:9
    |
 LL | /         Foo {
 LL | |             z,

From 78caecf8f30dbdbfcb6e0fda25edc72b3e4d04a5 Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Sat, 3 Aug 2024 21:04:19 -0700
Subject: [PATCH 042/685] Special case DUMMY_SP to emit line 0/column 0
 locations on DWARF platforms.

Line 0 has a special meaning in DWARF. From the version 5 spec:

    The compiler may emit the value 0 in cases
    where an instruction cannot be attributed to any
    source line.

DUMMY_SP spans cannot be attributed to any line. However, because rustc
internally stores line numbers starting at zero, lookup_debug_loc() adjusts
every line number by one. Special casing DUMMY_SP to actually emit line 0
ensures rustc communicates to the debugger that there's no meaningful source
code for this instruction, rather than telling the debugger to jump to line 1
randomly.
---
 compiler/rustc_codegen_llvm/src/debuginfo/mod.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index b23e05182ca1b..3706d31e66e17 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -20,7 +20,7 @@ use rustc_session::config::{self, DebugInfo};
 use rustc_session::Session;
 use rustc_span::symbol::Symbol;
 use rustc_span::{
-    BytePos, Pos, SourceFile, SourceFileAndLine, SourceFileHash, Span, StableSourceFileId,
+    BytePos, Pos, SourceFile, SourceFileAndLine, SourceFileHash, Span, StableSourceFileId, DUMMY_SP,
 };
 use rustc_target::abi::Size;
 use smallvec::SmallVec;
@@ -570,7 +570,12 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         inlined_at: Option<&'ll DILocation>,
         span: Span,
     ) -> &'ll DILocation {
-        let DebugLoc { line, col, .. } = self.lookup_debug_loc(span.lo());
+        let (line, col) = if span == DUMMY_SP && !self.sess().target.is_like_msvc {
+            (0, 0)
+        } else {
+            let DebugLoc { line, col, .. } = self.lookup_debug_loc(span.lo());
+            (line, col)
+        };
 
         unsafe { llvm::LLVMRustDIBuilderCreateDebugLocation(line, col, scope, inlined_at) }
     }

From 709406fc6c792bd5dd0d07fbc59c4437b3d47f95 Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Sat, 3 Aug 2024 21:23:35 -0700
Subject: [PATCH 043/685] When deduplicating unreachable blocks, erase the
 source information.

After deduplication the block conceptually belongs to multiple locations
in the source. Although these blocks are unreachable, in #123341 we did
come across a real side effect, an unreachable block that survives into
the compiled code can cause a debugger to set a breakpoint on the wrong
instruction. Erasing the source information ensures that a debugger will
never be misled into thinking that the unreachable block is worth setting
a breakpoint on, especially after #128627.

Technically we don't need to erase the source information if all the
deduplicated blocks have identical source information, but tracking
that seems like more effort than it's worth.
---
 compiler/rustc_mir_transform/src/simplify.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs
index 5bbe3bb747fd9..4fe8cf6213f80 100644
--- a/compiler/rustc_mir_transform/src/simplify.rs
+++ b/compiler/rustc_mir_transform/src/simplify.rs
@@ -31,6 +31,7 @@ use rustc_index::{Idx, IndexSlice, IndexVec};
 use rustc_middle::mir::visit::{MutVisitor, MutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
+use rustc_span::DUMMY_SP;
 use smallvec::SmallVec;
 
 pub enum SimplifyCfg {
@@ -318,6 +319,7 @@ pub(crate) fn remove_dead_blocks(body: &mut Body<'_>) {
     let mut orig_index = 0;
     let mut used_index = 0;
     let mut kept_unreachable = None;
+    let mut deduplicated_unreachable = false;
     basic_blocks.raw.retain(|bbdata| {
         let orig_bb = BasicBlock::new(orig_index);
         if !reachable.contains(orig_bb) {
@@ -330,6 +332,7 @@ pub(crate) fn remove_dead_blocks(body: &mut Body<'_>) {
             let kept_unreachable = *kept_unreachable.get_or_insert(used_bb);
             if kept_unreachable != used_bb {
                 replacements[orig_index] = kept_unreachable;
+                deduplicated_unreachable = true;
                 orig_index += 1;
                 return false;
             }
@@ -341,6 +344,14 @@ pub(crate) fn remove_dead_blocks(body: &mut Body<'_>) {
         true
     });
 
+    // If we deduplicated unreachable blocks we erase their source_info as we
+    // can no longer attribute their code to a particular location in the
+    // source.
+    if deduplicated_unreachable {
+        basic_blocks[kept_unreachable.unwrap()].terminator_mut().source_info =
+            SourceInfo { span: DUMMY_SP, scope: OUTERMOST_SOURCE_SCOPE };
+    }
+
     for block in basic_blocks {
         for target in block.terminator_mut().successors_mut() {
             *target = replacements[target.index()];

From e5878555387e4ced52b3dd6c5f6a04a5f47eeed7 Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Sun, 4 Aug 2024 05:26:50 -0700
Subject: [PATCH 044/685] Use Span::is_dummy().

---
 compiler/rustc_codegen_llvm/src/debuginfo/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index 3706d31e66e17..57b8fb2fe71b8 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -570,7 +570,7 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         inlined_at: Option<&'ll DILocation>,
         span: Span,
     ) -> &'ll DILocation {
-        let (line, col) = if span == DUMMY_SP && !self.sess().target.is_like_msvc {
+        let (line, col) = if span.is_dummy() && !self.sess().target.is_like_msvc {
             (0, 0)
         } else {
             let DebugLoc { line, col, .. } = self.lookup_debug_loc(span.lo());

From 5dc4a1969c6ea5ba0b1d11f9d43045ed5a2be5cc Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Sun, 4 Aug 2024 06:09:55 -0700
Subject: [PATCH 045/685] Fix warning.

---
 compiler/rustc_codegen_llvm/src/debuginfo/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index 57b8fb2fe71b8..66dd653bb2166 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -20,7 +20,7 @@ use rustc_session::config::{self, DebugInfo};
 use rustc_session::Session;
 use rustc_span::symbol::Symbol;
 use rustc_span::{
-    BytePos, Pos, SourceFile, SourceFileAndLine, SourceFileHash, Span, StableSourceFileId, DUMMY_SP,
+    BytePos, Pos, SourceFile, SourceFileAndLine, SourceFileHash, Span, StableSourceFileId,
 };
 use rustc_target::abi::Size;
 use smallvec::SmallVec;

From 8a61674559c58b9cfcc7d297425b33520fcf39fa Mon Sep 17 00:00:00 2001
From: Georgii Rylov <g0dj4n@gmail.com>
Date: Mon, 5 Aug 2024 09:48:26 +0100
Subject: [PATCH 046/685] WASI fixing unsafe_op_in_unsafe_fn for std::{os, sys}

---
 library/std/src/os/wasi/fs.rs           |  1 -
 library/std/src/os/wasi/mod.rs          |  2 +-
 library/std/src/os/wasip2/mod.rs        |  1 +
 library/std/src/sys/pal/wasi/args.rs    |  2 +-
 library/std/src/sys/pal/wasi/env.rs     |  2 ++
 library/std/src/sys/pal/wasi/fd.rs      |  2 +-
 library/std/src/sys/pal/wasi/fs.rs      |  2 +-
 library/std/src/sys/pal/wasi/helpers.rs |  2 ++
 library/std/src/sys/pal/wasi/io.rs      |  2 +-
 library/std/src/sys/pal/wasi/net.rs     |  2 +-
 library/std/src/sys/pal/wasi/os.rs      |  2 +-
 library/std/src/sys/pal/wasi/stdio.rs   |  2 +-
 library/std/src/sys/pal/wasi/thread.rs  | 18 ++++++++++--------
 library/std/src/sys/pal/wasi/time.rs    |  2 +-
 14 files changed, 24 insertions(+), 18 deletions(-)

diff --git a/library/std/src/os/wasi/fs.rs b/library/std/src/os/wasi/fs.rs
index a58ca543d6777..9ec3e387e2ba9 100644
--- a/library/std/src/os/wasi/fs.rs
+++ b/library/std/src/os/wasi/fs.rs
@@ -2,7 +2,6 @@
 //!
 //! [`std::fs`]: crate::fs
 
-#![deny(unsafe_op_in_unsafe_fn)]
 #![unstable(feature = "wasi_ext", issue = "71213")]
 
 // Used for `File::read` on intra-doc links
diff --git a/library/std/src/os/wasi/mod.rs b/library/std/src/os/wasi/mod.rs
index e36b93e60ea1c..33b50c9e53b8f 100644
--- a/library/std/src/os/wasi/mod.rs
+++ b/library/std/src/os/wasi/mod.rs
@@ -30,7 +30,7 @@
 
 #![cfg_attr(not(target_env = "p2"), stable(feature = "rust1", since = "1.0.0"))]
 #![cfg_attr(target_env = "p2", unstable(feature = "wasip2", issue = "none"))]
-#![deny(unsafe_op_in_unsafe_fn)]
+#![forbid(unsafe_op_in_unsafe_fn)]
 #![doc(cfg(target_os = "wasi"))]
 
 pub mod ffi;
diff --git a/library/std/src/os/wasip2/mod.rs b/library/std/src/os/wasip2/mod.rs
index 1d44dd72814b8..809a288f20d04 100644
--- a/library/std/src/os/wasip2/mod.rs
+++ b/library/std/src/os/wasip2/mod.rs
@@ -2,4 +2,5 @@
 //!
 //! This module is currently empty, but will be filled over time as wasi-libc support for WASI Preview 2 is stabilized.
 
+#![forbid(unsafe_op_in_unsafe_fn)]
 #![stable(feature = "raw_ext", since = "1.1.0")]
diff --git a/library/std/src/sys/pal/wasi/args.rs b/library/std/src/sys/pal/wasi/args.rs
index 6b6d1b8ff4e2e..52cfa202af825 100644
--- a/library/std/src/sys/pal/wasi/args.rs
+++ b/library/std/src/sys/pal/wasi/args.rs
@@ -1,4 +1,4 @@
-#![deny(unsafe_op_in_unsafe_fn)]
+#![forbid(unsafe_op_in_unsafe_fn)]
 
 use crate::ffi::{CStr, OsStr, OsString};
 use crate::os::wasi::ffi::OsStrExt;
diff --git a/library/std/src/sys/pal/wasi/env.rs b/library/std/src/sys/pal/wasi/env.rs
index 730e356d7fe95..8d44498267360 100644
--- a/library/std/src/sys/pal/wasi/env.rs
+++ b/library/std/src/sys/pal/wasi/env.rs
@@ -1,3 +1,5 @@
+#![forbid(unsafe_op_in_unsafe_fn)]
+
 pub mod os {
     pub const FAMILY: &str = "";
     pub const OS: &str = "";
diff --git a/library/std/src/sys/pal/wasi/fd.rs b/library/std/src/sys/pal/wasi/fd.rs
index 8966e4b80ad37..19b60157e2e00 100644
--- a/library/std/src/sys/pal/wasi/fd.rs
+++ b/library/std/src/sys/pal/wasi/fd.rs
@@ -1,4 +1,4 @@
-#![deny(unsafe_op_in_unsafe_fn)]
+#![forbid(unsafe_op_in_unsafe_fn)]
 #![allow(dead_code)]
 
 use super::err2io;
diff --git a/library/std/src/sys/pal/wasi/fs.rs b/library/std/src/sys/pal/wasi/fs.rs
index 11900886f0b5c..6a97621ad50a5 100644
--- a/library/std/src/sys/pal/wasi/fs.rs
+++ b/library/std/src/sys/pal/wasi/fs.rs
@@ -1,4 +1,4 @@
-#![deny(unsafe_op_in_unsafe_fn)]
+#![forbid(unsafe_op_in_unsafe_fn)]
 
 use super::fd::WasiFd;
 use crate::ffi::{CStr, OsStr, OsString};
diff --git a/library/std/src/sys/pal/wasi/helpers.rs b/library/std/src/sys/pal/wasi/helpers.rs
index 4b770ee23bc5d..d047bf2fce857 100644
--- a/library/std/src/sys/pal/wasi/helpers.rs
+++ b/library/std/src/sys/pal/wasi/helpers.rs
@@ -1,3 +1,5 @@
+#![forbid(unsafe_op_in_unsafe_fn)]
+
 use crate::{io as std_io, mem};
 
 #[inline]
diff --git a/library/std/src/sys/pal/wasi/io.rs b/library/std/src/sys/pal/wasi/io.rs
index 2cd45df88fad1..b7c2f03daa048 100644
--- a/library/std/src/sys/pal/wasi/io.rs
+++ b/library/std/src/sys/pal/wasi/io.rs
@@ -1,4 +1,4 @@
-#![deny(unsafe_op_in_unsafe_fn)]
+#![forbid(unsafe_op_in_unsafe_fn)]
 
 use crate::marker::PhantomData;
 use crate::os::fd::{AsFd, AsRawFd};
diff --git a/library/std/src/sys/pal/wasi/net.rs b/library/std/src/sys/pal/wasi/net.rs
index b4cf94c8781ec..a648679982812 100644
--- a/library/std/src/sys/pal/wasi/net.rs
+++ b/library/std/src/sys/pal/wasi/net.rs
@@ -1,4 +1,4 @@
-#![deny(unsafe_op_in_unsafe_fn)]
+#![forbid(unsafe_op_in_unsafe_fn)]
 
 use super::err2io;
 use super::fd::WasiFd;
diff --git a/library/std/src/sys/pal/wasi/os.rs b/library/std/src/sys/pal/wasi/os.rs
index f5b17d9df94b4..f7701360f5a9c 100644
--- a/library/std/src/sys/pal/wasi/os.rs
+++ b/library/std/src/sys/pal/wasi/os.rs
@@ -1,4 +1,4 @@
-#![deny(unsafe_op_in_unsafe_fn)]
+#![forbid(unsafe_op_in_unsafe_fn)]
 
 use core::slice::memchr;
 
diff --git a/library/std/src/sys/pal/wasi/stdio.rs b/library/std/src/sys/pal/wasi/stdio.rs
index 4cc0e4ed5a45a..ca49f871e1957 100644
--- a/library/std/src/sys/pal/wasi/stdio.rs
+++ b/library/std/src/sys/pal/wasi/stdio.rs
@@ -1,4 +1,4 @@
-#![deny(unsafe_op_in_unsafe_fn)]
+#![forbid(unsafe_op_in_unsafe_fn)]
 
 use super::fd::WasiFd;
 use crate::io::{self, IoSlice, IoSliceMut};
diff --git a/library/std/src/sys/pal/wasi/thread.rs b/library/std/src/sys/pal/wasi/thread.rs
index c37acd8dfeeb7..31c9cbd4699bd 100644
--- a/library/std/src/sys/pal/wasi/thread.rs
+++ b/library/std/src/sys/pal/wasi/thread.rs
@@ -1,3 +1,5 @@
+#![forbid(unsafe_op_in_unsafe_fn)]
+
 use crate::ffi::CStr;
 use crate::num::NonZero;
 use crate::sys::unsupported;
@@ -73,13 +75,13 @@ impl Thread {
         if #[cfg(target_feature = "atomics")] {
             pub unsafe fn new(stack: usize, p: Box<dyn FnOnce()>) -> io::Result<Thread> {
                 let p = Box::into_raw(Box::new(p));
-                let mut native: libc::pthread_t = mem::zeroed();
-                let mut attr: libc::pthread_attr_t = mem::zeroed();
-                assert_eq!(libc::pthread_attr_init(&mut attr), 0);
+                let mut native: libc::pthread_t = unsafe { mem::zeroed() };
+                let mut attr: libc::pthread_attr_t = unsafe { mem::zeroed() };
+                assert_eq!(unsafe { libc::pthread_attr_init(&mut attr) }, 0);
 
                 let stack_size = cmp::max(stack, DEFAULT_MIN_STACK_SIZE);
 
-                match libc::pthread_attr_setstacksize(&mut attr, stack_size) {
+                match unsafe { libc::pthread_attr_setstacksize(&mut attr, stack_size) } {
                     0 => {}
                     n => {
                         assert_eq!(n, libc::EINVAL);
@@ -90,20 +92,20 @@ impl Thread {
                         let page_size = os::page_size();
                         let stack_size =
                             (stack_size + page_size - 1) & (-(page_size as isize - 1) as usize - 1);
-                        assert_eq!(libc::pthread_attr_setstacksize(&mut attr, stack_size), 0);
+                        assert_eq!(unsafe { libc::pthread_attr_setstacksize(&mut attr, stack_size) }, 0);
                     }
                 };
 
-                let ret = libc::pthread_create(&mut native, &attr, thread_start, p as *mut _);
+                let ret = unsafe { libc::pthread_create(&mut native, &attr, thread_start, p as *mut _) };
                 // Note: if the thread creation fails and this assert fails, then p will
                 // be leaked. However, an alternative design could cause double-free
                 // which is clearly worse.
-                assert_eq!(libc::pthread_attr_destroy(&mut attr), 0);
+                assert_eq!(unsafe {libc::pthread_attr_destroy(&mut attr) }, 0);
 
                 return if ret != 0 {
                     // The thread failed to start and as a result p was not consumed. Therefore, it is
                     // safe to reconstruct the box so that it gets deallocated.
-                    drop(Box::from_raw(p));
+                    unsafe { drop(Box::from_raw(p)); }
                     Err(io::Error::from_raw_os_error(ret))
                 } else {
                     Ok(Thread { id: native })
diff --git a/library/std/src/sys/pal/wasi/time.rs b/library/std/src/sys/pal/wasi/time.rs
index 016b06efbdc63..0d8d0b59ac14a 100644
--- a/library/std/src/sys/pal/wasi/time.rs
+++ b/library/std/src/sys/pal/wasi/time.rs
@@ -1,4 +1,4 @@
-#![deny(unsafe_op_in_unsafe_fn)]
+#![forbid(unsafe_op_in_unsafe_fn)]
 
 use crate::time::Duration;
 

From 234a1d35d9f1acc1da25b5069908ca2de209d322 Mon Sep 17 00:00:00 2001
From: y21 <30553356+y21@users.noreply.github.com>
Date: Mon, 5 Aug 2024 12:02:08 +0200
Subject: [PATCH 047/685] recognize metavariables in tail expressions

---
 clippy_lints/src/macro_metavars_in_unsafe.rs  | 21 +++++++++++++++++--
 .../macro_metavars_in_unsafe/default/test.rs  | 15 ++++++++++++-
 .../default/test.stderr                       | 16 +++++++++++---
 3 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/macro_metavars_in_unsafe.rs b/clippy_lints/src/macro_metavars_in_unsafe.rs
index fed58f7ff1481..e215097142be9 100644
--- a/clippy_lints/src/macro_metavars_in_unsafe.rs
+++ b/clippy_lints/src/macro_metavars_in_unsafe.rs
@@ -122,8 +122,23 @@ struct BodyVisitor<'a, 'tcx> {
     /// within a relevant macro.
     macro_unsafe_blocks: Vec<HirId>,
     /// When this is >0, it means that the node currently being visited is "within" a
-    /// macro definition. This is not necessary for correctness, it merely helps reduce the number
-    /// of spans we need to insert into the map, since only spans from macros are relevant.
+    /// macro definition.
+    /// This is used to detect if an expression represents a metavariable.
+    ///
+    /// For example, the following pre-expansion code that we want to lint
+    /// ```ignore
+    /// macro_rules! m { ($e:expr) => { unsafe { $e; } } }
+    /// m!(1);
+    /// ```
+    /// would look like this post-expansion code:
+    /// ```ignore
+    /// unsafe { /* macro */
+    ///     1 /* root */; /* macro */
+    /// }
+    /// ```
+    /// Visiting the block and the statement will increment the `expn_depth` so that it is >0,
+    /// and visiting the expression with a root context while `expn_depth > 0` tells us
+    /// that it must be a metavariable.
     expn_depth: u32,
     cx: &'a LateContext<'tcx>,
     lint: &'a mut ExprMetavarsInUnsafe,
@@ -157,7 +172,9 @@ impl<'a, 'tcx> Visitor<'tcx> for BodyVisitor<'a, 'tcx> {
             && (self.lint.warn_unsafe_macro_metavars_in_private_macros || is_public_macro(self.cx, macro_def_id))
         {
             self.macro_unsafe_blocks.push(block.hir_id);
+            self.expn_depth += 1;
             walk_block(self, block);
+            self.expn_depth -= 1;
             self.macro_unsafe_blocks.pop();
         } else if ctxt.is_root() && self.expn_depth > 0 {
             let unsafe_block = self.macro_unsafe_blocks.last().copied();
diff --git a/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs b/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs
index a312df5a43a07..3dafea56514db 100644
--- a/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs
+++ b/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs
@@ -1,7 +1,7 @@
 //! Tests macro_metavars_in_unsafe with default configuration
 #![feature(decl_macro)]
 #![warn(clippy::macro_metavars_in_unsafe)]
-#![allow(clippy::no_effect)]
+#![allow(clippy::no_effect, clippy::not_unsafe_ptr_arg_deref)]
 
 #[macro_export]
 macro_rules! allow_works {
@@ -237,6 +237,19 @@ macro_rules! nested_macros {
     }};
 }
 
+pub mod issue13219 {
+    #[macro_export]
+    macro_rules! m {
+        ($e:expr) => {
+            // Metavariable in a block tail expression
+            unsafe { $e }
+        };
+    }
+    pub fn f(p: *const i32) -> i32 {
+        m!(*p)
+    }
+}
+
 fn main() {
     allow_works!(1);
     simple!(1);
diff --git a/tests/ui-toml/macro_metavars_in_unsafe/default/test.stderr b/tests/ui-toml/macro_metavars_in_unsafe/default/test.stderr
index d6b97f6fde1e1..6f0ebcbba0239 100644
--- a/tests/ui-toml/macro_metavars_in_unsafe/default/test.stderr
+++ b/tests/ui-toml/macro_metavars_in_unsafe/default/test.stderr
@@ -1,3 +1,15 @@
+error: this macro expands metavariables in an unsafe block
+  --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:245:13
+   |
+LL |             unsafe { $e }
+   |             ^^^^^^^^^^^^^
+   |
+   = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+   = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+   = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+   = note: `-D clippy::macro-metavars-in-unsafe` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::macro_metavars_in_unsafe)]`
+
 error: this macro expands metavariables in an unsafe block
   --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:19:9
    |
@@ -10,8 +22,6 @@ LL | |         }
    = note: this allows the user of the macro to write unsafe code outside of an unsafe block
    = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
    = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
-   = note: `-D clippy::macro-metavars-in-unsafe` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::macro_metavars_in_unsafe)]`
 
 error: this macro expands metavariables in an unsafe block
   --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:30:9
@@ -183,5 +193,5 @@ LL | |         }
    = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
    = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
 
-error: aborting due to 14 previous errors
+error: aborting due to 15 previous errors
 

From 2431949e2a406c8b3243620d72dd3eaaceafb325 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Tue, 6 Aug 2024 04:57:39 +0000
Subject: [PATCH 048/685] 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 b74f9759ebed6..f6fbc9844f860 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-29e924841f06bb181d87494eba2783761bc1ddec
+c9687a95a602091777e28703aa5abf20f1ce1797

From 7d066c4edd1dcb0291ae2ca8cb0e1b6548f0ce4c Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 6 Aug 2024 11:00:18 +0200
Subject: [PATCH 049/685] add return-place-protection tail-call test, and fix
 previous test

---
 ... return_pointer_aliasing_read.none.stderr} |  6 +--
 ...ing.rs => return_pointer_aliasing_read.rs} |  0
 ...return_pointer_aliasing_read.stack.stderr} | 10 ++---
 ... return_pointer_aliasing_read.tree.stderr} | 12 ++---
 ...g2.rs => return_pointer_aliasing_write.rs} |  8 ++--
 ...eturn_pointer_aliasing_write.stack.stderr} | 23 +++++-----
 ...return_pointer_aliasing_write.tree.stderr} | 16 +++----
 ...return_pointer_aliasing_write_tail_call.rs | 39 ++++++++++++++++
 ...nter_aliasing_write_tail_call.stack.stderr | 37 +++++++++++++++
 ...inter_aliasing_write_tail_call.tree.stderr | 45 +++++++++++++++++++
 10 files changed, 157 insertions(+), 39 deletions(-)
 rename src/tools/miri/tests/fail/function_calls/{return_pointer_aliasing.none.stderr => return_pointer_aliasing_read.none.stderr} (82%)
 rename src/tools/miri/tests/fail/function_calls/{return_pointer_aliasing.rs => return_pointer_aliasing_read.rs} (100%)
 rename src/tools/miri/tests/fail/function_calls/{return_pointer_aliasing.stack.stderr => return_pointer_aliasing_read.stack.stderr} (85%)
 rename src/tools/miri/tests/fail/function_calls/{return_pointer_aliasing.tree.stderr => return_pointer_aliasing_read.tree.stderr} (85%)
 rename src/tools/miri/tests/fail/function_calls/{return_pointer_aliasing2.rs => return_pointer_aliasing_write.rs} (73%)
 rename src/tools/miri/tests/fail/function_calls/{return_pointer_aliasing2.stack.stderr => return_pointer_aliasing_write.stack.stderr} (56%)
 rename src/tools/miri/tests/fail/function_calls/{return_pointer_aliasing2.tree.stderr => return_pointer_aliasing_write.tree.stderr} (81%)
 create mode 100644 src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs
 create mode 100644 src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr
 create mode 100644 src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.tree.stderr

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_read.none.stderr
similarity index 82%
rename from src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.none.stderr
rename to src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.none.stderr
index eb215a2d2e805..e8b766d0b0e28 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_read.none.stderr
@@ -1,5 +1,5 @@
 error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
    |              ^^^^^^^^^^ using uninitialized data, but this operation requires initialized memory
@@ -7,9 +7,9 @@ LL |     unsafe { ptr.read() };
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: BACKTRACE:
-   = note: inside `myfun` at $DIR/return_pointer_aliasing.rs:LL:CC
+   = note: inside `myfun` at $DIR/return_pointer_aliasing_read.rs:LL:CC
 note: inside `main`
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |             Call(*ptr = myfun(ptr), ReturnTo(after_call), UnwindContinue())
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.rs
similarity index 100%
rename from src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.rs
rename to src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.rs
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_read.stack.stderr
similarity index 85%
rename from src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.stack.stderr
rename to src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.stack.stderr
index 01357f430fc71..a8817fe639038 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_read.stack.stderr
@@ -1,5 +1,5 @@
 error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
    |              ^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
@@ -7,7 +7,7 @@ LL |     unsafe { ptr.read() };
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
 help: <TAG> was created by a SharedReadWrite retag at offsets [0x0..0x4]
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL | /     mir! {
 LL | |         {
@@ -18,14 +18,14 @@ LL | |         }
 LL | |     }
    | |_____^
 help: <TAG> is this argument
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
    |     ^^^^^^^^^^^^^^^^^^^^^
    = note: BACKTRACE (of the first span):
-   = note: inside `myfun` at $DIR/return_pointer_aliasing.rs:LL:CC
+   = note: inside `myfun` at $DIR/return_pointer_aliasing_read.rs:LL:CC
 note: inside `main`
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |             Call(*ptr = myfun(ptr), ReturnTo(after_call), UnwindContinue())
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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_read.tree.stderr
similarity index 85%
rename from src/tools/miri/tests/fail/function_calls/return_pointer_aliasing.tree.stderr
rename to src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.tree.stderr
index bbedba5a7ddb0..715ee33061994 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_read.tree.stderr
@@ -1,5 +1,5 @@
 error: Undefined Behavior: read access through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
    |              ^^^^^^^^^^ read access through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
@@ -9,7 +9,7 @@ LL |     unsafe { ptr.read() };
    = help: this foreign read access would cause the protected tag <TAG> (currently Active) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL | /     mir! {
 LL | |         {
@@ -20,20 +20,20 @@ LL | |         }
 LL | |     }
    | |_____^
 help: the protected tag <TAG> was created here, in the initial state Reserved
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
    |     ^^^^^^^^^^^^^^^^^^^^^
 help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
    |     ^^^^^^^^^^^^^^^^^^^^^
    = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
    = note: BACKTRACE (of the first span):
-   = note: inside `myfun` at $DIR/return_pointer_aliasing.rs:LL:CC
+   = note: inside `myfun` at $DIR/return_pointer_aliasing_read.rs:LL:CC
 note: inside `main`
-  --> $DIR/return_pointer_aliasing.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |             Call(*ptr = myfun(ptr), ReturnTo(after_call), UnwindContinue())
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs
similarity index 73%
rename from src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.rs
rename to src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs
index 7db641538ce55..8de0b12b8b040 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.rs
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs
@@ -1,4 +1,4 @@
-// This does need an aliasing model.
+// This does need an aliasing model and protectors.
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
 #![feature(raw_ref_op)]
@@ -14,8 +14,8 @@ pub fn main() {
             let _x = 0;
             let ptr = &raw mut _x;
             // We arrange for `myfun` to have a pointer that aliases
-            // its return place. Even just reading from that pointer is UB.
-            Call(_x = myfun(ptr), ReturnTo(after_call), UnwindContinue())
+            // its return place. Writing to that pointer is UB.
+            Call(*ptr = myfun(ptr), ReturnTo(after_call), UnwindContinue())
         }
 
         after_call = {
@@ -27,7 +27,7 @@ pub fn main() {
 fn myfun(ptr: *mut i32) -> i32 {
     // This overwrites the return place, which shouldn't be possible through another pointer.
     unsafe { ptr.write(0) };
-    //~[stack]^ ERROR: tag does not exist in the borrow stack
+    //~[stack]^ ERROR: strongly protected
     //~[tree]| ERROR: /write access .* forbidden/
     13
 }
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_aliasing_write.stack.stderr
similarity index 56%
rename from src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.stack.stderr
rename to src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.stack.stderr
index 04040827b0f97..09f9681ff8ebc 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.stack.stderr
@@ -1,16 +1,13 @@
-error: Undefined Behavior: attempting a write access using <TAG> at ALLOC[0x0], but that tag does not exist in the borrow stack for this location
-  --> $DIR/return_pointer_aliasing2.rs:LL:CC
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+  --> $DIR/return_pointer_aliasing_write.rs:LL:CC
    |
 LL |     unsafe { ptr.write(0) };
-   |              ^^^^^^^^^^^^
-   |              |
-   |              attempting a write access using <TAG> at ALLOC[0x0], but that tag does not exist in the borrow stack for this location
-   |              this error occurs as part of an access at ALLOC[0x0..0x4]
+   |              ^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
 help: <TAG> was created by a SharedReadWrite retag at offsets [0x0..0x4]
-  --> $DIR/return_pointer_aliasing2.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_write.rs:LL:CC
    |
 LL | /     mir! {
 LL | |         {
@@ -20,18 +17,18 @@ LL | |             let ptr = &raw mut _x;
 LL | |         }
 LL | |     }
    | |_____^
-help: <TAG> was later invalidated at offsets [0x0..0x4] by a Unique in-place function argument/return passing protection
-  --> $DIR/return_pointer_aliasing2.rs:LL:CC
+help: <TAG> is this argument
+  --> $DIR/return_pointer_aliasing_write.rs:LL:CC
    |
 LL |     unsafe { ptr.write(0) };
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    = note: BACKTRACE (of the first span):
-   = note: inside `myfun` at $DIR/return_pointer_aliasing2.rs:LL:CC
+   = note: inside `myfun` at $DIR/return_pointer_aliasing_write.rs:LL:CC
 note: inside `main`
-  --> $DIR/return_pointer_aliasing2.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_write.rs:LL:CC
    |
-LL |             Call(_x = myfun(ptr), ReturnTo(after_call), UnwindContinue())
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |             Call(*ptr = myfun(ptr), ReturnTo(after_call), UnwindContinue())
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in the macro `::core::intrinsics::mir::__internal_remove_let` which comes from the expansion of the macro `mir` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
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_aliasing_write.tree.stderr
similarity index 81%
rename from src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.tree.stderr
rename to src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.tree.stderr
index 146bcfc7c47d0..66ca1027edce2 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing2.tree.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.tree.stderr
@@ -1,5 +1,5 @@
 error: Undefined Behavior: write access through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
-  --> $DIR/return_pointer_aliasing2.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_write.rs:LL:CC
    |
 LL |     unsafe { ptr.write(0) };
    |              ^^^^^^^^^^^^ write access through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
@@ -9,7 +9,7 @@ LL |     unsafe { ptr.write(0) };
    = help: this foreign write access would cause the protected tag <TAG> (currently Active) to become Disabled
    = help: protected tags must never be Disabled
 help: the accessed tag <TAG> was created here
-  --> $DIR/return_pointer_aliasing2.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_write.rs:LL:CC
    |
 LL | /     mir! {
 LL | |         {
@@ -20,23 +20,23 @@ LL | |         }
 LL | |     }
    | |_____^
 help: the protected tag <TAG> was created here, in the initial state Reserved
-  --> $DIR/return_pointer_aliasing2.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_write.rs:LL:CC
    |
 LL |     unsafe { ptr.write(0) };
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
-  --> $DIR/return_pointer_aliasing2.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_write.rs:LL:CC
    |
 LL |     unsafe { ptr.write(0) };
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
    = note: BACKTRACE (of the first span):
-   = note: inside `myfun` at $DIR/return_pointer_aliasing2.rs:LL:CC
+   = note: inside `myfun` at $DIR/return_pointer_aliasing_write.rs:LL:CC
 note: inside `main`
-  --> $DIR/return_pointer_aliasing2.rs:LL:CC
+  --> $DIR/return_pointer_aliasing_write.rs:LL:CC
    |
-LL |             Call(_x = myfun(ptr), ReturnTo(after_call), UnwindContinue())
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |             Call(*ptr = myfun(ptr), ReturnTo(after_call), UnwindContinue())
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in the macro `::core::intrinsics::mir::__internal_remove_let` which comes from the expansion of the macro `mir` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs
new file mode 100644
index 0000000000000..facc323bbc518
--- /dev/null
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs
@@ -0,0 +1,39 @@
+// This does need an aliasing model and protectors.
+//@revisions: stack tree
+//@[tree]compile-flags: -Zmiri-tree-borrows
+#![feature(raw_ref_op)]
+#![feature(core_intrinsics)]
+#![feature(custom_mir)]
+#![feature(explicit_tail_calls)]
+#![allow(incomplete_features)]
+
+use std::intrinsics::mir::*;
+
+#[custom_mir(dialect = "runtime", phase = "optimized")]
+pub fn main() {
+    mir! {
+        {
+            let _x = 0;
+            let ptr = &raw mut _x;
+            // We arrange for `myfun` to have a pointer that aliases
+            // its return place. Writing to that pointer is UB.
+            Call(*ptr = myfun(ptr), ReturnTo(after_call), UnwindContinue())
+        }
+
+        after_call = {
+            Return()
+        }
+    }
+}
+
+fn myfun(ptr: *mut i32) -> i32 {
+    become myfun2(ptr)
+}
+
+fn myfun2(ptr: *mut i32) -> i32 {
+    // This overwrites the return place, which shouldn't be possible through another pointer.
+    unsafe { ptr.write(0) };
+    //~[stack]^ ERROR: strongly protected
+    //~[tree]| ERROR: /write access .* forbidden/
+    13
+}
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr
new file mode 100644
index 0000000000000..b8d8a93ec8329
--- /dev/null
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr
@@ -0,0 +1,37 @@
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+  --> $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+   |
+LL |     unsafe { ptr.write(0) };
+   |              ^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |
+   = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
+   = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
+help: <TAG> was created by a SharedReadWrite retag at offsets [0x0..0x4]
+  --> $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+   |
+LL | /     mir! {
+LL | |         {
+LL | |             let _x = 0;
+LL | |             let ptr = &raw mut _x;
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+help: <TAG> is this argument
+  --> $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+   |
+LL |     unsafe { ptr.write(0) };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   = note: BACKTRACE (of the first span):
+   = note: inside `myfun2` at $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+note: inside `main`
+  --> $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+   |
+LL |             Call(*ptr = myfun(ptr), ReturnTo(after_call), UnwindContinue())
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in the macro `::core::intrinsics::mir::__internal_remove_let` which comes from the expansion of the macro `mir` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.tree.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.tree.stderr
new file mode 100644
index 0000000000000..b1f2cab031e4d
--- /dev/null
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.tree.stderr
@@ -0,0 +1,45 @@
+error: Undefined Behavior: write access through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
+  --> $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+   |
+LL |     unsafe { ptr.write(0) };
+   |              ^^^^^^^^^^^^ write access through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
+   |
+   = help: this indicates a potential bug in the program: it performed an invalid operation, but the Tree Borrows rules it violated are still experimental
+   = help: the accessed tag <TAG> (root of the allocation) is foreign to the protected tag <TAG> (i.e., it is not a child)
+   = help: this foreign write access would cause the protected tag <TAG> (currently Active) to become Disabled
+   = help: protected tags must never be Disabled
+help: the accessed tag <TAG> was created here
+  --> $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+   |
+LL | /     mir! {
+LL | |         {
+LL | |             let _x = 0;
+LL | |             let ptr = &raw mut _x;
+...  |
+LL | |         }
+LL | |     }
+   | |_____^
+help: the protected tag <TAG> was created here, in the initial state Reserved
+  --> $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+   |
+LL |     unsafe { ptr.write(0) };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+help: the protected tag <TAG> later transitioned to Active due to a child write access at offsets [0x0..0x4]
+  --> $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+   |
+LL |     unsafe { ptr.write(0) };
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   = help: this transition corresponds to the first write to a 2-phase borrowed mutable reference
+   = note: BACKTRACE (of the first span):
+   = note: inside `myfun2` at $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+note: inside `main`
+  --> $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
+   |
+LL |             Call(*ptr = myfun(ptr), ReturnTo(after_call), UnwindContinue())
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in the macro `::core::intrinsics::mir::__internal_remove_let` which comes from the expansion of the macro `mir` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+

From ac23a2e5cd288ea6c160ecd51ea64662d3443dd4 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 6 Aug 2024 11:12:45 +0200
Subject: [PATCH 050/685] bump conflicting_repr_hints lint to be shown in
 dependencies

---
 compiler/rustc_lint_defs/src/builtin.rs       |  2 +-
 .../feature-gate-repr-simd.stderr             | 14 +++++++++++
 tests/ui/issues/issue-47094.stderr            | 25 +++++++++++++++++++
 tests/ui/repr/conflicting-repr-hints.stderr   | 22 ++++++++++++++++
 4 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index ff0bdfcc9d261..0bfc3d11c2f65 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -250,7 +250,7 @@ declare_lint! {
     Deny,
     "conflicts between `#[repr(..)]` hints that were previously accepted and used in practice",
     @future_incompatible = FutureIncompatibleInfo {
-        reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,
+        reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
         reference: "issue #68585 <https://github.com/rust-lang/rust/issues/68585>",
     };
 }
diff --git a/tests/ui/feature-gates/feature-gate-repr-simd.stderr b/tests/ui/feature-gates/feature-gate-repr-simd.stderr
index 5b490c0c0c33f..5a0ceb2dd74fb 100644
--- a/tests/ui/feature-gates/feature-gate-repr-simd.stderr
+++ b/tests/ui/feature-gates/feature-gate-repr-simd.stderr
@@ -35,3 +35,17 @@ error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0566, E0658.
 For more information about an error, try `rustc --explain E0566`.
+Future incompatibility report: Future breakage diagnostic:
+error[E0566]: conflicting representation hints
+  --> $DIR/feature-gate-repr-simd.rs:4:8
+   |
+LL | #[repr(C)]
+   |        ^
+LL |
+LL | #[repr(simd)]
+   |        ^^^^
+   |
+   = 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 #68585 <https://github.com/rust-lang/rust/issues/68585>
+   = note: `#[deny(conflicting_repr_hints)]` on by default
+
diff --git a/tests/ui/issues/issue-47094.stderr b/tests/ui/issues/issue-47094.stderr
index 970e318471049..1c6693403b85b 100644
--- a/tests/ui/issues/issue-47094.stderr
+++ b/tests/ui/issues/issue-47094.stderr
@@ -23,3 +23,28 @@ LL | #[repr(u8)]
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0566`.
+Future incompatibility report: Future breakage diagnostic:
+error[E0566]: conflicting representation hints
+  --> $DIR/issue-47094.rs:1:8
+   |
+LL | #[repr(C, u8)]
+   |        ^  ^^
+   |
+   = 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 #68585 <https://github.com/rust-lang/rust/issues/68585>
+   = note: `#[deny(conflicting_repr_hints)]` on by default
+
+Future breakage diagnostic:
+error[E0566]: conflicting representation hints
+  --> $DIR/issue-47094.rs:8:8
+   |
+LL | #[repr(C)]
+   |        ^
+LL |
+LL | #[repr(u8)]
+   |        ^^
+   |
+   = 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 #68585 <https://github.com/rust-lang/rust/issues/68585>
+   = note: `#[deny(conflicting_repr_hints)]` on by default
+
diff --git a/tests/ui/repr/conflicting-repr-hints.stderr b/tests/ui/repr/conflicting-repr-hints.stderr
index 4dcd8f4fc280a..fbfa69e7fb145 100644
--- a/tests/ui/repr/conflicting-repr-hints.stderr
+++ b/tests/ui/repr/conflicting-repr-hints.stderr
@@ -81,3 +81,25 @@ error: aborting due to 12 previous errors
 
 Some errors have detailed explanations: E0566, E0587, E0634.
 For more information about an error, try `rustc --explain E0566`.
+Future incompatibility report: Future breakage diagnostic:
+error[E0566]: conflicting representation hints
+  --> $DIR/conflicting-repr-hints.rs:13:8
+   |
+LL | #[repr(C, u64)]
+   |        ^  ^^^
+   |
+   = 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 #68585 <https://github.com/rust-lang/rust/issues/68585>
+   = note: `#[deny(conflicting_repr_hints)]` on by default
+
+Future breakage diagnostic:
+error[E0566]: conflicting representation hints
+  --> $DIR/conflicting-repr-hints.rs:19:8
+   |
+LL | #[repr(u32, u64)]
+   |        ^^^  ^^^
+   |
+   = 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 #68585 <https://github.com/rust-lang/rust/issues/68585>
+   = note: `#[deny(conflicting_repr_hints)]` on by default
+

From b335ec9ec8d1132efee4e900a1c173efc7f4a357 Mon Sep 17 00:00:00 2001
From: Flying-Toast <38232168+Flying-Toast@users.noreply.github.com>
Date: Sat, 23 Mar 2024 10:49:05 -0400
Subject: [PATCH 051/685] Add a special case for CStr/CString in the
 improper_ctypes lint

Instead of saying to "consider adding a `#[repr(C)]` or
`#[repr(transparent)]` attribute to this struct", we now tell users to
"Use `*const ffi::c_char` instead, and pass the value from
`CStr::as_ptr()`" when the type involved is a `CStr` or a `CString`.

Co-authored-by: Jieyou Xu <jieyouxu@outlook.com>
---
 compiler/rustc_lint/messages.ftl              |  5 ++
 compiler/rustc_lint/src/types.rs              | 54 ++++++++----
 compiler/rustc_span/src/symbol.rs             |  1 +
 library/core/src/ffi/c_str.rs                 |  1 +
 ...extern-C-non-FFI-safe-arg-ice-52334.stderr | 12 +--
 tests/ui/lint/lint-ctypes-cstr.rs             | 36 ++++++++
 tests/ui/lint/lint-ctypes-cstr.stderr         | 84 +++++++++++++++++++
 7 files changed, 172 insertions(+), 21 deletions(-)
 create mode 100644 tests/ui/lint/lint-ctypes-cstr.rs
 create mode 100644 tests/ui/lint/lint-ctypes-cstr.stderr

diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 7e4feb0a82716..52a03772dc23c 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -361,6 +361,11 @@ lint_improper_ctypes_box = box cannot be represented as a single pointer
 lint_improper_ctypes_char_help = consider using `u32` or `libc::wchar_t` instead
 
 lint_improper_ctypes_char_reason = the `char` type has no C equivalent
+
+lint_improper_ctypes_cstr_help =
+    consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+lint_improper_ctypes_cstr_reason = `CStr`/`CString` do not have a guaranteed layout
+
 lint_improper_ctypes_dyn = trait objects have no C equivalent
 
 lint_improper_ctypes_enum_repr_help =
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index f3196cfed533e..d84d60ef5a7c1 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -984,6 +984,14 @@ struct ImproperCTypesVisitor<'a, 'tcx> {
     mode: CItemKind,
 }
 
+/// Accumulator for recursive ffi type checking
+struct CTypesVisitorState<'tcx> {
+    cache: FxHashSet<Ty<'tcx>>,
+    /// The original type being checked, before we recursed
+    /// to any other types it contains.
+    base_ty: Ty<'tcx>,
+}
+
 enum FfiResult<'tcx> {
     FfiSafe,
     FfiPhantom(Ty<'tcx>),
@@ -1212,7 +1220,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
     /// Checks if the given field's type is "ffi-safe".
     fn check_field_type_for_ffi(
         &self,
-        cache: &mut FxHashSet<Ty<'tcx>>,
+        acc: &mut CTypesVisitorState<'tcx>,
         field: &ty::FieldDef,
         args: GenericArgsRef<'tcx>,
     ) -> FfiResult<'tcx> {
@@ -1222,13 +1230,13 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             .tcx
             .try_normalize_erasing_regions(self.cx.param_env, field_ty)
             .unwrap_or(field_ty);
-        self.check_type_for_ffi(cache, field_ty)
+        self.check_type_for_ffi(acc, field_ty)
     }
 
     /// Checks if the given `VariantDef`'s field types are "ffi-safe".
     fn check_variant_for_ffi(
         &self,
-        cache: &mut FxHashSet<Ty<'tcx>>,
+        acc: &mut CTypesVisitorState<'tcx>,
         ty: Ty<'tcx>,
         def: ty::AdtDef<'tcx>,
         variant: &ty::VariantDef,
@@ -1238,7 +1246,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         let transparent_with_all_zst_fields = if def.repr().transparent() {
             if let Some(field) = transparent_newtype_field(self.cx.tcx, variant) {
                 // Transparent newtypes have at most one non-ZST field which needs to be checked..
-                match self.check_field_type_for_ffi(cache, field, args) {
+                match self.check_field_type_for_ffi(acc, field, args) {
                     FfiUnsafe { ty, .. } if ty.is_unit() => (),
                     r => return r,
                 }
@@ -1256,7 +1264,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         // We can't completely trust `repr(C)` markings, so make sure the fields are actually safe.
         let mut all_phantom = !variant.fields.is_empty();
         for field in &variant.fields {
-            all_phantom &= match self.check_field_type_for_ffi(cache, field, args) {
+            all_phantom &= match self.check_field_type_for_ffi(acc, field, args) {
                 FfiSafe => false,
                 // `()` fields are FFI-safe!
                 FfiUnsafe { ty, .. } if ty.is_unit() => false,
@@ -1276,7 +1284,11 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
     /// Checks if the given type is "ffi-safe" (has a stable, well-defined
     /// representation which can be exported to C code).
-    fn check_type_for_ffi(&self, cache: &mut FxHashSet<Ty<'tcx>>, ty: Ty<'tcx>) -> FfiResult<'tcx> {
+    fn check_type_for_ffi(
+        &self,
+        acc: &mut CTypesVisitorState<'tcx>,
+        ty: Ty<'tcx>,
+    ) -> FfiResult<'tcx> {
         use FfiResult::*;
 
         let tcx = self.cx.tcx;
@@ -1285,7 +1297,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
         // `struct S(*mut S);`.
         // FIXME: A recursion limit is necessary as well, for irregular
         // recursive types.
-        if !cache.insert(ty) {
+        if !acc.cache.insert(ty) {
             return FfiSafe;
         }
 
@@ -1307,6 +1319,17 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 }
                 match def.adt_kind() {
                     AdtKind::Struct | AdtKind::Union => {
+                        if let Some(sym::cstring_type | sym::cstr_type) =
+                            tcx.get_diagnostic_name(def.did())
+                            && !acc.base_ty.is_mutable_ptr()
+                        {
+                            return FfiUnsafe {
+                                ty,
+                                reason: fluent::lint_improper_ctypes_cstr_reason,
+                                help: Some(fluent::lint_improper_ctypes_cstr_help),
+                            };
+                        }
+
                         if !def.repr().c() && !def.repr().transparent() {
                             return FfiUnsafe {
                                 ty,
@@ -1353,7 +1376,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                             };
                         }
 
-                        self.check_variant_for_ffi(cache, ty, def, def.non_enum_variant(), args)
+                        self.check_variant_for_ffi(acc, ty, def, def.non_enum_variant(), args)
                     }
                     AdtKind::Enum => {
                         if def.variants().is_empty() {
@@ -1377,7 +1400,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                             if let Some(ty) =
                                 repr_nullable_ptr(self.cx.tcx, self.cx.param_env, ty, self.mode)
                             {
-                                return self.check_type_for_ffi(cache, ty);
+                                return self.check_type_for_ffi(acc, ty);
                             }
 
                             return FfiUnsafe {
@@ -1398,7 +1421,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                                 };
                             }
 
-                            match self.check_variant_for_ffi(cache, ty, def, variant, args) {
+                            match self.check_variant_for_ffi(acc, ty, def, variant, args) {
                                 FfiSafe => (),
                                 r => return r,
                             }
@@ -1468,9 +1491,9 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                 FfiSafe
             }
 
-            ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.check_type_for_ffi(cache, ty),
+            ty::RawPtr(ty, _) | ty::Ref(_, ty, _) => self.check_type_for_ffi(acc, ty),
 
-            ty::Array(inner_ty, _) => self.check_type_for_ffi(cache, inner_ty),
+            ty::Array(inner_ty, _) => self.check_type_for_ffi(acc, inner_ty),
 
             ty::FnPtr(sig) => {
                 if self.is_internal_abi(sig.abi()) {
@@ -1483,7 +1506,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
                 let sig = tcx.instantiate_bound_regions_with_erased(sig);
                 for arg in sig.inputs() {
-                    match self.check_type_for_ffi(cache, *arg) {
+                    match self.check_type_for_ffi(acc, *arg) {
                         FfiSafe => {}
                         r => return r,
                     }
@@ -1494,7 +1517,7 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
                     return FfiSafe;
                 }
 
-                self.check_type_for_ffi(cache, ret_ty)
+                self.check_type_for_ffi(acc, ret_ty)
             }
 
             ty::Foreign(..) => FfiSafe,
@@ -1617,7 +1640,8 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             return;
         }
 
-        match self.check_type_for_ffi(&mut FxHashSet::default(), ty) {
+        let mut acc = CTypesVisitorState { cache: FxHashSet::default(), base_ty: ty };
+        match self.check_type_for_ffi(&mut acc, ty) {
             FfiResult::FfiSafe => {}
             FfiResult::FfiPhantom(ty) => {
                 self.emit_ffi_unsafe_type_lint(
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 94cf21da4efb8..407f95a0f21e3 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -671,6 +671,7 @@ symbols! {
         crate_visibility_modifier,
         crt_dash_static: "crt-static",
         csky_target_feature,
+        cstr_type,
         cstring_type,
         ctlz,
         ctlz_nonzero,
diff --git a/library/core/src/ffi/c_str.rs b/library/core/src/ffi/c_str.rs
index 22084dcff8f88..7808d42ab5de4 100644
--- a/library/core/src/ffi/c_str.rs
+++ b/library/core/src/ffi/c_str.rs
@@ -91,6 +91,7 @@ use crate::{fmt, intrinsics, ops, slice, str};
 /// [str]: prim@str "str"
 #[derive(PartialEq, Eq, Hash)]
 #[stable(feature = "core_c_str", since = "1.64.0")]
+#[rustc_diagnostic_item = "cstr_type"]
 #[rustc_has_incoherent_inherent_impls]
 #[lang = "CStr"]
 // `fn from` in `impl From<&CStr> for Box<CStr>` current implementation relies
diff --git a/tests/ui/extern/extern-C-non-FFI-safe-arg-ice-52334.stderr b/tests/ui/extern/extern-C-non-FFI-safe-arg-ice-52334.stderr
index 8349298847918..044c1ae2dd42f 100644
--- a/tests/ui/extern/extern-C-non-FFI-safe-arg-ice-52334.stderr
+++ b/tests/ui/extern/extern-C-non-FFI-safe-arg-ice-52334.stderr
@@ -1,21 +1,21 @@
-warning: `extern` fn uses type `[i8 or u8 (arch dependant)]`, which is not FFI-safe
+warning: `extern` fn uses type `CStr`, which is not FFI-safe
   --> $DIR/extern-C-non-FFI-safe-arg-ice-52334.rs:7:12
    |
 LL | type Foo = extern "C" fn(::std::ffi::CStr);
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not FFI-safe
    |
-   = help: consider using a raw pointer instead
-   = note: slices have no C equivalent
+   = help: consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+   = note: `CStr`/`CString` do not have a guaranteed layout
    = note: `#[warn(improper_ctypes_definitions)]` on by default
 
-warning: `extern` block uses type `[i8 or u8 (arch dependant)]`, which is not FFI-safe
+warning: `extern` block uses type `CStr`, which is not FFI-safe
   --> $DIR/extern-C-non-FFI-safe-arg-ice-52334.rs:10:18
    |
 LL |     fn meh(blah: Foo);
    |                  ^^^ not FFI-safe
    |
-   = help: consider using a raw pointer instead
-   = note: slices have no C equivalent
+   = help: consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+   = note: `CStr`/`CString` do not have a guaranteed layout
    = note: `#[warn(improper_ctypes)]` on by default
 
 warning: 2 warnings emitted
diff --git a/tests/ui/lint/lint-ctypes-cstr.rs b/tests/ui/lint/lint-ctypes-cstr.rs
new file mode 100644
index 0000000000000..b04decd0bcacc
--- /dev/null
+++ b/tests/ui/lint/lint-ctypes-cstr.rs
@@ -0,0 +1,36 @@
+#![crate_type = "lib"]
+#![deny(improper_ctypes, improper_ctypes_definitions)]
+
+use std::ffi::{CStr, CString};
+
+extern "C" {
+    fn take_cstr(s: CStr);
+    //~^ ERROR `extern` block uses type `CStr`, which is not FFI-safe
+    //~| HELP consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+    fn take_cstr_ref(s: &CStr);
+    //~^ ERROR `extern` block uses type `CStr`, which is not FFI-safe
+    //~| HELP consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+    fn take_cstring(s: CString);
+    //~^ ERROR `extern` block uses type `CString`, which is not FFI-safe
+    //~| HELP consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+    fn take_cstring_ref(s: &CString);
+    //~^ ERROR `extern` block uses type `CString`, which is not FFI-safe
+    //~| HELP consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+
+    fn no_special_help_for_mut_cstring(s: *mut CString);
+    //~^ ERROR `extern` block uses type `CString`, which is not FFI-safe
+    //~| HELP consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
+
+    fn no_special_help_for_mut_cstring_ref(s: &mut CString);
+    //~^ ERROR `extern` block uses type `CString`, which is not FFI-safe
+    //~| HELP consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
+}
+
+extern "C" fn rust_take_cstr_ref(s: &CStr) {}
+//~^ ERROR `extern` fn uses type `CStr`, which is not FFI-safe
+//~| HELP consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+extern "C" fn rust_take_cstring(s: CString) {}
+//~^ ERROR `extern` fn uses type `CString`, which is not FFI-safe
+//~| HELP consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+extern "C" fn rust_no_special_help_for_mut_cstring(s: *mut CString) {}
+extern "C" fn rust_no_special_help_for_mut_cstring_ref(s: &mut CString) {}
diff --git a/tests/ui/lint/lint-ctypes-cstr.stderr b/tests/ui/lint/lint-ctypes-cstr.stderr
new file mode 100644
index 0000000000000..8957758d57732
--- /dev/null
+++ b/tests/ui/lint/lint-ctypes-cstr.stderr
@@ -0,0 +1,84 @@
+error: `extern` block uses type `CStr`, which is not FFI-safe
+  --> $DIR/lint-ctypes-cstr.rs:7:21
+   |
+LL |     fn take_cstr(s: CStr);
+   |                     ^^^^ not FFI-safe
+   |
+   = help: consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+   = note: `CStr`/`CString` do not have a guaranteed layout
+note: the lint level is defined here
+  --> $DIR/lint-ctypes-cstr.rs:2:9
+   |
+LL | #![deny(improper_ctypes, improper_ctypes_definitions)]
+   |         ^^^^^^^^^^^^^^^
+
+error: `extern` block uses type `CStr`, which is not FFI-safe
+  --> $DIR/lint-ctypes-cstr.rs:10:25
+   |
+LL |     fn take_cstr_ref(s: &CStr);
+   |                         ^^^^^ not FFI-safe
+   |
+   = help: consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+   = note: `CStr`/`CString` do not have a guaranteed layout
+
+error: `extern` block uses type `CString`, which is not FFI-safe
+  --> $DIR/lint-ctypes-cstr.rs:13:24
+   |
+LL |     fn take_cstring(s: CString);
+   |                        ^^^^^^^ not FFI-safe
+   |
+   = help: consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+   = note: `CStr`/`CString` do not have a guaranteed layout
+
+error: `extern` block uses type `CString`, which is not FFI-safe
+  --> $DIR/lint-ctypes-cstr.rs:16:28
+   |
+LL |     fn take_cstring_ref(s: &CString);
+   |                            ^^^^^^^^ not FFI-safe
+   |
+   = help: consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+   = note: `CStr`/`CString` do not have a guaranteed layout
+
+error: `extern` block uses type `CString`, which is not FFI-safe
+  --> $DIR/lint-ctypes-cstr.rs:20:43
+   |
+LL |     fn no_special_help_for_mut_cstring(s: *mut CString);
+   |                                           ^^^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
+   = note: this struct has unspecified layout
+
+error: `extern` block uses type `CString`, which is not FFI-safe
+  --> $DIR/lint-ctypes-cstr.rs:24:47
+   |
+LL |     fn no_special_help_for_mut_cstring_ref(s: &mut CString);
+   |                                               ^^^^^^^^^^^^ not FFI-safe
+   |
+   = help: consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
+   = note: this struct has unspecified layout
+
+error: `extern` fn uses type `CStr`, which is not FFI-safe
+  --> $DIR/lint-ctypes-cstr.rs:29:37
+   |
+LL | extern "C" fn rust_take_cstr_ref(s: &CStr) {}
+   |                                     ^^^^^ not FFI-safe
+   |
+   = help: consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+   = note: `CStr`/`CString` do not have a guaranteed layout
+note: the lint level is defined here
+  --> $DIR/lint-ctypes-cstr.rs:2:26
+   |
+LL | #![deny(improper_ctypes, improper_ctypes_definitions)]
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `extern` fn uses type `CString`, which is not FFI-safe
+  --> $DIR/lint-ctypes-cstr.rs:32:36
+   |
+LL | extern "C" fn rust_take_cstring(s: CString) {}
+   |                                    ^^^^^^^ not FFI-safe
+   |
+   = help: consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()`
+   = note: `CStr`/`CString` do not have a guaranteed layout
+
+error: aborting due to 8 previous errors
+

From 37984bbde11e6bcd0a009d2bbdbe7a73f9605b05 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sat, 3 Aug 2024 08:58:53 +0300
Subject: [PATCH 052/685] unify path syncing logic for vendor and dist

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/build_steps/dist.rs   | 34 ++++++--------------
 src/bootstrap/src/core/build_steps/vendor.rs | 32 ++++++++++++------
 2 files changed, 31 insertions(+), 35 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index c14709ffb6324..cd7d602e859f8 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -19,6 +19,7 @@ use object::BinaryFormat;
 
 use crate::core::build_steps::doc::DocumentationFormat;
 use crate::core::build_steps::tool::{self, Tool};
+use crate::core::build_steps::vendor::default_paths_to_vendor;
 use crate::core::build_steps::{compile, llvm};
 use crate::core::builder::{Builder, Kind, RunConfig, ShouldRun, Step};
 use crate::core::config::TargetSelection;
@@ -1016,35 +1017,18 @@ impl Step for PlainSourceTarball {
         if builder.rust_info().is_managed_git_subrepository()
             || builder.rust_info().is_from_tarball()
         {
-            // FIXME: This code looks _very_ similar to what we have in `src/core/build_steps/vendor.rs`
-            // perhaps it should be removed in favor of making `dist` perform the `vendor` step?
-
             builder.require_and_update_all_submodules();
 
             // Vendor all Cargo dependencies
             let mut cmd = command(&builder.initial_cargo);
-            cmd.arg("vendor")
-                .arg("--versioned-dirs")
-                .arg("--sync")
-                .arg(builder.src.join("./src/tools/cargo/Cargo.toml"))
-                .arg("--sync")
-                .arg(builder.src.join("./src/tools/rust-analyzer/Cargo.toml"))
-                .arg("--sync")
-                .arg(builder.src.join("./compiler/rustc_codegen_cranelift/Cargo.toml"))
-                .arg("--sync")
-                .arg(builder.src.join("./compiler/rustc_codegen_gcc/Cargo.toml"))
-                .arg("--sync")
-                .arg(builder.src.join("./library/Cargo.toml"))
-                .arg("--sync")
-                .arg(builder.src.join("./src/bootstrap/Cargo.toml"))
-                .arg("--sync")
-                .arg(builder.src.join("./src/tools/opt-dist/Cargo.toml"))
-                .arg("--sync")
-                .arg(builder.src.join("./src/tools/rustc-perf/Cargo.toml"))
-                .arg("--sync")
-                .arg(builder.src.join("./src/tools/rustbook/Cargo.toml"))
-                // Will read the libstd Cargo.toml
-                // which uses the unstable `public-dependency` feature.
+            cmd.arg("vendor").arg("--versioned-dirs");
+
+            for p in default_paths_to_vendor(builder) {
+                cmd.arg("--sync").arg(p);
+            }
+
+            cmd
+                // Will read the libstd Cargo.toml which uses the unstable `public-dependency` feature.
                 .env("RUSTC_BOOTSTRAP", "1")
                 .current_dir(plain_dst_src);
 
diff --git a/src/bootstrap/src/core/build_steps/vendor.rs b/src/bootstrap/src/core/build_steps/vendor.rs
index 33768465225fe..82a6b4d4f28cb 100644
--- a/src/bootstrap/src/core/build_steps/vendor.rs
+++ b/src/bootstrap/src/core/build_steps/vendor.rs
@@ -4,6 +4,26 @@ use crate::core::build_steps::tool::SUBMODULES_FOR_RUSTBOOK;
 use crate::core::builder::{Builder, RunConfig, ShouldRun, Step};
 use crate::utils::exec::command;
 
+/// List of default paths used for vendoring for `x vendor` and dist tarballs.
+pub fn default_paths_to_vendor(builder: &Builder<'_>) -> Vec<PathBuf> {
+    let mut paths = vec![];
+    for p in [
+        "src/tools/cargo/Cargo.toml",
+        "src/tools/rust-analyzer/Cargo.toml",
+        "compiler/rustc_codegen_cranelift/Cargo.toml",
+        "compiler/rustc_codegen_gcc/Cargo.toml",
+        "library/Cargo.toml",
+        "src/bootstrap/Cargo.toml",
+        "src/tools/rustbook/Cargo.toml",
+        "src/tools/rustc-perf/Cargo.toml",
+        "src/tools/opt-dist/Cargo.toml",
+    ] {
+        paths.push(builder.src.join(p));
+    }
+
+    paths
+}
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub(crate) struct Vendor {
     sync_args: Vec<PathBuf>,
@@ -42,16 +62,8 @@ impl Step for Vendor {
         }
 
         // Sync these paths by default.
-        for p in [
-            "src/tools/cargo/Cargo.toml",
-            "src/tools/rust-analyzer/Cargo.toml",
-            "compiler/rustc_codegen_cranelift/Cargo.toml",
-            "compiler/rustc_codegen_gcc/Cargo.toml",
-            "library/Cargo.toml",
-            "src/bootstrap/Cargo.toml",
-            "src/tools/rustbook/Cargo.toml",
-        ] {
-            cmd.arg("--sync").arg(builder.src.join(p));
+        for p in default_paths_to_vendor(builder) {
+            cmd.arg("--sync").arg(p);
         }
 
         // Also sync explicitly requested paths.

From bc0bc91e109fb21243f6bf15747c6fe2158d6a4b Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sat, 3 Aug 2024 09:00:16 +0300
Subject: [PATCH 053/685] remove redundant FIXMEs

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/build_steps/tool.rs |  7 +------
 src/bootstrap/src/core/builder.rs          | 14 +++++---------
 src/bootstrap/src/core/download.rs         |  2 --
 3 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index 4d573b107b587..ff8ca2ad74aaf 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -1091,18 +1091,13 @@ macro_rules! tool_extended {
     }
 }
 
-// NOTE: tools need to be also added to `Builder::get_step_descriptions` in `builder.rs`
-// to make `./x.py build <tool>` work.
 tool_extended!((self, builder),
     Cargofmt, "src/tools/rustfmt", "cargo-fmt", stable=true;
     CargoClippy, "src/tools/clippy", "cargo-clippy", stable=true;
     Clippy, "src/tools/clippy", "clippy-driver", stable=true, add_bins_to_sysroot = ["clippy-driver", "cargo-clippy"];
     Miri, "src/tools/miri", "miri", stable=false, add_bins_to_sysroot = ["miri"];
     CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri", stable=true, add_bins_to_sysroot = ["cargo-miri"];
-    // FIXME: tool_std is not quite right, we shouldn't allow nightly features.
-    // But `builder.cargo` doesn't know how to handle ToolBootstrap in stages other than 0,
-    // and this is close enough for now.
-    Rls, "src/tools/rls", "rls", stable=true, tool_std=true;
+    Rls, "src/tools/rls", "rls", stable=true;
     Rustfmt, "src/tools/rustfmt", "rustfmt", stable=true, add_bins_to_sysroot = ["rustfmt", "cargo-fmt"];
 );
 
diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs
index 84c23c059e97e..d6c6de8f80df4 100644
--- a/src/bootstrap/src/core/builder.rs
+++ b/src/bootstrap/src/core/builder.rs
@@ -1449,15 +1449,11 @@ impl<'a> Builder<'a> {
             assert_eq!(target, compiler.host);
         }
 
-        if self.config.rust_optimize.is_release() {
-            // FIXME: cargo bench/install do not accept `--release`
-            // and miri doesn't want it
-            match cmd_kind {
-                Kind::Bench | Kind::Install | Kind::Miri | Kind::MiriSetup | Kind::MiriTest => {}
-                _ => {
-                    cargo.arg("--release");
-                }
-            }
+        if self.config.rust_optimize.is_release() &&
+        // cargo bench/install do not accept `--release` and miri doesn't want it
+        !matches!(cmd_kind, Kind::Bench | Kind::Install | Kind::Miri | Kind::MiriSetup | Kind::MiriTest)
+        {
+            cargo.arg("--release");
         }
 
         // Remove make-related flags to ensure Cargo can correctly set things up
diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index 4d1aea3cd956a..25daeeb721eed 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -616,8 +616,6 @@ impl Config {
         };
 
         // For the beta compiler, put special effort into ensuring the checksums are valid.
-        // FIXME: maybe we should do this for download-rustc as well? but it would be a pain to update
-        // this on each and every nightly ...
         let checksum = if should_verify {
             let error = format!(
                 "src/stage0 doesn't contain a checksum for {url}. \

From 8d7c374b2ec4f6cfd99f9c8e7cd5b2624909fa21 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sat, 3 Aug 2024 09:10:00 +0300
Subject: [PATCH 054/685] improve rustup check in `x setup`

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/build_steps/setup.rs | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/setup.rs b/src/bootstrap/src/core/build_steps/setup.rs
index 8cd9ba5fd146f..f7b26712cabd6 100644
--- a/src/bootstrap/src/core/build_steps/setup.rs
+++ b/src/bootstrap/src/core/build_steps/setup.rs
@@ -247,9 +247,11 @@ pub struct Link;
 impl Step for Link {
     type Output = ();
     const DEFAULT: bool = true;
+
     fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
         run.alias("link")
     }
+
     fn make_run(run: RunConfig<'_>) {
         if run.builder.config.dry_run() {
             return;
@@ -262,21 +264,30 @@ impl Step for Link {
     }
     fn run(self, builder: &Builder<'_>) -> Self::Output {
         let config = &builder.config;
+
         if config.dry_run() {
             return;
         }
+
+        if !rustup_installed(builder) {
+            println!("WARNING: `rustup` is not installed; Skipping `stage1` toolchain linking.");
+            return;
+        }
+
         let stage_path =
             ["build", config.build.rustc_target_arg(), "stage1"].join(MAIN_SEPARATOR_STR);
-        if !rustup_installed(builder) {
-            eprintln!("`rustup` is not installed; cannot link `stage1` toolchain");
-        } else if stage_dir_exists(&stage_path[..]) && !config.dry_run() {
+
+        if stage_dir_exists(&stage_path[..]) && !config.dry_run() {
             attempt_toolchain_link(builder, &stage_path[..]);
         }
     }
 }
 
 fn rustup_installed(builder: &Builder<'_>) -> bool {
-    command("rustup").arg("--version").run_capture_stdout(builder).is_success()
+    let mut rustup = command("rustup");
+    rustup.arg("--version");
+
+    rustup.allow_failure().run_always().run_capture_stdout(builder).is_success()
 }
 
 fn stage_dir_exists(stage_path: &str) -> bool {

From 6899f5a8e12986ee16e028f1597963d0de668aca Mon Sep 17 00:00:00 2001
From: Mrmaxmeier <Mrmaxmeier@gmail.com>
Date: Tue, 6 Aug 2024 20:31:12 +0200
Subject: [PATCH 055/685] -Zembed-source: Don't try to warn about incompatible
 codegen backends

---
 compiler/rustc_session/messages.ftl   | 2 --
 compiler/rustc_session/src/errors.rs  | 4 ----
 compiler/rustc_session/src/session.rs | 7 -------
 3 files changed, 13 deletions(-)

diff --git a/compiler/rustc_session/messages.ftl b/compiler/rustc_session/messages.ftl
index afd5360c81194..01c371ee49884 100644
--- a/compiler/rustc_session/messages.ftl
+++ b/compiler/rustc_session/messages.ftl
@@ -18,8 +18,6 @@ session_embed_source_insufficient_dwarf_version = `-Zembed-source=y` requires at
 
 session_embed_source_requires_debug_info = `-Zembed-source=y` requires debug information to be enabled
 
-session_embed_source_requires_llvm_backend = `-Zembed-source=y` is only supported on the LLVM codegen backend
-
 session_expr_parentheses_needed = parentheses are required to parse this as an expression
 
 session_failed_to_create_profiler = failed to create profiler: {$err}
diff --git a/compiler/rustc_session/src/errors.rs b/compiler/rustc_session/src/errors.rs
index f708109b87a0c..15bbd4ff7bf4b 100644
--- a/compiler/rustc_session/src/errors.rs
+++ b/compiler/rustc_session/src/errors.rs
@@ -175,10 +175,6 @@ pub(crate) struct EmbedSourceInsufficientDwarfVersion {
 #[diag(session_embed_source_requires_debug_info)]
 pub(crate) struct EmbedSourceRequiresDebugInfo;
 
-#[derive(Diagnostic)]
-#[diag(session_embed_source_requires_llvm_backend)]
-pub(crate) struct EmbedSourceRequiresLLVMBackend;
-
 #[derive(Diagnostic)]
 #[diag(session_target_stack_protector_not_supported)]
 pub(crate) struct StackProtectorNotSupportedForTarget<'a> {
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 634f3684b51aa..e2ef144e732a4 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -1305,9 +1305,6 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
         let dwarf_version =
             sess.opts.unstable_opts.dwarf_version.unwrap_or(sess.target.default_dwarf_version);
 
-        let uses_llvm_backend =
-            matches!(sess.opts.unstable_opts.codegen_backend.as_deref(), None | Some("llvm"));
-
         if dwarf_version < 5 {
             sess.dcx().emit_warn(errors::EmbedSourceInsufficientDwarfVersion { dwarf_version });
         }
@@ -1315,10 +1312,6 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
         if sess.opts.debuginfo == DebugInfo::None {
             sess.dcx().emit_warn(errors::EmbedSourceRequiresDebugInfo);
         }
-
-        if !uses_llvm_backend {
-            sess.dcx().emit_warn(errors::EmbedSourceRequiresLLVMBackend);
-        }
     }
 
     if sess.opts.unstable_opts.instrument_xray.is_some() && !sess.target.options.supports_xray {

From 1b587a6e76200fdd8364ef910246efa11c973e7b Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Tue, 6 Aug 2024 14:33:14 -0700
Subject: [PATCH 056/685] alloc: add ToString specialization for `&&str`

Fixes #128690
---
 library/alloc/src/string.rs                  | 43 ++++++++++++++++----
 tests/codegen/issues/str-to-string-128690.rs | 36 ++++++++++++++++
 2 files changed, 71 insertions(+), 8 deletions(-)
 create mode 100644 tests/codegen/issues/str-to-string-128690.rs

diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
index 124230812df56..d943901e9ecf9 100644
--- a/library/alloc/src/string.rs
+++ b/library/alloc/src/string.rs
@@ -2643,14 +2643,41 @@ impl ToString for i8 {
     }
 }
 
-#[doc(hidden)]
-#[cfg(not(no_global_oom_handling))]
-#[stable(feature = "str_to_string_specialization", since = "1.9.0")]
-impl ToString for str {
-    #[inline]
-    fn to_string(&self) -> String {
-        String::from(self)
-    }
+// Generic/generated code can sometimes have multiple, nested references
+// for strings, including `&&&str`s that would never be written
+// by hand. This macro generates twelve layers of nested `&`-impl
+// for primitive strings.
+macro_rules! to_string_str {
+    {type ; x $($x:ident)*} => {
+        &to_string_str! { type ; $($x)* }
+    };
+    {type ;} => { str };
+    {impl ; x $($x:ident)*} => {
+        to_string_str! { $($x)* }
+    };
+    {impl ;} => { };
+    {$self:expr ; x $($x:ident)*} => {
+        *(to_string_str! { $self ; $($x)* })
+    };
+    {$self:expr ;} => { $self };
+    {$($x:ident)*} => {
+        #[doc(hidden)]
+        #[cfg(not(no_global_oom_handling))]
+        #[stable(feature = "str_to_string_specialization", since = "1.9.0")]
+        impl ToString for to_string_str!(type ; $($x)*) {
+            #[inline]
+            fn to_string(&self) -> String {
+                String::from(to_string_str!(self ; $($x)*))
+            }
+        }
+        to_string_str! { impl ; $($x)* }
+    };
+}
+
+to_string_str! {
+    x x x x
+    x x x x
+    x x x x
 }
 
 #[doc(hidden)]
diff --git a/tests/codegen/issues/str-to-string-128690.rs b/tests/codegen/issues/str-to-string-128690.rs
new file mode 100644
index 0000000000000..8b416306ba66e
--- /dev/null
+++ b/tests/codegen/issues/str-to-string-128690.rs
@@ -0,0 +1,36 @@
+//@ compile-flags: -C opt-level=3 -Z merge-functions=disabled
+#![crate_type = "lib"]
+
+//! Make sure str::to_string is specialized not to use fmt machinery.
+
+// CHECK-LABEL: define {{(dso_local )?}}void @one_ref
+#[no_mangle]
+pub fn one_ref(input: &str) -> String {
+    // CHECK-NOT: {{(call|invoke).*}}fmt
+    input.to_string()
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}void @two_ref
+#[no_mangle]
+pub fn two_ref(input: &&str) -> String {
+    // CHECK-NOT: {{(call|invoke).*}}fmt
+    input.to_string()
+}
+
+// CHECK-LABEL: define {{(dso_local )?}}void @thirteen_ref
+#[no_mangle]
+pub fn thirteen_ref(input: &&&&&&&&&&&&&str) -> String {
+    // CHECK-NOT: {{(call|invoke).*}}fmt
+    input.to_string()
+}
+
+// This is a known performance cliff because of the macro-generated
+// specialized impl. If this test suddenly starts failing,
+// consider removing the `to_string_str!` macro in `alloc/str/string.rs`.
+//
+// CHECK-LABEL: define {{(dso_local )?}}void @fourteen_ref
+#[no_mangle]
+pub fn fourteen_ref(input: &&&&&&&&&&&&&&str) -> String {
+    // CHECK: {{(call|invoke).*}}fmt
+    input.to_string()
+}

From 20c833c632d76ee78284441226f12b919318bc4b Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Tue, 6 Aug 2024 18:18:15 -0700
Subject: [PATCH 057/685] diagnostics: `Box<dyn Trait>` suggestion with
 multiple matching impl

The two altered expectation messages both seem like improvements:

- `coerce-expect-unsized-ascribed.stderr` says you can go
  `Box<char> -> Box<dyn Debug>`, which you can.
- `upcast_soundness_bug.stderr` used to say that you could go
  `Box<dyn Trait<u8, u8>> -> Box<dyn Trait>`, which you can't,
  because the type parameters are missing in the destination
  and the only ones that work aren't what's needed.
---
 .../error_reporting/infer/note_and_explain.rs | 24 +++++++------------
 .../coerce-expect-unsized-ascribed.stderr     |  4 ++++
 tests/ui/traits/upcast_soundness_bug.stderr   |  1 -
 3 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
index 864510bb65047..0c140f93d94b2 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
@@ -313,11 +313,9 @@ impl<T> Trait<T> for X {
                     (ty::Dynamic(t, _, ty::DynKind::Dyn), _)
                         if let Some(def_id) = t.principal_def_id() =>
                     {
-                        let mut impl_def_ids = vec![];
-                        tcx.for_each_relevant_impl(def_id, values.found, |did| {
-                            impl_def_ids.push(did)
-                        });
-                        if let [_] = &impl_def_ids[..] {
+                        let has_non_blanket_impl =
+                            tcx.non_blanket_impls_for_ty(def_id, values.found).next().is_some();
+                        if has_non_blanket_impl {
                             let trait_name = tcx.item_name(def_id);
                             diag.help(format!(
                                 "`{}` implements `{trait_name}` so you could box the found value \
@@ -330,11 +328,9 @@ impl<T> Trait<T> for X {
                     (_, ty::Dynamic(t, _, ty::DynKind::Dyn))
                         if let Some(def_id) = t.principal_def_id() =>
                     {
-                        let mut impl_def_ids = vec![];
-                        tcx.for_each_relevant_impl(def_id, values.expected, |did| {
-                            impl_def_ids.push(did)
-                        });
-                        if let [_] = &impl_def_ids[..] {
+                        let has_non_blanket_impl =
+                            tcx.non_blanket_impls_for_ty(def_id, values.expected).next().is_some();
+                        if has_non_blanket_impl {
                             let trait_name = tcx.item_name(def_id);
                             diag.help(format!(
                                 "`{}` implements `{trait_name}` so you could change the expected \
@@ -346,11 +342,9 @@ impl<T> Trait<T> for X {
                     (ty::Dynamic(t, _, ty::DynKind::DynStar), _)
                         if let Some(def_id) = t.principal_def_id() =>
                     {
-                        let mut impl_def_ids = vec![];
-                        tcx.for_each_relevant_impl(def_id, values.found, |did| {
-                            impl_def_ids.push(did)
-                        });
-                        if let [_] = &impl_def_ids[..] {
+                        let has_non_blanket_impl =
+                            tcx.non_blanket_impls_for_ty(def_id, values.found).next().is_some();
+                        if has_non_blanket_impl {
                             let trait_name = tcx.item_name(def_id);
                             diag.help(format!(
                                 "`{}` implements `{trait_name}`, `#[feature(dyn_star)]` is likely \
diff --git a/tests/ui/coercion/coerce-expect-unsized-ascribed.stderr b/tests/ui/coercion/coerce-expect-unsized-ascribed.stderr
index 646044ae41abc..0c220a13876b8 100644
--- a/tests/ui/coercion/coerce-expect-unsized-ascribed.stderr
+++ b/tests/ui/coercion/coerce-expect-unsized-ascribed.stderr
@@ -42,6 +42,7 @@ LL |     let _ = type_ascribe!(Box::new( if true { false } else { true }), Box<d
    |
    = note: expected struct `Box<dyn Debug>`
               found struct `Box<bool>`
+   = help: `bool` implements `Debug` so you could box the found value and coerce it to the trait object `Box<dyn Debug>`, you will have to change the expected type as well
 
 error[E0308]: mismatched types
   --> $DIR/coerce-expect-unsized-ascribed.rs:16:27
@@ -51,6 +52,7 @@ LL |     let _ = type_ascribe!(Box::new( match true { true => 'a', false => 'b'
    |
    = note: expected struct `Box<dyn Debug>`
               found struct `Box<char>`
+   = help: `char` implements `Debug` so you could box the found value and coerce it to the trait object `Box<dyn Debug>`, you will have to change the expected type as well
 
 error[E0308]: mismatched types
   --> $DIR/coerce-expect-unsized-ascribed.rs:18:27
@@ -96,6 +98,7 @@ LL |     let _ = type_ascribe!(&if true { false } else { true }, &dyn Debug);
    |
    = note: expected reference `&dyn Debug`
               found reference `&bool`
+   = help: `bool` implements `Debug` so you could box the found value and coerce it to the trait object `Box<dyn Debug>`, you will have to change the expected type as well
 
 error[E0308]: mismatched types
   --> $DIR/coerce-expect-unsized-ascribed.rs:24:27
@@ -105,6 +108,7 @@ LL |     let _ = type_ascribe!(&match true { true => 'a', false => 'b' }, &dyn D
    |
    = note: expected reference `&dyn Debug`
               found reference `&char`
+   = help: `char` implements `Debug` so you could box the found value and coerce it to the trait object `Box<dyn Debug>`, you will have to change the expected type as well
 
 error[E0308]: mismatched types
   --> $DIR/coerce-expect-unsized-ascribed.rs:26:27
diff --git a/tests/ui/traits/upcast_soundness_bug.stderr b/tests/ui/traits/upcast_soundness_bug.stderr
index 5864abcdb41f5..31f77b52b5fbf 100644
--- a/tests/ui/traits/upcast_soundness_bug.stderr
+++ b/tests/ui/traits/upcast_soundness_bug.stderr
@@ -6,7 +6,6 @@ LL |     let p = p as *const dyn Trait<u8, u16>; // <- this is bad!
    |
    = note: expected trait object `dyn Trait<u8, u8>`
               found trait object `dyn Trait<u8, u16>`
-   = help: `dyn Trait<u8, u16>` implements `Trait` so you could box the found value and coerce it to the trait object `Box<dyn Trait>`, you will have to change the expected type as well
 
 error: aborting due to 1 previous error
 

From 0475bddae2905def7d61f305bd53367367536dd1 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Wed, 7 Aug 2024 04:57:07 +0000
Subject: [PATCH 058/685] 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 f6fbc9844f860..699a17a4943aa 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-c9687a95a602091777e28703aa5abf20f1ce1797
+6696447f784a888446d13bb400a8d507a68331c9

From de9b5c3ea280112169887065354706e102e6290d Mon Sep 17 00:00:00 2001
From: carbotaniuman <41451839+carbotaniuman@users.noreply.github.com>
Date: Wed, 7 Aug 2024 01:36:28 -0500
Subject: [PATCH 059/685] Stabilize `unsafe_attributes`

---
 .../rustc_ast_passes/src/ast_validation.rs    |  2 +-
 compiler/rustc_ast_passes/src/feature_gate.rs |  1 -
 .../src/cfg_accessible.rs                     |  1 -
 compiler/rustc_builtin_macros/src/derive.rs   |  1 -
 compiler/rustc_builtin_macros/src/util.rs     |  1 -
 compiler/rustc_expand/src/config.rs           | 13 +-----
 compiler/rustc_expand/src/expand.rs           |  2 +-
 compiler/rustc_feature/src/accepted.rs        |  2 +
 compiler/rustc_feature/src/unstable.rs        |  2 -
 compiler/rustc_lint_defs/src/builtin.rs       |  1 -
 compiler/rustc_parse/src/parser/attr.rs       |  4 +-
 compiler/rustc_parse/src/validate_attr.rs     | 40 ++++++-------------
 .../rustfmt/tests/target/unsafe_attributes.rs |  1 -
 .../unsafe/cfg-unsafe-attributes.rs           |  1 -
 .../unsafe/derive-unsafe-attributes.rs        |  2 -
 .../unsafe/derive-unsafe-attributes.stderr    | 14 +++----
 .../unsafe/double-unsafe-attributes.rs        |  2 -
 .../unsafe/double-unsafe-attributes.stderr    |  6 +--
 .../unsafe/extraneous-unsafe-attributes.rs    |  1 -
 .../extraneous-unsafe-attributes.stderr       | 16 ++++----
 .../unsafe/proc-unsafe-attributes.rs          |  2 -
 .../unsafe/proc-unsafe-attributes.stderr      | 30 +++++++-------
 .../ui/attributes/unsafe/unsafe-attributes.rs |  1 -
 .../unsafe/unsafe-safe-attribute.rs           |  2 -
 .../unsafe/unsafe-safe-attribute.stderr       |  2 +-
 .../unsafe-safe-attribute_diagnostic.rs       |  2 -
 .../unsafe-safe-attribute_diagnostic.stderr   |  2 +-
 .../feature-gate-unsafe-attributes.rs         |  8 ----
 .../feature-gate-unsafe-attributes.stderr     | 13 ------
 .../in_2024_compatibility.rs                  |  1 -
 .../in_2024_compatibility.stderr              |  2 +-
 .../unsafe-attribute-marked.rs                |  1 -
 .../unsafe-attributes-fix.fixed               |  1 -
 .../unsafe-attributes-fix.rs                  |  1 -
 .../unsafe-attributes-fix.stderr              | 14 +++----
 .../unsafe-attributes.edition2024.stderr      |  2 +-
 .../unsafe-attributes/unsafe-attributes.rs    |  1 -
 37 files changed, 64 insertions(+), 134 deletions(-)
 delete mode 100644 tests/ui/feature-gates/feature-gate-unsafe-attributes.rs
 delete mode 100644 tests/ui/feature-gates/feature-gate-unsafe-attributes.stderr

diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index a353c79f12d45..837cb805700d2 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -887,7 +887,7 @@ fn validate_generic_param_order(dcx: DiagCtxtHandle<'_>, generics: &[GenericPara
 
 impl<'a> Visitor<'a> for AstValidator<'a> {
     fn visit_attribute(&mut self, attr: &Attribute) {
-        validate_attr::check_attr(&self.features, &self.session.psess, attr);
+        validate_attr::check_attr(&self.session.psess, attr);
     }
 
     fn visit_ty(&mut self, ty: &'a Ty) {
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 3ceb8e0711a21..214a37bca03e2 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -559,7 +559,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     gate_all!(mut_ref, "mutable by-reference bindings are experimental");
     gate_all!(precise_capturing, "precise captures on `impl Trait` are experimental");
     gate_all!(global_registration, "global registration is experimental");
-    gate_all!(unsafe_attributes, "`#[unsafe()]` markers for attributes are experimental");
     gate_all!(return_type_notation, "return type notation is experimental");
 
     if !visitor.features.never_patterns {
diff --git a/compiler/rustc_builtin_macros/src/cfg_accessible.rs b/compiler/rustc_builtin_macros/src/cfg_accessible.rs
index 006b6aa823fbf..3d3bd3aea059c 100644
--- a/compiler/rustc_builtin_macros/src/cfg_accessible.rs
+++ b/compiler/rustc_builtin_macros/src/cfg_accessible.rs
@@ -47,7 +47,6 @@ impl MultiItemModifier for Expander {
     ) -> ExpandResult<Vec<Annotatable>, Annotatable> {
         let template = AttributeTemplate { list: Some("path"), ..Default::default() };
         validate_attr::check_builtin_meta_item(
-            &ecx.ecfg.features,
             &ecx.sess.psess,
             meta_item,
             ast::AttrStyle::Outer,
diff --git a/compiler/rustc_builtin_macros/src/derive.rs b/compiler/rustc_builtin_macros/src/derive.rs
index 57bddf0ab60ad..e8704bc2f639d 100644
--- a/compiler/rustc_builtin_macros/src/derive.rs
+++ b/compiler/rustc_builtin_macros/src/derive.rs
@@ -38,7 +38,6 @@ impl MultiItemModifier for Expander {
                 let template =
                     AttributeTemplate { list: Some("Trait1, Trait2, ..."), ..Default::default() };
                 validate_attr::check_builtin_meta_item(
-                    features,
                     &sess.psess,
                     meta_item,
                     ast::AttrStyle::Outer,
diff --git a/compiler/rustc_builtin_macros/src/util.rs b/compiler/rustc_builtin_macros/src/util.rs
index 73cc8ff547d51..0bcd5aef28bab 100644
--- a/compiler/rustc_builtin_macros/src/util.rs
+++ b/compiler/rustc_builtin_macros/src/util.rs
@@ -17,7 +17,6 @@ pub(crate) fn check_builtin_macro_attribute(ecx: &ExtCtxt<'_>, meta_item: &MetaI
     // All the built-in macro attributes are "words" at the moment.
     let template = AttributeTemplate { word: true, ..Default::default() };
     validate_attr::check_builtin_meta_item(
-        &ecx.ecfg.features,
         &ecx.sess.psess,
         meta_item,
         AttrStyle::Outer,
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index f6bf9f5e89f2f..b0d3fecbb479b 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -265,12 +265,7 @@ impl<'a> StripUnconfigured<'a> {
     /// is in the original source file. Gives a compiler error if the syntax of
     /// the attribute is incorrect.
     pub(crate) fn expand_cfg_attr(&self, cfg_attr: &Attribute, recursive: bool) -> Vec<Attribute> {
-        validate_attr::check_attribute_safety(
-            self.features.unwrap_or(&Features::default()),
-            &self.sess.psess,
-            AttributeSafety::Normal,
-            &cfg_attr,
-        );
+        validate_attr::check_attribute_safety(&self.sess.psess, AttributeSafety::Normal, &cfg_attr);
 
         let Some((cfg_predicate, expanded_attrs)) =
             rustc_parse::parse_cfg_attr(cfg_attr, &self.sess.psess)
@@ -395,11 +390,7 @@ impl<'a> StripUnconfigured<'a> {
             }
         };
 
-        validate_attr::deny_builtin_meta_unsafety(
-            self.features.unwrap_or(&Features::default()),
-            &self.sess.psess,
-            &meta_item,
-        );
+        validate_attr::deny_builtin_meta_unsafety(&self.sess.psess, &meta_item);
 
         (
             parse_cfg(&meta_item, self.sess).map_or(true, |meta_item| {
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index d8cb367e3face..61b36e15487e0 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -1883,7 +1883,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
         let mut span: Option<Span> = None;
         while let Some(attr) = attrs.next() {
             rustc_ast_passes::feature_gate::check_attribute(attr, self.cx.sess, features);
-            validate_attr::check_attr(features, &self.cx.sess.psess, attr);
+            validate_attr::check_attr(&self.cx.sess.psess, attr);
 
             let current_span = if let Some(sp) = span { sp.to(attr.span) } else { attr.span };
             span = Some(current_span);
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index e42a655531b5d..689e2d2771e6f 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -388,6 +388,8 @@ declare_features! (
     (accepted, universal_impl_trait, "1.26.0", Some(34511)),
     /// Allows arbitrary delimited token streams in non-macro attributes.
     (accepted, unrestricted_attribute_tokens, "1.34.0", Some(55208)),
+    /// Allows unsafe attributes.
+    (accepted, unsafe_attributes, "CURRENT_RUSTC_VERSION", Some(123757)),
     /// The `unsafe_op_in_unsafe_fn` lint (allowed by default): no longer treat an unsafe function as an unsafe block.
     (accepted, unsafe_block_in_unsafe_fn, "1.52.0", Some(71668)),
     /// Allows unsafe on extern declarations and safety qualifiers over internal items.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 88a4b5a838246..a9e9bdd6a4190 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -627,8 +627,6 @@ declare_features! (
     (unstable, type_changing_struct_update, "1.58.0", Some(86555)),
     /// Allows unnamed fields of struct and union type
     (incomplete, unnamed_fields, "1.74.0", Some(49804)),
-    /// Allows unsafe attributes.
-    (unstable, unsafe_attributes, "1.80.0", Some(123757)),
     /// Allows const generic parameters to be defined with types that
     /// are not `Sized`, e.g. `fn foo<const N: [u8]>() {`.
     (incomplete, unsized_const_params, "CURRENT_RUSTC_VERSION", Some(95174)),
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index ff0bdfcc9d261..aa281a6f67b45 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -4937,7 +4937,6 @@ declare_lint! {
     /// ### Example
     ///
     /// ```rust
-    /// #![feature(unsafe_attributes)]
     /// #![warn(unsafe_attr_outside_unsafe)]
     ///
     /// #[no_mangle]
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index 8fdfbcee38546..4fea00edebc67 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -4,7 +4,7 @@ use rustc_ast::token::{self, Delimiter};
 use rustc_errors::codes::*;
 use rustc_errors::{Diag, PResult};
 use rustc_span::symbol::kw;
-use rustc_span::{sym, BytePos, Span};
+use rustc_span::{BytePos, Span};
 use thin_vec::ThinVec;
 use tracing::debug;
 
@@ -261,7 +261,6 @@ impl<'a> Parser<'a> {
             let is_unsafe = this.eat_keyword(kw::Unsafe);
             let unsafety = if is_unsafe {
                 let unsafe_span = this.prev_token.span;
-                this.psess.gated_spans.gate(sym::unsafe_attributes, unsafe_span);
                 this.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
                 ast::Safety::Unsafe(unsafe_span)
             } else {
@@ -400,7 +399,6 @@ impl<'a> Parser<'a> {
         };
         let unsafety = if is_unsafe {
             let unsafe_span = self.prev_token.span;
-            self.psess.gated_spans.gate(sym::unsafe_attributes, unsafe_span);
             self.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
 
             ast::Safety::Unsafe(unsafe_span)
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index a64c00f3b6cbc..fce41bd90be7b 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -7,9 +7,7 @@ use rustc_ast::{
     NestedMetaItem, Safety,
 };
 use rustc_errors::{Applicability, FatalError, PResult};
-use rustc_feature::{
-    AttributeSafety, AttributeTemplate, BuiltinAttribute, Features, BUILTIN_ATTRIBUTE_MAP,
-};
+use rustc_feature::{AttributeSafety, AttributeTemplate, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP};
 use rustc_session::errors::report_lit_error;
 use rustc_session::lint::builtin::{ILL_FORMED_ATTRIBUTE_INPUT, UNSAFE_ATTR_OUTSIDE_UNSAFE};
 use rustc_session::lint::BuiltinLintDiag;
@@ -18,7 +16,7 @@ use rustc_span::{sym, BytePos, Span, Symbol};
 
 use crate::{errors, parse_in};
 
-pub fn check_attr(features: &Features, psess: &ParseSess, attr: &Attribute) {
+pub fn check_attr(psess: &ParseSess, attr: &Attribute) {
     if attr.is_doc_comment() {
         return;
     }
@@ -28,7 +26,7 @@ pub fn check_attr(features: &Features, psess: &ParseSess, attr: &Attribute) {
 
     // All non-builtin attributes are considered safe
     let safety = attr_info.map(|x| x.safety).unwrap_or(AttributeSafety::Normal);
-    check_attribute_safety(features, psess, safety, attr);
+    check_attribute_safety(psess, safety, attr);
 
     // Check input tokens for built-in and key-value attributes.
     match attr_info {
@@ -36,9 +34,9 @@ pub fn check_attr(features: &Features, psess: &ParseSess, attr: &Attribute) {
         Some(BuiltinAttribute { name, template, .. }) if *name != sym::rustc_dummy => {
             match parse_meta(psess, attr) {
                 // Don't check safety again, we just did that
-                Ok(meta) => check_builtin_meta_item(
-                    features, psess, &meta, attr.style, *name, *template, false,
-                ),
+                Ok(meta) => {
+                    check_builtin_meta_item(psess, &meta, attr.style, *name, *template, false)
+                }
                 Err(err) => {
                     err.emit();
                 }
@@ -157,16 +155,7 @@ fn is_attr_template_compatible(template: &AttributeTemplate, meta: &ast::MetaIte
     }
 }
 
-pub fn check_attribute_safety(
-    features: &Features,
-    psess: &ParseSess,
-    safety: AttributeSafety,
-    attr: &Attribute,
-) {
-    if !features.unsafe_attributes {
-        return;
-    }
-
+pub fn check_attribute_safety(psess: &ParseSess, safety: AttributeSafety, attr: &Attribute) {
     let attr_item = attr.get_normal_item();
 
     if safety == AttributeSafety::Unsafe {
@@ -215,21 +204,18 @@ pub fn check_attribute_safety(
 
 // Called by `check_builtin_meta_item` and code that manually denies
 // `unsafe(...)` in `cfg`
-pub fn deny_builtin_meta_unsafety(features: &Features, psess: &ParseSess, meta: &MetaItem) {
+pub fn deny_builtin_meta_unsafety(psess: &ParseSess, meta: &MetaItem) {
     // This only supports denying unsafety right now - making builtin attributes
     // support unsafety will requite us to thread the actual `Attribute` through
     // for the nice diagnostics.
-    if features.unsafe_attributes {
-        if let Safety::Unsafe(unsafe_span) = meta.unsafety {
-            psess
-                .dcx()
-                .emit_err(errors::InvalidAttrUnsafe { span: unsafe_span, name: meta.path.clone() });
-        }
+    if let Safety::Unsafe(unsafe_span) = meta.unsafety {
+        psess
+            .dcx()
+            .emit_err(errors::InvalidAttrUnsafe { span: unsafe_span, name: meta.path.clone() });
     }
 }
 
 pub fn check_builtin_meta_item(
-    features: &Features,
     psess: &ParseSess,
     meta: &MetaItem,
     style: ast::AttrStyle,
@@ -246,7 +232,7 @@ pub fn check_builtin_meta_item(
     }
 
     if deny_unsafety {
-        deny_builtin_meta_unsafety(features, psess, meta);
+        deny_builtin_meta_unsafety(psess, meta);
     }
 }
 
diff --git a/src/tools/rustfmt/tests/target/unsafe_attributes.rs b/src/tools/rustfmt/tests/target/unsafe_attributes.rs
index a05bedc751ae2..d79c56f21479f 100644
--- a/src/tools/rustfmt/tests/target/unsafe_attributes.rs
+++ b/src/tools/rustfmt/tests/target/unsafe_attributes.rs
@@ -1,4 +1,3 @@
-#![feature(unsafe_attributes)]
 // https://github.com/rust-lang/rust/issues/123757
 //
 #![simple_ident]
diff --git a/tests/ui/attributes/unsafe/cfg-unsafe-attributes.rs b/tests/ui/attributes/unsafe/cfg-unsafe-attributes.rs
index ce365d1a8b1c8..6a9853b2f6fc6 100644
--- a/tests/ui/attributes/unsafe/cfg-unsafe-attributes.rs
+++ b/tests/ui/attributes/unsafe/cfg-unsafe-attributes.rs
@@ -1,5 +1,4 @@
 //@ build-pass
-#![feature(unsafe_attributes)]
 
 #[cfg_attr(all(), unsafe(no_mangle))]
 fn a() {}
diff --git a/tests/ui/attributes/unsafe/derive-unsafe-attributes.rs b/tests/ui/attributes/unsafe/derive-unsafe-attributes.rs
index b8edb4aab907b..95fc19f506b24 100644
--- a/tests/ui/attributes/unsafe/derive-unsafe-attributes.rs
+++ b/tests/ui/attributes/unsafe/derive-unsafe-attributes.rs
@@ -1,5 +1,3 @@
-#![feature(unsafe_attributes)]
-
 #[derive(unsafe(Debug))]
 //~^ ERROR: expected identifier, found keyword `unsafe`
 //~| ERROR: traits in `#[derive(...)]` don't accept arguments
diff --git a/tests/ui/attributes/unsafe/derive-unsafe-attributes.stderr b/tests/ui/attributes/unsafe/derive-unsafe-attributes.stderr
index c40a5512fd5cd..4002c930b63e5 100644
--- a/tests/ui/attributes/unsafe/derive-unsafe-attributes.stderr
+++ b/tests/ui/attributes/unsafe/derive-unsafe-attributes.stderr
@@ -1,5 +1,5 @@
 error: expected identifier, found keyword `unsafe`
-  --> $DIR/derive-unsafe-attributes.rs:3:10
+  --> $DIR/derive-unsafe-attributes.rs:1:10
    |
 LL | #[derive(unsafe(Debug))]
    |          ^^^^^^ expected identifier, found keyword
@@ -10,13 +10,13 @@ LL | #[derive(r#unsafe(Debug))]
    |          ++
 
 error: traits in `#[derive(...)]` don't accept arguments
-  --> $DIR/derive-unsafe-attributes.rs:3:16
+  --> $DIR/derive-unsafe-attributes.rs:1:16
    |
 LL | #[derive(unsafe(Debug))]
    |                ^^^^^^^ help: remove the arguments
 
 error: `derive` is not an unsafe attribute
-  --> $DIR/derive-unsafe-attributes.rs:12:3
+  --> $DIR/derive-unsafe-attributes.rs:10:3
    |
 LL | #[unsafe(derive(Debug))]
    |   ^^^^^^ this is not an unsafe attribute
@@ -24,7 +24,7 @@ LL | #[unsafe(derive(Debug))]
    = note: extraneous unsafe is not allowed in attributes
 
 error: expected identifier, found keyword `unsafe`
-  --> $DIR/derive-unsafe-attributes.rs:3:10
+  --> $DIR/derive-unsafe-attributes.rs:1:10
    |
 LL | #[derive(unsafe(Debug))]
    |          ^^^^^^ expected identifier, found keyword
@@ -36,7 +36,7 @@ LL | #[derive(r#unsafe(Debug))]
    |          ++
 
 error: expected identifier, found keyword `unsafe`
-  --> $DIR/derive-unsafe-attributes.rs:3:10
+  --> $DIR/derive-unsafe-attributes.rs:1:10
    |
 LL | #[derive(unsafe(Debug))]
    |          ^^^^^^ expected identifier, found keyword
@@ -48,13 +48,13 @@ LL | #[derive(r#unsafe(Debug))]
    |          ++
 
 error: cannot find derive macro `r#unsafe` in this scope
-  --> $DIR/derive-unsafe-attributes.rs:3:10
+  --> $DIR/derive-unsafe-attributes.rs:1:10
    |
 LL | #[derive(unsafe(Debug))]
    |          ^^^^^^
 
 error: cannot find derive macro `r#unsafe` in this scope
-  --> $DIR/derive-unsafe-attributes.rs:3:10
+  --> $DIR/derive-unsafe-attributes.rs:1:10
    |
 LL | #[derive(unsafe(Debug))]
    |          ^^^^^^
diff --git a/tests/ui/attributes/unsafe/double-unsafe-attributes.rs b/tests/ui/attributes/unsafe/double-unsafe-attributes.rs
index a6c0ea578f25a..894d1327da799 100644
--- a/tests/ui/attributes/unsafe/double-unsafe-attributes.rs
+++ b/tests/ui/attributes/unsafe/double-unsafe-attributes.rs
@@ -1,5 +1,3 @@
-#![feature(unsafe_attributes)]
-
 #[unsafe(unsafe(no_mangle))]
 //~^ ERROR expected identifier, found keyword `unsafe`
 //~| ERROR cannot find attribute `r#unsafe` in this scope
diff --git a/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr b/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr
index 950b2636993c1..0825cf794083d 100644
--- a/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr
+++ b/tests/ui/attributes/unsafe/double-unsafe-attributes.stderr
@@ -1,5 +1,5 @@
 error: expected identifier, found keyword `unsafe`
-  --> $DIR/double-unsafe-attributes.rs:3:10
+  --> $DIR/double-unsafe-attributes.rs:1:10
    |
 LL | #[unsafe(unsafe(no_mangle))]
    |          ^^^^^^ expected identifier, found keyword
@@ -10,7 +10,7 @@ LL | #[unsafe(r#unsafe(no_mangle))]
    |          ++
 
 error: `r#unsafe` is not an unsafe attribute
-  --> $DIR/double-unsafe-attributes.rs:3:3
+  --> $DIR/double-unsafe-attributes.rs:1:3
    |
 LL | #[unsafe(unsafe(no_mangle))]
    |   ^^^^^^ this is not an unsafe attribute
@@ -18,7 +18,7 @@ LL | #[unsafe(unsafe(no_mangle))]
    = note: extraneous unsafe is not allowed in attributes
 
 error: cannot find attribute `r#unsafe` in this scope
-  --> $DIR/double-unsafe-attributes.rs:3:10
+  --> $DIR/double-unsafe-attributes.rs:1:10
    |
 LL | #[unsafe(unsafe(no_mangle))]
    |          ^^^^^^
diff --git a/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.rs b/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.rs
index 0181add843bcd..b561550c19843 100644
--- a/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.rs
+++ b/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.rs
@@ -1,6 +1,5 @@
 //@ edition: 2024
 //@ compile-flags: -Zunstable-options
-#![feature(unsafe_attributes)]
 
 #[unsafe(cfg(any()))] //~ ERROR: is not an unsafe attribute
 fn a() {}
diff --git a/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.stderr b/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.stderr
index f39074b613d40..9fb7f062b912b 100644
--- a/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.stderr
+++ b/tests/ui/attributes/unsafe/extraneous-unsafe-attributes.stderr
@@ -1,5 +1,5 @@
 error: `cfg` is not an unsafe attribute
-  --> $DIR/extraneous-unsafe-attributes.rs:5:3
+  --> $DIR/extraneous-unsafe-attributes.rs:4:3
    |
 LL | #[unsafe(cfg(any()))]
    |   ^^^^^^ this is not an unsafe attribute
@@ -7,7 +7,7 @@ LL | #[unsafe(cfg(any()))]
    = note: extraneous unsafe is not allowed in attributes
 
 error: `cfg_attr` is not an unsafe attribute
-  --> $DIR/extraneous-unsafe-attributes.rs:8:3
+  --> $DIR/extraneous-unsafe-attributes.rs:7:3
    |
 LL | #[unsafe(cfg_attr(any(), allow(dead_code)))]
    |   ^^^^^^ this is not an unsafe attribute
@@ -15,7 +15,7 @@ LL | #[unsafe(cfg_attr(any(), allow(dead_code)))]
    = note: extraneous unsafe is not allowed in attributes
 
 error: `test` is not an unsafe attribute
-  --> $DIR/extraneous-unsafe-attributes.rs:11:3
+  --> $DIR/extraneous-unsafe-attributes.rs:10:3
    |
 LL | #[unsafe(test)]
    |   ^^^^^^ this is not an unsafe attribute
@@ -23,7 +23,7 @@ LL | #[unsafe(test)]
    = note: extraneous unsafe is not allowed in attributes
 
 error: `ignore` is not an unsafe attribute
-  --> $DIR/extraneous-unsafe-attributes.rs:14:3
+  --> $DIR/extraneous-unsafe-attributes.rs:13:3
    |
 LL | #[unsafe(ignore = "test")]
    |   ^^^^^^ this is not an unsafe attribute
@@ -31,7 +31,7 @@ LL | #[unsafe(ignore = "test")]
    = note: extraneous unsafe is not allowed in attributes
 
 error: `should_panic` is not an unsafe attribute
-  --> $DIR/extraneous-unsafe-attributes.rs:17:3
+  --> $DIR/extraneous-unsafe-attributes.rs:16:3
    |
 LL | #[unsafe(should_panic(expected = "test"))]
    |   ^^^^^^ this is not an unsafe attribute
@@ -39,7 +39,7 @@ LL | #[unsafe(should_panic(expected = "test"))]
    = note: extraneous unsafe is not allowed in attributes
 
 error: `macro_use` is not an unsafe attribute
-  --> $DIR/extraneous-unsafe-attributes.rs:20:3
+  --> $DIR/extraneous-unsafe-attributes.rs:19:3
    |
 LL | #[unsafe(macro_use)]
    |   ^^^^^^ this is not an unsafe attribute
@@ -47,7 +47,7 @@ LL | #[unsafe(macro_use)]
    = note: extraneous unsafe is not allowed in attributes
 
 error: `macro_export` is not an unsafe attribute
-  --> $DIR/extraneous-unsafe-attributes.rs:22:7
+  --> $DIR/extraneous-unsafe-attributes.rs:21:7
    |
 LL |     #[unsafe(macro_export)]
    |       ^^^^^^ this is not an unsafe attribute
@@ -55,7 +55,7 @@ LL |     #[unsafe(macro_export)]
    = note: extraneous unsafe is not allowed in attributes
 
 error: `used` is not an unsafe attribute
-  --> $DIR/extraneous-unsafe-attributes.rs:28:3
+  --> $DIR/extraneous-unsafe-attributes.rs:27:3
    |
 LL | #[unsafe(used)]
    |   ^^^^^^ this is not an unsafe attribute
diff --git a/tests/ui/attributes/unsafe/proc-unsafe-attributes.rs b/tests/ui/attributes/unsafe/proc-unsafe-attributes.rs
index f29a5b3252b0a..eaf8706369a5a 100644
--- a/tests/ui/attributes/unsafe/proc-unsafe-attributes.rs
+++ b/tests/ui/attributes/unsafe/proc-unsafe-attributes.rs
@@ -1,5 +1,3 @@
-#![feature(unsafe_attributes)]
-
 #[unsafe(proc_macro)]
 //~^ ERROR: is not an unsafe attribute
 //~| ERROR attribute is only usable with crates of the `proc-macro` crate type
diff --git a/tests/ui/attributes/unsafe/proc-unsafe-attributes.stderr b/tests/ui/attributes/unsafe/proc-unsafe-attributes.stderr
index 79d34d458bd6c..9c5751c82e4c4 100644
--- a/tests/ui/attributes/unsafe/proc-unsafe-attributes.stderr
+++ b/tests/ui/attributes/unsafe/proc-unsafe-attributes.stderr
@@ -1,11 +1,11 @@
 error[E0452]: malformed lint attribute input
-  --> $DIR/proc-unsafe-attributes.rs:28:16
+  --> $DIR/proc-unsafe-attributes.rs:26:16
    |
 LL | #[unsafe(allow(unsafe(dead_code)))]
    |                ^^^^^^^^^^^^^^^^^ bad attribute argument
 
 error[E0452]: malformed lint attribute input
-  --> $DIR/proc-unsafe-attributes.rs:28:16
+  --> $DIR/proc-unsafe-attributes.rs:26:16
    |
 LL | #[unsafe(allow(unsafe(dead_code)))]
    |                ^^^^^^^^^^^^^^^^^ bad attribute argument
@@ -13,7 +13,7 @@ LL | #[unsafe(allow(unsafe(dead_code)))]
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: `proc_macro` is not an unsafe attribute
-  --> $DIR/proc-unsafe-attributes.rs:3:3
+  --> $DIR/proc-unsafe-attributes.rs:1:3
    |
 LL | #[unsafe(proc_macro)]
    |   ^^^^^^ this is not an unsafe attribute
@@ -21,7 +21,7 @@ LL | #[unsafe(proc_macro)]
    = note: extraneous unsafe is not allowed in attributes
 
 error: `proc_macro_derive` is not an unsafe attribute
-  --> $DIR/proc-unsafe-attributes.rs:9:3
+  --> $DIR/proc-unsafe-attributes.rs:7:3
    |
 LL | #[unsafe(proc_macro_derive(Foo))]
    |   ^^^^^^ this is not an unsafe attribute
@@ -29,7 +29,7 @@ LL | #[unsafe(proc_macro_derive(Foo))]
    = note: extraneous unsafe is not allowed in attributes
 
 error: expected identifier, found keyword `unsafe`
-  --> $DIR/proc-unsafe-attributes.rs:14:21
+  --> $DIR/proc-unsafe-attributes.rs:12:21
    |
 LL | #[proc_macro_derive(unsafe(Foo))]
    |                     ^^^^^^ expected identifier, found keyword
@@ -40,7 +40,7 @@ LL | #[proc_macro_derive(r#unsafe(Foo))]
    |                     ++
 
 error: `proc_macro_attribute` is not an unsafe attribute
-  --> $DIR/proc-unsafe-attributes.rs:19:3
+  --> $DIR/proc-unsafe-attributes.rs:17:3
    |
 LL | #[unsafe(proc_macro_attribute)]
    |   ^^^^^^ this is not an unsafe attribute
@@ -48,7 +48,7 @@ LL | #[unsafe(proc_macro_attribute)]
    = note: extraneous unsafe is not allowed in attributes
 
 error: `allow` is not an unsafe attribute
-  --> $DIR/proc-unsafe-attributes.rs:24:3
+  --> $DIR/proc-unsafe-attributes.rs:22:3
    |
 LL | #[unsafe(allow(dead_code))]
    |   ^^^^^^ this is not an unsafe attribute
@@ -56,7 +56,7 @@ LL | #[unsafe(allow(dead_code))]
    = note: extraneous unsafe is not allowed in attributes
 
 error: `allow` is not an unsafe attribute
-  --> $DIR/proc-unsafe-attributes.rs:28:3
+  --> $DIR/proc-unsafe-attributes.rs:26:3
    |
 LL | #[unsafe(allow(unsafe(dead_code)))]
    |   ^^^^^^ this is not an unsafe attribute
@@ -64,7 +64,7 @@ LL | #[unsafe(allow(unsafe(dead_code)))]
    = note: extraneous unsafe is not allowed in attributes
 
 error: expected identifier, found keyword `unsafe`
-  --> $DIR/proc-unsafe-attributes.rs:28:16
+  --> $DIR/proc-unsafe-attributes.rs:26:16
    |
 LL | #[unsafe(allow(unsafe(dead_code)))]
    |                ^^^^^^ expected identifier, found keyword
@@ -75,31 +75,31 @@ LL | #[unsafe(allow(r#unsafe(dead_code)))]
    |                ++
 
 error: the `#[proc_macro]` attribute is only usable with crates of the `proc-macro` crate type
-  --> $DIR/proc-unsafe-attributes.rs:3:1
+  --> $DIR/proc-unsafe-attributes.rs:1:1
    |
 LL | #[unsafe(proc_macro)]
    | ^^^^^^^^^^^^^^^^^^^^^
 
 error: the `#[proc_macro_derive]` attribute is only usable with crates of the `proc-macro` crate type
-  --> $DIR/proc-unsafe-attributes.rs:9:1
+  --> $DIR/proc-unsafe-attributes.rs:7:1
    |
 LL | #[unsafe(proc_macro_derive(Foo))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the `#[proc_macro_derive]` attribute is only usable with crates of the `proc-macro` crate type
-  --> $DIR/proc-unsafe-attributes.rs:14:1
+  --> $DIR/proc-unsafe-attributes.rs:12:1
    |
 LL | #[proc_macro_derive(unsafe(Foo))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the `#[proc_macro_attribute]` attribute is only usable with crates of the `proc-macro` crate type
-  --> $DIR/proc-unsafe-attributes.rs:19:1
+  --> $DIR/proc-unsafe-attributes.rs:17:1
    |
 LL | #[unsafe(proc_macro_attribute)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0452]: malformed lint attribute input
-  --> $DIR/proc-unsafe-attributes.rs:28:16
+  --> $DIR/proc-unsafe-attributes.rs:26:16
    |
 LL | #[unsafe(allow(unsafe(dead_code)))]
    |                ^^^^^^^^^^^^^^^^^ bad attribute argument
@@ -107,7 +107,7 @@ LL | #[unsafe(allow(unsafe(dead_code)))]
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0452]: malformed lint attribute input
-  --> $DIR/proc-unsafe-attributes.rs:28:16
+  --> $DIR/proc-unsafe-attributes.rs:26:16
    |
 LL | #[unsafe(allow(unsafe(dead_code)))]
    |                ^^^^^^^^^^^^^^^^^ bad attribute argument
diff --git a/tests/ui/attributes/unsafe/unsafe-attributes.rs b/tests/ui/attributes/unsafe/unsafe-attributes.rs
index 33a412add500c..5c57767b3b964 100644
--- a/tests/ui/attributes/unsafe/unsafe-attributes.rs
+++ b/tests/ui/attributes/unsafe/unsafe-attributes.rs
@@ -1,5 +1,4 @@
 //@ build-pass
-#![feature(unsafe_attributes)]
 
 #[unsafe(no_mangle)]
 fn a() {}
diff --git a/tests/ui/attributes/unsafe/unsafe-safe-attribute.rs b/tests/ui/attributes/unsafe/unsafe-safe-attribute.rs
index 67db36afd2e69..5af03a2b8d137 100644
--- a/tests/ui/attributes/unsafe/unsafe-safe-attribute.rs
+++ b/tests/ui/attributes/unsafe/unsafe-safe-attribute.rs
@@ -1,5 +1,3 @@
-#![feature(unsafe_attributes)]
-
 #[unsafe(repr(C))] //~ ERROR: is not an unsafe attribute
 struct Foo {}
 
diff --git a/tests/ui/attributes/unsafe/unsafe-safe-attribute.stderr b/tests/ui/attributes/unsafe/unsafe-safe-attribute.stderr
index 584b0ea797d0a..55172c91aaeef 100644
--- a/tests/ui/attributes/unsafe/unsafe-safe-attribute.stderr
+++ b/tests/ui/attributes/unsafe/unsafe-safe-attribute.stderr
@@ -1,5 +1,5 @@
 error: `repr` is not an unsafe attribute
-  --> $DIR/unsafe-safe-attribute.rs:3:3
+  --> $DIR/unsafe-safe-attribute.rs:1:3
    |
 LL | #[unsafe(repr(C))]
    |   ^^^^^^ this is not an unsafe attribute
diff --git a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs
index ff2eb61b40538..0f241cc439f34 100644
--- a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs
+++ b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.rs
@@ -1,5 +1,3 @@
-#![feature(unsafe_attributes)]
-
 #[unsafe(diagnostic::on_unimplemented( //~ ERROR: is not an unsafe attribute
     message = "testing",
 ))]
diff --git a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr
index 26b5e4e37b931..3bc291db5acf8 100644
--- a/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr
+++ b/tests/ui/attributes/unsafe/unsafe-safe-attribute_diagnostic.stderr
@@ -1,5 +1,5 @@
 error: `diagnostic::on_unimplemented` is not an unsafe attribute
-  --> $DIR/unsafe-safe-attribute_diagnostic.rs:3:3
+  --> $DIR/unsafe-safe-attribute_diagnostic.rs:1:3
    |
 LL | #[unsafe(diagnostic::on_unimplemented(
    |   ^^^^^^ this is not an unsafe attribute
diff --git a/tests/ui/feature-gates/feature-gate-unsafe-attributes.rs b/tests/ui/feature-gates/feature-gate-unsafe-attributes.rs
deleted file mode 100644
index 9eba415dda0e5..0000000000000
--- a/tests/ui/feature-gates/feature-gate-unsafe-attributes.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#[unsafe(no_mangle)] //~ ERROR [E0658]
-extern "C" fn foo() {
-
-}
-
-fn main() {
-    foo();
-}
diff --git a/tests/ui/feature-gates/feature-gate-unsafe-attributes.stderr b/tests/ui/feature-gates/feature-gate-unsafe-attributes.stderr
deleted file mode 100644
index dfcea756b02b6..0000000000000
--- a/tests/ui/feature-gates/feature-gate-unsafe-attributes.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0658]: `#[unsafe()]` markers for attributes are experimental
-  --> $DIR/feature-gate-unsafe-attributes.rs:1:3
-   |
-LL | #[unsafe(no_mangle)]
-   |   ^^^^^^
-   |
-   = note: see issue #123757 <https://github.com/rust-lang/rust/issues/123757> for more information
-   = help: add `#![feature(unsafe_attributes)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.rs b/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.rs
index c6f9115cde750..f3b8645abaf89 100644
--- a/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.rs
+++ b/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.rs
@@ -1,5 +1,4 @@
 #![deny(rust_2024_compatibility)]
-#![feature(unsafe_attributes)]
 
 #[no_mangle]
 //~^ ERROR: unsafe attribute used without unsafe
diff --git a/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.stderr b/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.stderr
index f0689d9883c9e..4629a154ac3ce 100644
--- a/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.stderr
+++ b/tests/ui/rust-2024/unsafe-attributes/in_2024_compatibility.stderr
@@ -1,5 +1,5 @@
 error: unsafe attribute used without unsafe
-  --> $DIR/in_2024_compatibility.rs:4:3
+  --> $DIR/in_2024_compatibility.rs:3:3
    |
 LL | #[no_mangle]
    |   ^^^^^^^^^ usage of unsafe attribute
diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attribute-marked.rs b/tests/ui/rust-2024/unsafe-attributes/unsafe-attribute-marked.rs
index 279ced2525a23..7c919fed976f5 100644
--- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attribute-marked.rs
+++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attribute-marked.rs
@@ -4,7 +4,6 @@
 //@[edition2024] compile-flags: -Zunstable-options
 //@ check-pass
 
-#![feature(unsafe_attributes)]
 
 #[unsafe(no_mangle)]
 extern "C" fn foo() {}
diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.fixed b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.fixed
index 6ebdff0334c8b..586881d180767 100644
--- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.fixed
+++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.fixed
@@ -1,5 +1,4 @@
 //@ run-rustfix
-#![feature(unsafe_attributes)]
 #![deny(unsafe_attr_outside_unsafe)]
 
 macro_rules! tt {
diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.rs b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.rs
index c78ff45ea4cdf..03e122c7d57e7 100644
--- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.rs
+++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.rs
@@ -1,5 +1,4 @@
 //@ run-rustfix
-#![feature(unsafe_attributes)]
 #![deny(unsafe_attr_outside_unsafe)]
 
 macro_rules! tt {
diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.stderr b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.stderr
index c95984f58ecf7..64debc58905c3 100644
--- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.stderr
+++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes-fix.stderr
@@ -1,5 +1,5 @@
 error: unsafe attribute used without unsafe
-  --> $DIR/unsafe-attributes-fix.rs:44:6
+  --> $DIR/unsafe-attributes-fix.rs:43:6
    |
 LL | tt!([no_mangle]);
    |      ^^^^^^^^^ usage of unsafe attribute
@@ -7,7 +7,7 @@ LL | tt!([no_mangle]);
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2024!
    = note: for more information, see issue #123757 <https://github.com/rust-lang/rust/issues/123757>
 note: the lint level is defined here
-  --> $DIR/unsafe-attributes-fix.rs:3:9
+  --> $DIR/unsafe-attributes-fix.rs:2:9
    |
 LL | #![deny(unsafe_attr_outside_unsafe)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | tt!([unsafe(no_mangle)]);
    |      +++++++         +
 
 error: unsafe attribute used without unsafe
-  --> $DIR/unsafe-attributes-fix.rs:14:11
+  --> $DIR/unsafe-attributes-fix.rs:13:11
    |
 LL |         #[$e]
    |           ^^ usage of unsafe attribute
@@ -34,7 +34,7 @@ LL |         #[unsafe($e)]
    |           +++++++  +
 
 error: unsafe attribute used without unsafe
-  --> $DIR/unsafe-attributes-fix.rs:48:7
+  --> $DIR/unsafe-attributes-fix.rs:47:7
    |
 LL | meta!(no_mangle);
    |       ^^^^^^^^^ usage of unsafe attribute
@@ -47,7 +47,7 @@ LL | meta!(unsafe(no_mangle));
    |       +++++++         +
 
 error: unsafe attribute used without unsafe
-  --> $DIR/unsafe-attributes-fix.rs:51:8
+  --> $DIR/unsafe-attributes-fix.rs:50:8
    |
 LL | meta2!(export_name = "baw");
    |        ^^^^^^^^^^^ usage of unsafe attribute
@@ -60,7 +60,7 @@ LL | meta2!(unsafe(export_name = "baw"));
    |        +++++++                   +
 
 error: unsafe attribute used without unsafe
-  --> $DIR/unsafe-attributes-fix.rs:23:11
+  --> $DIR/unsafe-attributes-fix.rs:22:11
    |
 LL |         #[$e = $l]
    |           ^^ usage of unsafe attribute
@@ -77,7 +77,7 @@ LL |         #[unsafe($e = $l)]
    |           +++++++       +
 
 error: unsafe attribute used without unsafe
-  --> $DIR/unsafe-attributes-fix.rs:56:3
+  --> $DIR/unsafe-attributes-fix.rs:55:3
    |
 LL | #[no_mangle]
    |   ^^^^^^^^^ usage of unsafe attribute
diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.edition2024.stderr b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.edition2024.stderr
index 35475d6671626..fb697e14ef1c7 100644
--- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.edition2024.stderr
+++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.edition2024.stderr
@@ -1,5 +1,5 @@
 error: unsafe attribute used without unsafe
-  --> $DIR/unsafe-attributes.rs:9:3
+  --> $DIR/unsafe-attributes.rs:8:3
    |
 LL | #[no_mangle]
    |   ^^^^^^^^^ usage of unsafe attribute
diff --git a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.rs b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.rs
index 3a6af9dfb2b0f..f6f2994bb6def 100644
--- a/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.rs
+++ b/tests/ui/rust-2024/unsafe-attributes/unsafe-attributes.rs
@@ -4,7 +4,6 @@
 //@[edition2024] edition:2024
 //@[edition2024] compile-flags: -Zunstable-options
 
-#![feature(unsafe_attributes)]
 
 #[no_mangle] //[edition2024]~ ERROR: unsafe attribute used without unsafe
 extern "C" fn foo() {}

From deeccf9d3e951459169bbfe6f0f36bc6f74da293 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 13 Jul 2024 18:47:44 +0200
Subject: [PATCH 060/685] remove some SSE/SSE2 intrinsics that are no longer
 used by stdarch

---
 src/tools/miri/src/shims/x86/avx.rs           |  5 +--
 src/tools/miri/src/shims/x86/mod.rs           | 20 +---------
 src/tools/miri/src/shims/x86/sse.rs           | 17 +++-----
 src/tools/miri/src/shims/x86/sse2.rs          | 40 -------------------
 .../intrinsics/intrinsic_target_feature.rs    |  6 +--
 5 files changed, 11 insertions(+), 77 deletions(-)

diff --git a/src/tools/miri/src/shims/x86/avx.rs b/src/tools/miri/src/shims/x86/avx.rs
index f36bb4826e487..2f6569e1823de 100644
--- a/src/tools/miri/src/shims/x86/avx.rs
+++ b/src/tools/miri/src/shims/x86/avx.rs
@@ -73,13 +73,12 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                 round_all::<rustc_apfloat::ieee::Double>(this, op, rounding, dest)?;
             }
-            // Used to implement _mm256_{sqrt,rcp,rsqrt}_ps functions.
+            // Used to implement _mm256_{rcp,rsqrt}_ps functions.
             // Performs the operations on all components of `op`.
-            "sqrt.ps.256" | "rcp.ps.256" | "rsqrt.ps.256" => {
+            "rcp.ps.256" | "rsqrt.ps.256" => {
                 let [op] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
 
                 let which = match unprefixed_name {
-                    "sqrt.ps.256" => FloatUnaryOp::Sqrt,
                     "rcp.ps.256" => FloatUnaryOp::Rcp,
                     "rsqrt.ps.256" => FloatUnaryOp::Rsqrt,
                     _ => unreachable!(),
diff --git a/src/tools/miri/src/shims/x86/mod.rs b/src/tools/miri/src/shims/x86/mod.rs
index 1bd32fce8bd9e..c1117e4d811f7 100644
--- a/src/tools/miri/src/shims/x86/mod.rs
+++ b/src/tools/miri/src/shims/x86/mod.rs
@@ -159,8 +159,6 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
 #[derive(Copy, Clone)]
 enum FloatBinOp {
-    /// Arithmetic operation
-    Arith(mir::BinOp),
     /// Comparison
     ///
     /// The semantics of this operator is a case distinction: we compare the two operands,
@@ -247,16 +245,11 @@ impl FloatBinOp {
 /// Performs `which` scalar operation on `left` and `right` and returns
 /// the result.
 fn bin_op_float<'tcx, F: rustc_apfloat::Float>(
-    this: &crate::MiriInterpCx<'tcx>,
     which: FloatBinOp,
     left: &ImmTy<'tcx>,
     right: &ImmTy<'tcx>,
 ) -> InterpResult<'tcx, Scalar> {
     match which {
-        FloatBinOp::Arith(which) => {
-            let res = this.binary_op(which, left, right)?;
-            Ok(res.to_scalar())
-        }
         FloatBinOp::Cmp { gt, lt, eq, unord } => {
             let left = left.to_scalar().to_float::<F>()?;
             let right = right.to_scalar().to_float::<F>()?;
@@ -323,7 +316,6 @@ fn bin_op_simd_float_first<'tcx, F: rustc_apfloat::Float>(
     assert_eq!(dest_len, right_len);
 
     let res0 = bin_op_float::<F>(
-        this,
         which,
         &this.read_immediate(&this.project_index(&left, 0)?)?,
         &this.read_immediate(&this.project_index(&right, 0)?)?,
@@ -358,7 +350,7 @@ fn bin_op_simd_float_all<'tcx, F: rustc_apfloat::Float>(
         let right = this.read_immediate(&this.project_index(&right, i)?)?;
         let dest = this.project_index(&dest, i)?;
 
-        let res = bin_op_float::<F>(this, which, &left, &right)?;
+        let res = bin_op_float::<F>(which, &left, &right)?;
         this.write_scalar(res, &dest)?;
     }
 
@@ -367,11 +359,6 @@ fn bin_op_simd_float_all<'tcx, F: rustc_apfloat::Float>(
 
 #[derive(Copy, Clone)]
 enum FloatUnaryOp {
-    /// sqrt(x)
-    ///
-    /// <https://www.felixcloutier.com/x86/sqrtss>
-    /// <https://www.felixcloutier.com/x86/sqrtps>
-    Sqrt,
     /// Approximation of 1/x
     ///
     /// <https://www.felixcloutier.com/x86/rcpss>
@@ -392,11 +379,6 @@ fn unary_op_f32<'tcx>(
     op: &ImmTy<'tcx>,
 ) -> InterpResult<'tcx, Scalar> {
     match which {
-        FloatUnaryOp::Sqrt => {
-            let op = op.to_scalar();
-            // FIXME using host floats
-            Ok(Scalar::from_u32(f32::from_bits(op.to_u32()?).sqrt().to_bits()))
-        }
         FloatUnaryOp::Rcp => {
             let op = op.to_scalar().to_f32()?;
             let div = (Single::from_u128(1).value / op).value;
diff --git a/src/tools/miri/src/shims/x86/sse.rs b/src/tools/miri/src/shims/x86/sse.rs
index 32e8e8a66c13c..07a4eaa85f3e3 100644
--- a/src/tools/miri/src/shims/x86/sse.rs
+++ b/src/tools/miri/src/shims/x86/sse.rs
@@ -1,5 +1,4 @@
 use rustc_apfloat::ieee::Single;
-use rustc_middle::mir;
 use rustc_span::Symbol;
 use rustc_target::spec::abi::Abi;
 
@@ -29,18 +28,14 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // performed only on the first element, copying the remaining elements from the input
         // vector (for binary operations, from the left-hand side).
         match unprefixed_name {
-            // Used to implement _mm_{add,sub,mul,div,min,max}_ss functions.
+            // Used to implement _mm_{min,max}_ss functions.
             // Performs the operations on the first component of `left` and
             // `right` and copies the remaining components from `left`.
-            "add.ss" | "sub.ss" | "mul.ss" | "div.ss" | "min.ss" | "max.ss" => {
+            "min.ss" | "max.ss" => {
                 let [left, right] =
                     this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
 
                 let which = match unprefixed_name {
-                    "add.ss" => FloatBinOp::Arith(mir::BinOp::Add),
-                    "sub.ss" => FloatBinOp::Arith(mir::BinOp::Sub),
-                    "mul.ss" => FloatBinOp::Arith(mir::BinOp::Mul),
-                    "div.ss" => FloatBinOp::Arith(mir::BinOp::Div),
                     "min.ss" => FloatBinOp::Min,
                     "max.ss" => FloatBinOp::Max,
                     _ => unreachable!(),
@@ -65,14 +60,13 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                 bin_op_simd_float_all::<Single>(this, which, left, right, dest)?;
             }
-            // Used to implement _mm_{sqrt,rcp,rsqrt}_ss functions.
+            // Used to implement _mm_{rcp,rsqrt}_ss functions.
             // Performs the operations on the first component of `op` and
             // copies the remaining components from `op`.
-            "sqrt.ss" | "rcp.ss" | "rsqrt.ss" => {
+            "rcp.ss" | "rsqrt.ss" => {
                 let [op] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
 
                 let which = match unprefixed_name {
-                    "sqrt.ss" => FloatUnaryOp::Sqrt,
                     "rcp.ss" => FloatUnaryOp::Rcp,
                     "rsqrt.ss" => FloatUnaryOp::Rsqrt,
                     _ => unreachable!(),
@@ -82,11 +76,10 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
             // Used to implement _mm_{sqrt,rcp,rsqrt}_ps functions.
             // Performs the operations on all components of `op`.
-            "sqrt.ps" | "rcp.ps" | "rsqrt.ps" => {
+            "rcp.ps" | "rsqrt.ps" => {
                 let [op] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
 
                 let which = match unprefixed_name {
-                    "sqrt.ps" => FloatUnaryOp::Sqrt,
                     "rcp.ps" => FloatUnaryOp::Rcp,
                     "rsqrt.ps" => FloatUnaryOp::Rsqrt,
                     _ => unreachable!(),
diff --git a/src/tools/miri/src/shims/x86/sse2.rs b/src/tools/miri/src/shims/x86/sse2.rs
index 3efdd561d6c60..163d74a6de4e9 100644
--- a/src/tools/miri/src/shims/x86/sse2.rs
+++ b/src/tools/miri/src/shims/x86/sse2.rs
@@ -227,46 +227,6 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                 bin_op_simd_float_all::<Double>(this, which, left, right, dest)?;
             }
-            // Used to implement _mm_sqrt_sd functions.
-            // Performs the operations on the first component of `op` and
-            // copies the remaining components from `op`.
-            "sqrt.sd" => {
-                let [op] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
-
-                let (op, op_len) = this.operand_to_simd(op)?;
-                let (dest, dest_len) = this.mplace_to_simd(dest)?;
-
-                assert_eq!(dest_len, op_len);
-
-                let op0 = this.read_scalar(&this.project_index(&op, 0)?)?.to_u64()?;
-                // FIXME using host floats
-                let res0 = Scalar::from_u64(f64::from_bits(op0).sqrt().to_bits());
-                this.write_scalar(res0, &this.project_index(&dest, 0)?)?;
-
-                for i in 1..dest_len {
-                    this.copy_op(&this.project_index(&op, i)?, &this.project_index(&dest, i)?)?;
-                }
-            }
-            // Used to implement _mm_sqrt_pd functions.
-            // Performs the operations on all components of `op`.
-            "sqrt.pd" => {
-                let [op] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
-
-                let (op, op_len) = this.operand_to_simd(op)?;
-                let (dest, dest_len) = this.mplace_to_simd(dest)?;
-
-                assert_eq!(dest_len, op_len);
-
-                for i in 0..dest_len {
-                    let op = this.read_scalar(&this.project_index(&op, i)?)?.to_u64()?;
-                    let dest = this.project_index(&dest, i)?;
-
-                    // FIXME using host floats
-                    let res = Scalar::from_u64(f64::from_bits(op).sqrt().to_bits());
-
-                    this.write_scalar(res, &dest)?;
-                }
-            }
             // Used to implement the _mm_cmp*_sd functions.
             // Performs a comparison operation on the first component of `left`
             // and `right`, returning 0 if false or `u64::MAX` if true. The remaining
diff --git a/src/tools/miri/tests/fail/intrinsics/intrinsic_target_feature.rs b/src/tools/miri/tests/fail/intrinsics/intrinsic_target_feature.rs
index 9263ad381d1b6..860798f2ab156 100644
--- a/src/tools/miri/tests/fail/intrinsics/intrinsic_target_feature.rs
+++ b/src/tools/miri/tests/fail/intrinsics/intrinsic_target_feature.rs
@@ -24,7 +24,7 @@ fn main() {
 
     unsafe {
         // Pass, since SSE is enabled
-        addss(_mm_setzero_ps(), _mm_setzero_ps());
+        minss(_mm_setzero_ps(), _mm_setzero_ps());
 
         // Fail, since SSE4.1 is not enabled
         dpps(_mm_setzero_ps(), _mm_setzero_ps(), 0);
@@ -34,8 +34,8 @@ fn main() {
 
 #[allow(improper_ctypes)]
 extern "C" {
-    #[link_name = "llvm.x86.sse.add.ss"]
-    fn addss(a: __m128, b: __m128) -> __m128;
+    #[link_name = "llvm.x86.sse.min.ss"]
+    fn minss(a: __m128, b: __m128) -> __m128;
 
     #[link_name = "llvm.x86.sse41.dpps"]
     fn dpps(a: __m128, b: __m128, imm8: u8) -> __m128;

From 5e25e7c37051df50009b7fad52adacd30eda5824 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Wed, 7 Aug 2024 21:43:52 +0900
Subject: [PATCH 061/685] add a test for ice-3717.rs

https://github.com/rust-lang/rust-clippy/issues/13099
---
 tests/ui/crashes/ice-3717.fixed  | 11 +++++++++++
 tests/ui/crashes/ice-3717.rs     |  2 --
 tests/ui/crashes/ice-3717.stderr |  2 +-
 3 files changed, 12 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/crashes/ice-3717.fixed

diff --git a/tests/ui/crashes/ice-3717.fixed b/tests/ui/crashes/ice-3717.fixed
new file mode 100644
index 0000000000000..3f54b326979c9
--- /dev/null
+++ b/tests/ui/crashes/ice-3717.fixed
@@ -0,0 +1,11 @@
+#![deny(clippy::implicit_hasher)]
+
+use std::collections::HashSet;
+
+fn main() {}
+
+pub fn ice_3717<S: ::std::hash::BuildHasher + Default>(_: &HashSet<usize, S>) {
+    //~^ ERROR: parameter of type `HashSet` should be generalized over different hashers
+    let _ = [0u8; 0];
+    let _: HashSet<usize> = HashSet::default();
+}
diff --git a/tests/ui/crashes/ice-3717.rs b/tests/ui/crashes/ice-3717.rs
index 770f6cf448a63..2890a9277c719 100644
--- a/tests/ui/crashes/ice-3717.rs
+++ b/tests/ui/crashes/ice-3717.rs
@@ -1,7 +1,5 @@
 #![deny(clippy::implicit_hasher)]
 
-//@no-rustfix: need to change the suggestion to a multipart suggestion
-
 use std::collections::HashSet;
 
 fn main() {}
diff --git a/tests/ui/crashes/ice-3717.stderr b/tests/ui/crashes/ice-3717.stderr
index 4b4618ee1bbd0..aac72c669654a 100644
--- a/tests/ui/crashes/ice-3717.stderr
+++ b/tests/ui/crashes/ice-3717.stderr
@@ -1,5 +1,5 @@
 error: parameter of type `HashSet` should be generalized over different hashers
-  --> tests/ui/crashes/ice-3717.rs:9:21
+  --> tests/ui/crashes/ice-3717.rs:7:21
    |
 LL | pub fn ice_3717(_: &HashSet<usize>) {
    |                     ^^^^^^^^^^^^^^

From d4809545eecb8f411415cd45dc0153967a5e5fec Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 7 Aug 2024 15:25:12 +0200
Subject: [PATCH 062/685] allow all code to call getuid()

---
 src/tools/miri/src/shims/unix/foreign_items.rs  | 14 ++++++--------
 src/tools/miri/tests/pass-dep/libc/libc-misc.rs |  6 +++++-
 2 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 57930f9807d62..6c35281ecf2fb 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -815,6 +815,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.handle_miri_start_unwind(payload)?;
                 return Ok(EmulateItemResult::NeedsUnwind);
             }
+            "getuid" => {
+                let [] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
+                // For now, just pretend we always have this fixed UID.
+                this.write_int(UID, dest)?;
+            }
 
             // Incomplete shims that we "stub out" just to get pre-main initialization code to work.
             // These shims are enabled only when the caller is in the standard library.
@@ -877,13 +882,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_null(dest)?;
             }
 
-            "getuid"
-            if this.frame_in_std() => {
-                let [] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
-                // For now, just pretend we always have this fixed UID.
-                this.write_int(super::UID, dest)?;
-            }
-
             "getpwuid_r" | "__posix_getpwuid_r"
             if this.frame_in_std() => {
                 // getpwuid_r is the standard name, __posix_getpwuid_r is used on solarish
@@ -898,7 +896,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let result = this.deref_pointer(result)?;
 
                 // Must be for "us".
-                if uid != crate::shims::unix::UID {
+                if uid != UID {
                     throw_unsup_format!("`getpwuid_r` on other users is not supported");
                 }
 
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-misc.rs b/src/tools/miri/tests/pass-dep/libc/libc-misc.rs
index f7e1d9faa6a27..a5b944e9d426a 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-misc.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-misc.rs
@@ -75,11 +75,15 @@ fn test_dlsym() {
     assert_eq!(errno, libc::EBADF);
 }
 
+fn test_getuid() {
+    let _val = unsafe { libc::getuid() };
+}
+
 fn main() {
     test_thread_local_errno();
     test_environ();
-
     test_dlsym();
+    test_getuid();
 
     #[cfg(target_os = "linux")]
     test_sigrt();

From 3312f5d65244b4ccb035be7b4c61541afc211914 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Wed, 7 Aug 2024 09:06:49 -0700
Subject: [PATCH 063/685] alloc: make `to_string_str!` a bit less complex

---
 library/alloc/src/string.rs | 57 +++++++++++++++++++++++--------------
 1 file changed, 35 insertions(+), 22 deletions(-)

diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
index d943901e9ecf9..e628be1546f76 100644
--- a/library/alloc/src/string.rs
+++ b/library/alloc/src/string.rs
@@ -2647,37 +2647,50 @@ impl ToString for i8 {
 // for strings, including `&&&str`s that would never be written
 // by hand. This macro generates twelve layers of nested `&`-impl
 // for primitive strings.
-macro_rules! to_string_str {
-    {type ; x $($x:ident)*} => {
-        &to_string_str! { type ; $($x)* }
-    };
-    {type ;} => { str };
-    {impl ; x $($x:ident)*} => {
-        to_string_str! { $($x)* }
+#[cfg(not(no_global_oom_handling))]
+macro_rules! to_string_str_wrap_in_ref {
+    {x $($x:ident)*} => {
+        &to_string_str_wrap_in_ref! { $($x)* }
     };
-    {impl ;} => { };
+    {} => { str };
+}
+#[cfg(not(no_global_oom_handling))]
+macro_rules! to_string_expr_wrap_in_deref {
     {$self:expr ; x $($x:ident)*} => {
-        *(to_string_str! { $self ; $($x)* })
+        *(to_string_expr_wrap_in_deref! { $self ; $($x)* })
     };
     {$self:expr ;} => { $self };
-    {$($x:ident)*} => {
-        #[doc(hidden)]
-        #[cfg(not(no_global_oom_handling))]
-        #[stable(feature = "str_to_string_specialization", since = "1.9.0")]
-        impl ToString for to_string_str!(type ; $($x)*) {
-            #[inline]
-            fn to_string(&self) -> String {
-                String::from(to_string_str!(self ; $($x)*))
+}
+#[cfg(not(no_global_oom_handling))]
+macro_rules! to_string_str {
+    {$($($x:ident)*),+} => {
+        $(
+            #[doc(hidden)]
+            #[stable(feature = "str_to_string_specialization", since = "1.9.0")]
+            impl ToString for to_string_str_wrap_in_ref!($($x)*) {
+                #[inline]
+                fn to_string(&self) -> String {
+                    String::from(to_string_expr_wrap_in_deref!(self ; $($x)*))
+                }
             }
-        }
-        to_string_str! { impl ; $($x)* }
+        )+
     };
 }
 
+#[cfg(not(no_global_oom_handling))]
 to_string_str! {
-    x x x x
-    x x x x
-    x x x x
+    x x x x x x x x x x x x,
+    x x x x x x x x x x x,
+    x x x x x x x x x x,
+    x x x x x x x x x,
+    x x x x x x x x,
+    x x x x x x x,
+    x x x x x x,
+    x x x x x,
+    x x x x,
+    x x x,
+    x x,
+    x,
 }
 
 #[doc(hidden)]

From 9ebe5ae3064af4f7f0f79c774e778ee26f36bdcb Mon Sep 17 00:00:00 2001
From: EtomicBomb <ethan@ethan.ws>
Date: Wed, 24 Jul 2024 22:56:38 +0000
Subject: [PATCH 064/685] initial implementation of mergable rustdoc cci

---
 src/librustdoc/Cargo.toml                     |    2 +-
 src/librustdoc/clean/types.rs                 |    2 +-
 src/librustdoc/config.rs                      |    1 -
 src/librustdoc/html/render/context.rs         |   10 +-
 src/librustdoc/html/render/mod.rs             |    2 +
 src/librustdoc/html/render/search_index.rs    |   34 +-
 src/librustdoc/html/render/sorted_json.rs     |   82 +
 src/librustdoc/html/render/sorted_template.rs |  136 ++
 src/librustdoc/html/render/tests.rs           |  271 +++
 src/librustdoc/html/render/write_shared.rs    | 1462 +++++++++--------
 10 files changed, 1317 insertions(+), 685 deletions(-)
 create mode 100644 src/librustdoc/html/render/sorted_json.rs
 create mode 100644 src/librustdoc/html/render/sorted_template.rs

diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index b3fccbf6456e0..67ba8c773175c 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -16,7 +16,7 @@ minifier = "0.3.0"
 pulldown-cmark-old = { version = "0.9.6", package = "pulldown-cmark", default-features = false }
 regex = "1"
 rustdoc-json-types = { path = "../rustdoc-json-types" }
-serde_json = "1.0"
+serde_json = { version = "1.0", features = ["preserve_order"] }
 serde = { version = "1.0", features = ["derive"] }
 smallvec = "1.8.1"
 tempfile = "3"
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 4850500a1bfae..542e810b5cfa8 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -128,7 +128,7 @@ pub(crate) struct ExternalCrate {
 }
 
 impl ExternalCrate {
-    const LOCAL: Self = Self { crate_num: LOCAL_CRATE };
+    pub(crate) const LOCAL: Self = Self { crate_num: LOCAL_CRATE };
 
     #[inline]
     pub(crate) fn def_id(&self) -> DefId {
diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index e4549796b3e83..2e54a22840bb5 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -730,7 +730,6 @@ impl Options {
         let extern_html_root_takes_precedence =
             matches.opt_present("extern-html-root-takes-precedence");
         let html_no_source = matches.opt_present("html-no-source");
-
         if generate_link_to_definition && (show_coverage || output_format != OutputFormat::Html) {
             dcx.fatal(
                 "--generate-link-to-definition option can only be used with HTML output format",
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index 0334eacc16149..8e72dd6a864ae 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -14,7 +14,6 @@ use rustc_span::edition::Edition;
 use rustc_span::{sym, FileName, Symbol};
 
 use super::print_item::{full_path, item_path, print_item};
-use super::search_index::build_index;
 use super::sidebar::{print_sidebar, sidebar_module_like, Sidebar};
 use super::write_shared::write_shared;
 use super::{collect_spans_and_sources, scrape_examples_help, AllTypes, LinkFromSrc, StylePath};
@@ -573,13 +572,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
         }
 
         if !no_emit_shared {
-            // Build our search index
-            let index = build_index(&krate, &mut Rc::get_mut(&mut cx.shared).unwrap().cache, tcx);
-
-            // Write shared runs within a flock; disable thread dispatching of IO temporarily.
-            Rc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(true);
-            write_shared(&mut cx, &krate, index, &md_opts)?;
-            Rc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(false);
+            write_shared(&mut cx, &krate, &md_opts, tcx)?;
         }
 
         Ok((cx, krate))
@@ -729,6 +722,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
         );
         shared.fs.write(help_file, v)?;
 
+        // if to avoid writing files to doc root unless we're on the final invocation
         if shared.layout.scrape_examples_extension {
             page.title = "About scraped examples";
             page.description = "How the scraped examples feature works in Rustdoc";
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 9074e40a53614..4b1c9b4af474a 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -31,6 +31,8 @@ mod tests;
 mod context;
 mod print_item;
 pub(crate) mod sidebar;
+mod sorted_json;
+mod sorted_template;
 mod span_map;
 mod type_layout;
 mod write_shared;
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 8a2f31f7413e1..184e5afba3c99 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -18,6 +18,7 @@ use crate::formats::cache::{Cache, OrphanImplItem};
 use crate::formats::item_type::ItemType;
 use crate::html::format::join_with_double_colon;
 use crate::html::markdown::short_markdown_summary;
+use crate::html::render::sorted_json::SortedJson;
 use crate::html::render::{self, IndexItem, IndexItemFunctionType, RenderType, RenderTypeId};
 
 /// The serialized search description sharded version
@@ -46,7 +47,7 @@ use crate::html::render::{self, IndexItem, IndexItemFunctionType, RenderType, Re
 /// [2]: https://en.wikipedia.org/wiki/Sliding_window_protocol#Basic_concept
 /// [3]: https://learn.microsoft.com/en-us/troubleshoot/windows-server/networking/description-tcp-features
 pub(crate) struct SerializedSearchIndex {
-    pub(crate) index: String,
+    pub(crate) index: SortedJson,
     pub(crate) desc: Vec<(usize, String)>,
 }
 
@@ -683,24 +684,19 @@ pub(crate) fn build_index<'tcx>(
     // The index, which is actually used to search, is JSON
     // It uses `JSON.parse(..)` to actually load, since JSON
     // parses faster than the full JavaScript syntax.
-    let index = format!(
-        r#"["{}",{}]"#,
-        krate.name(tcx),
-        serde_json::to_string(&CrateData {
-            items: crate_items,
-            paths: crate_paths,
-            aliases: &aliases,
-            associated_item_disambiguators: &associated_item_disambiguators,
-            desc_index,
-            empty_desc,
-        })
-        .expect("failed serde conversion")
-        // All these `replace` calls are because we have to go through JS string for JSON content.
-        .replace('\\', r"\\")
-        .replace('\'', r"\'")
-        // We need to escape double quotes for the JSON.
-        .replace("\\\"", "\\\\\"")
-    );
+    let crate_name = krate.name(tcx);
+    let data = CrateData {
+        items: crate_items,
+        paths: crate_paths,
+        aliases: &aliases,
+        associated_item_disambiguators: &associated_item_disambiguators,
+        desc_index,
+        empty_desc,
+    };
+    let index = SortedJson::array_unsorted([
+        SortedJson::serialize(crate_name.as_str()),
+        SortedJson::serialize(data),
+    ]);
     SerializedSearchIndex { index, desc }
 }
 
diff --git a/src/librustdoc/html/render/sorted_json.rs b/src/librustdoc/html/render/sorted_json.rs
new file mode 100644
index 0000000000000..3a097733b8b20
--- /dev/null
+++ b/src/librustdoc/html/render/sorted_json.rs
@@ -0,0 +1,82 @@
+use itertools::Itertools as _;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::borrow::Borrow;
+use std::fmt;
+
+/// Prerenedered json.
+///
+/// Arrays are sorted by their stringified entries, and objects are sorted by their stringified
+/// keys.
+///
+/// Must use serde_json with the preserve_order feature.
+///
+/// Both the Display and serde_json::to_string implementations write the serialized json
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+#[serde(from = "Value")]
+#[serde(into = "Value")]
+pub(crate) struct SortedJson(String);
+
+impl SortedJson {
+    /// If you pass in an array, it will not be sorted.
+    pub(crate) fn serialize<T: Serialize>(item: T) -> Self {
+        SortedJson(serde_json::to_string(&item).unwrap())
+    }
+
+    /// Serializes and sorts
+    pub(crate) fn array<T: Borrow<SortedJson>, I: IntoIterator<Item = T>>(items: I) -> Self {
+        let items = items
+            .into_iter()
+            .sorted_unstable_by(|a, b| a.borrow().cmp(&b.borrow()))
+            .format_with(",", |item, f| f(item.borrow()));
+        SortedJson(format!("[{}]", items))
+    }
+
+    pub(crate) fn array_unsorted<T: Borrow<SortedJson>, I: IntoIterator<Item = T>>(
+        items: I,
+    ) -> Self {
+        let items = items.into_iter().format_with(",", |item, f| f(item.borrow()));
+        SortedJson(format!("[{items}]"))
+    }
+}
+
+impl fmt::Display for SortedJson {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl From<Value> for SortedJson {
+    fn from(value: Value) -> Self {
+        SortedJson(serde_json::to_string(&value).unwrap())
+    }
+}
+
+impl From<SortedJson> for Value {
+    fn from(json: SortedJson) -> Self {
+        serde_json::from_str(&json.0).unwrap()
+    }
+}
+
+/// For use in JSON.parse('{...}').
+///
+/// JSON.parse supposedly loads faster than raw JS source,
+/// so this is used for large objects.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub(crate) struct EscapedJson(SortedJson);
+
+impl From<SortedJson> for EscapedJson {
+    fn from(json: SortedJson) -> Self {
+        EscapedJson(json)
+    }
+}
+
+impl fmt::Display for EscapedJson {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // All these `replace` calls are because we have to go through JS string
+        // for JSON content.
+        // We need to escape double quotes for the JSON
+        let json = self.0.0.replace('\\', r"\\").replace('\'', r"\'").replace("\\\"", "\\\\\"");
+        write!(f, "{}", json)
+    }
+}
diff --git a/src/librustdoc/html/render/sorted_template.rs b/src/librustdoc/html/render/sorted_template.rs
new file mode 100644
index 0000000000000..95240616b01dc
--- /dev/null
+++ b/src/librustdoc/html/render/sorted_template.rs
@@ -0,0 +1,136 @@
+use std::collections::BTreeSet;
+use std::fmt;
+use std::marker::PhantomData;
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+
+/// Append-only templates for sorted, deduplicated lists of items.
+///
+/// Last line of the rendered output is a comment encoding the next insertion point.
+#[derive(Debug, Clone)]
+pub(crate) struct SortedTemplate<F> {
+    format: PhantomData<F>,
+    before: String,
+    after: String,
+    contents: BTreeSet<String>,
+}
+
+/// Written to last line of file to specify the location of each fragment
+#[derive(Serialize, Deserialize, Debug, Clone)]
+struct Offset {
+    /// Index of the first byte in the template
+    start: usize,
+    /// The length of each fragment in the encoded template, including the separator
+    delta: Vec<usize>,
+}
+
+impl<F> SortedTemplate<F> {
+    /// Generate this template from arbitary text.
+    /// Will insert wherever the substring `magic` can be found.
+    /// Errors if it does not appear exactly once.
+    pub(crate) fn magic(template: &str, magic: &str) -> Result<Self, Error> {
+        let mut split = template.split(magic);
+        let before = split.next().ok_or(Error)?;
+        let after = split.next().ok_or(Error)?;
+        if split.next().is_some() {
+            return Err(Error);
+        }
+        Ok(Self::before_after(before, after))
+    }
+
+    /// Template will insert contents between `before` and `after`
+    pub(crate) fn before_after<S: ToString, T: ToString>(before: S, after: T) -> Self {
+        let before = before.to_string();
+        let after = after.to_string();
+        SortedTemplate { format: PhantomData, before, after, contents: Default::default() }
+    }
+}
+
+impl<F: FileFormat> SortedTemplate<F> {
+    /// Adds this text to the template
+    pub(crate) fn append(&mut self, insert: String) {
+        self.contents.insert(insert);
+    }
+}
+
+impl<F: FileFormat> fmt::Display for SortedTemplate<F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut delta = Vec::default();
+        write!(f, "{}", self.before)?;
+        let contents: Vec<_> = self.contents.iter().collect();
+        let mut sep = "";
+        for content in contents {
+            delta.push(sep.len() + content.len());
+            write!(f, "{}{}", sep, content)?;
+            sep = F::SEPARATOR;
+        }
+        let offset = Offset { start: self.before.len(), delta };
+        let offset = serde_json::to_string(&offset).unwrap();
+        write!(f, "{}\n{}{}{}", self.after, F::COMMENT_START, offset, F::COMMENT_END)?;
+        Ok(())
+    }
+}
+
+fn checked_split_at(s: &str, index: usize) -> Option<(&str, &str)> {
+    s.is_char_boundary(index).then(|| s.split_at(index))
+}
+
+impl<F: FileFormat> FromStr for SortedTemplate<F> {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let (s, offset) = s.rsplit_once("\n").ok_or(Error)?;
+        let offset = offset.strip_prefix(F::COMMENT_START).ok_or(Error)?;
+        let offset = offset.strip_suffix(F::COMMENT_END).ok_or(Error)?;
+        let offset: Offset = serde_json::from_str(&offset).map_err(|_| Error)?;
+        let (before, mut s) = checked_split_at(s, offset.start).ok_or(Error)?;
+        let mut contents = BTreeSet::default();
+        let mut sep = "";
+        for &index in offset.delta.iter() {
+            let (content, rest) = checked_split_at(s, index).ok_or(Error)?;
+            s = rest;
+            let content = content.strip_prefix(sep).ok_or(Error)?;
+            contents.insert(content.to_string());
+            sep = F::SEPARATOR;
+        }
+        Ok(SortedTemplate {
+            format: PhantomData,
+            before: before.to_string(),
+            after: s.to_string(),
+            contents,
+        })
+    }
+}
+
+pub(crate) trait FileFormat {
+    const COMMENT_START: &'static str;
+    const COMMENT_END: &'static str;
+    const SEPARATOR: &'static str;
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct Html;
+
+impl FileFormat for Html {
+    const COMMENT_START: &'static str = "<!--";
+    const COMMENT_END: &'static str = "-->";
+    const SEPARATOR: &'static str = "";
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct Js;
+
+impl FileFormat for Js {
+    const COMMENT_START: &'static str = "//";
+    const COMMENT_END: &'static str = "";
+    const SEPARATOR: &'static str = ",";
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct Error;
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "invalid template")
+    }
+}
diff --git a/src/librustdoc/html/render/tests.rs b/src/librustdoc/html/render/tests.rs
index 4a9724a6f840f..16e67b0f1180e 100644
--- a/src/librustdoc/html/render/tests.rs
+++ b/src/librustdoc/html/render/tests.rs
@@ -52,3 +52,274 @@ fn test_all_types_prints_header_once() {
 
     assert_eq!(1, buffer.into_inner().matches("List of all items").count());
 }
+
+mod sorted_json {
+    use super::super::sorted_json::*;
+
+    fn check(json: SortedJson, serialized: &str) {
+        assert_eq!(json.to_string(), serialized);
+        assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
+
+        let json = json.to_string();
+        let json: SortedJson = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(json.to_string(), serialized);
+        assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
+
+        let json = serde_json::to_string(&json).unwrap();
+        let json: SortedJson = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(json.to_string(), serialized);
+        assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
+    }
+
+    #[test]
+    fn escape_json_number() {
+        let json = SortedJson::serialize(3);
+        let json = EscapedJson::from(json);
+        assert_eq!(format!("{json}"), "3");
+    }
+
+    #[test]
+    fn escape_json_single_quote() {
+        let json = SortedJson::serialize("he's");
+        let json = EscapedJson::from(json);
+        assert_eq!(format!("{json}"), r#""he\'s""#);
+    }
+
+    #[test]
+    fn escape_json_array() {
+        let json = SortedJson::serialize([1, 2, 3]);
+        let json = EscapedJson::from(json);
+        assert_eq!(format!("{json}"), r#"[1,2,3]"#);
+    }
+
+    #[test]
+    fn escape_json_string() {
+        let json = SortedJson::serialize(r#"he"llo"#);
+        let json = EscapedJson::from(json);
+        assert_eq!(format!("{json}"), r#""he\\\"llo""#);
+    }
+
+    #[test]
+    fn escape_json_string_escaped() {
+        let json = SortedJson::serialize(r#"he\"llo"#);
+        let json = EscapedJson::from(json);
+        assert_eq!(format!("{json}"), r#""he\\\\\\\"llo""#);
+    }
+
+    #[test]
+    fn escape_json_string_escaped_escaped() {
+        let json = SortedJson::serialize(r#"he\\"llo"#);
+        let json = EscapedJson::from(json);
+        assert_eq!(format!("{json}"), r#""he\\\\\\\\\\\"llo""#);
+    }
+
+    #[test]
+    fn number() {
+        let json = SortedJson::serialize(3);
+        let serialized = "3";
+        check(json, serialized);
+    }
+
+    #[test]
+    fn boolean() {
+        let json = SortedJson::serialize(true);
+        let serialized = "true";
+        check(json, serialized);
+    }
+
+    #[test]
+    fn string() {
+        let json = SortedJson::serialize("he\"llo");
+        let serialized = r#""he\"llo""#;
+        check(json, serialized);
+    }
+
+    #[test]
+    fn serialize_array() {
+        let json = SortedJson::serialize([3, 1, 2]);
+        let serialized = "[3,1,2]";
+        check(json, serialized);
+    }
+
+    #[test]
+    fn sorted_array() {
+        let items = ["c", "a", "b"];
+        let serialized = r#"["a","b","c"]"#;
+        let items: Vec<SortedJson> = items.into_iter().map(SortedJson::serialize).collect();
+        let json = SortedJson::array(items);
+        check(json, serialized);
+    }
+
+    #[test]
+    fn nested_array() {
+        let a = SortedJson::serialize(3);
+        let b = SortedJson::serialize(2);
+        let c = SortedJson::serialize(1);
+        let d = SortedJson::serialize([1, 3, 2]);
+        let json = SortedJson::array([a, b, c, d]);
+        let serialized = r#"[1,2,3,[1,3,2]]"#;
+        check(json, serialized);
+    }
+
+    #[test]
+    fn array_unsorted() {
+        let items = ["c", "a", "b"];
+        let serialized = r#"["c","a","b"]"#;
+        let items: Vec<SortedJson> = items.into_iter().map(SortedJson::serialize).collect();
+        let json = SortedJson::array_unsorted(items);
+        check(json, serialized);
+    }
+}
+
+mod sorted_template {
+    use super::super::sorted_template::*;
+    use std::str::FromStr;
+
+    fn is_comment_js(s: &str) -> bool {
+        s.starts_with("//")
+    }
+
+    fn is_comment_html(s: &str) -> bool {
+        // not correct but good enough for these tests
+        s.starts_with("<!--") && s.ends_with("-->")
+    }
+
+    #[test]
+    fn html_from_empty() {
+        let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>hello</p>", "<p>world</p>"];
+        let mut template = SortedTemplate::<Html>::before_after("", "");
+        for insert in inserts {
+            template.append(insert.to_string());
+        }
+        let template = format!("{template}");
+        let (template, end) = template.rsplit_once("\n").unwrap();
+        assert_eq!(template, "<p>hello</p><p>kind</p><p>world</p>");
+        assert!(is_comment_html(end));
+        assert!(!end.contains("\n"));
+    }
+
+    #[test]
+    fn html_page() {
+        let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>world</p>"];
+        let before = "<html><head></head><body>";
+        let after = "</body>";
+        let mut template = SortedTemplate::<Html>::before_after(before, after);
+        for insert in inserts {
+            template.append(insert.to_string());
+        }
+        let template = format!("{template}");
+        let (template, end) = template.rsplit_once("\n").unwrap();
+        assert_eq!(template, format!("{before}{}{after}", inserts.join("")));
+        assert!(is_comment_html(end));
+        assert!(!end.contains("\n"));
+    }
+
+    #[test]
+    fn js_from_empty() {
+        let inserts = ["1", "2", "2", "2", "3", "1"];
+        let mut template = SortedTemplate::<Js>::before_after("", "");
+        for insert in inserts {
+            template.append(insert.to_string());
+        }
+        let template = format!("{template}");
+        let (template, end) = template.rsplit_once("\n").unwrap();
+        assert_eq!(template, "1,2,3");
+        assert!(is_comment_js(end));
+        assert!(!end.contains("\n"));
+    }
+
+    #[test]
+    fn js_empty_array() {
+        let template = SortedTemplate::<Js>::before_after("[", "]");
+        let template = format!("{template}");
+        let (template, end) = template.rsplit_once("\n").unwrap();
+        assert_eq!(template, format!("[]"));
+        assert!(is_comment_js(end));
+        assert!(!end.contains("\n"));
+    }
+
+    #[test]
+    fn js_number_array() {
+        let inserts = ["1", "2", "3"];
+        let mut template = SortedTemplate::<Js>::before_after("[", "]");
+        for insert in inserts {
+            template.append(insert.to_string());
+        }
+        let template = format!("{template}");
+        let (template, end) = template.rsplit_once("\n").unwrap();
+        assert_eq!(template, format!("[1,2,3]"));
+        assert!(is_comment_js(end));
+        assert!(!end.contains("\n"));
+    }
+
+    #[test]
+    fn magic_js_number_array() {
+        let inserts = ["1", "1"];
+        let mut template = SortedTemplate::<Js>::magic("[#]", "#").unwrap();
+        for insert in inserts {
+            template.append(insert.to_string());
+        }
+        let template = format!("{template}");
+        let (template, end) = template.rsplit_once("\n").unwrap();
+        assert_eq!(template, format!("[1]"));
+        assert!(is_comment_js(end));
+        assert!(!end.contains("\n"));
+    }
+
+    #[test]
+    fn round_trip_js() {
+        let inserts = ["1", "2", "3"];
+        let mut template = SortedTemplate::<Js>::before_after("[", "]");
+        for insert in inserts {
+            template.append(insert.to_string());
+        }
+        let template1 = format!("{template}");
+        let mut template = SortedTemplate::<Js>::from_str(&template1).unwrap();
+        assert_eq!(template1, format!("{template}"));
+        template.append("4".to_string());
+        let template = format!("{template}");
+        let (template, end) = template.rsplit_once("\n").unwrap();
+        assert_eq!(template, "[1,2,3,4]");
+        assert!(is_comment_js(end));
+    }
+
+    #[test]
+    fn round_trip_html() {
+        let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>world</p>", "<p>kind</p>"];
+        let before = "<html><head></head><body>";
+        let after = "</body>";
+        let mut template = SortedTemplate::<Html>::before_after(before, after);
+        template.append(inserts[0].to_string());
+        template.append(inserts[1].to_string());
+        let template = format!("{template}");
+        let mut template = SortedTemplate::<Html>::from_str(&template).unwrap();
+        template.append(inserts[2].to_string());
+        let template = format!("{template}");
+        let (template, end) = template.rsplit_once("\n").unwrap();
+        assert_eq!(template, format!("{before}<p>hello</p><p>kind</p><p>world</p>{after}"));
+        assert!(is_comment_html(end));
+    }
+
+    #[test]
+    fn blank_js() {
+        let inserts = ["1", "2", "3"];
+        let template = SortedTemplate::<Js>::before_after("", "");
+        let template = format!("{template}");
+        let (t, _) = template.rsplit_once("\n").unwrap();
+        assert_eq!(t, "");
+        let mut template = SortedTemplate::<Js>::from_str(&template).unwrap();
+        for insert in inserts {
+            template.append(insert.to_string());
+        }
+        let template1 = format!("{template}");
+        let mut template = SortedTemplate::<Js>::from_str(&template1).unwrap();
+        assert_eq!(template1, format!("{template}"));
+        template.append("4".to_string());
+        let template = format!("{template}");
+        let (template, end) = template.rsplit_once("\n").unwrap();
+        assert_eq!(template, "1,2,3,4");
+        assert!(is_comment_js(end));
+    }
+}
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index 8fd56eae37ffc..eaebeadd8817e 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -1,19 +1,43 @@
+//! Rustdoc writes out two kinds of shared files:
+//!  - Static files, which are embedded in the rustdoc binary and are written with a
+//!    filename that includes a hash of their contents. These will always have a new
+//!    URL if the contents change, so they are safe to cache with the
+//!    `Cache-Control: immutable` directive. They are written under the static.files/
+//!    directory and are written when --emit-type is empty (default) or contains
+//!    "toolchain-specific". If using the --static-root-path flag, it should point
+//!    to a URL path prefix where each of these filenames can be fetched.
+//!  - Invocation specific files. These are generated based on the crate(s) being
+//!    documented. Their filenames need to be predictable without knowing their
+//!    contents, so they do not include a hash in their filename and are not safe to
+//!    cache with `Cache-Control: immutable`. They include the contents of the
+//!    --resource-suffix flag and are emitted when --emit-type is empty (default)
+//!    or contains "invocation-specific".
+
+use std::any::Any;
 use std::cell::RefCell;
-use std::fs::{self, File};
-use std::io::prelude::*;
-use std::io::{self, BufReader};
-use std::path::{Component, Path};
+use std::collections::hash_map::Entry;
+use std::ffi::OsString;
+use std::fs::File;
+use std::io::BufWriter;
+use std::io::Write as _;
+use std::iter::once;
+use std::marker::PhantomData;
+use std::path::{Component, Path, PathBuf};
 use std::rc::{Rc, Weak};
+use std::str::FromStr;
+use std::{fmt, fs, io};
 
 use indexmap::IndexMap;
 use itertools::Itertools;
+use regex::Regex;
 use rustc_data_structures::flock;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_middle::ty::fast_reject::{DeepRejectCtxt, TreatParams};
+use rustc_middle::ty::TyCtxt;
 use rustc_span::def_id::DefId;
 use rustc_span::Symbol;
 use serde::ser::SerializeSeq;
-use serde::{Serialize, Serializer};
+use serde::{de::DeserializeOwned, Deserialize, Serialize, Serializer};
 
 use super::{collect_paths_for_type, ensure_trailing_slash, Context, RenderMode};
 use crate::clean::{Crate, Item, ItemId, ItemKind};
@@ -24,53 +48,92 @@ use crate::formats::cache::Cache;
 use crate::formats::item_type::ItemType;
 use crate::formats::Impl;
 use crate::html::format::Buffer;
+use crate::html::layout;
+use crate::html::render::search_index::build_index;
 use crate::html::render::search_index::SerializedSearchIndex;
+use crate::html::render::sorted_json::{EscapedJson, SortedJson};
+use crate::html::render::sorted_template::{self, SortedTemplate};
 use crate::html::render::{AssocItemLink, ImplRenderingParameters};
-use crate::html::{layout, static_files};
+use crate::html::static_files::{self, suffix_path};
 use crate::visit::DocVisitor;
 use crate::{try_err, try_none};
 
-/// Rustdoc writes out two kinds of shared files:
-///  - Static files, which are embedded in the rustdoc binary and are written with a
-///    filename that includes a hash of their contents. These will always have a new
-///    URL if the contents change, so they are safe to cache with the
-///    `Cache-Control: immutable` directive. They are written under the static.files/
-///    directory and are written when --emit-type is empty (default) or contains
-///    "toolchain-specific". If using the --static-root-path flag, it should point
-///    to a URL path prefix where each of these filenames can be fetched.
-///  - Invocation specific files. These are generated based on the crate(s) being
-///    documented. Their filenames need to be predictable without knowing their
-///    contents, so they do not include a hash in their filename and are not safe to
-///    cache with `Cache-Control: immutable`. They include the contents of the
-///    --resource-suffix flag and are emitted when --emit-type is empty (default)
-///    or contains "invocation-specific".
-pub(super) fn write_shared(
+/// Write crate-info.json cross-crate information, static files, invocation-specific files, etc. to disk
+pub(crate) fn write_shared(
     cx: &mut Context<'_>,
     krate: &Crate,
-    search_index: SerializedSearchIndex,
-    options: &RenderOptions,
+    opt: &RenderOptions,
+    tcx: TyCtxt<'_>,
 ) -> Result<(), Error> {
-    // Write out the shared files. Note that these are shared among all rustdoc
-    // docs placed in the output directory, so this needs to be a synchronized
-    // operation with respect to all other rustdocs running around.
+    // NOTE(EtomicBomb): I don't think we need sync here because no read-after-write?
+    Rc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(true);
     let lock_file = cx.dst.join(".lock");
+    // Write shared runs within a flock; disable thread dispatching of IO temporarily.
     let _lock = try_err!(flock::Lock::new(&lock_file, true, true, true), &lock_file);
 
-    // InvocationSpecific resources should always be dynamic.
-    let write_invocation_specific = |p: &str, make_content: &dyn Fn() -> Result<Vec<u8>, Error>| {
-        let content = make_content()?;
-        if options.emit.is_empty() || options.emit.contains(&EmitType::InvocationSpecific) {
-            let output_filename = static_files::suffix_path(p, &cx.shared.resource_suffix);
-            cx.shared.fs.write(cx.dst.join(output_filename), content)
-        } else {
-            Ok(())
-        }
+    let SerializedSearchIndex { index, desc } =
+        build_index(&krate, &mut Rc::get_mut(&mut cx.shared).unwrap().cache, tcx);
+    write_search_desc(cx, &krate, &desc)?; // does not need to be merged; written unconditionally
+
+    let crate_name = krate.name(cx.tcx());
+    let crate_name = crate_name.as_str(); // rand
+    let crate_name_json = SortedJson::serialize(crate_name); // "rand"
+    let external_crates = hack_get_external_crate_names(cx)?;
+    let info = CrateInfo {
+        src_files_js: SourcesPart::get(cx, &crate_name_json)?,
+        search_index_js: SearchIndexPart::get(cx, index)?,
+        all_crates: AllCratesPart::get(crate_name_json.clone())?,
+        crates_index: CratesIndexPart::get(&crate_name, &external_crates)?,
+        trait_impl: TraitAliasPart::get(cx, &crate_name_json)?,
+        type_impl: TypeAliasPart::get(cx, krate, &crate_name_json)?,
     };
 
-    cx.shared
-        .fs
-        .create_dir_all(cx.dst.join("static.files"))
-        .map_err(|e| PathError::new(e, "static.files"))?;
+    let crates_info = vec![info]; // we have info from just one crate
+
+    write_static_files(cx, &opt)?;
+    let dst = &cx.dst;
+    if opt.emit.is_empty() || opt.emit.contains(&EmitType::InvocationSpecific) {
+        if cx.include_sources {
+            write_rendered_cci::<SourcesPart, _>(SourcesPart::blank, dst, &crates_info)?;
+        }
+        write_rendered_cci::<SearchIndexPart, _>(
+            SearchIndexPart::blank,
+            dst,
+            &crates_info,
+        )?;
+        write_rendered_cci::<AllCratesPart, _>(AllCratesPart::blank, dst, &crates_info)?;
+    }
+    write_rendered_cci::<TraitAliasPart, _>(TraitAliasPart::blank, dst, &crates_info)?;
+    write_rendered_cci::<TypeAliasPart, _>(TypeAliasPart::blank, dst, &crates_info)?;
+    match &opt.index_page {
+        Some(index_page) if opt.enable_index_page => {
+            let mut md_opts = opt.clone();
+            md_opts.output = cx.dst.clone();
+            md_opts.external_html = cx.shared.layout.external_html.clone();
+            try_err!(
+                crate::markdown::render(&index_page, md_opts, cx.shared.edition()),
+                &index_page
+            );
+        }
+        None if opt.enable_index_page => {
+            write_rendered_cci::<CratesIndexPart, _>(
+                || CratesIndexPart::blank(cx),
+                dst,
+                &crates_info,
+            )?;
+        }
+        _ => {} // they don't want an index page
+    }
+
+    Rc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(false);
+    Ok(())
+}
+
+/// Writes the static files, the style files, and the css extensions
+fn write_static_files(cx: &mut Context<'_>, options: &RenderOptions) -> Result<(), Error> {
+    let static_dir = cx.dst.join("static.files");
+
+    cx.shared.fs.create_dir_all(&static_dir).map_err(|e| PathError::new(e, "static.files"))?;
 
     // Handle added third-party themes
     for entry in &cx.shared.style_files {
@@ -97,680 +160,769 @@ pub(super) fn write_shared(
     }
 
     if options.emit.is_empty() || options.emit.contains(&EmitType::Toolchain) {
-        let static_dir = cx.dst.join(Path::new("static.files"));
         static_files::for_each(|f: &static_files::StaticFile| {
             let filename = static_dir.join(f.output_filename());
             cx.shared.fs.write(filename, f.minified())
         })?;
     }
 
-    /// Read a file and return all lines that match the `"{crate}":{data},` format,
-    /// and return a tuple `(Vec<DataString>, Vec<CrateNameString>)`.
-    ///
-    /// This forms the payload of files that look like this:
-    ///
-    /// ```javascript
-    /// var data = {
-    /// "{crate1}":{data},
-    /// "{crate2}":{data}
-    /// };
-    /// use_data(data);
-    /// ```
-    ///
-    /// The file needs to be formatted so that *only crate data lines start with `"`*.
-    fn collect(path: &Path, krate: &str) -> io::Result<(Vec<String>, Vec<String>)> {
-        let mut ret = Vec::new();
-        let mut krates = Vec::new();
-
-        if path.exists() {
-            let prefix = format!("\"{krate}\"");
-            for line in BufReader::new(File::open(path)?).lines() {
-                let line = line?;
-                if !line.starts_with('"') {
-                    continue;
-                }
-                if line.starts_with(&prefix) {
-                    continue;
-                }
-                if line.ends_with(',') {
-                    ret.push(line[..line.len() - 1].to_string());
-                } else {
-                    // No comma (it's the case for the last added crate line)
-                    ret.push(line.to_string());
-                }
-                krates.push(
-                    line.split('"')
-                        .find(|s| !s.is_empty())
-                        .map(|s| s.to_owned())
-                        .unwrap_or_else(String::new),
-                );
-            }
-        }
-        Ok((ret, krates))
-    }
-
-    /// Read a file and return all lines that match the <code>"{crate}":{data},\ </code> format,
-    /// and return a tuple `(Vec<DataString>, Vec<CrateNameString>)`.
-    ///
-    /// This forms the payload of files that look like this:
-    ///
-    /// ```javascript
-    /// var data = JSON.parse('{\
-    /// "{crate1}":{data},\
-    /// "{crate2}":{data}\
-    /// }');
-    /// use_data(data);
-    /// ```
-    ///
-    /// The file needs to be formatted so that *only crate data lines start with `"`*.
-    fn collect_json(path: &Path, krate: &str) -> io::Result<(Vec<String>, Vec<String>)> {
-        let mut ret = Vec::new();
-        let mut krates = Vec::new();
-
-        if path.exists() {
-            let prefix = format!("[\"{krate}\"");
-            for line in BufReader::new(File::open(path)?).lines() {
-                let line = line?;
-                if !line.starts_with("[\"") {
-                    continue;
-                }
-                if line.starts_with(&prefix) {
-                    continue;
-                }
-                if line.ends_with("],\\") {
-                    ret.push(line[..line.len() - 2].to_string());
-                } else {
-                    // Ends with "\\" (it's the case for the last added crate line)
-                    ret.push(line[..line.len() - 1].to_string());
-                }
-                krates.push(
-                    line[1..] // We skip the `[` parent at the beginning of the line.
-                        .split('"')
-                        .find(|s| !s.is_empty())
-                        .map(|s| s.to_owned())
-                        .unwrap_or_else(String::new),
-                );
-            }
-        }
-        Ok((ret, krates))
+    Ok(())
+}
+
+/// Write the search description shards to disk
+fn write_search_desc(
+    cx: &mut Context<'_>,
+    krate: &Crate,
+    search_desc: &[(usize, String)],
+) -> Result<(), Error> {
+    let crate_name = krate.name(cx.tcx()).to_string();
+    let encoded_crate_name = SortedJson::serialize(&crate_name);
+    let path = PathBuf::from_iter([&cx.dst, Path::new("search.desc"), Path::new(&crate_name)]);
+    if Path::new(&path).exists() {
+        try_err!(fs::remove_dir_all(&path), &path);
+    }
+    for (i, (_, part)) in search_desc.iter().enumerate() {
+        let filename = static_files::suffix_path(
+            &format!("{crate_name}-desc-{i}-.js"),
+            &cx.shared.resource_suffix,
+        );
+        let path = path.join(filename);
+        let part = SortedJson::serialize(&part);
+        let part = format!("searchState.loadedDescShard({encoded_crate_name}, {i}, {part})");
+        write_create_parents(&path, part)?;
     }
+    Ok(())
+}
 
-    use std::ffi::OsString;
+/// Written to `crate-info.json`. Contains pre-rendered contents to insert into the CCI template
+#[derive(Serialize, Deserialize, Clone, Debug)]
+struct CrateInfo {
+    src_files_js: PartsAndLocations<SourcesPart>,
+    search_index_js: PartsAndLocations<SearchIndexPart>,
+    all_crates: PartsAndLocations<AllCratesPart>,
+    crates_index: PartsAndLocations<CratesIndexPart>,
+    trait_impl: PartsAndLocations<TraitAliasPart>,
+    type_impl: PartsAndLocations<TypeAliasPart>,
+}
 
-    #[derive(Debug, Default)]
-    struct Hierarchy {
-        parent: Weak<Self>,
-        elem: OsString,
-        children: RefCell<FxHashMap<OsString, Rc<Self>>>,
-        elems: RefCell<FxHashSet<OsString>>,
+impl CrateInfo {
+    /// Gets a reference to the cross-crate information parts for `T`
+    fn get<T: CciPart>(&self) -> &PartsAndLocations<T> {
+        (&self.src_files_js as &dyn Any)
+            .downcast_ref()
+            .or_else(|| (&self.search_index_js as &dyn Any).downcast_ref())
+            .or_else(|| (&self.all_crates as &dyn Any).downcast_ref())
+            .or_else(|| (&self.crates_index as &dyn Any).downcast_ref())
+            .or_else(|| (&self.trait_impl as &dyn Any).downcast_ref())
+            .or_else(|| (&self.type_impl as &dyn Any).downcast_ref())
+            .expect("this should be an exhaustive list of `CciPart`s")
     }
+}
 
-    impl Hierarchy {
-        fn with_parent(elem: OsString, parent: &Rc<Self>) -> Self {
-            Self { elem, parent: Rc::downgrade(parent), ..Self::default() }
-        }
+/// Paths (relative to the doc root) and their pre-merge contents
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(transparent)]
+struct PartsAndLocations<P> {
+    parts: Vec<(PathBuf, P)>,
+}
 
-        fn to_json_string(&self) -> String {
-            let borrow = self.children.borrow();
-            let mut subs: Vec<_> = borrow.values().collect();
-            subs.sort_unstable_by(|a, b| a.elem.cmp(&b.elem));
-            let mut files = self
-                .elems
-                .borrow()
-                .iter()
-                .map(|s| format!("\"{}\"", s.to_str().expect("invalid osstring conversion")))
-                .collect::<Vec<_>>();
-            files.sort_unstable();
-            let subs = subs.iter().map(|s| s.to_json_string()).collect::<Vec<_>>().join(",");
-            let dirs = if subs.is_empty() && files.is_empty() {
-                String::new()
-            } else {
-                format!(",[{subs}]")
-            };
-            let files = files.join(",");
-            let files = if files.is_empty() { String::new() } else { format!(",[{files}]") };
-            format!(
-                "[\"{name}\"{dirs}{files}]",
-                name = self.elem.to_str().expect("invalid osstring conversion"),
-                dirs = dirs,
-                files = files
-            )
-        }
+impl<P> Default for PartsAndLocations<P> {
+    fn default() -> Self {
+        Self { parts: Vec::default() }
+    }
+}
 
-        fn add_path(self: &Rc<Self>, path: &Path) {
-            let mut h = Rc::clone(&self);
-            let mut elems = path
-                .components()
-                .filter_map(|s| match s {
-                    Component::Normal(s) => Some(s.to_owned()),
-                    Component::ParentDir => Some(OsString::from("..")),
-                    _ => None,
-                })
-                .peekable();
-            loop {
-                let cur_elem = elems.next().expect("empty file path");
-                if cur_elem == ".." {
-                    if let Some(parent) = h.parent.upgrade() {
-                        h = parent;
-                    }
-                    continue;
-                }
-                if elems.peek().is_none() {
-                    h.elems.borrow_mut().insert(cur_elem);
-                    break;
-                } else {
-                    let entry = Rc::clone(
-                        h.children
-                            .borrow_mut()
-                            .entry(cur_elem.clone())
-                            .or_insert_with(|| Rc::new(Self::with_parent(cur_elem, &h))),
-                    );
-                    h = entry;
-                }
-            }
+impl<T, U> PartsAndLocations<Part<T, U>> {
+    fn push(&mut self, path: PathBuf, item: U) {
+        self.parts.push((path, Part { _artifact: PhantomData, item }));
+    }
+
+    /// Singleton part, one file
+    fn with(path: PathBuf, part: U) -> Self {
+        let mut ret = Self::default();
+        ret.push(path, part);
+        ret
+    }
+}
+
+/// A piece of one of the shared artifacts for documentation (search index, sources, alias list, etc.)
+///
+/// Merged at a user specified time and written to the `doc/` directory
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(transparent)]
+struct Part<T, U> {
+    #[serde(skip)]
+    _artifact: PhantomData<T>,
+    item: U,
+}
+
+impl<T, U: fmt::Display> fmt::Display for Part<T, U> {
+    /// Writes serialized JSON
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.item)
+    }
+}
+
+/// Wrapper trait for `Part<T, U>`
+trait CciPart: Sized + fmt::Display + DeserializeOwned + 'static {
+    /// Identifies the file format of the cross-crate information
+    type FileFormat: sorted_template::FileFormat;
+}
+
+#[derive(Serialize, Deserialize, Clone, Default, Debug)]
+struct SearchIndex;
+type SearchIndexPart = Part<SearchIndex, EscapedJson>;
+impl CciPart for SearchIndexPart {
+    type FileFormat = sorted_template::Js;
+}
+
+impl SearchIndexPart {
+    fn blank() -> SortedTemplate<<Self as CciPart>::FileFormat> {
+        SortedTemplate::before_after(
+            r"var searchIndex = new Map(JSON.parse('[",
+            r"]'));
+if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
+else if (window.initSearch) window.initSearch(searchIndex);",
+        )
+    }
+
+    fn get(cx: &Context<'_>, search_index: SortedJson) -> Result<PartsAndLocations<Self>, Error> {
+        let path = suffix_path("search-index.js", &cx.shared.resource_suffix);
+        let search_index = EscapedJson::from(search_index);
+        Ok(PartsAndLocations::with(path, search_index))
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Default, Debug)]
+struct AllCrates;
+type AllCratesPart = Part<AllCrates, SortedJson>;
+impl CciPart for AllCratesPart {
+    type FileFormat = sorted_template::Js;
+}
+
+impl AllCratesPart {
+    fn blank() -> SortedTemplate<<Self as CciPart>::FileFormat> {
+        SortedTemplate::before_after("window.ALL_CRATES = [", "];")
+    }
+
+    fn get(crate_name_json: SortedJson) -> Result<PartsAndLocations<Self>, Error> {
+        // external hack_get_external_crate_names not needed here, because
+        // there's no way that we write the search index but not crates.js
+        let path = PathBuf::from("crates.js");
+        Ok(PartsAndLocations::with(path, crate_name_json))
+    }
+}
+
+/// Reads `crates.js`, which seems like the best
+/// place to obtain the list of externally documented crates if the index
+/// page was disabled when documenting the deps.
+///
+/// This is to match the current behavior of rustdoc, which allows you to get all crates
+/// on the index page, even if --enable-index-page is only passed to the last crate.
+fn hack_get_external_crate_names(cx: &Context<'_>) -> Result<Vec<String>, Error> {
+    let path = cx.dst.join("crates.js");
+    let Ok(content) = fs::read_to_string(&path) else {
+        // they didn't emit invocation specific, so we just say there were no crates
+        return Ok(Vec::default());
+    };
+    // this is only run once so it's fine not to cache it
+    // !dot_matches_new_line: all crates on same line. greedy: match last bracket
+    let regex = Regex::new(r"\[.*\]").unwrap();
+    let Some(content) = regex.find(&content) else {
+        return Err(Error::new("could not find crates list in crates.js", path));
+    };
+    let content: Vec<String> = try_err!(serde_json::from_str(content.as_str()), &path);
+    Ok(content)
+}
+
+#[derive(Serialize, Deserialize, Clone, Default, Debug)]
+struct CratesIndex;
+type CratesIndexPart = Part<CratesIndex, String>;
+impl CciPart for CratesIndexPart {
+    type FileFormat = sorted_template::Html;
+}
+
+impl CratesIndexPart {
+    fn blank(cx: &Context<'_>) -> SortedTemplate<<Self as CciPart>::FileFormat> {
+        let page = layout::Page {
+            title: "Index of crates",
+            css_class: "mod sys",
+            root_path: "./",
+            static_root_path: cx.shared.static_root_path.as_deref(),
+            description: "List of crates",
+            resource_suffix: &cx.shared.resource_suffix,
+            rust_logo: true,
+        };
+        let layout = &cx.shared.layout;
+        let style_files = &cx.shared.style_files;
+        const MAGIC: &str = "\u{FFFC}"; // users are being naughty if they have this
+        let content = format!("<h1>List of all crates</h1><ul class=\"all-items\">{MAGIC}</ul>");
+        let template = layout::render(layout, &page, "", content, &style_files);
+        match SortedTemplate::magic(&template, MAGIC) {
+            Ok(template) => template,
+            Err(e) => panic!(
+                "{e}: Object Replacement Character (U+FFFC) should not appear in the --index-page"
+            ),
         }
     }
 
-    if cx.include_sources {
-        let hierarchy = Rc::new(Hierarchy::default());
-        for source in cx
-            .shared
-            .local_sources
-            .iter()
-            .filter_map(|p| p.0.strip_prefix(&cx.shared.src_root).ok())
-        {
-            hierarchy.add_path(source);
+    /// Might return parts that are duplicate with ones in prexisting index.html
+    fn get(crate_name: &str, external_crates: &[String]) -> Result<PartsAndLocations<Self>, Error> {
+        let mut ret = PartsAndLocations::default();
+        let path = PathBuf::from("index.html");
+        for crate_name in external_crates.iter().map(|s| s.as_str()).chain(once(crate_name)) {
+            let part = format!(
+                "<li><a href=\"{trailing_slash}index.html\">{crate_name}</a></li>",
+                trailing_slash = ensure_trailing_slash(crate_name),
+            );
+            ret.push(path.clone(), part);
         }
-        let hierarchy = Rc::try_unwrap(hierarchy).unwrap();
-        let dst = cx.dst.join(&format!("src-files{}.js", cx.shared.resource_suffix));
-        let make_sources = || {
-            let (mut all_sources, _krates) =
-                try_err!(collect_json(&dst, krate.name(cx.tcx()).as_str()), &dst);
-            all_sources.push(format!(
-                r#"["{}",{}]"#,
-                &krate.name(cx.tcx()),
-                hierarchy
-                    .to_json_string()
-                    // All these `replace` calls are because we have to go through JS string for JSON content.
-                    .replace('\\', r"\\")
-                    .replace('\'', r"\'")
-                    // We need to escape double quotes for the JSON.
-                    .replace("\\\"", "\\\\\"")
-            ));
-            all_sources.sort();
-            // This needs to be `var`, not `const`.
-            // This variable needs declared in the current global scope so that if
-            // src-script.js loads first, it can pick it up.
-            let mut v = String::from("var srcIndex = new Map(JSON.parse('[\\\n");
-            v.push_str(&all_sources.join(",\\\n"));
-            v.push_str("\\\n]'));\ncreateSrcSidebar();\n");
-            Ok(v.into_bytes())
-        };
-        write_invocation_specific("src-files.js", &make_sources)?;
+        Ok(ret)
     }
+}
 
-    // Update the search index and crate list.
-    let dst = cx.dst.join(&format!("search-index{}.js", cx.shared.resource_suffix));
-    let (mut all_indexes, mut krates) =
-        try_err!(collect_json(&dst, krate.name(cx.tcx()).as_str()), &dst);
-    all_indexes.push(search_index.index);
-    krates.push(krate.name(cx.tcx()).to_string());
-    krates.sort();
+#[derive(Serialize, Deserialize, Clone, Default, Debug)]
+struct Sources;
+type SourcesPart = Part<Sources, EscapedJson>;
+impl CciPart for SourcesPart {
+    type FileFormat = sorted_template::Js;
+}
 
-    // Sort the indexes by crate so the file will be generated identically even
-    // with rustdoc running in parallel.
-    all_indexes.sort();
-    write_invocation_specific("search-index.js", &|| {
+impl SourcesPart {
+    fn blank() -> SortedTemplate<<Self as CciPart>::FileFormat> {
         // This needs to be `var`, not `const`.
         // This variable needs declared in the current global scope so that if
-        // search.js loads first, it can pick it up.
-        let mut v = String::from("var searchIndex = new Map(JSON.parse('[\\\n");
-        v.push_str(&all_indexes.join(",\\\n"));
-        v.push_str(
-            r#"\
-]'));
-if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
-else if (window.initSearch) window.initSearch(searchIndex);
-"#,
-        );
-        Ok(v.into_bytes())
-    })?;
-
-    let search_desc_dir = cx.dst.join(format!("search.desc/{krate}", krate = krate.name(cx.tcx())));
-    if Path::new(&search_desc_dir).exists() {
-        try_err!(std::fs::remove_dir_all(&search_desc_dir), &search_desc_dir);
-    }
-    try_err!(std::fs::create_dir_all(&search_desc_dir), &search_desc_dir);
-    let kratename = krate.name(cx.tcx()).to_string();
-    for (i, (_, data)) in search_index.desc.into_iter().enumerate() {
-        let output_filename = static_files::suffix_path(
-            &format!("{kratename}-desc-{i}-.js"),
-            &cx.shared.resource_suffix,
-        );
-        let path = search_desc_dir.join(output_filename);
-        try_err!(
-            std::fs::write(
-                &path,
-                &format!(
-                    r##"searchState.loadedDescShard({kratename}, {i}, {data})"##,
-                    kratename = serde_json::to_string(&kratename).unwrap(),
-                    data = serde_json::to_string(&data).unwrap(),
-                )
-                .into_bytes()
-            ),
-            &path
-        );
+        // src-script.js loads first, it can pick it up.
+        SortedTemplate::before_after(
+            r"var srcIndex = new Map(JSON.parse('[",
+            r"]'));
+createSrcSidebar();",
+        )
     }
 
-    write_invocation_specific("crates.js", &|| {
-        let krates = krates.iter().map(|k| format!("\"{k}\"")).join(",");
-        Ok(format!("window.ALL_CRATES = [{krates}];").into_bytes())
-    })?;
+    fn get(cx: &Context<'_>, crate_name: &SortedJson) -> Result<PartsAndLocations<Self>, Error> {
+        let hierarchy = Rc::new(Hierarchy::default());
+        cx.shared
+            .local_sources
+            .iter()
+            .filter_map(|p| p.0.strip_prefix(&cx.shared.src_root).ok())
+            .for_each(|source| hierarchy.add_path(source));
+        let path = suffix_path("src-files.js", &cx.shared.resource_suffix);
+        let hierarchy = hierarchy.to_json_string();
+        let part = SortedJson::array_unsorted([crate_name, &hierarchy]);
+        let part = EscapedJson::from(part);
+        Ok(PartsAndLocations::with(path, part))
+    }
+}
 
-    if options.enable_index_page {
-        if let Some(index_page) = options.index_page.clone() {
-            let mut md_opts = options.clone();
-            md_opts.output = cx.dst.clone();
-            md_opts.external_html = (*cx.shared).layout.external_html.clone();
+/// Source files directory tree
+#[derive(Debug, Default)]
+struct Hierarchy {
+    parent: Weak<Self>,
+    elem: OsString,
+    children: RefCell<FxHashMap<OsString, Rc<Self>>>,
+    elems: RefCell<FxHashSet<OsString>>,
+}
 
-            crate::markdown::render(&index_page, md_opts, cx.shared.edition())
-                .map_err(|e| Error::new(e, &index_page))?;
-        } else {
-            let shared = Rc::clone(&cx.shared);
-            let dst = cx.dst.join("index.html");
-            let page = layout::Page {
-                title: "Index of crates",
-                css_class: "mod sys",
-                root_path: "./",
-                static_root_path: shared.static_root_path.as_deref(),
-                description: "List of crates",
-                resource_suffix: &shared.resource_suffix,
-                rust_logo: true,
-            };
+impl Hierarchy {
+    fn with_parent(elem: OsString, parent: &Rc<Self>) -> Self {
+        Self { elem, parent: Rc::downgrade(parent), ..Self::default() }
+    }
 
-            let content = format!(
-                "<h1>List of all crates</h1><ul class=\"all-items\">{}</ul>",
-                krates.iter().format_with("", |k, f| {
-                    f(&format_args!(
-                        "<li><a href=\"{trailing_slash}index.html\">{k}</a></li>",
-                        trailing_slash = ensure_trailing_slash(k),
-                    ))
-                })
-            );
-            let v = layout::render(&shared.layout, &page, "", content, &shared.style_files);
-            shared.fs.write(dst, v)?;
+    fn to_json_string(&self) -> SortedJson {
+        let subs = self.children.borrow();
+        let files = self.elems.borrow();
+        let name = SortedJson::serialize(self.elem.to_str().expect("invalid osstring conversion"));
+        let mut out = Vec::from([name]);
+        if !subs.is_empty() || !files.is_empty() {
+            let subs = subs.iter().map(|(_, s)| s.to_json_string());
+            out.push(SortedJson::array(subs));
         }
+        if !files.is_empty() {
+            let files =
+                files.iter().map(|s| SortedJson::serialize(s.to_str().expect("invalid osstring")));
+            out.push(SortedJson::array(files));
+        }
+        SortedJson::array_unsorted(out)
     }
 
-    let cloned_shared = Rc::clone(&cx.shared);
-    let cache = &cloned_shared.cache;
-
-    // Collect the list of aliased types and their aliases.
-    // <https://github.com/search?q=repo%3Arust-lang%2Frust+[RUSTDOCIMPL]+type.impl&type=code>
-    //
-    // The clean AST has type aliases that point at their types, but
-    // this visitor works to reverse that: `aliased_types` is a map
-    // from target to the aliases that reference it, and each one
-    // will generate one file.
-    struct TypeImplCollector<'cx, 'cache> {
-        // Map from DefId-of-aliased-type to its data.
-        aliased_types: IndexMap<DefId, AliasedType<'cache>>,
-        visited_aliases: FxHashSet<DefId>,
-        cache: &'cache Cache,
-        cx: &'cache mut Context<'cx>,
-    }
-    // Data for an aliased type.
-    //
-    // In the final file, the format will be roughly:
-    //
-    // ```json
-    // // type.impl/CRATE/TYPENAME.js
-    // JSONP(
-    // "CRATE": [
-    //   ["IMPL1 HTML", "ALIAS1", "ALIAS2", ...],
-    //   ["IMPL2 HTML", "ALIAS3", "ALIAS4", ...],
-    //    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ struct AliasedType
-    //   ...
-    // ]
-    // )
-    // ```
-    struct AliasedType<'cache> {
-        // This is used to generate the actual filename of this aliased type.
-        target_fqp: &'cache [Symbol],
-        target_type: ItemType,
-        // This is the data stored inside the file.
-        // ItemId is used to deduplicate impls.
-        impl_: IndexMap<ItemId, AliasedTypeImpl<'cache>>,
-    }
-    // The `impl_` contains data that's used to figure out if an alias will work,
-    // and to generate the HTML at the end.
-    //
-    // The `type_aliases` list is built up with each type alias that matches.
-    struct AliasedTypeImpl<'cache> {
-        impl_: &'cache Impl,
-        type_aliases: Vec<(&'cache [Symbol], Item)>,
-    }
-    impl<'cx, 'cache> DocVisitor for TypeImplCollector<'cx, 'cache> {
-        fn visit_item(&mut self, it: &Item) {
-            self.visit_item_recur(it);
-            let cache = self.cache;
-            let ItemKind::TypeAliasItem(ref t) = *it.kind else { return };
-            let Some(self_did) = it.item_id.as_def_id() else { return };
-            if !self.visited_aliases.insert(self_did) {
-                return;
-            }
-            let Some(target_did) = t.type_.def_id(cache) else { return };
-            let get_extern = { || cache.external_paths.get(&target_did) };
-            let Some(&(ref target_fqp, target_type)) =
-                cache.paths.get(&target_did).or_else(get_extern)
-            else {
-                return;
-            };
-            let aliased_type = self.aliased_types.entry(target_did).or_insert_with(|| {
-                let impl_ = cache
-                    .impls
-                    .get(&target_did)
-                    .map(|v| &v[..])
-                    .unwrap_or_default()
-                    .iter()
-                    .map(|impl_| {
-                        (
-                            impl_.impl_item.item_id,
-                            AliasedTypeImpl { impl_, type_aliases: Vec::new() },
-                        )
-                    })
-                    .collect();
-                AliasedType { target_fqp: &target_fqp[..], target_type, impl_ }
-            });
-            let get_local = { || cache.paths.get(&self_did).map(|(p, _)| p) };
-            let Some(self_fqp) = cache.exact_paths.get(&self_did).or_else(get_local) else {
-                return;
-            };
-            let aliased_ty = self.cx.tcx().type_of(self_did).skip_binder();
-            // Exclude impls that are directly on this type. They're already in the HTML.
-            // Some inlining scenarios can cause there to be two versions of the same
-            // impl: one on the type alias and one on the underlying target type.
-            let mut seen_impls: FxHashSet<ItemId> = cache
-                .impls
-                .get(&self_did)
-                .map(|s| &s[..])
-                .unwrap_or_default()
-                .iter()
-                .map(|i| i.impl_item.item_id)
-                .collect();
-            for (impl_item_id, aliased_type_impl) in &mut aliased_type.impl_ {
-                // Only include this impl if it actually unifies with this alias.
-                // Synthetic impls are not included; those are also included in the HTML.
-                //
-                // FIXME(lazy_type_alias): Once the feature is complete or stable, rewrite this
-                // to use type unification.
-                // Be aware of `tests/rustdoc/type-alias/deeply-nested-112515.rs` which might regress.
-                let Some(impl_did) = impl_item_id.as_def_id() else { continue };
-                let for_ty = self.cx.tcx().type_of(impl_did).skip_binder();
-                let reject_cx = DeepRejectCtxt::new(self.cx.tcx(), TreatParams::AsCandidateKey);
-                if !reject_cx.types_may_unify(aliased_ty, for_ty) {
-                    continue;
-                }
-                // Avoid duplicates
-                if !seen_impls.insert(*impl_item_id) {
-                    continue;
+    fn add_path(self: &Rc<Self>, path: &Path) {
+        let mut h = Rc::clone(&self);
+        let mut elems = path
+            .components()
+            .filter_map(|s| match s {
+                Component::Normal(s) => Some(s.to_owned()),
+                Component::ParentDir => Some(OsString::from("..")),
+                _ => None,
+            })
+            .peekable();
+        loop {
+            let cur_elem = elems.next().expect("empty file path");
+            if cur_elem == ".." {
+                if let Some(parent) = h.parent.upgrade() {
+                    h = parent;
                 }
-                // This impl was not found in the set of rejected impls
-                aliased_type_impl.type_aliases.push((&self_fqp[..], it.clone()));
+                continue;
             }
-        }
-    }
-    let mut type_impl_collector = TypeImplCollector {
-        aliased_types: IndexMap::default(),
-        visited_aliases: FxHashSet::default(),
-        cache,
-        cx,
-    };
-    DocVisitor::visit_crate(&mut type_impl_collector, &krate);
-    // Final serialized form of the alias impl
-    struct AliasSerializableImpl {
-        text: String,
-        trait_: Option<String>,
-        aliases: Vec<String>,
-    }
-    impl Serialize for AliasSerializableImpl {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let mut seq = serializer.serialize_seq(None)?;
-            seq.serialize_element(&self.text)?;
-            if let Some(trait_) = &self.trait_ {
-                seq.serialize_element(trait_)?;
+            if elems.peek().is_none() {
+                h.elems.borrow_mut().insert(cur_elem);
+                break;
             } else {
-                seq.serialize_element(&0)?;
-            }
-            for type_ in &self.aliases {
-                seq.serialize_element(type_)?;
+                let entry = Rc::clone(
+                    h.children
+                        .borrow_mut()
+                        .entry(cur_elem.clone())
+                        .or_insert_with(|| Rc::new(Self::with_parent(cur_elem, &h))),
+                );
+                h = entry;
             }
-            seq.end()
         }
     }
-    let cx = type_impl_collector.cx;
-    let dst = cx.dst.join("type.impl");
-    let aliased_types = type_impl_collector.aliased_types;
-    for aliased_type in aliased_types.values() {
-        let impls = aliased_type
-            .impl_
-            .values()
-            .flat_map(|AliasedTypeImpl { impl_, type_aliases }| {
-                let mut ret = Vec::new();
-                let trait_ = impl_
-                    .inner_impl()
-                    .trait_
-                    .as_ref()
-                    .map(|trait_| format!("{:#}", trait_.print(cx)));
-                // render_impl will filter out "impossible-to-call" methods
-                // to make that functionality work here, it needs to be called with
-                // each type alias, and if it gives a different result, split the impl
-                for &(type_alias_fqp, ref type_alias_item) in type_aliases {
-                    let mut buf = Buffer::html();
-                    cx.id_map = Default::default();
-                    cx.deref_id_map = Default::default();
-                    let target_did = impl_
+}
+
+#[derive(Serialize, Deserialize, Clone, Default, Debug)]
+struct TypeAlias;
+type TypeAliasPart = Part<TypeAlias, SortedJson>;
+impl CciPart for TypeAliasPart {
+    type FileFormat = sorted_template::Js;
+}
+
+impl TypeAliasPart {
+    fn blank() -> SortedTemplate<<Self as CciPart>::FileFormat> {
+        SortedTemplate::before_after(
+            r"(function() {
+    var type_impls = Object.fromEntries([",
+            r"]);
+    if (window.register_type_impls) {
+        window.register_type_impls(type_impls);
+    } else {
+        window.pending_type_impls = type_impls;
+    }
+})()",
+        )
+    }
+
+    fn get(
+        cx: &mut Context<'_>,
+        krate: &Crate,
+        crate_name_json: &SortedJson,
+    ) -> Result<PartsAndLocations<Self>, Error> {
+        let cache = &Rc::clone(&cx.shared).cache;
+        let mut path_parts = PartsAndLocations::default();
+
+        let mut type_impl_collector = TypeImplCollector {
+            aliased_types: IndexMap::default(),
+            visited_aliases: FxHashSet::default(),
+            cache,
+            cx,
+        };
+        DocVisitor::visit_crate(&mut type_impl_collector, &krate);
+        let cx = type_impl_collector.cx;
+        let aliased_types = type_impl_collector.aliased_types;
+        for aliased_type in aliased_types.values() {
+            let impls = aliased_type
+                .impl_
+                .values()
+                .flat_map(|AliasedTypeImpl { impl_, type_aliases }| {
+                    let mut ret = Vec::new();
+                    let trait_ = impl_
                         .inner_impl()
                         .trait_
                         .as_ref()
-                        .map(|trait_| trait_.def_id())
-                        .or_else(|| impl_.inner_impl().for_.def_id(cache));
-                    let provided_methods;
-                    let assoc_link = if let Some(target_did) = target_did {
-                        provided_methods = impl_.inner_impl().provided_trait_methods(cx.tcx());
-                        AssocItemLink::GotoSource(ItemId::DefId(target_did), &provided_methods)
-                    } else {
-                        AssocItemLink::Anchor(None)
-                    };
-                    super::render_impl(
-                        &mut buf,
-                        cx,
-                        *impl_,
-                        &type_alias_item,
-                        assoc_link,
-                        RenderMode::Normal,
-                        None,
-                        &[],
-                        ImplRenderingParameters {
-                            show_def_docs: true,
-                            show_default_items: true,
-                            show_non_assoc_items: true,
-                            toggle_open_by_default: true,
-                        },
-                    );
-                    let text = buf.into_inner();
-                    let type_alias_fqp = (*type_alias_fqp).iter().join("::");
-                    if Some(&text) == ret.last().map(|s: &AliasSerializableImpl| &s.text) {
-                        ret.last_mut()
-                            .expect("already established that ret.last() is Some()")
-                            .aliases
-                            .push(type_alias_fqp);
+                        .map(|trait_| format!("{:#}", trait_.print(cx)));
+                    // render_impl will filter out "impossible-to-call" methods
+                    // to make that functionality work here, it needs to be called with
+                    // each type alias, and if it gives a different result, split the impl
+                    for &(type_alias_fqp, ref type_alias_item) in type_aliases {
+                        let mut buf = Buffer::html();
+                        cx.id_map = Default::default();
+                        cx.deref_id_map = Default::default();
+                        let target_did = impl_
+                            .inner_impl()
+                            .trait_
+                            .as_ref()
+                            .map(|trait_| trait_.def_id())
+                            .or_else(|| impl_.inner_impl().for_.def_id(cache));
+                        let provided_methods;
+                        let assoc_link = if let Some(target_did) = target_did {
+                            provided_methods = impl_.inner_impl().provided_trait_methods(cx.tcx());
+                            AssocItemLink::GotoSource(ItemId::DefId(target_did), &provided_methods)
+                        } else {
+                            AssocItemLink::Anchor(None)
+                        };
+                        super::render_impl(
+                            &mut buf,
+                            cx,
+                            *impl_,
+                            &type_alias_item,
+                            assoc_link,
+                            RenderMode::Normal,
+                            None,
+                            &[],
+                            ImplRenderingParameters {
+                                show_def_docs: true,
+                                show_default_items: true,
+                                show_non_assoc_items: true,
+                                toggle_open_by_default: true,
+                            },
+                        );
+                        let text = buf.into_inner();
+                        let type_alias_fqp = (*type_alias_fqp).iter().join("::");
+                        if Some(&text) == ret.last().map(|s: &AliasSerializableImpl| &s.text) {
+                            ret.last_mut()
+                                .expect("already established that ret.last() is Some()")
+                                .aliases
+                                .push(type_alias_fqp);
+                        } else {
+                            ret.push(AliasSerializableImpl {
+                                text,
+                                trait_: trait_.clone(),
+                                aliases: vec![type_alias_fqp],
+                            })
+                        }
+                    }
+                    ret
+                })
+                .collect::<Vec<_>>();
+
+            let mut path = PathBuf::from("type.impl");
+            for component in &aliased_type.target_fqp[..aliased_type.target_fqp.len() - 1] {
+                path.push(component.as_str());
+            }
+            let aliased_item_type = aliased_type.target_type;
+            path.push(&format!(
+                "{aliased_item_type}.{}.js",
+                aliased_type.target_fqp[aliased_type.target_fqp.len() - 1]
+            ));
+
+            let part =
+                SortedJson::array(impls.iter().map(SortedJson::serialize).collect::<Vec<_>>());
+            path_parts.push(path, SortedJson::array_unsorted([crate_name_json, &part]));
+        }
+        Ok(path_parts)
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Default, Debug)]
+struct TraitAlias;
+type TraitAliasPart = Part<TraitAlias, SortedJson>;
+impl CciPart for TraitAliasPart {
+    type FileFormat = sorted_template::Js;
+}
+
+impl TraitAliasPart {
+    fn blank() -> SortedTemplate<<Self as CciPart>::FileFormat> {
+        SortedTemplate::before_after(
+            r"(function() {
+    var implementors = Object.fromEntries([",
+            r"]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()",
+        )
+    }
+
+    fn get(
+        cx: &mut Context<'_>,
+        crate_name_json: &SortedJson,
+    ) -> Result<PartsAndLocations<Self>, Error> {
+        let cache = &cx.shared.cache;
+        let mut path_parts = PartsAndLocations::default();
+        // Update the list of all implementors for traits
+        // <https://github.com/search?q=repo%3Arust-lang%2Frust+[RUSTDOCIMPL]+trait.impl&type=code>
+        for (&did, imps) in &cache.implementors {
+            // Private modules can leak through to this phase of rustdoc, which
+            // could contain implementations for otherwise private types. In some
+            // rare cases we could find an implementation for an item which wasn't
+            // indexed, so we just skip this step in that case.
+            //
+            // FIXME: this is a vague explanation for why this can't be a `get`, in
+            //        theory it should be...
+            let (remote_path, remote_item_type) = match cache.exact_paths.get(&did) {
+                Some(p) => match cache.paths.get(&did).or_else(|| cache.external_paths.get(&did)) {
+                    Some((_, t)) => (p, t),
+                    None => continue,
+                },
+                None => match cache.external_paths.get(&did) {
+                    Some((p, t)) => (p, t),
+                    None => continue,
+                },
+            };
+
+            let implementors = imps
+                .iter()
+                .filter_map(|imp| {
+                    // If the trait and implementation are in the same crate, then
+                    // there's no need to emit information about it (there's inlining
+                    // going on). If they're in different crates then the crate defining
+                    // the trait will be interested in our implementation.
+                    //
+                    // If the implementation is from another crate then that crate
+                    // should add it.
+                    if imp.impl_item.item_id.krate() == did.krate
+                        || !imp.impl_item.item_id.is_local()
+                    {
+                        None
                     } else {
-                        ret.push(AliasSerializableImpl {
-                            text,
-                            trait_: trait_.clone(),
-                            aliases: vec![type_alias_fqp],
+                        Some(Implementor {
+                            text: imp.inner_impl().print(false, cx).to_string(),
+                            synthetic: imp.inner_impl().kind.is_auto(),
+                            types: collect_paths_for_type(imp.inner_impl().for_.clone(), cache),
                         })
                     }
-                }
-                ret
-            })
-            .collect::<Vec<_>>();
+                })
+                .collect::<Vec<_>>();
 
-        // FIXME: this fixes only rustdoc part of instability of trait impls
-        // for js files, see #120371
-        // Manually collect to string and sort to make list not depend on order
-        let mut impls = impls
-            .iter()
-            .map(|i| serde_json::to_string(i).expect("failed serde conversion"))
-            .collect::<Vec<_>>();
-        impls.sort();
+            // Only create a js file if we have impls to add to it. If the trait is
+            // documented locally though we always create the file to avoid dead
+            // links.
+            if implementors.is_empty() && !cache.paths.contains_key(&did) {
+                continue;
+            }
 
-        let impls = format!(r#""{}":[{}]"#, krate.name(cx.tcx()), impls.join(","));
+            let mut path = PathBuf::from("trait.impl");
+            for component in &remote_path[..remote_path.len() - 1] {
+                path.push(component.as_str());
+            }
+            path.push(&format!("{remote_item_type}.{}.js", remote_path[remote_path.len() - 1]));
 
-        let mut mydst = dst.clone();
-        for part in &aliased_type.target_fqp[..aliased_type.target_fqp.len() - 1] {
-            mydst.push(part.to_string());
+            let part = SortedJson::array(
+                implementors.iter().map(SortedJson::serialize).collect::<Vec<_>>(),
+            );
+            path_parts.push(path, SortedJson::array_unsorted([crate_name_json, &part]));
         }
-        cx.shared.ensure_dir(&mydst)?;
-        let aliased_item_type = aliased_type.target_type;
-        mydst.push(&format!(
-            "{aliased_item_type}.{}.js",
-            aliased_type.target_fqp[aliased_type.target_fqp.len() - 1]
-        ));
-
-        let (mut all_impls, _) = try_err!(collect(&mydst, krate.name(cx.tcx()).as_str()), &mydst);
-        all_impls.push(impls);
-        // Sort the implementors by crate so the file will be generated
-        // identically even with rustdoc running in parallel.
-        all_impls.sort();
-
-        let mut v = String::from("(function() {var type_impls = {\n");
-        v.push_str(&all_impls.join(",\n"));
-        v.push_str("\n};");
-        v.push_str(
-            "if (window.register_type_impls) {\
-                 window.register_type_impls(type_impls);\
-             } else {\
-                 window.pending_type_impls = type_impls;\
-             }",
-        );
-        v.push_str("})()");
-        cx.shared.fs.write(mydst, v)?;
-    }
-
-    // Update the list of all implementors for traits
-    // <https://github.com/search?q=repo%3Arust-lang%2Frust+[RUSTDOCIMPL]+trait.impl&type=code>
-    let dst = cx.dst.join("trait.impl");
-    for (&did, imps) in &cache.implementors {
-        // Private modules can leak through to this phase of rustdoc, which
-        // could contain implementations for otherwise private types. In some
-        // rare cases we could find an implementation for an item which wasn't
-        // indexed, so we just skip this step in that case.
-        //
-        // FIXME: this is a vague explanation for why this can't be a `get`, in
-        //        theory it should be...
-        let (remote_path, remote_item_type) = match cache.exact_paths.get(&did) {
-            Some(p) => match cache.paths.get(&did).or_else(|| cache.external_paths.get(&did)) {
-                Some((_, t)) => (p, t),
-                None => continue,
-            },
-            None => match cache.external_paths.get(&did) {
-                Some((p, t)) => (p, t),
-                None => continue,
-            },
-        };
+        Ok(path_parts)
+    }
+}
 
-        struct Implementor {
-            text: String,
-            synthetic: bool,
-            types: Vec<String>,
+struct Implementor {
+    text: String,
+    synthetic: bool,
+    types: Vec<String>,
+}
+
+impl Serialize for Implementor {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut seq = serializer.serialize_seq(None)?;
+        seq.serialize_element(&self.text)?;
+        if self.synthetic {
+            seq.serialize_element(&1)?;
+            seq.serialize_element(&self.types)?;
         }
+        seq.end()
+    }
+}
 
-        impl Serialize for Implementor {
-            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            where
-                S: Serializer,
-            {
-                let mut seq = serializer.serialize_seq(None)?;
-                seq.serialize_element(&self.text)?;
-                if self.synthetic {
-                    seq.serialize_element(&1)?;
-                    seq.serialize_element(&self.types)?;
-                }
-                seq.end()
+/// Collect the list of aliased types and their aliases.
+/// <https://github.com/search?q=repo%3Arust-lang%2Frust+[RUSTDOCIMPL]+type.impl&type=code>
+///
+/// The clean AST has type aliases that point at their types, but
+/// this visitor works to reverse that: `aliased_types` is a map
+/// from target to the aliases that reference it, and each one
+/// will generate one file.
+struct TypeImplCollector<'cx, 'cache> {
+    /// Map from DefId-of-aliased-type to its data.
+    aliased_types: IndexMap<DefId, AliasedType<'cache>>,
+    visited_aliases: FxHashSet<DefId>,
+    cache: &'cache Cache,
+    cx: &'cache mut Context<'cx>,
+}
+
+/// Data for an aliased type.
+///
+/// In the final file, the format will be roughly:
+///
+/// ```json
+/// // type.impl/CRATE/TYPENAME.js
+/// JSONP(
+/// "CRATE": [
+///   ["IMPL1 HTML", "ALIAS1", "ALIAS2", ...],
+///   ["IMPL2 HTML", "ALIAS3", "ALIAS4", ...],
+///    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ struct AliasedType
+///   ...
+/// ]
+/// )
+/// ```
+struct AliasedType<'cache> {
+    /// This is used to generate the actual filename of this aliased type.
+    target_fqp: &'cache [Symbol],
+    target_type: ItemType,
+    /// This is the data stored inside the file.
+    /// ItemId is used to deduplicate impls.
+    impl_: IndexMap<ItemId, AliasedTypeImpl<'cache>>,
+}
+
+/// The `impl_` contains data that's used to figure out if an alias will work,
+/// and to generate the HTML at the end.
+///
+/// The `type_aliases` list is built up with each type alias that matches.
+struct AliasedTypeImpl<'cache> {
+    impl_: &'cache Impl,
+    type_aliases: Vec<(&'cache [Symbol], Item)>,
+}
+
+impl<'cx, 'cache> DocVisitor for TypeImplCollector<'cx, 'cache> {
+    fn visit_item(&mut self, it: &Item) {
+        self.visit_item_recur(it);
+        let cache = self.cache;
+        let ItemKind::TypeAliasItem(ref t) = *it.kind else { return };
+        let Some(self_did) = it.item_id.as_def_id() else { return };
+        if !self.visited_aliases.insert(self_did) {
+            return;
+        }
+        let Some(target_did) = t.type_.def_id(cache) else { return };
+        let get_extern = { || cache.external_paths.get(&target_did) };
+        let Some(&(ref target_fqp, target_type)) = cache.paths.get(&target_did).or_else(get_extern)
+        else {
+            return;
+        };
+        let aliased_type = self.aliased_types.entry(target_did).or_insert_with(|| {
+            let impl_ = cache
+                .impls
+                .get(&target_did)
+                .map(|v| &v[..])
+                .unwrap_or_default()
+                .iter()
+                .map(|impl_| {
+                    (impl_.impl_item.item_id, AliasedTypeImpl { impl_, type_aliases: Vec::new() })
+                })
+                .collect();
+            AliasedType { target_fqp: &target_fqp[..], target_type, impl_ }
+        });
+        let get_local = { || cache.paths.get(&self_did).map(|(p, _)| p) };
+        let Some(self_fqp) = cache.exact_paths.get(&self_did).or_else(get_local) else {
+            return;
+        };
+        let aliased_ty = self.cx.tcx().type_of(self_did).skip_binder();
+        // Exclude impls that are directly on this type. They're already in the HTML.
+        // Some inlining scenarios can cause there to be two versions of the same
+        // impl: one on the type alias and one on the underlying target type.
+        let mut seen_impls: FxHashSet<ItemId> = cache
+            .impls
+            .get(&self_did)
+            .map(|s| &s[..])
+            .unwrap_or_default()
+            .iter()
+            .map(|i| i.impl_item.item_id)
+            .collect();
+        for (impl_item_id, aliased_type_impl) in &mut aliased_type.impl_ {
+            // Only include this impl if it actually unifies with this alias.
+            // Synthetic impls are not included; those are also included in the HTML.
+            //
+            // FIXME(lazy_type_alias): Once the feature is complete or stable, rewrite this
+            // to use type unification.
+            // Be aware of `tests/rustdoc/type-alias/deeply-nested-112515.rs` which might regress.
+            let Some(impl_did) = impl_item_id.as_def_id() else { continue };
+            let for_ty = self.cx.tcx().type_of(impl_did).skip_binder();
+            let reject_cx = DeepRejectCtxt::new(self.cx.tcx(), TreatParams::AsCandidateKey);
+            if !reject_cx.types_may_unify(aliased_ty, for_ty) {
+                continue;
+            }
+            // Avoid duplicates
+            if !seen_impls.insert(*impl_item_id) {
+                continue;
             }
+            // This impl was not found in the set of rejected impls
+            aliased_type_impl.type_aliases.push((&self_fqp[..], it.clone()));
         }
+    }
+}
 
-        let implementors = imps
-            .iter()
-            .filter_map(|imp| {
-                // If the trait and implementation are in the same crate, then
-                // there's no need to emit information about it (there's inlining
-                // going on). If they're in different crates then the crate defining
-                // the trait will be interested in our implementation.
-                //
-                // If the implementation is from another crate then that crate
-                // should add it.
-                if imp.impl_item.item_id.krate() == did.krate || !imp.impl_item.item_id.is_local() {
-                    None
-                } else {
-                    Some(Implementor {
-                        text: imp.inner_impl().print(false, cx).to_string(),
-                        synthetic: imp.inner_impl().kind.is_auto(),
-                        types: collect_paths_for_type(imp.inner_impl().for_.clone(), cache),
-                    })
-                }
-            })
-            .collect::<Vec<_>>();
+/// Final serialized form of the alias impl
+struct AliasSerializableImpl {
+    text: String,
+    trait_: Option<String>,
+    aliases: Vec<String>,
+}
 
-        // Only create a js file if we have impls to add to it. If the trait is
-        // documented locally though we always create the file to avoid dead
-        // links.
-        if implementors.is_empty() && !cache.paths.contains_key(&did) {
-            continue;
+impl Serialize for AliasSerializableImpl {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut seq = serializer.serialize_seq(None)?;
+        seq.serialize_element(&self.text)?;
+        if let Some(trait_) = &self.trait_ {
+            seq.serialize_element(trait_)?;
+        } else {
+            seq.serialize_element(&0)?;
+        }
+        for type_ in &self.aliases {
+            seq.serialize_element(type_)?;
         }
+        seq.end()
+    }
+}
 
-        // FIXME: this fixes only rustdoc part of instability of trait impls
-        // for js files, see #120371
-        // Manually collect to string and sort to make list not depend on order
-        let mut implementors = implementors
-            .iter()
-            .map(|i| serde_json::to_string(i).expect("failed serde conversion"))
-            .collect::<Vec<_>>();
-        implementors.sort();
+/// Create all parents
+fn create_parents(path: &Path) -> Result<(), Error> {
+    let parent = path.parent().expect("should not have an empty path here");
+    try_err!(fs::create_dir_all(parent), parent);
+    Ok(())
+}
 
-        let implementors = format!(r#""{}":[{}]"#, krate.name(cx.tcx()), implementors.join(","));
+/// Create parents and then write
+fn write_create_parents(path: &Path, content: String) -> Result<(), Error> {
+    create_parents(path)?;
+    try_err!(fs::write(path, content), path);
+    Ok(())
+}
 
-        let mut mydst = dst.clone();
-        for part in &remote_path[..remote_path.len() - 1] {
-            mydst.push(part.to_string());
+/// Returns a blank template unless we could find one to append to
+fn read_template_or_blank<F, T: CciPart>(
+    mut make_blank: F,
+    path: &Path,
+) -> Result<SortedTemplate<T::FileFormat>, Error>
+where
+    F: FnMut() -> SortedTemplate<T::FileFormat>,
+{
+    match fs::read_to_string(&path) {
+        Ok(template) => Ok(try_err!(SortedTemplate::from_str(&template), &path)),
+        Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(make_blank()),
+        Err(e) => Err(Error::new(e, &path)),
+    }
+}
+
+/// info from this crate and the --include-info-json'd crates
+fn write_rendered_cci<T: CciPart, F>(
+    mut make_blank: F,
+    dst: &Path,
+    crates_info: &[CrateInfo],
+) -> Result<(), Error>
+where
+    F: FnMut() -> SortedTemplate<T::FileFormat>,
+{
+    // read parts from disk
+    let path_parts =
+        crates_info.iter().map(|crate_info| crate_info.get::<T>().parts.iter()).flatten();
+    // read previous rendered cci from storage, append to them
+    let mut templates: FxHashMap<PathBuf, SortedTemplate<T::FileFormat>> = Default::default();
+    for (path, part) in path_parts {
+        let part = format!("{part}");
+        let path = dst.join(&path);
+        match templates.entry(path.clone()) {
+            Entry::Vacant(entry) => {
+                let template = read_template_or_blank::<_, T>(&mut make_blank, &path)?;
+                let template = entry.insert(template);
+                template.append(part);
+            }
+            Entry::Occupied(mut t) => t.get_mut().append(part),
         }
-        cx.shared.ensure_dir(&mydst)?;
-        mydst.push(&format!("{remote_item_type}.{}.js", remote_path[remote_path.len() - 1]));
-
-        let (mut all_implementors, _) =
-            try_err!(collect(&mydst, krate.name(cx.tcx()).as_str()), &mydst);
-        all_implementors.push(implementors);
-        // Sort the implementors by crate so the file will be generated
-        // identically even with rustdoc running in parallel.
-        all_implementors.sort();
-
-        let mut v = String::from("(function() {var implementors = {\n");
-        v.push_str(&all_implementors.join(",\n"));
-        v.push_str("\n};");
-        v.push_str(
-            "if (window.register_implementors) {\
-                 window.register_implementors(implementors);\
-             } else {\
-                 window.pending_implementors = implementors;\
-             }",
-        );
-        v.push_str("})()");
-        cx.shared.fs.write(mydst, v)?;
+    }
+
+    // write the merged cci to disk
+    for (path, template) in templates {
+        create_parents(&path)?;
+        let file = try_err!(File::create(&path), &path);
+        let mut file = BufWriter::new(file);
+        try_err!(write!(file, "{template}"), &path);
+        try_err!(file.flush(), &path);
     }
     Ok(())
 }

From f1a996c39b4accf958cb02028e9b8e5d4e3d796d Mon Sep 17 00:00:00 2001
From: EtomicBomb <ethan@ethan.ws>
Date: Thu, 25 Jul 2024 00:05:32 +0000
Subject: [PATCH 065/685] add blank line, remove extraneous comment

---
 src/librustdoc/config.rs              | 1 +
 src/librustdoc/html/render/context.rs | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index 2e54a22840bb5..e4549796b3e83 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -730,6 +730,7 @@ impl Options {
         let extern_html_root_takes_precedence =
             matches.opt_present("extern-html-root-takes-precedence");
         let html_no_source = matches.opt_present("html-no-source");
+
         if generate_link_to_definition && (show_coverage || output_format != OutputFormat::Html) {
             dcx.fatal(
                 "--generate-link-to-definition option can only be used with HTML output format",
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index 8e72dd6a864ae..0ed8921b1e8d7 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -722,7 +722,6 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
         );
         shared.fs.write(help_file, v)?;
 
-        // if to avoid writing files to doc root unless we're on the final invocation
         if shared.layout.scrape_examples_extension {
             page.title = "About scraped examples";
             page.description = "How the scraped examples feature works in Rustdoc";

From 17c89239d92eca1e4e22ff6ba9d1be0f2f7b36fc Mon Sep 17 00:00:00 2001
From: EtomicBomb <ethan@ethan.ws>
Date: Wed, 24 Jul 2024 23:36:49 +0000
Subject: [PATCH 066/685] move sorted_template and sorted_json tests

---
 src/librustdoc/clean/types.rs                 |   2 +-
 .../html/render/sorted_json/tests.rs          | 119 ++++++++
 src/librustdoc/html/render/sorted_template.rs |   3 +
 .../html/render/sorted_template/tests.rs      | 148 ++++++++++
 src/librustdoc/html/render/tests.rs           | 271 ------------------
 5 files changed, 271 insertions(+), 272 deletions(-)
 create mode 100644 src/librustdoc/html/render/sorted_json/tests.rs
 create mode 100644 src/librustdoc/html/render/sorted_template/tests.rs

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 542e810b5cfa8..4850500a1bfae 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -128,7 +128,7 @@ pub(crate) struct ExternalCrate {
 }
 
 impl ExternalCrate {
-    pub(crate) const LOCAL: Self = Self { crate_num: LOCAL_CRATE };
+    const LOCAL: Self = Self { crate_num: LOCAL_CRATE };
 
     #[inline]
     pub(crate) fn def_id(&self) -> DefId {
diff --git a/src/librustdoc/html/render/sorted_json/tests.rs b/src/librustdoc/html/render/sorted_json/tests.rs
new file mode 100644
index 0000000000000..1e72c6f614c38
--- /dev/null
+++ b/src/librustdoc/html/render/sorted_json/tests.rs
@@ -0,0 +1,119 @@
+use super::super::sorted_json::*;
+
+fn check(json: SortedJson, serialized: &str) {
+    assert_eq!(json.to_string(), serialized);
+    assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
+
+    let json = json.to_string();
+    let json: SortedJson = serde_json::from_str(&json).unwrap();
+
+    assert_eq!(json.to_string(), serialized);
+    assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
+
+    let json = serde_json::to_string(&json).unwrap();
+    let json: SortedJson = serde_json::from_str(&json).unwrap();
+
+    assert_eq!(json.to_string(), serialized);
+    assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
+}
+
+// Test this basic are needed because we are testing that our Display impl + serialize impl don't
+// nest everything in extra level of string. We also are testing round trip.
+#[test]
+fn escape_json_number() {
+    let json = SortedJson::serialize(3);
+    let json = EscapedJson::from(json);
+    assert_eq!(format!("{json}"), "3");
+}
+
+#[test]
+fn escape_json_single_quote() {
+    let json = SortedJson::serialize("he's");
+    let json = EscapedJson::from(json);
+    assert_eq!(format!("{json}"), r#""he\'s""#);
+}
+
+#[test]
+fn escape_json_array() {
+    let json = SortedJson::serialize([1, 2, 3]);
+    let json = EscapedJson::from(json);
+    assert_eq!(format!("{json}"), r#"[1,2,3]"#);
+}
+
+#[test]
+fn escape_json_string() {
+    let json = SortedJson::serialize(r#"he"llo"#);
+    let json = EscapedJson::from(json);
+    assert_eq!(format!("{json}"), r#""he\\\"llo""#);
+}
+
+#[test]
+fn escape_json_string_escaped() {
+    let json = SortedJson::serialize(r#"he\"llo"#);
+    let json = EscapedJson::from(json);
+    assert_eq!(format!("{json}"), r#""he\\\\\\\"llo""#);
+}
+
+#[test]
+fn escape_json_string_escaped_escaped() {
+    let json = SortedJson::serialize(r#"he\\"llo"#);
+    let json = EscapedJson::from(json);
+    assert_eq!(format!("{json}"), r#""he\\\\\\\\\\\"llo""#);
+}
+
+#[test]
+fn number() {
+    let json = SortedJson::serialize(3);
+    let serialized = "3";
+    check(json, serialized);
+}
+
+#[test]
+fn boolean() {
+    let json = SortedJson::serialize(true);
+    let serialized = "true";
+    check(json, serialized);
+}
+
+#[test]
+fn string() {
+    let json = SortedJson::serialize("he\"llo");
+    let serialized = r#""he\"llo""#;
+    check(json, serialized);
+}
+
+#[test]
+fn serialize_array() {
+    let json = SortedJson::serialize([3, 1, 2]);
+    let serialized = "[3,1,2]";
+    check(json, serialized);
+}
+
+#[test]
+fn sorted_array() {
+    let items = ["c", "a", "b"];
+    let serialized = r#"["a","b","c"]"#;
+    let items: Vec<SortedJson> = items.into_iter().map(SortedJson::serialize).collect();
+    let json = SortedJson::array(items);
+    check(json, serialized);
+}
+
+#[test]
+fn nested_array() {
+    let a = SortedJson::serialize(3);
+    let b = SortedJson::serialize(2);
+    let c = SortedJson::serialize(1);
+    let d = SortedJson::serialize([1, 3, 2]);
+    let json = SortedJson::array([a, b, c, d]);
+    let serialized = r#"[1,2,3,[1,3,2]]"#;
+    check(json, serialized);
+}
+
+#[test]
+fn array_unsorted() {
+    let items = ["c", "a", "b"];
+    let serialized = r#"["c","a","b"]"#;
+    let items: Vec<SortedJson> = items.into_iter().map(SortedJson::serialize).collect();
+    let json = SortedJson::array_unsorted(items);
+    check(json, serialized);
+}
diff --git a/src/librustdoc/html/render/sorted_template.rs b/src/librustdoc/html/render/sorted_template.rs
index 95240616b01dc..8e0a2ee0fd4d9 100644
--- a/src/librustdoc/html/render/sorted_template.rs
+++ b/src/librustdoc/html/render/sorted_template.rs
@@ -134,3 +134,6 @@ impl fmt::Display for Error {
         write!(f, "invalid template")
     }
 }
+
+#[cfg(test)]
+mod tests;
diff --git a/src/librustdoc/html/render/sorted_template/tests.rs b/src/librustdoc/html/render/sorted_template/tests.rs
new file mode 100644
index 0000000000000..04553f65a2154
--- /dev/null
+++ b/src/librustdoc/html/render/sorted_template/tests.rs
@@ -0,0 +1,148 @@
+use super::super::sorted_template::*;
+use std::str::FromStr;
+
+fn is_comment_js(s: &str) -> bool {
+    s.starts_with("//")
+}
+
+fn is_comment_html(s: &str) -> bool {
+    // not correct but good enough for these tests
+    s.starts_with("<!--") && s.ends_with("-->")
+}
+
+#[test]
+fn html_from_empty() {
+    let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>hello</p>", "<p>world</p>"];
+    let mut template = SortedTemplate::<Html>::before_after("", "");
+    for insert in inserts {
+        template.append(insert.to_string());
+    }
+    let template = format!("{template}");
+    let (template, end) = template.rsplit_once("\n").unwrap();
+    assert_eq!(template, "<p>hello</p><p>kind</p><p>world</p>");
+    assert!(is_comment_html(end));
+    assert!(!end.contains("\n"));
+}
+
+#[test]
+fn html_page() {
+    let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>world</p>"];
+    let before = "<html><head></head><body>";
+    let after = "</body>";
+    let mut template = SortedTemplate::<Html>::before_after(before, after);
+    for insert in inserts {
+        template.append(insert.to_string());
+    }
+    let template = format!("{template}");
+    let (template, end) = template.rsplit_once("\n").unwrap();
+    assert_eq!(template, format!("{before}{}{after}", inserts.join("")));
+    assert!(is_comment_html(end));
+    assert!(!end.contains("\n"));
+}
+
+#[test]
+fn js_from_empty() {
+    let inserts = ["1", "2", "2", "2", "3", "1"];
+    let mut template = SortedTemplate::<Js>::before_after("", "");
+    for insert in inserts {
+        template.append(insert.to_string());
+    }
+    let template = format!("{template}");
+    let (template, end) = template.rsplit_once("\n").unwrap();
+    assert_eq!(template, "1,2,3");
+    assert!(is_comment_js(end));
+    assert!(!end.contains("\n"));
+}
+
+#[test]
+fn js_empty_array() {
+    let template = SortedTemplate::<Js>::before_after("[", "]");
+    let template = format!("{template}");
+    let (template, end) = template.rsplit_once("\n").unwrap();
+    assert_eq!(template, format!("[]"));
+    assert!(is_comment_js(end));
+    assert!(!end.contains("\n"));
+}
+
+#[test]
+fn js_number_array() {
+    let inserts = ["1", "2", "3"];
+    let mut template = SortedTemplate::<Js>::before_after("[", "]");
+    for insert in inserts {
+        template.append(insert.to_string());
+    }
+    let template = format!("{template}");
+    let (template, end) = template.rsplit_once("\n").unwrap();
+    assert_eq!(template, format!("[1,2,3]"));
+    assert!(is_comment_js(end));
+    assert!(!end.contains("\n"));
+}
+
+#[test]
+fn magic_js_number_array() {
+    let inserts = ["1", "1"];
+    let mut template = SortedTemplate::<Js>::magic("[#]", "#").unwrap();
+    for insert in inserts {
+        template.append(insert.to_string());
+    }
+    let template = format!("{template}");
+    let (template, end) = template.rsplit_once("\n").unwrap();
+    assert_eq!(template, format!("[1]"));
+    assert!(is_comment_js(end));
+    assert!(!end.contains("\n"));
+}
+
+#[test]
+fn round_trip_js() {
+    let inserts = ["1", "2", "3"];
+    let mut template = SortedTemplate::<Js>::before_after("[", "]");
+    for insert in inserts {
+        template.append(insert.to_string());
+    }
+    let template1 = format!("{template}");
+    let mut template = SortedTemplate::<Js>::from_str(&template1).unwrap();
+    assert_eq!(template1, format!("{template}"));
+    template.append("4".to_string());
+    let template = format!("{template}");
+    let (template, end) = template.rsplit_once("\n").unwrap();
+    assert_eq!(template, "[1,2,3,4]");
+    assert!(is_comment_js(end));
+}
+
+#[test]
+fn round_trip_html() {
+    let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>world</p>", "<p>kind</p>"];
+    let before = "<html><head></head><body>";
+    let after = "</body>";
+    let mut template = SortedTemplate::<Html>::before_after(before, after);
+    template.append(inserts[0].to_string());
+    template.append(inserts[1].to_string());
+    let template = format!("{template}");
+    let mut template = SortedTemplate::<Html>::from_str(&template).unwrap();
+    template.append(inserts[2].to_string());
+    let template = format!("{template}");
+    let (template, end) = template.rsplit_once("\n").unwrap();
+    assert_eq!(template, format!("{before}<p>hello</p><p>kind</p><p>world</p>{after}"));
+    assert!(is_comment_html(end));
+}
+
+#[test]
+fn blank_js() {
+    let inserts = ["1", "2", "3"];
+    let template = SortedTemplate::<Js>::before_after("", "");
+    let template = format!("{template}");
+    let (t, _) = template.rsplit_once("\n").unwrap();
+    assert_eq!(t, "");
+    let mut template = SortedTemplate::<Js>::from_str(&template).unwrap();
+    for insert in inserts {
+        template.append(insert.to_string());
+    }
+    let template1 = format!("{template}");
+    let mut template = SortedTemplate::<Js>::from_str(&template1).unwrap();
+    assert_eq!(template1, format!("{template}"));
+    template.append("4".to_string());
+    let template = format!("{template}");
+    let (template, end) = template.rsplit_once("\n").unwrap();
+    assert_eq!(template, "1,2,3,4");
+    assert!(is_comment_js(end));
+}
diff --git a/src/librustdoc/html/render/tests.rs b/src/librustdoc/html/render/tests.rs
index 16e67b0f1180e..4a9724a6f840f 100644
--- a/src/librustdoc/html/render/tests.rs
+++ b/src/librustdoc/html/render/tests.rs
@@ -52,274 +52,3 @@ fn test_all_types_prints_header_once() {
 
     assert_eq!(1, buffer.into_inner().matches("List of all items").count());
 }
-
-mod sorted_json {
-    use super::super::sorted_json::*;
-
-    fn check(json: SortedJson, serialized: &str) {
-        assert_eq!(json.to_string(), serialized);
-        assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
-
-        let json = json.to_string();
-        let json: SortedJson = serde_json::from_str(&json).unwrap();
-
-        assert_eq!(json.to_string(), serialized);
-        assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
-
-        let json = serde_json::to_string(&json).unwrap();
-        let json: SortedJson = serde_json::from_str(&json).unwrap();
-
-        assert_eq!(json.to_string(), serialized);
-        assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
-    }
-
-    #[test]
-    fn escape_json_number() {
-        let json = SortedJson::serialize(3);
-        let json = EscapedJson::from(json);
-        assert_eq!(format!("{json}"), "3");
-    }
-
-    #[test]
-    fn escape_json_single_quote() {
-        let json = SortedJson::serialize("he's");
-        let json = EscapedJson::from(json);
-        assert_eq!(format!("{json}"), r#""he\'s""#);
-    }
-
-    #[test]
-    fn escape_json_array() {
-        let json = SortedJson::serialize([1, 2, 3]);
-        let json = EscapedJson::from(json);
-        assert_eq!(format!("{json}"), r#"[1,2,3]"#);
-    }
-
-    #[test]
-    fn escape_json_string() {
-        let json = SortedJson::serialize(r#"he"llo"#);
-        let json = EscapedJson::from(json);
-        assert_eq!(format!("{json}"), r#""he\\\"llo""#);
-    }
-
-    #[test]
-    fn escape_json_string_escaped() {
-        let json = SortedJson::serialize(r#"he\"llo"#);
-        let json = EscapedJson::from(json);
-        assert_eq!(format!("{json}"), r#""he\\\\\\\"llo""#);
-    }
-
-    #[test]
-    fn escape_json_string_escaped_escaped() {
-        let json = SortedJson::serialize(r#"he\\"llo"#);
-        let json = EscapedJson::from(json);
-        assert_eq!(format!("{json}"), r#""he\\\\\\\\\\\"llo""#);
-    }
-
-    #[test]
-    fn number() {
-        let json = SortedJson::serialize(3);
-        let serialized = "3";
-        check(json, serialized);
-    }
-
-    #[test]
-    fn boolean() {
-        let json = SortedJson::serialize(true);
-        let serialized = "true";
-        check(json, serialized);
-    }
-
-    #[test]
-    fn string() {
-        let json = SortedJson::serialize("he\"llo");
-        let serialized = r#""he\"llo""#;
-        check(json, serialized);
-    }
-
-    #[test]
-    fn serialize_array() {
-        let json = SortedJson::serialize([3, 1, 2]);
-        let serialized = "[3,1,2]";
-        check(json, serialized);
-    }
-
-    #[test]
-    fn sorted_array() {
-        let items = ["c", "a", "b"];
-        let serialized = r#"["a","b","c"]"#;
-        let items: Vec<SortedJson> = items.into_iter().map(SortedJson::serialize).collect();
-        let json = SortedJson::array(items);
-        check(json, serialized);
-    }
-
-    #[test]
-    fn nested_array() {
-        let a = SortedJson::serialize(3);
-        let b = SortedJson::serialize(2);
-        let c = SortedJson::serialize(1);
-        let d = SortedJson::serialize([1, 3, 2]);
-        let json = SortedJson::array([a, b, c, d]);
-        let serialized = r#"[1,2,3,[1,3,2]]"#;
-        check(json, serialized);
-    }
-
-    #[test]
-    fn array_unsorted() {
-        let items = ["c", "a", "b"];
-        let serialized = r#"["c","a","b"]"#;
-        let items: Vec<SortedJson> = items.into_iter().map(SortedJson::serialize).collect();
-        let json = SortedJson::array_unsorted(items);
-        check(json, serialized);
-    }
-}
-
-mod sorted_template {
-    use super::super::sorted_template::*;
-    use std::str::FromStr;
-
-    fn is_comment_js(s: &str) -> bool {
-        s.starts_with("//")
-    }
-
-    fn is_comment_html(s: &str) -> bool {
-        // not correct but good enough for these tests
-        s.starts_with("<!--") && s.ends_with("-->")
-    }
-
-    #[test]
-    fn html_from_empty() {
-        let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>hello</p>", "<p>world</p>"];
-        let mut template = SortedTemplate::<Html>::before_after("", "");
-        for insert in inserts {
-            template.append(insert.to_string());
-        }
-        let template = format!("{template}");
-        let (template, end) = template.rsplit_once("\n").unwrap();
-        assert_eq!(template, "<p>hello</p><p>kind</p><p>world</p>");
-        assert!(is_comment_html(end));
-        assert!(!end.contains("\n"));
-    }
-
-    #[test]
-    fn html_page() {
-        let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>world</p>"];
-        let before = "<html><head></head><body>";
-        let after = "</body>";
-        let mut template = SortedTemplate::<Html>::before_after(before, after);
-        for insert in inserts {
-            template.append(insert.to_string());
-        }
-        let template = format!("{template}");
-        let (template, end) = template.rsplit_once("\n").unwrap();
-        assert_eq!(template, format!("{before}{}{after}", inserts.join("")));
-        assert!(is_comment_html(end));
-        assert!(!end.contains("\n"));
-    }
-
-    #[test]
-    fn js_from_empty() {
-        let inserts = ["1", "2", "2", "2", "3", "1"];
-        let mut template = SortedTemplate::<Js>::before_after("", "");
-        for insert in inserts {
-            template.append(insert.to_string());
-        }
-        let template = format!("{template}");
-        let (template, end) = template.rsplit_once("\n").unwrap();
-        assert_eq!(template, "1,2,3");
-        assert!(is_comment_js(end));
-        assert!(!end.contains("\n"));
-    }
-
-    #[test]
-    fn js_empty_array() {
-        let template = SortedTemplate::<Js>::before_after("[", "]");
-        let template = format!("{template}");
-        let (template, end) = template.rsplit_once("\n").unwrap();
-        assert_eq!(template, format!("[]"));
-        assert!(is_comment_js(end));
-        assert!(!end.contains("\n"));
-    }
-
-    #[test]
-    fn js_number_array() {
-        let inserts = ["1", "2", "3"];
-        let mut template = SortedTemplate::<Js>::before_after("[", "]");
-        for insert in inserts {
-            template.append(insert.to_string());
-        }
-        let template = format!("{template}");
-        let (template, end) = template.rsplit_once("\n").unwrap();
-        assert_eq!(template, format!("[1,2,3]"));
-        assert!(is_comment_js(end));
-        assert!(!end.contains("\n"));
-    }
-
-    #[test]
-    fn magic_js_number_array() {
-        let inserts = ["1", "1"];
-        let mut template = SortedTemplate::<Js>::magic("[#]", "#").unwrap();
-        for insert in inserts {
-            template.append(insert.to_string());
-        }
-        let template = format!("{template}");
-        let (template, end) = template.rsplit_once("\n").unwrap();
-        assert_eq!(template, format!("[1]"));
-        assert!(is_comment_js(end));
-        assert!(!end.contains("\n"));
-    }
-
-    #[test]
-    fn round_trip_js() {
-        let inserts = ["1", "2", "3"];
-        let mut template = SortedTemplate::<Js>::before_after("[", "]");
-        for insert in inserts {
-            template.append(insert.to_string());
-        }
-        let template1 = format!("{template}");
-        let mut template = SortedTemplate::<Js>::from_str(&template1).unwrap();
-        assert_eq!(template1, format!("{template}"));
-        template.append("4".to_string());
-        let template = format!("{template}");
-        let (template, end) = template.rsplit_once("\n").unwrap();
-        assert_eq!(template, "[1,2,3,4]");
-        assert!(is_comment_js(end));
-    }
-
-    #[test]
-    fn round_trip_html() {
-        let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>world</p>", "<p>kind</p>"];
-        let before = "<html><head></head><body>";
-        let after = "</body>";
-        let mut template = SortedTemplate::<Html>::before_after(before, after);
-        template.append(inserts[0].to_string());
-        template.append(inserts[1].to_string());
-        let template = format!("{template}");
-        let mut template = SortedTemplate::<Html>::from_str(&template).unwrap();
-        template.append(inserts[2].to_string());
-        let template = format!("{template}");
-        let (template, end) = template.rsplit_once("\n").unwrap();
-        assert_eq!(template, format!("{before}<p>hello</p><p>kind</p><p>world</p>{after}"));
-        assert!(is_comment_html(end));
-    }
-
-    #[test]
-    fn blank_js() {
-        let inserts = ["1", "2", "3"];
-        let template = SortedTemplate::<Js>::before_after("", "");
-        let template = format!("{template}");
-        let (t, _) = template.rsplit_once("\n").unwrap();
-        assert_eq!(t, "");
-        let mut template = SortedTemplate::<Js>::from_str(&template).unwrap();
-        for insert in inserts {
-            template.append(insert.to_string());
-        }
-        let template1 = format!("{template}");
-        let mut template = SortedTemplate::<Js>::from_str(&template1).unwrap();
-        assert_eq!(template1, format!("{template}"));
-        template.append("4".to_string());
-        let template = format!("{template}");
-        let (template, end) = template.rsplit_once("\n").unwrap();
-        assert_eq!(template, "1,2,3,4");
-        assert!(is_comment_js(end));
-    }
-}

From 67663fc680428cf22267f974106d2805008a8568 Mon Sep 17 00:00:00 2001
From: EtomicBomb <ethan@ethan.ws>
Date: Thu, 25 Jul 2024 15:27:29 +0000
Subject: [PATCH 067/685] added unit tests for write_shared

---
 src/librustdoc/html/render/sorted_json.rs     |   3 +
 src/librustdoc/html/render/write_shared.rs    |  99 ++++-----
 .../html/render/write_shared/tests.rs         | 206 ++++++++++++++++++
 3 files changed, 257 insertions(+), 51 deletions(-)
 create mode 100644 src/librustdoc/html/render/write_shared/tests.rs

diff --git a/src/librustdoc/html/render/sorted_json.rs b/src/librustdoc/html/render/sorted_json.rs
index 3a097733b8b20..e937382f5b0a6 100644
--- a/src/librustdoc/html/render/sorted_json.rs
+++ b/src/librustdoc/html/render/sorted_json.rs
@@ -80,3 +80,6 @@ impl fmt::Display for EscapedJson {
         write!(f, "{}", json)
     }
 }
+
+#[cfg(test)]
+mod tests;
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index eaebeadd8817e..c2d2b4cd7d9fb 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -15,7 +15,6 @@
 
 use std::any::Any;
 use std::cell::RefCell;
-use std::collections::hash_map::Entry;
 use std::ffi::OsString;
 use std::fs::File;
 use std::io::BufWriter;
@@ -52,7 +51,7 @@ use crate::html::layout;
 use crate::html::render::search_index::build_index;
 use crate::html::render::search_index::SerializedSearchIndex;
 use crate::html::render::sorted_json::{EscapedJson, SortedJson};
-use crate::html::render::sorted_template::{self, SortedTemplate};
+use crate::html::render::sorted_template::{self, FileFormat, SortedTemplate};
 use crate::html::render::{AssocItemLink, ImplRenderingParameters};
 use crate::html::static_files::{self, suffix_path};
 use crate::visit::DocVisitor;
@@ -78,33 +77,29 @@ pub(crate) fn write_shared(
     let crate_name = krate.name(cx.tcx());
     let crate_name = crate_name.as_str(); // rand
     let crate_name_json = SortedJson::serialize(crate_name); // "rand"
-    let external_crates = hack_get_external_crate_names(cx)?;
+    let external_crates = hack_get_external_crate_names(&cx.dst)?;
     let info = CrateInfo {
         src_files_js: SourcesPart::get(cx, &crate_name_json)?,
-        search_index_js: SearchIndexPart::get(cx, index)?,
+        search_index_js: SearchIndexPart::get(index, &cx.shared.resource_suffix)?,
         all_crates: AllCratesPart::get(crate_name_json.clone())?,
         crates_index: CratesIndexPart::get(&crate_name, &external_crates)?,
         trait_impl: TraitAliasPart::get(cx, &crate_name_json)?,
         type_impl: TypeAliasPart::get(cx, krate, &crate_name_json)?,
     };
 
-    let crates_info = vec![info]; // we have info from just one crate
+    let crates = vec![info]; // we have info from just one crate. rest will found in out dir
 
     write_static_files(cx, &opt)?;
     let dst = &cx.dst;
     if opt.emit.is_empty() || opt.emit.contains(&EmitType::InvocationSpecific) {
         if cx.include_sources {
-            write_rendered_cci::<SourcesPart, _>(SourcesPart::blank, dst, &crates_info)?;
+            write_rendered_cci::<SourcesPart, _>(SourcesPart::blank, dst, &crates)?;
         }
-        write_rendered_cci::<SearchIndexPart, _>(
-            SearchIndexPart::blank,
-            dst,
-            &crates_info,
-        )?;
-        write_rendered_cci::<AllCratesPart, _>(AllCratesPart::blank, dst, &crates_info)?;
-    }
-    write_rendered_cci::<TraitAliasPart, _>(TraitAliasPart::blank, dst, &crates_info)?;
-    write_rendered_cci::<TypeAliasPart, _>(TypeAliasPart::blank, dst, &crates_info)?;
+        write_rendered_cci::<SearchIndexPart, _>(SearchIndexPart::blank, dst, &crates)?;
+        write_rendered_cci::<AllCratesPart, _>(AllCratesPart::blank, dst, &crates)?;
+    }
+    write_rendered_cci::<TraitAliasPart, _>(TraitAliasPart::blank, dst, &crates)?;
+    write_rendered_cci::<TypeAliasPart, _>(TypeAliasPart::blank, dst, &crates)?;
     match &opt.index_page {
         Some(index_page) if opt.enable_index_page => {
             let mut md_opts = opt.clone();
@@ -119,7 +114,7 @@ pub(crate) fn write_shared(
             write_rendered_cci::<CratesIndexPart, _>(
                 || CratesIndexPart::blank(cx),
                 dst,
-                &crates_info,
+                &crates,
             )?;
         }
         _ => {} // they don't want an index page
@@ -189,7 +184,8 @@ fn write_search_desc(
         let path = path.join(filename);
         let part = SortedJson::serialize(&part);
         let part = format!("searchState.loadedDescShard({encoded_crate_name}, {i}, {part})");
-        write_create_parents(&path, part)?;
+        create_parents(&path)?;
+        try_err!(fs::write(&path, part), &path);
     }
     Ok(())
 }
@@ -286,8 +282,11 @@ else if (window.initSearch) window.initSearch(searchIndex);",
         )
     }
 
-    fn get(cx: &Context<'_>, search_index: SortedJson) -> Result<PartsAndLocations<Self>, Error> {
-        let path = suffix_path("search-index.js", &cx.shared.resource_suffix);
+    fn get(
+        search_index: SortedJson,
+        resource_suffix: &str,
+    ) -> Result<PartsAndLocations<Self>, Error> {
+        let path = suffix_path("search-index.js", resource_suffix);
         let search_index = EscapedJson::from(search_index);
         Ok(PartsAndLocations::with(path, search_index))
     }
@@ -319,8 +318,8 @@ impl AllCratesPart {
 ///
 /// This is to match the current behavior of rustdoc, which allows you to get all crates
 /// on the index page, even if --enable-index-page is only passed to the last crate.
-fn hack_get_external_crate_names(cx: &Context<'_>) -> Result<Vec<String>, Error> {
-    let path = cx.dst.join("crates.js");
+fn hack_get_external_crate_names(doc_root: &Path) -> Result<Vec<String>, Error> {
+    let path = doc_root.join("crates.js");
     let Ok(content) = fs::read_to_string(&path) else {
         // they didn't emit invocation specific, so we just say there were no crates
         return Ok(Vec::default());
@@ -361,7 +360,7 @@ impl CratesIndexPart {
         match SortedTemplate::magic(&template, MAGIC) {
             Ok(template) => template,
             Err(e) => panic!(
-                "{e}: Object Replacement Character (U+FFFC) should not appear in the --index-page"
+                "Object Replacement Character (U+FFFC) should not appear in the --index-page: {e}"
             ),
         }
     }
@@ -860,6 +859,21 @@ impl Serialize for AliasSerializableImpl {
     }
 }
 
+fn get_path_parts<T: CciPart>(
+    dst: &Path,
+    crates_info: &[CrateInfo],
+) -> FxHashMap<PathBuf, Vec<String>> {
+    let mut templates: FxHashMap<PathBuf, Vec<String>> = FxHashMap::default();
+    crates_info.iter().map(|crate_info| crate_info.get::<T>().parts.iter()).flatten().for_each(
+        |(path, part)| {
+            let path = dst.join(&path);
+            let part = part.to_string();
+            templates.entry(path).or_default().push(part);
+        },
+    );
+    templates
+}
+
 /// Create all parents
 fn create_parents(path: &Path) -> Result<(), Error> {
     let parent = path.parent().expect("should not have an empty path here");
@@ -867,20 +881,13 @@ fn create_parents(path: &Path) -> Result<(), Error> {
     Ok(())
 }
 
-/// Create parents and then write
-fn write_create_parents(path: &Path, content: String) -> Result<(), Error> {
-    create_parents(path)?;
-    try_err!(fs::write(path, content), path);
-    Ok(())
-}
-
 /// Returns a blank template unless we could find one to append to
-fn read_template_or_blank<F, T: CciPart>(
+fn read_template_or_blank<F, T: FileFormat>(
     mut make_blank: F,
     path: &Path,
-) -> Result<SortedTemplate<T::FileFormat>, Error>
+) -> Result<SortedTemplate<T>, Error>
 where
-    F: FnMut() -> SortedTemplate<T::FileFormat>,
+    F: FnMut() -> SortedTemplate<T>,
 {
     match fs::read_to_string(&path) {
         Ok(template) => Ok(try_err!(SortedTemplate::from_str(&template), &path)),
@@ -898,27 +905,14 @@ fn write_rendered_cci<T: CciPart, F>(
 where
     F: FnMut() -> SortedTemplate<T::FileFormat>,
 {
-    // read parts from disk
-    let path_parts =
-        crates_info.iter().map(|crate_info| crate_info.get::<T>().parts.iter()).flatten();
-    // read previous rendered cci from storage, append to them
-    let mut templates: FxHashMap<PathBuf, SortedTemplate<T::FileFormat>> = Default::default();
-    for (path, part) in path_parts {
-        let part = format!("{part}");
-        let path = dst.join(&path);
-        match templates.entry(path.clone()) {
-            Entry::Vacant(entry) => {
-                let template = read_template_or_blank::<_, T>(&mut make_blank, &path)?;
-                let template = entry.insert(template);
-                template.append(part);
-            }
-            Entry::Occupied(mut t) => t.get_mut().append(part),
-        }
-    }
-
     // write the merged cci to disk
-    for (path, template) in templates {
+    for (path, parts) in get_path_parts::<T>(dst, crates_info) {
         create_parents(&path)?;
+        // read previous rendered cci from storage, append to them
+        let mut template = read_template_or_blank::<_, T::FileFormat>(&mut make_blank, &path)?;
+        for part in parts {
+            template.append(part);
+        }
         let file = try_err!(File::create(&path), &path);
         let mut file = BufWriter::new(file);
         try_err!(write!(file, "{template}"), &path);
@@ -926,3 +920,6 @@ where
     }
     Ok(())
 }
+
+#[cfg(test)]
+mod tests;
diff --git a/src/librustdoc/html/render/write_shared/tests.rs b/src/librustdoc/html/render/write_shared/tests.rs
new file mode 100644
index 0000000000000..000e233aec00f
--- /dev/null
+++ b/src/librustdoc/html/render/write_shared/tests.rs
@@ -0,0 +1,206 @@
+use crate::html::render::sorted_json::{EscapedJson, SortedJson};
+use crate::html::render::sorted_template::{Html, SortedTemplate};
+use crate::html::render::write_shared::*;
+
+#[test]
+fn hack_external_crate_names() {
+    let path = tempfile::TempDir::new().unwrap();
+    let path = path.path();
+    let crates = hack_get_external_crate_names(&path).unwrap();
+    assert!(crates.is_empty());
+    fs::write(path.join("crates.js"), r#"window.ALL_CRATES = ["a","b","c"];"#).unwrap();
+    let crates = hack_get_external_crate_names(&path).unwrap();
+    assert_eq!(crates, ["a".to_string(), "b".to_string(), "c".to_string()]);
+}
+
+fn but_last_line(s: &str) -> &str {
+    let (before, _) = s.rsplit_once("\n").unwrap();
+    before
+}
+
+#[test]
+fn sources_template() {
+    let mut template = SourcesPart::blank();
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r"var srcIndex = new Map(JSON.parse('[]'));
+createSrcSidebar();"
+    );
+    template.append(EscapedJson::from(SortedJson::serialize("u")).to_string());
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r#"var srcIndex = new Map(JSON.parse('["u"]'));
+createSrcSidebar();"#
+    );
+    template.append(EscapedJson::from(SortedJson::serialize("v")).to_string());
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r#"var srcIndex = new Map(JSON.parse('["u","v"]'));
+createSrcSidebar();"#
+    );
+}
+
+#[test]
+fn sources_parts() {
+    let parts = SearchIndexPart::get(SortedJson::serialize(["foo", "bar"]), "suffix").unwrap();
+    assert_eq!(&parts.parts[0].0, Path::new("search-indexsuffix.js"));
+    assert_eq!(&parts.parts[0].1.to_string(), r#"["foo","bar"]"#);
+}
+
+#[test]
+fn all_crates_template() {
+    let mut template = AllCratesPart::blank();
+    assert_eq!(but_last_line(&template.to_string()), r"window.ALL_CRATES = [];");
+    template.append(EscapedJson::from(SortedJson::serialize("b")).to_string());
+    assert_eq!(but_last_line(&template.to_string()), r#"window.ALL_CRATES = ["b"];"#);
+    template.append(EscapedJson::from(SortedJson::serialize("a")).to_string());
+    assert_eq!(but_last_line(&template.to_string()), r#"window.ALL_CRATES = ["a","b"];"#);
+}
+
+#[test]
+fn all_crates_parts() {
+    let parts = AllCratesPart::get(SortedJson::serialize("crate")).unwrap();
+    assert_eq!(&parts.parts[0].0, Path::new("crates.js"));
+    assert_eq!(&parts.parts[0].1.to_string(), r#""crate""#);
+}
+
+#[test]
+fn search_index_template() {
+    let mut template = SearchIndexPart::blank();
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r"var searchIndex = new Map(JSON.parse('[]'));
+if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
+else if (window.initSearch) window.initSearch(searchIndex);"
+    );
+    template.append(EscapedJson::from(SortedJson::serialize([1, 2])).to_string());
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r"var searchIndex = new Map(JSON.parse('[[1,2]]'));
+if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
+else if (window.initSearch) window.initSearch(searchIndex);"
+    );
+    template.append(EscapedJson::from(SortedJson::serialize([4, 3])).to_string());
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r"var searchIndex = new Map(JSON.parse('[[1,2],[4,3]]'));
+if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
+else if (window.initSearch) window.initSearch(searchIndex);"
+    );
+}
+
+#[test]
+fn crates_index_part() {
+    let external_crates = ["bar".to_string(), "baz".to_string()];
+    let mut parts = CratesIndexPart::get("foo", &external_crates).unwrap();
+    parts.parts.sort_by(|a, b| a.1.to_string().cmp(&b.1.to_string()));
+
+    assert_eq!(&parts.parts[0].0, Path::new("index.html"));
+    assert_eq!(&parts.parts[0].1.to_string(), r#"<li><a href="bar/index.html">bar</a></li>"#);
+
+    assert_eq!(&parts.parts[1].0, Path::new("index.html"));
+    assert_eq!(&parts.parts[1].1.to_string(), r#"<li><a href="baz/index.html">baz</a></li>"#);
+
+    assert_eq!(&parts.parts[2].0, Path::new("index.html"));
+    assert_eq!(&parts.parts[2].1.to_string(), r#"<li><a href="foo/index.html">foo</a></li>"#);
+}
+
+#[test]
+fn trait_alias_template() {
+    let mut template = TraitAliasPart::blank();
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r#"(function() {
+    var implementors = Object.fromEntries([]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()"#,
+    );
+    template.append(SortedJson::serialize(["a"]).to_string());
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r#"(function() {
+    var implementors = Object.fromEntries([["a"]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()"#,
+    );
+    template.append(SortedJson::serialize(["b"]).to_string());
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r#"(function() {
+    var implementors = Object.fromEntries([["a"],["b"]]);
+    if (window.register_implementors) {
+        window.register_implementors(implementors);
+    } else {
+        window.pending_implementors = implementors;
+    }
+})()"#,
+    );
+}
+
+#[test]
+fn type_alias_template() {
+    let mut template = TypeAliasPart::blank();
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r#"(function() {
+    var type_impls = Object.fromEntries([]);
+    if (window.register_type_impls) {
+        window.register_type_impls(type_impls);
+    } else {
+        window.pending_type_impls = type_impls;
+    }
+})()"#,
+    );
+    template.append(SortedJson::serialize(["a"]).to_string());
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r#"(function() {
+    var type_impls = Object.fromEntries([["a"]]);
+    if (window.register_type_impls) {
+        window.register_type_impls(type_impls);
+    } else {
+        window.pending_type_impls = type_impls;
+    }
+})()"#,
+    );
+    template.append(SortedJson::serialize(["b"]).to_string());
+    assert_eq!(
+        but_last_line(&template.to_string()),
+        r#"(function() {
+    var type_impls = Object.fromEntries([["a"],["b"]]);
+    if (window.register_type_impls) {
+        window.register_type_impls(type_impls);
+    } else {
+        window.pending_type_impls = type_impls;
+    }
+})()"#,
+    );
+}
+
+#[test]
+fn read_template_test() {
+    let path = tempfile::TempDir::new().unwrap();
+    let path = path.path().join("file.html");
+    let make_blank = || SortedTemplate::<Html>::before_after("<div>", "</div>");
+
+    let template = read_template_or_blank(make_blank, &path).unwrap();
+    assert_eq!(but_last_line(&template.to_string()), "<div></div>");
+    fs::write(&path, template.to_string()).unwrap();
+    let mut template = read_template_or_blank(make_blank, &path).unwrap();
+    template.append("<img/>".to_string());
+    fs::write(&path, template.to_string()).unwrap();
+    let mut template = read_template_or_blank(make_blank, &path).unwrap();
+    template.append("<br/>".to_string());
+    fs::write(&path, template.to_string()).unwrap();
+    let template = read_template_or_blank(make_blank, &path).unwrap();
+
+    assert_eq!(but_last_line(&template.to_string()), "<div><br/><img/></div>");
+}

From 4b418cd4aa9b2b8c52e8029c13b0530abf97bce7 Mon Sep 17 00:00:00 2001
From: EtomicBomb <ethan@ethan.ws>
Date: Fri, 26 Jul 2024 17:09:32 +0000
Subject: [PATCH 068/685] rename sortedjson -> orderedjson

---
 src/librustdoc/Cargo.toml                     |   2 +-
 src/librustdoc/html/render/mod.rs             |   2 +-
 .../{sorted_json.rs => ordered_json.rs}       |  56 +++----
 .../{sorted_json => ordered_json}/tests.rs    |  52 +++----
 src/librustdoc/html/render/search_index.rs    |  10 +-
 src/librustdoc/html/render/sorted_template.rs | 108 ++++++++------
 .../html/render/sorted_template/tests.rs      |  21 +--
 src/librustdoc/html/render/write_shared.rs    | 141 ++++++++++--------
 .../html/render/write_shared/tests.rs         |  29 ++--
 9 files changed, 228 insertions(+), 193 deletions(-)
 rename src/librustdoc/html/render/{sorted_json.rs => ordered_json.rs} (55%)
 rename src/librustdoc/html/render/{sorted_json => ordered_json}/tests.rs (55%)

diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index 67ba8c773175c..b3fccbf6456e0 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -16,7 +16,7 @@ minifier = "0.3.0"
 pulldown-cmark-old = { version = "0.9.6", package = "pulldown-cmark", default-features = false }
 regex = "1"
 rustdoc-json-types = { path = "../rustdoc-json-types" }
-serde_json = { version = "1.0", features = ["preserve_order"] }
+serde_json = "1.0"
 serde = { version = "1.0", features = ["derive"] }
 smallvec = "1.8.1"
 tempfile = "3"
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 4b1c9b4af474a..586c3c509b4ce 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -29,9 +29,9 @@ pub(crate) mod search_index;
 mod tests;
 
 mod context;
+mod ordered_json;
 mod print_item;
 pub(crate) mod sidebar;
-mod sorted_json;
 mod sorted_template;
 mod span_map;
 mod type_layout;
diff --git a/src/librustdoc/html/render/sorted_json.rs b/src/librustdoc/html/render/ordered_json.rs
similarity index 55%
rename from src/librustdoc/html/render/sorted_json.rs
rename to src/librustdoc/html/render/ordered_json.rs
index e937382f5b0a6..3f76ff659d04e 100644
--- a/src/librustdoc/html/render/sorted_json.rs
+++ b/src/librustdoc/html/render/ordered_json.rs
@@ -1,72 +1,74 @@
+use std::borrow::Borrow;
+use std::fmt;
+
 use itertools::Itertools as _;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
-use std::borrow::Borrow;
-use std::fmt;
 
 /// Prerenedered json.
 ///
-/// Arrays are sorted by their stringified entries, and objects are sorted by their stringified
-/// keys.
-///
-/// Must use serde_json with the preserve_order feature.
-///
 /// Both the Display and serde_json::to_string implementations write the serialized json
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
 #[serde(from = "Value")]
 #[serde(into = "Value")]
-pub(crate) struct SortedJson(String);
+pub(crate) struct OrderedJson(String);
 
-impl SortedJson {
+impl OrderedJson {
     /// If you pass in an array, it will not be sorted.
-    pub(crate) fn serialize<T: Serialize>(item: T) -> Self {
-        SortedJson(serde_json::to_string(&item).unwrap())
+    pub(crate) fn serialize<T: Serialize>(item: T) -> Result<Self, serde_json::Error> {
+        Ok(OrderedJson(serde_json::to_string(&item)?))
     }
 
     /// Serializes and sorts
-    pub(crate) fn array<T: Borrow<SortedJson>, I: IntoIterator<Item = T>>(items: I) -> Self {
+    pub(crate) fn array_sorted<T: Borrow<OrderedJson>, I: IntoIterator<Item = T>>(
+        items: I,
+    ) -> Self {
         let items = items
             .into_iter()
             .sorted_unstable_by(|a, b| a.borrow().cmp(&b.borrow()))
             .format_with(",", |item, f| f(item.borrow()));
-        SortedJson(format!("[{}]", items))
+        OrderedJson(format!("[{}]", items))
     }
 
-    pub(crate) fn array_unsorted<T: Borrow<SortedJson>, I: IntoIterator<Item = T>>(
+    pub(crate) fn array_unsorted<T: Borrow<OrderedJson>, I: IntoIterator<Item = T>>(
         items: I,
     ) -> Self {
         let items = items.into_iter().format_with(",", |item, f| f(item.borrow()));
-        SortedJson(format!("[{items}]"))
+        OrderedJson(format!("[{items}]"))
     }
 }
 
-impl fmt::Display for SortedJson {
+impl fmt::Display for OrderedJson {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
+        self.0.fmt(f)
     }
 }
 
-impl From<Value> for SortedJson {
+impl From<Value> for OrderedJson {
     fn from(value: Value) -> Self {
-        SortedJson(serde_json::to_string(&value).unwrap())
+        let serialized =
+            serde_json::to_string(&value).expect("Serializing a Value to String should never fail");
+        OrderedJson(serialized)
     }
 }
 
-impl From<SortedJson> for Value {
-    fn from(json: SortedJson) -> Self {
-        serde_json::from_str(&json.0).unwrap()
+impl From<OrderedJson> for Value {
+    fn from(json: OrderedJson) -> Self {
+        serde_json::from_str(&json.0).expect("OrderedJson should always store valid JSON")
     }
 }
 
 /// For use in JSON.parse('{...}').
 ///
-/// JSON.parse supposedly loads faster than raw JS source,
+/// Assumes we are going to be wrapped in single quoted strings.
+///
+/// JSON.parse loads faster than raw JS source,
 /// so this is used for large objects.
 #[derive(Debug, Clone, Serialize, Deserialize)]
-pub(crate) struct EscapedJson(SortedJson);
+pub(crate) struct EscapedJson(OrderedJson);
 
-impl From<SortedJson> for EscapedJson {
-    fn from(json: SortedJson) -> Self {
+impl From<OrderedJson> for EscapedJson {
+    fn from(json: OrderedJson) -> Self {
         EscapedJson(json)
     }
 }
@@ -77,7 +79,7 @@ impl fmt::Display for EscapedJson {
         // for JSON content.
         // We need to escape double quotes for the JSON
         let json = self.0.0.replace('\\', r"\\").replace('\'', r"\'").replace("\\\"", "\\\\\"");
-        write!(f, "{}", json)
+        json.fmt(f)
     }
 }
 
diff --git a/src/librustdoc/html/render/sorted_json/tests.rs b/src/librustdoc/html/render/ordered_json/tests.rs
similarity index 55%
rename from src/librustdoc/html/render/sorted_json/tests.rs
rename to src/librustdoc/html/render/ordered_json/tests.rs
index 1e72c6f614c38..e0fe6446b9aff 100644
--- a/src/librustdoc/html/render/sorted_json/tests.rs
+++ b/src/librustdoc/html/render/ordered_json/tests.rs
@@ -1,90 +1,90 @@
-use super::super::sorted_json::*;
+use super::super::ordered_json::*;
 
-fn check(json: SortedJson, serialized: &str) {
+fn check(json: OrderedJson, serialized: &str) {
     assert_eq!(json.to_string(), serialized);
     assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
 
     let json = json.to_string();
-    let json: SortedJson = serde_json::from_str(&json).unwrap();
+    let json: OrderedJson = serde_json::from_str(&json).unwrap();
 
     assert_eq!(json.to_string(), serialized);
     assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
 
     let json = serde_json::to_string(&json).unwrap();
-    let json: SortedJson = serde_json::from_str(&json).unwrap();
+    let json: OrderedJson = serde_json::from_str(&json).unwrap();
 
     assert_eq!(json.to_string(), serialized);
     assert_eq!(serde_json::to_string(&json).unwrap(), serialized);
 }
 
-// Test this basic are needed because we are testing that our Display impl + serialize impl don't
-// nest everything in extra level of string. We also are testing round trip.
+// Make sure there is no extra level of string, plus number of escapes.
 #[test]
 fn escape_json_number() {
-    let json = SortedJson::serialize(3);
+    let json = OrderedJson::serialize(3).unwrap();
     let json = EscapedJson::from(json);
     assert_eq!(format!("{json}"), "3");
 }
 
 #[test]
 fn escape_json_single_quote() {
-    let json = SortedJson::serialize("he's");
+    let json = OrderedJson::serialize("he's").unwrap();
     let json = EscapedJson::from(json);
     assert_eq!(format!("{json}"), r#""he\'s""#);
 }
 
 #[test]
 fn escape_json_array() {
-    let json = SortedJson::serialize([1, 2, 3]);
+    let json = OrderedJson::serialize([1, 2, 3]).unwrap();
     let json = EscapedJson::from(json);
     assert_eq!(format!("{json}"), r#"[1,2,3]"#);
 }
 
 #[test]
 fn escape_json_string() {
-    let json = SortedJson::serialize(r#"he"llo"#);
+    let json = OrderedJson::serialize(r#"he"llo"#).unwrap();
     let json = EscapedJson::from(json);
     assert_eq!(format!("{json}"), r#""he\\\"llo""#);
 }
 
 #[test]
 fn escape_json_string_escaped() {
-    let json = SortedJson::serialize(r#"he\"llo"#);
+    let json = OrderedJson::serialize(r#"he\"llo"#).unwrap();
     let json = EscapedJson::from(json);
     assert_eq!(format!("{json}"), r#""he\\\\\\\"llo""#);
 }
 
 #[test]
 fn escape_json_string_escaped_escaped() {
-    let json = SortedJson::serialize(r#"he\\"llo"#);
+    let json = OrderedJson::serialize(r#"he\\"llo"#).unwrap();
     let json = EscapedJson::from(json);
     assert_eq!(format!("{json}"), r#""he\\\\\\\\\\\"llo""#);
 }
 
+// Testing round trip + making sure there is no extra level of string
 #[test]
 fn number() {
-    let json = SortedJson::serialize(3);
+    let json = OrderedJson::serialize(3).unwrap();
     let serialized = "3";
     check(json, serialized);
 }
 
 #[test]
 fn boolean() {
-    let json = SortedJson::serialize(true);
+    let json = OrderedJson::serialize(true).unwrap();
     let serialized = "true";
     check(json, serialized);
 }
 
 #[test]
 fn string() {
-    let json = SortedJson::serialize("he\"llo");
+    let json = OrderedJson::serialize("he\"llo").unwrap();
     let serialized = r#""he\"llo""#;
     check(json, serialized);
 }
 
 #[test]
 fn serialize_array() {
-    let json = SortedJson::serialize([3, 1, 2]);
+    let json = OrderedJson::serialize([3, 1, 2]).unwrap();
     let serialized = "[3,1,2]";
     check(json, serialized);
 }
@@ -93,18 +93,19 @@ fn serialize_array() {
 fn sorted_array() {
     let items = ["c", "a", "b"];
     let serialized = r#"["a","b","c"]"#;
-    let items: Vec<SortedJson> = items.into_iter().map(SortedJson::serialize).collect();
-    let json = SortedJson::array(items);
+    let items: Vec<OrderedJson> =
+        items.into_iter().map(OrderedJson::serialize).collect::<Result<Vec<_>, _>>().unwrap();
+    let json = OrderedJson::array_sorted(items);
     check(json, serialized);
 }
 
 #[test]
 fn nested_array() {
-    let a = SortedJson::serialize(3);
-    let b = SortedJson::serialize(2);
-    let c = SortedJson::serialize(1);
-    let d = SortedJson::serialize([1, 3, 2]);
-    let json = SortedJson::array([a, b, c, d]);
+    let a = OrderedJson::serialize(3).unwrap();
+    let b = OrderedJson::serialize(2).unwrap();
+    let c = OrderedJson::serialize(1).unwrap();
+    let d = OrderedJson::serialize([1, 3, 2]).unwrap();
+    let json = OrderedJson::array_sorted([a, b, c, d]);
     let serialized = r#"[1,2,3,[1,3,2]]"#;
     check(json, serialized);
 }
@@ -113,7 +114,8 @@ fn nested_array() {
 fn array_unsorted() {
     let items = ["c", "a", "b"];
     let serialized = r#"["c","a","b"]"#;
-    let items: Vec<SortedJson> = items.into_iter().map(SortedJson::serialize).collect();
-    let json = SortedJson::array_unsorted(items);
+    let items: Vec<OrderedJson> =
+        items.into_iter().map(OrderedJson::serialize).collect::<Result<Vec<_>, _>>().unwrap();
+    let json = OrderedJson::array_unsorted(items);
     check(json, serialized);
 }
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 184e5afba3c99..8a12bdef69bf4 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -18,7 +18,7 @@ use crate::formats::cache::{Cache, OrphanImplItem};
 use crate::formats::item_type::ItemType;
 use crate::html::format::join_with_double_colon;
 use crate::html::markdown::short_markdown_summary;
-use crate::html::render::sorted_json::SortedJson;
+use crate::html::render::ordered_json::OrderedJson;
 use crate::html::render::{self, IndexItem, IndexItemFunctionType, RenderType, RenderTypeId};
 
 /// The serialized search description sharded version
@@ -47,7 +47,7 @@ use crate::html::render::{self, IndexItem, IndexItemFunctionType, RenderType, Re
 /// [2]: https://en.wikipedia.org/wiki/Sliding_window_protocol#Basic_concept
 /// [3]: https://learn.microsoft.com/en-us/troubleshoot/windows-server/networking/description-tcp-features
 pub(crate) struct SerializedSearchIndex {
-    pub(crate) index: SortedJson,
+    pub(crate) index: OrderedJson,
     pub(crate) desc: Vec<(usize, String)>,
 }
 
@@ -693,9 +693,9 @@ pub(crate) fn build_index<'tcx>(
         desc_index,
         empty_desc,
     };
-    let index = SortedJson::array_unsorted([
-        SortedJson::serialize(crate_name.as_str()),
-        SortedJson::serialize(data),
+    let index = OrderedJson::array_unsorted([
+        OrderedJson::serialize(crate_name.as_str()).unwrap(),
+        OrderedJson::serialize(data).unwrap(),
     ]);
     SerializedSearchIndex { index, desc }
 }
diff --git a/src/librustdoc/html/render/sorted_template.rs b/src/librustdoc/html/render/sorted_template.rs
index 8e0a2ee0fd4d9..1dc70408f013d 100644
--- a/src/librustdoc/html/render/sorted_template.rs
+++ b/src/librustdoc/html/render/sorted_template.rs
@@ -1,8 +1,9 @@
 use std::collections::BTreeSet;
-use std::fmt;
+use std::fmt::{self, Write as _};
 use std::marker::PhantomData;
 use std::str::FromStr;
 
+use itertools::{Itertools as _, Position};
 use serde::{Deserialize, Serialize};
 
 /// Append-only templates for sorted, deduplicated lists of items.
@@ -13,7 +14,7 @@ pub(crate) struct SortedTemplate<F> {
     format: PhantomData<F>,
     before: String,
     after: String,
-    contents: BTreeSet<String>,
+    fragments: BTreeSet<String>,
 }
 
 /// Written to last line of file to specify the location of each fragment
@@ -22,82 +23,88 @@ struct Offset {
     /// Index of the first byte in the template
     start: usize,
     /// The length of each fragment in the encoded template, including the separator
-    delta: Vec<usize>,
+    fragment_lengths: Vec<usize>,
 }
 
 impl<F> SortedTemplate<F> {
     /// Generate this template from arbitary text.
     /// Will insert wherever the substring `magic` can be found.
     /// Errors if it does not appear exactly once.
-    pub(crate) fn magic(template: &str, magic: &str) -> Result<Self, Error> {
-        let mut split = template.split(magic);
-        let before = split.next().ok_or(Error)?;
-        let after = split.next().ok_or(Error)?;
+    pub(crate) fn from_template(template: &str, delimiter: &str) -> Result<Self, Error> {
+        let mut split = template.split(delimiter);
+        let before = split.next().ok_or(Error("delimiter should appear at least once"))?;
+        let after = split.next().ok_or(Error("delimiter should appear at least once"))?;
+        // not `split_once` because we want to check for too many occurrences
         if split.next().is_some() {
-            return Err(Error);
+            return Err(Error("delimiter should appear at most once"));
         }
-        Ok(Self::before_after(before, after))
+        Ok(Self::from_before_after(before, after))
     }
 
-    /// Template will insert contents between `before` and `after`
-    pub(crate) fn before_after<S: ToString, T: ToString>(before: S, after: T) -> Self {
+    /// Template will insert fragments between `before` and `after`
+    pub(crate) fn from_before_after<S: ToString, T: ToString>(before: S, after: T) -> Self {
         let before = before.to_string();
         let after = after.to_string();
-        SortedTemplate { format: PhantomData, before, after, contents: Default::default() }
+        SortedTemplate { format: PhantomData, before, after, fragments: Default::default() }
     }
 }
 
-impl<F: FileFormat> SortedTemplate<F> {
+impl<F> SortedTemplate<F> {
     /// Adds this text to the template
     pub(crate) fn append(&mut self, insert: String) {
-        self.contents.insert(insert);
+        self.fragments.insert(insert);
     }
 }
 
 impl<F: FileFormat> fmt::Display for SortedTemplate<F> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut delta = Vec::default();
+    fn fmt(&self, mut f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut fragment_lengths = Vec::default();
         write!(f, "{}", self.before)?;
-        let contents: Vec<_> = self.contents.iter().collect();
-        let mut sep = "";
-        for content in contents {
-            delta.push(sep.len() + content.len());
-            write!(f, "{}{}", sep, content)?;
-            sep = F::SEPARATOR;
+        for (p, fragment) in self.fragments.iter().with_position() {
+            let mut f = DeltaWriter { inner: &mut f, delta: 0 };
+            let sep = if matches!(p, Position::First | Position::Only) { "" } else { F::SEPARATOR };
+            write!(f, "{}{}", sep, fragment)?;
+            fragment_lengths.push(f.delta);
         }
-        let offset = Offset { start: self.before.len(), delta };
+        let offset = Offset { start: self.before.len(), fragment_lengths };
         let offset = serde_json::to_string(&offset).unwrap();
-        write!(f, "{}\n{}{}{}", self.after, F::COMMENT_START, offset, F::COMMENT_END)?;
-        Ok(())
+        write!(f, "{}\n{}{}{}", self.after, F::COMMENT_START, offset, F::COMMENT_END)
     }
 }
 
-fn checked_split_at(s: &str, index: usize) -> Option<(&str, &str)> {
-    s.is_char_boundary(index).then(|| s.split_at(index))
-}
-
 impl<F: FileFormat> FromStr for SortedTemplate<F> {
     type Err = Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let (s, offset) = s.rsplit_once("\n").ok_or(Error)?;
-        let offset = offset.strip_prefix(F::COMMENT_START).ok_or(Error)?;
-        let offset = offset.strip_suffix(F::COMMENT_END).ok_or(Error)?;
-        let offset: Offset = serde_json::from_str(&offset).map_err(|_| Error)?;
-        let (before, mut s) = checked_split_at(s, offset.start).ok_or(Error)?;
-        let mut contents = BTreeSet::default();
-        let mut sep = "";
-        for &index in offset.delta.iter() {
-            let (content, rest) = checked_split_at(s, index).ok_or(Error)?;
+        let (s, offset) = s
+            .rsplit_once("\n")
+            .ok_or(Error("invalid format: should have a newline on the last line"))?;
+        let offset = offset
+            .strip_prefix(F::COMMENT_START)
+            .ok_or(Error("last line expected to start with a comment"))?;
+        let offset = offset
+            .strip_suffix(F::COMMENT_END)
+            .ok_or(Error("last line expected to end with a comment"))?;
+        let offset: Offset = serde_json::from_str(&offset).map_err(|_| {
+            Error("could not find insertion location descriptor object on last line")
+        })?;
+        let (before, mut s) =
+            s.split_at_checked(offset.start).ok_or(Error("invalid start: out of bounds"))?;
+        let mut fragments = BTreeSet::default();
+        for (p, &index) in offset.fragment_lengths.iter().with_position() {
+            let (fragment, rest) =
+                s.split_at_checked(index).ok_or(Error("invalid fragment length: out of bounds"))?;
             s = rest;
-            let content = content.strip_prefix(sep).ok_or(Error)?;
-            contents.insert(content.to_string());
-            sep = F::SEPARATOR;
+            let sep = if matches!(p, Position::First | Position::Only) { "" } else { F::SEPARATOR };
+            let fragment = fragment
+                .strip_prefix(sep)
+                .ok_or(Error("invalid fragment length: expected to find separator here"))?;
+            fragments.insert(fragment.to_string());
         }
         Ok(SortedTemplate {
             format: PhantomData,
             before: before.to_string(),
             after: s.to_string(),
-            contents,
+            fragments,
         })
     }
 }
@@ -127,11 +134,24 @@ impl FileFormat for Js {
 }
 
 #[derive(Debug, Clone)]
-pub(crate) struct Error;
+pub(crate) struct Error(&'static str);
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "invalid template")
+        write!(f, "invalid template: {}", self.0)
+    }
+}
+
+struct DeltaWriter<W> {
+    inner: W,
+    delta: usize,
+}
+
+impl<W: fmt::Write> fmt::Write for DeltaWriter<W> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.inner.write_str(s)?;
+        self.delta += s.len();
+        Ok(())
     }
 }
 
diff --git a/src/librustdoc/html/render/sorted_template/tests.rs b/src/librustdoc/html/render/sorted_template/tests.rs
index 04553f65a2154..db057463005c9 100644
--- a/src/librustdoc/html/render/sorted_template/tests.rs
+++ b/src/librustdoc/html/render/sorted_template/tests.rs
@@ -1,6 +1,7 @@
-use super::super::sorted_template::*;
 use std::str::FromStr;
 
+use super::super::sorted_template::*;
+
 fn is_comment_js(s: &str) -> bool {
     s.starts_with("//")
 }
@@ -13,7 +14,7 @@ fn is_comment_html(s: &str) -> bool {
 #[test]
 fn html_from_empty() {
     let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>hello</p>", "<p>world</p>"];
-    let mut template = SortedTemplate::<Html>::before_after("", "");
+    let mut template = SortedTemplate::<Html>::from_before_after("", "");
     for insert in inserts {
         template.append(insert.to_string());
     }
@@ -29,7 +30,7 @@ fn html_page() {
     let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>world</p>"];
     let before = "<html><head></head><body>";
     let after = "</body>";
-    let mut template = SortedTemplate::<Html>::before_after(before, after);
+    let mut template = SortedTemplate::<Html>::from_before_after(before, after);
     for insert in inserts {
         template.append(insert.to_string());
     }
@@ -43,7 +44,7 @@ fn html_page() {
 #[test]
 fn js_from_empty() {
     let inserts = ["1", "2", "2", "2", "3", "1"];
-    let mut template = SortedTemplate::<Js>::before_after("", "");
+    let mut template = SortedTemplate::<Js>::from_before_after("", "");
     for insert in inserts {
         template.append(insert.to_string());
     }
@@ -56,7 +57,7 @@ fn js_from_empty() {
 
 #[test]
 fn js_empty_array() {
-    let template = SortedTemplate::<Js>::before_after("[", "]");
+    let template = SortedTemplate::<Js>::from_before_after("[", "]");
     let template = format!("{template}");
     let (template, end) = template.rsplit_once("\n").unwrap();
     assert_eq!(template, format!("[]"));
@@ -67,7 +68,7 @@ fn js_empty_array() {
 #[test]
 fn js_number_array() {
     let inserts = ["1", "2", "3"];
-    let mut template = SortedTemplate::<Js>::before_after("[", "]");
+    let mut template = SortedTemplate::<Js>::from_before_after("[", "]");
     for insert in inserts {
         template.append(insert.to_string());
     }
@@ -81,7 +82,7 @@ fn js_number_array() {
 #[test]
 fn magic_js_number_array() {
     let inserts = ["1", "1"];
-    let mut template = SortedTemplate::<Js>::magic("[#]", "#").unwrap();
+    let mut template = SortedTemplate::<Js>::from_template("[#]", "#").unwrap();
     for insert in inserts {
         template.append(insert.to_string());
     }
@@ -95,7 +96,7 @@ fn magic_js_number_array() {
 #[test]
 fn round_trip_js() {
     let inserts = ["1", "2", "3"];
-    let mut template = SortedTemplate::<Js>::before_after("[", "]");
+    let mut template = SortedTemplate::<Js>::from_before_after("[", "]");
     for insert in inserts {
         template.append(insert.to_string());
     }
@@ -114,7 +115,7 @@ fn round_trip_html() {
     let inserts = ["<p>hello</p>", "<p>kind</p>", "<p>world</p>", "<p>kind</p>"];
     let before = "<html><head></head><body>";
     let after = "</body>";
-    let mut template = SortedTemplate::<Html>::before_after(before, after);
+    let mut template = SortedTemplate::<Html>::from_before_after(before, after);
     template.append(inserts[0].to_string());
     template.append(inserts[1].to_string());
     let template = format!("{template}");
@@ -129,7 +130,7 @@ fn round_trip_html() {
 #[test]
 fn blank_js() {
     let inserts = ["1", "2", "3"];
-    let template = SortedTemplate::<Js>::before_after("", "");
+    let template = SortedTemplate::<Js>::from_before_after("", "");
     let template = format!("{template}");
     let (t, _) = template.rsplit_once("\n").unwrap();
     assert_eq!(t, "");
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index c2d2b4cd7d9fb..ef3c35c20ab01 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -1,4 +1,4 @@
-//! Rustdoc writes out two kinds of shared files:
+//! Rustdoc writes aut two kinds of shared files:
 //!  - Static files, which are embedded in the rustdoc binary and are written with a
 //!    filename that includes a hash of their contents. These will always have a new
 //!    URL if the contents change, so they are safe to cache with the
@@ -13,18 +13,16 @@
 //!    --resource-suffix flag and are emitted when --emit-type is empty (default)
 //!    or contains "invocation-specific".
 
-use std::any::Any;
 use std::cell::RefCell;
 use std::ffi::OsString;
 use std::fs::File;
-use std::io::BufWriter;
-use std::io::Write as _;
+use std::io::{self, BufWriter, Write as _};
 use std::iter::once;
 use std::marker::PhantomData;
 use std::path::{Component, Path, PathBuf};
 use std::rc::{Rc, Weak};
 use std::str::FromStr;
-use std::{fmt, fs, io};
+use std::{fmt, fs};
 
 use indexmap::IndexMap;
 use itertools::Itertools;
@@ -35,8 +33,9 @@ use rustc_middle::ty::fast_reject::{DeepRejectCtxt, TreatParams};
 use rustc_middle::ty::TyCtxt;
 use rustc_span::def_id::DefId;
 use rustc_span::Symbol;
+use serde::de::DeserializeOwned;
 use serde::ser::SerializeSeq;
-use serde::{de::DeserializeOwned, Deserialize, Serialize, Serializer};
+use serde::{Deserialize, Serialize, Serializer};
 
 use super::{collect_paths_for_type, ensure_trailing_slash, Context, RenderMode};
 use crate::clean::{Crate, Item, ItemId, ItemKind};
@@ -48,9 +47,8 @@ use crate::formats::item_type::ItemType;
 use crate::formats::Impl;
 use crate::html::format::Buffer;
 use crate::html::layout;
-use crate::html::render::search_index::build_index;
-use crate::html::render::search_index::SerializedSearchIndex;
-use crate::html::render::sorted_json::{EscapedJson, SortedJson};
+use crate::html::render::ordered_json::{EscapedJson, OrderedJson};
+use crate::html::render::search_index::{build_index, SerializedSearchIndex};
 use crate::html::render::sorted_template::{self, FileFormat, SortedTemplate};
 use crate::html::render::{AssocItemLink, ImplRenderingParameters};
 use crate::html::static_files::{self, suffix_path};
@@ -76,7 +74,7 @@ pub(crate) fn write_shared(
 
     let crate_name = krate.name(cx.tcx());
     let crate_name = crate_name.as_str(); // rand
-    let crate_name_json = SortedJson::serialize(crate_name); // "rand"
+    let crate_name_json = OrderedJson::serialize(crate_name).unwrap(); // "rand"
     let external_crates = hack_get_external_crate_names(&cx.dst)?;
     let info = CrateInfo {
         src_files_js: SourcesPart::get(cx, &crate_name_json)?,
@@ -111,11 +109,7 @@ pub(crate) fn write_shared(
             );
         }
         None if opt.enable_index_page => {
-            write_rendered_cci::<CratesIndexPart, _>(
-                || CratesIndexPart::blank(cx),
-                dst,
-                &crates,
-            )?;
+            write_rendered_cci::<CratesIndexPart, _>(|| CratesIndexPart::blank(cx), dst, &crates)?;
         }
         _ => {} // they don't want an index page
     }
@@ -171,9 +165,9 @@ fn write_search_desc(
     search_desc: &[(usize, String)],
 ) -> Result<(), Error> {
     let crate_name = krate.name(cx.tcx()).to_string();
-    let encoded_crate_name = SortedJson::serialize(&crate_name);
+    let encoded_crate_name = OrderedJson::serialize(&crate_name).unwrap();
     let path = PathBuf::from_iter([&cx.dst, Path::new("search.desc"), Path::new(&crate_name)]);
-    if Path::new(&path).exists() {
+    if path.exists() {
         try_err!(fs::remove_dir_all(&path), &path);
     }
     for (i, (_, part)) in search_desc.iter().enumerate() {
@@ -182,7 +176,7 @@ fn write_search_desc(
             &cx.shared.resource_suffix,
         );
         let path = path.join(filename);
-        let part = SortedJson::serialize(&part);
+        let part = OrderedJson::serialize(&part).unwrap();
         let part = format!("searchState.loadedDescShard({encoded_crate_name}, {i}, {part})");
         create_parents(&path)?;
         try_err!(fs::write(&path, part), &path);
@@ -201,20 +195,6 @@ struct CrateInfo {
     type_impl: PartsAndLocations<TypeAliasPart>,
 }
 
-impl CrateInfo {
-    /// Gets a reference to the cross-crate information parts for `T`
-    fn get<T: CciPart>(&self) -> &PartsAndLocations<T> {
-        (&self.src_files_js as &dyn Any)
-            .downcast_ref()
-            .or_else(|| (&self.search_index_js as &dyn Any).downcast_ref())
-            .or_else(|| (&self.all_crates as &dyn Any).downcast_ref())
-            .or_else(|| (&self.crates_index as &dyn Any).downcast_ref())
-            .or_else(|| (&self.trait_impl as &dyn Any).downcast_ref())
-            .or_else(|| (&self.type_impl as &dyn Any).downcast_ref())
-            .expect("this should be an exhaustive list of `CciPart`s")
-    }
-}
-
 /// Paths (relative to the doc root) and their pre-merge contents
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(transparent)]
@@ -263,6 +243,7 @@ impl<T, U: fmt::Display> fmt::Display for Part<T, U> {
 trait CciPart: Sized + fmt::Display + DeserializeOwned + 'static {
     /// Identifies the file format of the cross-crate information
     type FileFormat: sorted_template::FileFormat;
+    fn from_crate_info(crate_info: &CrateInfo) -> &PartsAndLocations<Self>;
 }
 
 #[derive(Serialize, Deserialize, Clone, Default, Debug)]
@@ -270,11 +251,14 @@ struct SearchIndex;
 type SearchIndexPart = Part<SearchIndex, EscapedJson>;
 impl CciPart for SearchIndexPart {
     type FileFormat = sorted_template::Js;
+    fn from_crate_info(crate_info: &CrateInfo) -> &PartsAndLocations<Self> {
+        &crate_info.search_index_js
+    }
 }
 
 impl SearchIndexPart {
     fn blank() -> SortedTemplate<<Self as CciPart>::FileFormat> {
-        SortedTemplate::before_after(
+        SortedTemplate::from_before_after(
             r"var searchIndex = new Map(JSON.parse('[",
             r"]'));
 if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
@@ -283,7 +267,7 @@ else if (window.initSearch) window.initSearch(searchIndex);",
     }
 
     fn get(
-        search_index: SortedJson,
+        search_index: OrderedJson,
         resource_suffix: &str,
     ) -> Result<PartsAndLocations<Self>, Error> {
         let path = suffix_path("search-index.js", resource_suffix);
@@ -294,17 +278,20 @@ else if (window.initSearch) window.initSearch(searchIndex);",
 
 #[derive(Serialize, Deserialize, Clone, Default, Debug)]
 struct AllCrates;
-type AllCratesPart = Part<AllCrates, SortedJson>;
+type AllCratesPart = Part<AllCrates, OrderedJson>;
 impl CciPart for AllCratesPart {
     type FileFormat = sorted_template::Js;
+    fn from_crate_info(crate_info: &CrateInfo) -> &PartsAndLocations<Self> {
+        &crate_info.all_crates
+    }
 }
 
 impl AllCratesPart {
     fn blank() -> SortedTemplate<<Self as CciPart>::FileFormat> {
-        SortedTemplate::before_after("window.ALL_CRATES = [", "];")
+        SortedTemplate::from_before_after("window.ALL_CRATES = [", "];")
     }
 
-    fn get(crate_name_json: SortedJson) -> Result<PartsAndLocations<Self>, Error> {
+    fn get(crate_name_json: OrderedJson) -> Result<PartsAndLocations<Self>, Error> {
         // external hack_get_external_crate_names not needed here, because
         // there's no way that we write the search index but not crates.js
         let path = PathBuf::from("crates.js");
@@ -339,6 +326,9 @@ struct CratesIndex;
 type CratesIndexPart = Part<CratesIndex, String>;
 impl CciPart for CratesIndexPart {
     type FileFormat = sorted_template::Html;
+    fn from_crate_info(crate_info: &CrateInfo) -> &PartsAndLocations<Self> {
+        &crate_info.crates_index
+    }
 }
 
 impl CratesIndexPart {
@@ -354,10 +344,11 @@ impl CratesIndexPart {
         };
         let layout = &cx.shared.layout;
         let style_files = &cx.shared.style_files;
-        const MAGIC: &str = "\u{FFFC}"; // users are being naughty if they have this
-        let content = format!("<h1>List of all crates</h1><ul class=\"all-items\">{MAGIC}</ul>");
+        const DELIMITER: &str = "\u{FFFC}"; // users are being naughty if they have this
+        let content =
+            format!("<h1>List of all crates</h1><ul class=\"all-items\">{DELIMITER}</ul>");
         let template = layout::render(layout, &page, "", content, &style_files);
-        match SortedTemplate::magic(&template, MAGIC) {
+        match SortedTemplate::from_template(&template, DELIMITER) {
             Ok(template) => template,
             Err(e) => panic!(
                 "Object Replacement Character (U+FFFC) should not appear in the --index-page: {e}"
@@ -385,6 +376,9 @@ struct Sources;
 type SourcesPart = Part<Sources, EscapedJson>;
 impl CciPart for SourcesPart {
     type FileFormat = sorted_template::Js;
+    fn from_crate_info(crate_info: &CrateInfo) -> &PartsAndLocations<Self> {
+        &crate_info.src_files_js
+    }
 }
 
 impl SourcesPart {
@@ -392,14 +386,14 @@ impl SourcesPart {
         // This needs to be `var`, not `const`.
         // This variable needs declared in the current global scope so that if
         // src-script.js loads first, it can pick it up.
-        SortedTemplate::before_after(
+        SortedTemplate::from_before_after(
             r"var srcIndex = new Map(JSON.parse('[",
             r"]'));
 createSrcSidebar();",
         )
     }
 
-    fn get(cx: &Context<'_>, crate_name: &SortedJson) -> Result<PartsAndLocations<Self>, Error> {
+    fn get(cx: &Context<'_>, crate_name: &OrderedJson) -> Result<PartsAndLocations<Self>, Error> {
         let hierarchy = Rc::new(Hierarchy::default());
         cx.shared
             .local_sources
@@ -408,7 +402,7 @@ createSrcSidebar();",
             .for_each(|source| hierarchy.add_path(source));
         let path = suffix_path("src-files.js", &cx.shared.resource_suffix);
         let hierarchy = hierarchy.to_json_string();
-        let part = SortedJson::array_unsorted([crate_name, &hierarchy]);
+        let part = OrderedJson::array_unsorted([crate_name, &hierarchy]);
         let part = EscapedJson::from(part);
         Ok(PartsAndLocations::with(path, part))
     }
@@ -428,21 +422,23 @@ impl Hierarchy {
         Self { elem, parent: Rc::downgrade(parent), ..Self::default() }
     }
 
-    fn to_json_string(&self) -> SortedJson {
+    fn to_json_string(&self) -> OrderedJson {
         let subs = self.children.borrow();
         let files = self.elems.borrow();
-        let name = SortedJson::serialize(self.elem.to_str().expect("invalid osstring conversion"));
+        let name = OrderedJson::serialize(self.elem.to_str().expect("invalid osstring conversion"))
+            .unwrap();
         let mut out = Vec::from([name]);
         if !subs.is_empty() || !files.is_empty() {
             let subs = subs.iter().map(|(_, s)| s.to_json_string());
-            out.push(SortedJson::array(subs));
+            out.push(OrderedJson::array_sorted(subs));
         }
         if !files.is_empty() {
-            let files =
-                files.iter().map(|s| SortedJson::serialize(s.to_str().expect("invalid osstring")));
-            out.push(SortedJson::array(files));
+            let files = files
+                .iter()
+                .map(|s| OrderedJson::serialize(s.to_str().expect("invalid osstring")).unwrap());
+            out.push(OrderedJson::array_sorted(files));
         }
-        SortedJson::array_unsorted(out)
+        OrderedJson::array_unsorted(out)
     }
 
     fn add_path(self: &Rc<Self>, path: &Path) {
@@ -481,14 +477,17 @@ impl Hierarchy {
 
 #[derive(Serialize, Deserialize, Clone, Default, Debug)]
 struct TypeAlias;
-type TypeAliasPart = Part<TypeAlias, SortedJson>;
+type TypeAliasPart = Part<TypeAlias, OrderedJson>;
 impl CciPart for TypeAliasPart {
     type FileFormat = sorted_template::Js;
+    fn from_crate_info(crate_info: &CrateInfo) -> &PartsAndLocations<Self> {
+        &crate_info.type_impl
+    }
 }
 
 impl TypeAliasPart {
     fn blank() -> SortedTemplate<<Self as CciPart>::FileFormat> {
-        SortedTemplate::before_after(
+        SortedTemplate::from_before_after(
             r"(function() {
     var type_impls = Object.fromEntries([",
             r"]);
@@ -504,7 +503,7 @@ impl TypeAliasPart {
     fn get(
         cx: &mut Context<'_>,
         krate: &Crate,
-        crate_name_json: &SortedJson,
+        crate_name_json: &OrderedJson,
     ) -> Result<PartsAndLocations<Self>, Error> {
         let cache = &Rc::clone(&cx.shared).cache;
         let mut path_parts = PartsAndLocations::default();
@@ -594,9 +593,10 @@ impl TypeAliasPart {
                 aliased_type.target_fqp[aliased_type.target_fqp.len() - 1]
             ));
 
-            let part =
-                SortedJson::array(impls.iter().map(SortedJson::serialize).collect::<Vec<_>>());
-            path_parts.push(path, SortedJson::array_unsorted([crate_name_json, &part]));
+            let part = OrderedJson::array_sorted(
+                impls.iter().map(OrderedJson::serialize).collect::<Result<Vec<_>, _>>().unwrap(),
+            );
+            path_parts.push(path, OrderedJson::array_unsorted([crate_name_json, &part]));
         }
         Ok(path_parts)
     }
@@ -604,14 +604,17 @@ impl TypeAliasPart {
 
 #[derive(Serialize, Deserialize, Clone, Default, Debug)]
 struct TraitAlias;
-type TraitAliasPart = Part<TraitAlias, SortedJson>;
+type TraitAliasPart = Part<TraitAlias, OrderedJson>;
 impl CciPart for TraitAliasPart {
     type FileFormat = sorted_template::Js;
+    fn from_crate_info(crate_info: &CrateInfo) -> &PartsAndLocations<Self> {
+        &crate_info.trait_impl
+    }
 }
 
 impl TraitAliasPart {
     fn blank() -> SortedTemplate<<Self as CciPart>::FileFormat> {
-        SortedTemplate::before_after(
+        SortedTemplate::from_before_after(
             r"(function() {
     var implementors = Object.fromEntries([",
             r"]);
@@ -626,7 +629,7 @@ impl TraitAliasPart {
 
     fn get(
         cx: &mut Context<'_>,
-        crate_name_json: &SortedJson,
+        crate_name_json: &OrderedJson,
     ) -> Result<PartsAndLocations<Self>, Error> {
         let cache = &cx.shared.cache;
         let mut path_parts = PartsAndLocations::default();
@@ -688,10 +691,14 @@ impl TraitAliasPart {
             }
             path.push(&format!("{remote_item_type}.{}.js", remote_path[remote_path.len() - 1]));
 
-            let part = SortedJson::array(
-                implementors.iter().map(SortedJson::serialize).collect::<Vec<_>>(),
+            let part = OrderedJson::array_sorted(
+                implementors
+                    .iter()
+                    .map(OrderedJson::serialize)
+                    .collect::<Result<Vec<_>, _>>()
+                    .unwrap(),
             );
-            path_parts.push(path, SortedJson::array_unsorted([crate_name_json, &part]));
+            path_parts.push(path, OrderedJson::array_unsorted([crate_name_json, &part]));
         }
         Ok(path_parts)
     }
@@ -864,13 +871,15 @@ fn get_path_parts<T: CciPart>(
     crates_info: &[CrateInfo],
 ) -> FxHashMap<PathBuf, Vec<String>> {
     let mut templates: FxHashMap<PathBuf, Vec<String>> = FxHashMap::default();
-    crates_info.iter().map(|crate_info| crate_info.get::<T>().parts.iter()).flatten().for_each(
-        |(path, part)| {
+    crates_info
+        .iter()
+        .map(|crate_info| T::from_crate_info(crate_info).parts.iter())
+        .flatten()
+        .for_each(|(path, part)| {
             let path = dst.join(&path);
             let part = part.to_string();
             templates.entry(path).or_default().push(part);
-        },
-    );
+        });
     templates
 }
 
diff --git a/src/librustdoc/html/render/write_shared/tests.rs b/src/librustdoc/html/render/write_shared/tests.rs
index 000e233aec00f..4d1874b7df5f9 100644
--- a/src/librustdoc/html/render/write_shared/tests.rs
+++ b/src/librustdoc/html/render/write_shared/tests.rs
@@ -1,4 +1,4 @@
-use crate::html::render::sorted_json::{EscapedJson, SortedJson};
+use crate::html::render::ordered_json::{EscapedJson, OrderedJson};
 use crate::html::render::sorted_template::{Html, SortedTemplate};
 use crate::html::render::write_shared::*;
 
@@ -26,13 +26,13 @@ fn sources_template() {
         r"var srcIndex = new Map(JSON.parse('[]'));
 createSrcSidebar();"
     );
-    template.append(EscapedJson::from(SortedJson::serialize("u")).to_string());
+    template.append(EscapedJson::from(OrderedJson::serialize("u").unwrap()).to_string());
     assert_eq!(
         but_last_line(&template.to_string()),
         r#"var srcIndex = new Map(JSON.parse('["u"]'));
 createSrcSidebar();"#
     );
-    template.append(EscapedJson::from(SortedJson::serialize("v")).to_string());
+    template.append(EscapedJson::from(OrderedJson::serialize("v").unwrap()).to_string());
     assert_eq!(
         but_last_line(&template.to_string()),
         r#"var srcIndex = new Map(JSON.parse('["u","v"]'));
@@ -42,7 +42,8 @@ createSrcSidebar();"#
 
 #[test]
 fn sources_parts() {
-    let parts = SearchIndexPart::get(SortedJson::serialize(["foo", "bar"]), "suffix").unwrap();
+    let parts =
+        SearchIndexPart::get(OrderedJson::serialize(["foo", "bar"]).unwrap(), "suffix").unwrap();
     assert_eq!(&parts.parts[0].0, Path::new("search-indexsuffix.js"));
     assert_eq!(&parts.parts[0].1.to_string(), r#"["foo","bar"]"#);
 }
@@ -51,15 +52,15 @@ fn sources_parts() {
 fn all_crates_template() {
     let mut template = AllCratesPart::blank();
     assert_eq!(but_last_line(&template.to_string()), r"window.ALL_CRATES = [];");
-    template.append(EscapedJson::from(SortedJson::serialize("b")).to_string());
+    template.append(EscapedJson::from(OrderedJson::serialize("b").unwrap()).to_string());
     assert_eq!(but_last_line(&template.to_string()), r#"window.ALL_CRATES = ["b"];"#);
-    template.append(EscapedJson::from(SortedJson::serialize("a")).to_string());
+    template.append(EscapedJson::from(OrderedJson::serialize("a").unwrap()).to_string());
     assert_eq!(but_last_line(&template.to_string()), r#"window.ALL_CRATES = ["a","b"];"#);
 }
 
 #[test]
 fn all_crates_parts() {
-    let parts = AllCratesPart::get(SortedJson::serialize("crate")).unwrap();
+    let parts = AllCratesPart::get(OrderedJson::serialize("crate").unwrap()).unwrap();
     assert_eq!(&parts.parts[0].0, Path::new("crates.js"));
     assert_eq!(&parts.parts[0].1.to_string(), r#""crate""#);
 }
@@ -73,14 +74,14 @@ fn search_index_template() {
 if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
 else if (window.initSearch) window.initSearch(searchIndex);"
     );
-    template.append(EscapedJson::from(SortedJson::serialize([1, 2])).to_string());
+    template.append(EscapedJson::from(OrderedJson::serialize([1, 2]).unwrap()).to_string());
     assert_eq!(
         but_last_line(&template.to_string()),
         r"var searchIndex = new Map(JSON.parse('[[1,2]]'));
 if (typeof exports !== 'undefined') exports.searchIndex = searchIndex;
 else if (window.initSearch) window.initSearch(searchIndex);"
     );
-    template.append(EscapedJson::from(SortedJson::serialize([4, 3])).to_string());
+    template.append(EscapedJson::from(OrderedJson::serialize([4, 3]).unwrap()).to_string());
     assert_eq!(
         but_last_line(&template.to_string()),
         r"var searchIndex = new Map(JSON.parse('[[1,2],[4,3]]'));
@@ -119,7 +120,7 @@ fn trait_alias_template() {
     }
 })()"#,
     );
-    template.append(SortedJson::serialize(["a"]).to_string());
+    template.append(OrderedJson::serialize(["a"]).unwrap().to_string());
     assert_eq!(
         but_last_line(&template.to_string()),
         r#"(function() {
@@ -131,7 +132,7 @@ fn trait_alias_template() {
     }
 })()"#,
     );
-    template.append(SortedJson::serialize(["b"]).to_string());
+    template.append(OrderedJson::serialize(["b"]).unwrap().to_string());
     assert_eq!(
         but_last_line(&template.to_string()),
         r#"(function() {
@@ -159,7 +160,7 @@ fn type_alias_template() {
     }
 })()"#,
     );
-    template.append(SortedJson::serialize(["a"]).to_string());
+    template.append(OrderedJson::serialize(["a"]).unwrap().to_string());
     assert_eq!(
         but_last_line(&template.to_string()),
         r#"(function() {
@@ -171,7 +172,7 @@ fn type_alias_template() {
     }
 })()"#,
     );
-    template.append(SortedJson::serialize(["b"]).to_string());
+    template.append(OrderedJson::serialize(["b"]).unwrap().to_string());
     assert_eq!(
         but_last_line(&template.to_string()),
         r#"(function() {
@@ -189,7 +190,7 @@ fn type_alias_template() {
 fn read_template_test() {
     let path = tempfile::TempDir::new().unwrap();
     let path = path.path().join("file.html");
-    let make_blank = || SortedTemplate::<Html>::before_after("<div>", "</div>");
+    let make_blank = || SortedTemplate::<Html>::from_before_after("<div>", "</div>");
 
     let template = read_template_or_blank(make_blank, &path).unwrap();
     assert_eq!(but_last_line(&template.to_string()), "<div></div>");

From 0732f7d5e1ea2b735db98d53b628e512f8d5a372 Mon Sep 17 00:00:00 2001
From: daxpedda <daxpedda@gmail.com>
Date: Sun, 8 Oct 2023 10:54:15 +0200
Subject: [PATCH 069/685] Stabilize `Ready::into_inner()`

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

diff --git a/library/core/src/future/ready.rs b/library/core/src/future/ready.rs
index a07b63fb62b90..6f6da8ce51ddf 100644
--- a/library/core/src/future/ready.rs
+++ b/library/core/src/future/ready.rs
@@ -34,13 +34,12 @@ impl<T> Ready<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(ready_into_inner)]
     /// use std::future;
     ///
     /// let a = future::ready(1);
     /// assert_eq!(a.into_inner(), 1);
     /// ```
-    #[unstable(feature = "ready_into_inner", issue = "101196")]
+    #[stable(feature = "ready_into_inner", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     #[inline]
     pub fn into_inner(self) -> T {

From 6ce7e6d99f8bc97375f70331204c78f6438e7495 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 8 Aug 2024 11:56:12 -0400
Subject: [PATCH 070/685] Rename struct_tail_erasing_lifetimes to
 struct_tail_for_codegen

---
 clippy_utils/src/qualify_min_const_fn.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index f206b2ceebcb1..553af913ef9df 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -142,7 +142,7 @@ fn check_rvalue<'tcx>(
                 // We cannot allow this for now.
                 return Err((span, "unsizing casts are only allowed for references right now".into()));
             };
-            let unsized_ty = tcx.struct_tail_erasing_lifetimes(pointee_ty, tcx.param_env(def_id));
+            let unsized_ty = tcx.struct_tail_for_codegen(pointee_ty, tcx.param_env(def_id));
             if let ty::Slice(_) | ty::Str = unsized_ty.kind() {
                 check_operand(tcx, op, span, body, msrv)?;
                 // Casting/coercing things to slices is fine.

From b4f057f01ddb414d250c0a70d1feb966cdfa9d99 Mon Sep 17 00:00:00 2001
From: EtomicBomb <ethan@ethan.ws>
Date: Fri, 26 Jul 2024 17:09:32 +0000
Subject: [PATCH 071/685] fix typos, more Self

typos in comments, remove references to crate-info, Self type in
ordered_json and sorted_template
---
 src/librustdoc/html/render/ordered_json.rs    | 20 ++++++++-----------
 src/librustdoc/html/render/sorted_template.rs |  6 +++---
 src/librustdoc/html/render/write_shared.rs    |  4 ++--
 3 files changed, 13 insertions(+), 17 deletions(-)

diff --git a/src/librustdoc/html/render/ordered_json.rs b/src/librustdoc/html/render/ordered_json.rs
index 3f76ff659d04e..7abe40eef3bdb 100644
--- a/src/librustdoc/html/render/ordered_json.rs
+++ b/src/librustdoc/html/render/ordered_json.rs
@@ -5,7 +5,7 @@ use itertools::Itertools as _;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-/// Prerenedered json.
+/// Prerendered json.
 ///
 /// Both the Display and serde_json::to_string implementations write the serialized json
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
@@ -16,25 +16,21 @@ pub(crate) struct OrderedJson(String);
 impl OrderedJson {
     /// If you pass in an array, it will not be sorted.
     pub(crate) fn serialize<T: Serialize>(item: T) -> Result<Self, serde_json::Error> {
-        Ok(OrderedJson(serde_json::to_string(&item)?))
+        Ok(Self(serde_json::to_string(&item)?))
     }
 
     /// Serializes and sorts
-    pub(crate) fn array_sorted<T: Borrow<OrderedJson>, I: IntoIterator<Item = T>>(
-        items: I,
-    ) -> Self {
+    pub(crate) fn array_sorted<T: Borrow<Self>, I: IntoIterator<Item = T>>(items: I) -> Self {
         let items = items
             .into_iter()
             .sorted_unstable_by(|a, b| a.borrow().cmp(&b.borrow()))
             .format_with(",", |item, f| f(item.borrow()));
-        OrderedJson(format!("[{}]", items))
+        Self(format!("[{}]", items))
     }
 
-    pub(crate) fn array_unsorted<T: Borrow<OrderedJson>, I: IntoIterator<Item = T>>(
-        items: I,
-    ) -> Self {
+    pub(crate) fn array_unsorted<T: Borrow<Self>, I: IntoIterator<Item = T>>(items: I) -> Self {
         let items = items.into_iter().format_with(",", |item, f| f(item.borrow()));
-        OrderedJson(format!("[{items}]"))
+        Self(format!("[{items}]"))
     }
 }
 
@@ -48,7 +44,7 @@ impl From<Value> for OrderedJson {
     fn from(value: Value) -> Self {
         let serialized =
             serde_json::to_string(&value).expect("Serializing a Value to String should never fail");
-        OrderedJson(serialized)
+        Self(serialized)
     }
 }
 
@@ -69,7 +65,7 @@ pub(crate) struct EscapedJson(OrderedJson);
 
 impl From<OrderedJson> for EscapedJson {
     fn from(json: OrderedJson) -> Self {
-        EscapedJson(json)
+        Self(json)
     }
 }
 
diff --git a/src/librustdoc/html/render/sorted_template.rs b/src/librustdoc/html/render/sorted_template.rs
index 1dc70408f013d..28f7766d7c7ac 100644
--- a/src/librustdoc/html/render/sorted_template.rs
+++ b/src/librustdoc/html/render/sorted_template.rs
@@ -28,7 +28,7 @@ struct Offset {
 
 impl<F> SortedTemplate<F> {
     /// Generate this template from arbitary text.
-    /// Will insert wherever the substring `magic` can be found.
+    /// Will insert wherever the substring `delimiter` can be found.
     /// Errors if it does not appear exactly once.
     pub(crate) fn from_template(template: &str, delimiter: &str) -> Result<Self, Error> {
         let mut split = template.split(delimiter);
@@ -45,7 +45,7 @@ impl<F> SortedTemplate<F> {
     pub(crate) fn from_before_after<S: ToString, T: ToString>(before: S, after: T) -> Self {
         let before = before.to_string();
         let after = after.to_string();
-        SortedTemplate { format: PhantomData, before, after, fragments: Default::default() }
+        Self { format: PhantomData, before, after, fragments: Default::default() }
     }
 }
 
@@ -100,7 +100,7 @@ impl<F: FileFormat> FromStr for SortedTemplate<F> {
                 .ok_or(Error("invalid fragment length: expected to find separator here"))?;
             fragments.insert(fragment.to_string());
         }
-        Ok(SortedTemplate {
+        Ok(Self {
             format: PhantomData,
             before: before.to_string(),
             after: s.to_string(),
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index ef3c35c20ab01..a18b7a252a402 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -55,7 +55,7 @@ use crate::html::static_files::{self, suffix_path};
 use crate::visit::DocVisitor;
 use crate::{try_err, try_none};
 
-/// Write crate-info.json cross-crate information, static files, invocation-specific files, etc. to disk
+/// Write cross-crate information files, static files, invocation-specific files, etc. to disk
 pub(crate) fn write_shared(
     cx: &mut Context<'_>,
     krate: &Crate,
@@ -184,7 +184,7 @@ fn write_search_desc(
     Ok(())
 }
 
-/// Written to `crate-info.json`. Contains pre-rendered contents to insert into the CCI template
+/// Contains pre-rendered contents to insert into the CCI template
 #[derive(Serialize, Deserialize, Clone, Debug)]
 struct CrateInfo {
     src_files_js: PartsAndLocations<SourcesPart>,

From 1ac76a2062b94b72c36650d21ac1af40b4aea0e3 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 8 Aug 2024 19:13:50 +0200
Subject: [PATCH 072/685] Merge commit
 'cb806113e0f83a8f9b47d35b453b676543bcc40e' into clippy-subtree-update

---
 .cargo/config.toml                            |   7 +
 .github/workflows/clippy.yml                  |  13 +-
 .github/workflows/clippy_bors.yml             |  17 +-
 .github/workflows/clippy_dev.yml              |   5 +-
 .github/workflows/lintcheck.yml               |   4 +-
 CHANGELOG.md                                  |   2 +
 Cargo.toml                                    |   3 +-
 book/src/lint_configuration.md                |   6 +-
 clippy_config/Cargo.toml                      |   4 +-
 clippy_config/src/conf.rs                     | 724 +++++++++---------
 clippy_config/src/lib.rs                      |   3 +-
 clippy_config/src/metadata.rs                 | 105 +--
 clippy_dev/Cargo.toml                         |   3 -
 clippy_dev/src/fmt.rs                         | 392 +++++++---
 clippy_dev/src/lib.rs                         |   1 -
 clippy_dev/src/main.rs                        |   5 +-
 clippy_dev/src/serve.rs                       |  15 +-
 clippy_dev/src/update_lints.rs                | 324 +++-----
 clippy_lints/Cargo.toml                       |   1 -
 clippy_lints/src/approx_const.rs              |   2 +-
 clippy_lints/src/as_conversions.rs            |  10 +-
 clippy_lints/src/asm_syntax.rs                |  22 +-
 clippy_lints/src/assertions_on_constants.rs   |   4 +-
 .../src/assertions_on_result_states.rs        |  47 +-
 clippy_lints/src/assigning_clones.rs          |  29 +-
 clippy_lints/src/attrs/allow_attributes.rs    |  20 +-
 .../attrs/allow_attributes_without_reason.rs  |  10 +-
 clippy_lints/src/bool_to_int_with_if.rs       |   4 +-
 clippy_lints/src/booleans.rs                  |  10 +-
 clippy_lints/src/casts/cast_lossless.rs       |   8 +-
 clippy_lints/src/casts/cast_nan_to_int.rs     |   4 +-
 .../src/casts/cast_possible_truncation.rs     |   4 +-
 clippy_lints/src/casts/cast_sign_loss.rs      |   6 +-
 .../src/casts/fn_to_numeric_cast_any.rs       |  37 +-
 clippy_lints/src/casts/zero_ptr.rs            |   4 +-
 clippy_lints/src/checked_conversions.rs       |   4 +-
 clippy_lints/src/comparison_chain.rs          |   4 +-
 clippy_lints/src/create_dir.rs                |  24 +-
 clippy_lints/src/dbg_macro.rs                 | 108 +--
 clippy_lints/src/declared_lints.rs            |   3 +-
 clippy_lints/src/default.rs                   |   2 +-
 clippy_lints/src/default_numeric_fallback.rs  |  23 +-
 .../src/default_union_representation.rs       |  16 +-
 clippy_lints/src/deprecated_lints.rs          | 394 ++++------
 clippy_lints/src/dereference.rs               |   4 +-
 clippy_lints/src/doc/mod.rs                   |   9 +-
 clippy_lints/src/drop_forget_ref.rs           |  18 +-
 clippy_lints/src/else_if_without_else.rs      |  10 +-
 clippy_lints/src/empty_drop.rs                |  19 +-
 clippy_lints/src/endian_bytes.rs              |  89 +--
 clippy_lints/src/enum_clike.rs                |   2 +-
 clippy_lints/src/eta_reduction.rs             | 327 ++++----
 clippy_lints/src/exhaustive_items.rs          |   6 +-
 .../src/field_scoped_visibility_modifiers.rs  |  10 +-
 clippy_lints/src/float_literal.rs             |  45 +-
 clippy_lints/src/floating_point_arithmetic.rs |  36 +-
 clippy_lints/src/format_push_string.rs        |  10 +-
 clippy_lints/src/from_str_radix_10.rs         |   6 +-
 clippy_lints/src/if_let_mutex.rs              |  66 +-
 clippy_lints/src/if_not_else.rs               |   4 +-
 clippy_lints/src/if_then_some_else_none.rs    |  47 +-
 clippy_lints/src/implicit_hasher.rs           |  53 +-
 clippy_lints/src/implicit_return.rs           |  21 +-
 clippy_lints/src/implicit_saturating_add.rs   |   8 +-
 clippy_lints/src/incompatible_msrv.rs         |   7 +-
 clippy_lints/src/index_refutable_slice.rs     |   4 +-
 clippy_lints/src/indexing_slicing.rs          |  11 +-
 clippy_lints/src/infinite_iter.rs             |   1 -
 clippy_lints/src/inherent_impl.rs             |   9 +-
 .../src/invalid_upcast_comparisons.rs         |   4 +-
 clippy_lints/src/large_include_file.rs        |  16 +-
 clippy_lints/src/let_underscore.rs            |  58 +-
 clippy_lints/src/lib.deprecated.rs            |  78 --
 clippy_lints/src/lib.rs                       |  81 +-
 clippy_lints/src/literal_representation.rs    |  77 +-
 .../src/loops/explicit_counter_loop.rs        |   8 +-
 clippy_lints/src/loops/for_kv_map.rs          |   7 +-
 .../src/loops/manual_while_let_some.rs        |   7 +-
 clippy_lints/src/loops/mod.rs                 |  10 +-
 clippy_lints/src/loops/needless_range_loop.rs |  11 +-
 .../src/loops/unused_enumerate_index.rs       |   7 +-
 .../src/loops/while_immutable_condition.rs    |   4 +-
 .../src/loops/while_let_on_iterator.rs        |   7 +-
 clippy_lints/src/manual_clamp.rs              |  13 +-
 clippy_lints/src/manual_float_methods.rs      |   7 +-
 clippy_lints/src/manual_is_ascii_check.rs     |   4 +-
 clippy_lints/src/manual_rem_euclid.rs         |   8 +-
 clippy_lints/src/manual_rotate.rs             |   4 +-
 .../src/manual_slice_size_calculation.rs      |   4 +-
 clippy_lints/src/manual_strip.rs              |  26 +-
 clippy_lints/src/manual_unwrap_or_default.rs  |   4 +-
 clippy_lints/src/matches/manual_unwrap_or.rs  |   4 +-
 clippy_lints/src/matches/match_ref_pats.rs    |   8 +-
 clippy_lints/src/matches/match_wild_enum.rs   |  39 +-
 .../src/matches/match_wild_err_arm.rs         |   4 +-
 clippy_lints/src/matches/mod.rs               |   6 +-
 clippy_lints/src/matches/overlapping_arms.rs  |  30 +-
 clippy_lints/src/matches/redundant_guards.rs  |   4 +-
 .../matches/rest_pat_in_fully_bound_struct.rs |  10 +-
 clippy_lints/src/matches/single_match.rs      | 394 ++++++----
 clippy_lints/src/matches/try_err.rs           |  39 +-
 .../src/methods/bind_instead_of_map.rs        |  19 +-
 clippy_lints/src/methods/clone_on_ref_ptr.rs  |  23 +-
 clippy_lints/src/methods/filetype_is_file.rs  |   9 +-
 clippy_lints/src/methods/get_unwrap.rs        |  44 +-
 clippy_lints/src/methods/implicit_clone.rs    |   6 +-
 .../src/methods/is_digit_ascii_radix.rs       |   4 +-
 clippy_lints/src/methods/is_empty.rs          |   4 +-
 clippy_lints/src/methods/iter_kv_map.rs       |  15 +-
 clippy_lints/src/methods/iter_nth_zero.rs     |   4 +-
 clippy_lints/src/methods/iter_skip_zero.rs    |   4 +-
 .../src/methods/iterator_step_by_zero.rs      |   4 +-
 clippy_lints/src/methods/map_clone.rs         |   6 +-
 clippy_lints/src/methods/map_err_ignore.rs    |  12 +-
 clippy_lints/src/methods/mod.rs               |  28 +-
 clippy_lints/src/methods/open_options.rs      |   2 +-
 clippy_lints/src/methods/repeat_once.rs       |   4 +-
 clippy_lints/src/methods/str_splitn.rs        |   4 +-
 .../src/methods/unnecessary_min_or_max.rs     |  13 +-
 .../src/methods/unnecessary_to_owned.rs       |  13 +-
 .../src/methods/unused_enumerate_index.rs     |   7 +-
 clippy_lints/src/methods/useless_asref.rs     |   6 +-
 .../src/methods/verbose_file_reads.rs         |   7 +-
 .../src/methods/wrong_self_convention.rs      |   2 +-
 clippy_lints/src/minmax.rs                    |  20 +-
 clippy_lints/src/misc_early/literal_suffix.rs |  30 +-
 .../src/misc_early/unneeded_field_pattern.rs  |  21 +-
 clippy_lints/src/missing_assert_message.rs    |  10 +-
 clippy_lints/src/missing_const_for_fn.rs      |   2 +-
 clippy_lints/src/missing_trait_methods.rs     |  46 +-
 .../src/mixed_read_write_in_expression.rs     |  12 +-
 clippy_lints/src/module_style.rs              |  32 +-
 .../src/needless_borrows_for_generic_args.rs  |  48 +-
 clippy_lints/src/needless_pass_by_value.rs    |  11 +-
 clippy_lints/src/no_effect.rs                 |   2 +-
 clippy_lints/src/non_copy_const.rs            |   4 +-
 clippy_lints/src/only_used_in_recursion.rs    |   1 -
 .../operators/absurd_extreme_comparisons.rs   |   4 +-
 .../src/operators/arithmetic_side_effects.rs  |  10 +-
 clippy_lints/src/operators/bit_mask.rs        |   4 +-
 .../src/operators/const_comparisons.rs        |   7 +-
 clippy_lints/src/operators/duration_subsec.rs |   4 +-
 clippy_lints/src/operators/erasing_op.rs      |   6 +-
 clippy_lints/src/operators/float_cmp.rs       |   8 +-
 clippy_lints/src/operators/identity_op.rs     |  13 +-
 .../src/operators/integer_division.rs         |  14 +-
 .../src/operators/modulo_arithmetic.rs        |  16 +-
 .../src/operators/numeric_arithmetic.rs       |   4 +-
 clippy_lints/src/operators/op_ref.rs          |   6 +-
 clippy_lints/src/option_if_let_else.rs        |   6 +-
 clippy_lints/src/partial_pub_fields.rs        |  26 +-
 clippy_lints/src/pathbuf_init_then_push.rs    |   4 +-
 clippy_lints/src/pattern_type_mismatch.rs     |  30 +-
 clippy_lints/src/pub_use.rs                   |  14 +-
 clippy_lints/src/question_mark.rs             |   8 +-
 clippy_lints/src/question_mark_used.rs        |  10 +-
 clippy_lints/src/ranges.rs                    |  15 +-
 clippy_lints/src/redundant_clone.rs           |   2 +-
 clippy_lints/src/redundant_slicing.rs         |  68 +-
 clippy_lints/src/ref_patterns.rs              |  14 +-
 clippy_lints/src/regex.rs                     |   4 +-
 clippy_lints/src/renamed_lints.rs             |  65 --
 clippy_lints/src/repeat_vec_with_capacity.rs  |   4 +-
 clippy_lints/src/returns.rs                   |   2 +-
 clippy_lints/src/semicolon_block.rs           |  12 +-
 clippy_lints/src/set_contains_or_insert.rs    |  33 +-
 clippy_lints/src/shadow.rs                    |  13 +-
 .../src/single_char_lifetime_names.rs         |  10 +-
 clippy_lints/src/size_of_ref.rs               |   5 +-
 clippy_lints/src/std_instead_of_core.rs       |  69 +-
 clippy_lints/src/strings.rs                   |  23 +-
 .../src/suspicious_xor_used_as_pow.rs         |  15 +-
 clippy_lints/src/swap.rs                      |   4 +-
 clippy_lints/src/tests_outside_test_module.rs |  10 +-
 clippy_lints/src/transmute/mod.rs             |   4 +-
 .../src/transmute/transmute_null_to_fn.rs     |   7 +-
 .../src/transmute/transmuting_null.rs         |   4 +-
 clippy_lints/src/types/borrowed_box.rs        |  24 +-
 clippy_lints/src/types/rc_buffer.rs           |  62 +-
 clippy_lints/src/types/rc_mutex.rs            |  14 +-
 .../src/undocumented_unsafe_blocks.rs         |  53 +-
 clippy_lints/src/unicode.rs                   |  64 +-
 clippy_lints/src/unused_result_ok.rs          |  59 ++
 .../interning_defined_symbol.rs               |   6 +-
 .../src/utils/internal_lints/invalid_paths.rs |   8 +-
 .../internal_lints/lint_without_lint_pass.rs  |  85 +-
 .../internal_lints/metadata_collector.rs      | 117 ++-
 clippy_lints/src/vec.rs                       |   4 +-
 clippy_lints/src/visibility.rs                |  43 +-
 clippy_lints/src/zero_div_zero.rs             |   7 +-
 clippy_utils/Cargo.toml                       |   3 -
 clippy_utils/src/consts.rs                    | 279 ++++---
 clippy_utils/src/diagnostics.rs               |  29 -
 clippy_utils/src/eager_or_lazy.rs             |  16 +-
 clippy_utils/src/higher.rs                    |  13 +-
 clippy_utils/src/hir_utils.rs                 |  12 +-
 clippy_utils/src/lib.rs                       |  46 +-
 clippy_utils/src/paths.rs                     |   1 -
 clippy_utils/src/source.rs                    | 129 ++--
 clippy_utils/src/ty.rs                        |  13 -
 clippy_utils/src/visitors.rs                  |  98 ++-
 declare_clippy_lint/Cargo.toml                |   3 -
 declare_clippy_lint/src/lib.rs                |   1 -
 lintcheck/Cargo.toml                          |   3 -
 lintcheck/src/config.rs                       |   8 +-
 lintcheck/src/input.rs                        |   6 +-
 lintcheck/src/main.rs                         |  28 +-
 rust-toolchain                                |   2 +-
 rustc_tools_util/Cargo.toml                   |   3 -
 rustc_tools_util/src/lib.rs                   |  59 +-
 src/driver.rs                                 |   2 -
 src/main.rs                                   |   1 -
 tests/check-fmt.rs                            |   1 -
 tests/compile-test.rs                         |   6 +-
 tests/dogfood.rs                              |   1 -
 tests/integration.rs                          |   1 -
 tests/lint_message_convention.rs              |   1 -
 tests/missing-test-files.rs                   |   1 -
 .../ui-internal/default_deprecation_reason.rs |  30 -
 .../default_deprecation_reason.stderr         |  22 -
 .../excessive_nesting/excessive_nesting.rs    |  20 +-
 .../excessive_nesting.stderr                  |  74 +-
 tests/ui-toml/unwrap_used/unwrap_used.stderr  | 134 +++-
 tests/ui/assigning_clones.fixed               |  68 ++
 tests/ui/assigning_clones.rs                  |  68 ++
 tests/ui/assigning_clones.stderr              |  86 ++-
 tests/ui/bind_instead_of_map_multipart.stderr |  10 +-
 tests/ui/crashes/ice-3717.stderr              |  11 +-
 tests/ui/crashes/ice-6254.rs                  |   3 +-
 tests/ui/create_dir.stderr                    |  13 +-
 tests/ui/dbg_macro/dbg_macro.stderr           |   4 +-
 tests/ui/dbg_macro/dbg_macro_unfixable.stderr |   2 +-
 tests/ui/deprecated.rs                        |  31 +-
 tests/ui/deprecated.stderr                    |  68 +-
 tests/ui/deprecated_old.rs                    |   9 -
 tests/ui/deprecated_old.stderr                |  23 -
 tests/ui/deref_by_slicing.fixed               |   4 +
 tests/ui/deref_by_slicing.rs                  |   4 +
 tests/ui/deref_by_slicing.stderr              |   8 +-
 tests/ui/doc/footnote_issue_13183.rs          |  10 +
 tests/ui/empty_drop.stderr                    |   7 +-
 tests/ui/eta.fixed                            |  17 +
 tests/ui/eta.rs                               |  17 +
 tests/ui/eta.stderr                           |  74 +-
 tests/ui/excessive_precision.stderr           | 111 ++-
 tests/ui/explicit_counter_loop.rs             |  13 +
 tests/ui/explicit_counter_loop.stderr         |   8 +-
 tests/ui/fn_to_numeric_cast_any.stderr        | 118 ++-
 tests/ui/for_kv_map.fixed                     |  10 +
 tests/ui/for_kv_map.rs                        |  10 +
 tests/ui/for_kv_map.stderr                    |  13 +-
 tests/ui/get_unwrap.stderr                    | 152 +++-
 tests/ui/if_let_mutex.rs                      |   9 +
 tests/ui/if_let_mutex.stderr                  |  24 +-
 tests/ui/if_then_some_else_none.fixed         | 119 +++
 tests/ui/if_then_some_else_none.rs            |   2 +-
 tests/ui/if_then_some_else_none.stderr        |  19 +-
 tests/ui/implicit_hasher.fixed                | 102 +++
 tests/ui/implicit_hasher.rs                   |   9 +-
 tests/ui/implicit_hasher.stderr               | 131 +++-
 tests/ui/implicit_return.stderr               | 104 ++-
 tests/ui/lossy_float_literal.stderr           |  76 +-
 tests/ui/missing_trait_methods.rs             |   8 +
 tests/ui/missing_trait_methods.stderr         |  38 +-
 .../needless_borrows_for_generic_args.fixed   |   8 +
 tests/ui/needless_borrows_for_generic_args.rs |   8 +
 tests/ui/needless_pub_self.stderr             |  11 +-
 tests/ui/nonminimal_bool.rs                   |   6 +
 tests/ui/patterns.fixed                       |   2 +-
 tests/ui/patterns.rs                          |   2 +-
 tests/ui/rename.fixed                         | 131 ++--
 tests/ui/rename.rs                            | 131 ++--
 tests/ui/rename.stderr                        | 158 ++--
 tests/ui/set_contains_or_insert.rs            |  83 +-
 tests/ui/set_contains_or_insert.stderr        |  72 +-
 tests/ui/single_match.fixed                   |  43 ++
 tests/ui/single_match.rs                      |  49 ++
 tests/ui/single_match.stderr                  |  20 +-
 tests/ui/std_instead_of_core.fixed            |  17 +-
 tests/ui/std_instead_of_core.rs               |  17 +-
 tests/ui/std_instead_of_core.stderr           |  14 +-
 tests/ui/suspicious_xor_used_as_pow.stderr    |  47 +-
 tests/ui/try_err.fixed                        |  10 +-
 tests/ui/try_err.rs                           |  10 +-
 tests/ui/uninit_vec.rs                        |   2 +-
 tests/ui/unneeded_field_pattern.rs            |   2 +-
 tests/ui/unused_result_ok.fixed               |  40 +
 tests/ui/unused_result_ok.rs                  |  40 +
 tests/ui/unused_result_ok.stderr              |  52 ++
 tests/ui/unwrap_expect_used.rs                |   2 +-
 tests/ui/while_let_on_iterator.fixed          |   9 +
 tests/ui/while_let_on_iterator.rs             |   9 +
 tests/ui/while_let_on_iterator.stderr         |   8 +-
 tests/versioncheck.rs                         |   1 -
 tests/workspace_test/path_dep/Cargo.toml      |   3 +
 util/gh-pages/index.html                      |   4 +-
 util/gh-pages/script.js                       |  74 +-
 297 files changed, 5572 insertions(+), 4012 deletions(-)
 delete mode 100644 clippy_lints/src/lib.deprecated.rs
 delete mode 100644 clippy_lints/src/renamed_lints.rs
 create mode 100644 clippy_lints/src/unused_result_ok.rs
 delete mode 100644 tests/ui-internal/default_deprecation_reason.rs
 delete mode 100644 tests/ui-internal/default_deprecation_reason.stderr
 delete mode 100644 tests/ui/deprecated_old.rs
 delete mode 100644 tests/ui/deprecated_old.stderr
 create mode 100644 tests/ui/doc/footnote_issue_13183.rs
 create mode 100644 tests/ui/if_then_some_else_none.fixed
 create mode 100644 tests/ui/implicit_hasher.fixed
 create mode 100644 tests/ui/unused_result_ok.fixed
 create mode 100644 tests/ui/unused_result_ok.rs
 create mode 100644 tests/ui/unused_result_ok.stderr

diff --git a/.cargo/config.toml b/.cargo/config.toml
index 7afdd068a9905..ce07290d1e1e5 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -13,6 +13,13 @@ target-dir = "target"
 
 [unstable]
 binary-dep-depinfo = true
+profile-rustflags = true
 
 [profile.dev]
 split-debuginfo = "unpacked"
+
+# Add back the containing directory of the packages we have to refer to using --manifest-path
+[profile.dev.package.clippy_dev]
+rustflags = ["--remap-path-prefix", "=clippy_dev"]
+[profile.dev.package.lintcheck]
+rustflags = ["--remap-path-prefix", "=lintcheck"]
diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml
index 06bf3b6fdbfab..0a0538490cce9 100644
--- a/.github/workflows/clippy.yml
+++ b/.github/workflows/clippy.yml
@@ -25,6 +25,7 @@ env:
   CARGO_TARGET_DIR: '${{ github.workspace }}/target'
   NO_FMT_TEST: 1
   CARGO_INCREMENTAL: 0
+  RUSTFLAGS: -D warnings
 
 concurrency:
   # For a given workflow, if we push to the same PR, cancel all previous builds on that PR.
@@ -47,25 +48,25 @@ jobs:
 
     # Run
     - name: Build
-      run: cargo build --tests --features deny-warnings,internal
+      run: cargo build --tests --features internal
 
     - name: Test
-      run: cargo test --features deny-warnings,internal
+      run: cargo test --features internal
 
     - name: Test clippy_lints
-      run: cargo test --features deny-warnings,internal
+      run: cargo test --features internal
       working-directory: clippy_lints
 
     - name: Test clippy_utils
-      run: cargo test --features deny-warnings
+      run: cargo test
       working-directory: clippy_utils
 
     - name: Test rustc_tools_util
-      run: cargo test --features deny-warnings
+      run: cargo test
       working-directory: rustc_tools_util
 
     - name: Test clippy_dev
-      run: cargo test --features deny-warnings
+      run: cargo test
       working-directory: clippy_dev
 
     - name: Test clippy-driver
diff --git a/.github/workflows/clippy_bors.yml b/.github/workflows/clippy_bors.yml
index 1f4bec9291823..10e18e84c89fd 100644
--- a/.github/workflows/clippy_bors.yml
+++ b/.github/workflows/clippy_bors.yml
@@ -11,6 +11,7 @@ env:
   CARGO_TARGET_DIR: '${{ github.workspace }}/target'
   NO_FMT_TEST: 1
   CARGO_INCREMENTAL: 0
+  RUSTFLAGS: -D warnings
 
 concurrency:
   # For a given workflow, if we push to the same branch, cancel all previous builds on that branch.
@@ -85,34 +86,34 @@ jobs:
 
     # Run
     - name: Build
-      run: cargo build --tests --features deny-warnings,internal
+      run: cargo build --tests --features internal
 
     - name: Test
       if: matrix.host == 'x86_64-unknown-linux-gnu'
-      run: cargo test --features deny-warnings,internal
+      run: cargo test --features internal
 
     - name: Test
       if: matrix.host != 'x86_64-unknown-linux-gnu'
-      run: cargo test --features deny-warnings,internal -- --skip dogfood
+      run: cargo test --features internal -- --skip dogfood
 
     - name: Test clippy_lints
-      run: cargo test --features deny-warnings,internal
+      run: cargo test --features internal
       working-directory: clippy_lints
 
     - name: Test clippy_utils
-      run: cargo test --features deny-warnings
+      run: cargo test
       working-directory: clippy_utils
 
     - name: Test clippy_config
-      run: cargo test --features deny-warnings
+      run: cargo test
       working-directory: clippy_config
 
     - name: Test rustc_tools_util
-      run: cargo test --features deny-warnings
+      run: cargo test
       working-directory: rustc_tools_util
 
     - name: Test clippy_dev
-      run: cargo test --features deny-warnings
+      run: cargo test
       working-directory: clippy_dev
 
     - name: Test clippy-driver
diff --git a/.github/workflows/clippy_dev.yml b/.github/workflows/clippy_dev.yml
index 37f18a4c08740..cf0a8bde202ad 100644
--- a/.github/workflows/clippy_dev.yml
+++ b/.github/workflows/clippy_dev.yml
@@ -16,6 +16,7 @@ on:
 env:
   RUST_BACKTRACE: 1
   CARGO_INCREMENTAL: 0
+  RUSTFLAGS: -D warnings
 
 jobs:
   clippy_dev:
@@ -28,7 +29,7 @@ jobs:
 
     # Run
     - name: Build
-      run: cargo build --features deny-warnings
+      run: cargo build
       working-directory: clippy_dev
 
     - name: Test update_lints
@@ -38,6 +39,8 @@ jobs:
       run: cargo dev fmt --check
 
     - name: Test cargo dev new lint
+      env:
+        RUSTFLAGS: -A unused-imports
       run: |
         cargo dev new_lint --name new_early_pass --pass early
         cargo dev new_lint --name new_late_pass --pass late
diff --git a/.github/workflows/lintcheck.yml b/.github/workflows/lintcheck.yml
index 6a5139b6dc0bb..3cbda0b382436 100644
--- a/.github/workflows/lintcheck.yml
+++ b/.github/workflows/lintcheck.yml
@@ -58,7 +58,7 @@ jobs:
 
     - name: Run lintcheck
       if: steps.cache-json.outputs.cache-hit != 'true'
-      run: ./target/debug/lintcheck --format json --warn-all --crates-toml ./lintcheck/ci_crates.toml
+      run: ./target/debug/lintcheck --format json --all-lints --crates-toml ./lintcheck/ci_crates.toml
 
     - name: Upload base JSON
       uses: actions/upload-artifact@v4
@@ -86,7 +86,7 @@ jobs:
       run: cargo build --manifest-path=lintcheck/Cargo.toml
 
     - name: Run lintcheck
-      run: ./target/debug/lintcheck --format json --warn-all --crates-toml ./lintcheck/ci_crates.toml
+      run: ./target/debug/lintcheck --format json --all-lints --crates-toml ./lintcheck/ci_crates.toml
 
     - name: Upload head JSON
       uses: actions/upload-artifact@v4
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 60c03b03d9be3..fddc2fd994e87 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5830,6 +5830,7 @@ Released 2018-09-13
 [`result_unit_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unit_err
 [`result_unwrap_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_unwrap_used
 [`return_self_not_must_use`]: https://rust-lang.github.io/rust-clippy/master/index.html#return_self_not_must_use
+[`reverse_range_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#reverse_range_loop
 [`reversed_empty_ranges`]: https://rust-lang.github.io/rust-clippy/master/index.html#reversed_empty_ranges
 [`same_functions_in_if_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_functions_in_if_condition
 [`same_item_push`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push
@@ -5998,6 +5999,7 @@ Released 2018-09-13
 [`unused_io_amount`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_io_amount
 [`unused_label`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_label
 [`unused_peekable`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_peekable
+[`unused_result_ok`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_result_ok
 [`unused_rounding`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_rounding
 [`unused_self`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_self
 [`unused_unit`]: https://rust-lang.github.io/rust-clippy/master/index.html#unused_unit
diff --git a/Cargo.toml b/Cargo.toml
index bb4dc97e748e3..78409c7a09e29 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ color-print = "0.3.4"
 anstream = "0.6.0"
 
 [dev-dependencies]
-ui_test = "0.24"
+ui_test = "0.25"
 regex = "1.5.5"
 toml = "0.7.3"
 walkdir = "2.3"
@@ -51,7 +51,6 @@ tokio = { version = "1", features = ["io-util"] }
 rustc_tools_util = "0.3.0"
 
 [features]
-deny-warnings = ["clippy_lints/deny-warnings"]
 integration = ["tempfile"]
 internal = ["clippy_lints/internal", "tempfile"]
 
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index fb717a2c166d4..e3d550b146629 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -364,7 +364,7 @@ Suppress lints whenever the suggested change would cause breakage for other crat
 
 
 ## `await-holding-invalid-types`
-
+The list of types which may not be held across an await point.
 
 **Default Value:** `[]`
 
@@ -668,6 +668,8 @@ crate. For example, `pub(crate)` items.
 ## `msrv`
 The minimum rust version that the project supports. Defaults to the `rust-version` field in `Cargo.toml`
 
+**Default Value:** `current version`
+
 ---
 **Affected lints:**
 * [`allow_attributes`](https://rust-lang.github.io/rust-clippy/master/index.html#allow_attributes)
@@ -862,6 +864,8 @@ The maximum number of lines a function or method can have
 The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by
 reference. By default there is no limit
 
+**Default Value:** `target_pointer_width * 2`
+
 ---
 **Affected lints:**
 * [`trivially_copy_pass_by_ref`](https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref)
diff --git a/clippy_config/Cargo.toml b/clippy_config/Cargo.toml
index e1b2edc8a6ff9..d5b28e2532371 100644
--- a/clippy_config/Cargo.toml
+++ b/clippy_config/Cargo.toml
@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+itertools = "0.12"
 rustc-semver = "1.1"
 serde = { version = "1.0", features = ["derive"] }
 toml = "0.7.3"
@@ -13,9 +14,6 @@ toml = "0.7.3"
 [dev-dependencies]
 walkdir = "2.3"
 
-[features]
-deny-warnings = []
-
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
 rustc_private = true
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 63140a36875da..4c2a8255d6b65 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -123,7 +123,8 @@ macro_rules! define_Conf {
         $(#[doc = $doc:literal])+
         $(#[conf_deprecated($dep:literal, $new_conf:ident)])?
         $(#[default_text = $default_text:expr])?
-        ($name:ident: $ty:ty = $default:expr),
+        $(#[lints($($for_lints:ident),* $(,)?)])?
+        $name:ident: $ty:ty = $default:expr,
     )*) => {
         /// Clippy lint configuration
         pub struct Conf {
@@ -201,29 +202,128 @@ macro_rules! define_Conf {
         }
 
         pub fn get_configuration_metadata() -> Vec<ClippyConfiguration> {
-            let mut sorted = vec![
-                $(
-                    {
-                        let deprecation_reason = wrap_option!($($dep)?);
-
-                        ClippyConfiguration::new(
-                            stringify!($name),
-                            default_text!(defaults::$name() $(, $default_text)?),
-                            concat!($($doc, '\n',)*),
-                            deprecation_reason,
-                        )
-                    },
-                )+
-            ];
-            sorted.sort_by(|a, b| a.name.cmp(&b.name));
-            sorted
+            vec![$(
+                ClippyConfiguration {
+                    name: stringify!($name).replace('_', "-"),
+                    default: default_text!(defaults::$name() $(, $default_text)?),
+                    lints: &[$($(stringify!($for_lints)),*)?],
+                    doc: concat!($($doc, '\n',)*),
+                    deprecation_reason: wrap_option!($($dep)?)
+                },
+            )*]
         }
     };
 }
 
 define_Conf! {
-    /// Lint: ARITHMETIC_SIDE_EFFECTS.
+    /// Which crates to allow absolute paths from
+    #[lints(absolute_paths)]
+    absolute_paths_allowed_crates: FxHashSet<String> = FxHashSet::default(),
+    /// The maximum number of segments a path can have before being linted, anything above this will
+    /// be linted.
+    #[lints(absolute_paths)]
+    absolute_paths_max_segments: u64 = 2,
+    /// Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
+    #[lints(undocumented_unsafe_blocks)]
+    accept_comment_above_attributes: bool = true,
+    /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
+    #[lints(undocumented_unsafe_blocks)]
+    accept_comment_above_statement: bool = true,
+    /// Don't lint when comparing the result of a modulo operation to zero.
+    #[lints(modulo_arithmetic)]
+    allow_comparison_to_zero: bool = true,
+    /// Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
+    #[lints(dbg_macro)]
+    allow_dbg_in_tests: bool = false,
+    /// Whether `expect` should be allowed in test functions or `#[cfg(test)]`
+    #[lints(expect_used)]
+    allow_expect_in_tests: bool = false,
+    /// Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
+    #[lints(uninlined_format_args)]
+    allow_mixed_uninlined_format_args: bool = true,
+    /// Whether to allow `r#""#` when `r""` can be used
+    #[lints(unnecessary_raw_string_hashes)]
+    allow_one_hash_in_raw_strings: bool = false,
+    /// Whether `panic` should be allowed in test functions or `#[cfg(test)]`
+    #[lints(panic)]
+    allow_panic_in_tests: bool = false,
+    /// Whether print macros (ex. `println!`) should be allowed in test functions or `#[cfg(test)]`
+    #[lints(print_stderr, print_stdout)]
+    allow_print_in_tests: bool = false,
+    /// Whether to allow module inception if it's not public.
+    #[lints(module_inception)]
+    allow_private_module_inception: bool = false,
+    /// List of trait paths to ignore when checking renamed function parameters.
+    ///
+    /// #### Example
+    ///
+    /// ```toml
+    /// allow-renamed-params-for = [ "std::convert::From" ]
+    /// ```
+    ///
+    /// #### Noteworthy
+    ///
+    /// - By default, the following traits are ignored: `From`, `TryFrom`, `FromStr`
+    /// - `".."` can be used as part of the list to indicate that the configured values should be appended to the
+    /// default configuration of Clippy. By default, any configuration will replace the default value.
+    #[lints(renamed_function_params)]
+    allow_renamed_params_for: Vec<String> =
+        DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS.iter().map(ToString::to_string).collect(),
+    /// Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
+    #[lints(unwrap_used)]
+    allow_unwrap_in_tests: bool = false,
+    /// Whether `useless_vec` should ignore test functions or `#[cfg(test)]`
+    #[lints(useless_vec)]
+    allow_useless_vec_in_tests: bool = false,
+    /// Additional dotfiles (files or directories starting with a dot) to allow
+    #[lints(path_ends_with_ext)]
+    allowed_dotfiles: Vec<String> = Vec::default(),
+    /// A list of crate names to allow duplicates of
+    #[lints(multiple_crate_versions)]
+    allowed_duplicate_crates: FxHashSet<String> = FxHashSet::default(),
+    /// Allowed names below the minimum allowed characters. The value `".."` can be used as part of
+    /// the list to indicate, that the configured values should be appended to the default
+    /// configuration of Clippy. By default, any configuration will replace the default value.
+    #[lints(min_ident_chars)]
+    allowed_idents_below_min_chars: FxHashSet<String> =
+        DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string).collect(),
+    /// List of prefixes to allow when determining whether an item's name ends with the module's name.
+    /// If the rest of an item's name is an allowed prefix (e.g. item `ToFoo` or `to_foo` in module `foo`),
+    /// then don't emit a warning.
+    ///
+    /// #### Example
+    ///
+    /// ```toml
+    /// allowed-prefixes = [ "to", "from" ]
+    /// ```
+    ///
+    /// #### Noteworthy
+    ///
+    /// - By default, the following prefixes are allowed: `to`, `as`, `into`, `from`, `try_into` and `try_from`
+    /// - PascalCase variant is included automatically for each snake_case variant (e.g. if `try_into` is included,
+    ///   `TryInto` will also be included)
+    /// - Use `".."` as part of the list to indicate that the configured values should be appended to the
+    /// default configuration of Clippy. By default, any configuration will replace the default value
+    #[lints(module_name_repetitions)]
+    allowed_prefixes: Vec<String> = DEFAULT_ALLOWED_PREFIXES.iter().map(ToString::to_string).collect(),
+    /// The list of unicode scripts allowed to be used in the scope.
+    #[lints(disallowed_script_idents)]
+    allowed_scripts: Vec<String> = vec!["Latin".to_string()],
+    /// List of path segments allowed to have wildcard imports.
     ///
+    /// #### Example
+    ///
+    /// ```toml
+    /// allowed-wildcard-imports = [ "utils", "common" ]
+    /// ```
+    ///
+    /// #### Noteworthy
+    ///
+    /// 1. This configuration has no effects if used with `warn_on_all_wildcard_imports = true`.
+    /// 2. Paths with any segment that containing the word 'prelude'
+    /// are already allowed by default.
+    #[lints(wildcard_imports)]
+    allowed_wildcard_imports: FxHashSet<String> = FxHashSet::default(),
     /// Suppress checking of the passed type names in all types of operations.
     ///
     /// If a specific operation is desired, consider using `arithmetic_side_effects_allowed_binary` or `arithmetic_side_effects_allowed_unary` instead.
@@ -238,9 +338,8 @@ define_Conf! {
     ///
     /// A type, say `SomeType`, listed in this configuration has the same behavior of
     /// `["SomeType" , "*"], ["*", "SomeType"]` in `arithmetic_side_effects_allowed_binary`.
-    (arithmetic_side_effects_allowed: Vec<String> = <_>::default()),
-    /// Lint: ARITHMETIC_SIDE_EFFECTS.
-    ///
+    #[lints(arithmetic_side_effects)]
+    arithmetic_side_effects_allowed: Vec<String> = <_>::default(),
     /// Suppress checking of the passed type pair names in binary operations like addition or
     /// multiplication.
     ///
@@ -255,9 +354,8 @@ define_Conf! {
     /// ```toml
     /// arithmetic-side-effects-allowed-binary = [["SomeType" , "f32"], ["AnotherType", "*"]]
     /// ```
-    (arithmetic_side_effects_allowed_binary: Vec<[String; 2]> = <_>::default()),
-    /// Lint: ARITHMETIC_SIDE_EFFECTS.
-    ///
+    #[lints(arithmetic_side_effects)]
+    arithmetic_side_effects_allowed_binary: Vec<[String; 2]> = <_>::default(),
     /// Suppress checking of the passed type names in unary operations like "negation" (`-`).
     ///
     /// #### Example
@@ -265,298 +363,78 @@ define_Conf! {
     /// ```toml
     /// arithmetic-side-effects-allowed-unary = ["SomeType", "AnotherType"]
     /// ```
-    (arithmetic_side_effects_allowed_unary: Vec<String> = <_>::default()),
-    /// Lint: ENUM_VARIANT_NAMES, LARGE_TYPES_PASSED_BY_VALUE, TRIVIALLY_COPY_PASS_BY_REF, UNNECESSARY_WRAPS, UNUSED_SELF, UPPER_CASE_ACRONYMS, WRONG_SELF_CONVENTION, BOX_COLLECTION, REDUNDANT_ALLOCATION, RC_BUFFER, VEC_BOX, OPTION_OPTION, LINKEDLIST, RC_MUTEX, UNNECESSARY_BOX_RETURNS, SINGLE_CALL_FN, NEEDLESS_PASS_BY_REF_MUT.
-    ///
+    #[lints(arithmetic_side_effects)]
+    arithmetic_side_effects_allowed_unary: Vec<String> = <_>::default(),
+    /// The maximum allowed size for arrays on the stack
+    #[lints(large_const_arrays, large_stack_arrays)]
+    array_size_threshold: u64 = 512_000,
     /// Suppress lints whenever the suggested change would cause breakage for other crates.
-    (avoid_breaking_exported_api: bool = true),
-    /// Lint: MANUAL_SPLIT_ONCE, MANUAL_STR_REPEAT, CLONED_INSTEAD_OF_COPIED, REDUNDANT_FIELD_NAMES, OPTION_MAP_UNWRAP_OR, REDUNDANT_STATIC_LIFETIMES, FILTER_MAP_NEXT, CHECKED_CONVERSIONS, MANUAL_RANGE_CONTAINS, USE_SELF, MEM_REPLACE_WITH_DEFAULT, MANUAL_NON_EXHAUSTIVE, OPTION_AS_REF_DEREF, MAP_UNWRAP_OR, MATCH_LIKE_MATCHES_MACRO, MANUAL_STRIP, MISSING_CONST_FOR_FN, UNNESTED_OR_PATTERNS, FROM_OVER_INTO, PTR_AS_PTR, IF_THEN_SOME_ELSE_NONE, APPROX_CONSTANT, DEPRECATED_CFG_ATTR, INDEX_REFUTABLE_SLICE, MAP_CLONE, BORROW_AS_PTR, MANUAL_BITS, ERR_EXPECT, CAST_ABS_TO_UNSIGNED, UNINLINED_FORMAT_ARGS, MANUAL_CLAMP, MANUAL_LET_ELSE, UNCHECKED_DURATION_SUBTRACTION, COLLAPSIBLE_STR_REPLACE, SEEK_FROM_CURRENT, SEEK_REWIND, UNNECESSARY_LAZY_EVALUATIONS, TRANSMUTE_PTR_TO_REF, ALMOST_COMPLETE_RANGE, NEEDLESS_BORROW, DERIVABLE_IMPLS, MANUAL_IS_ASCII_CHECK, MANUAL_REM_EUCLID, MANUAL_RETAIN, TYPE_REPETITION_IN_BOUNDS, TUPLE_ARRAY_CONVERSIONS, MANUAL_TRY_FOLD, MANUAL_HASH_ONE, ITER_KV_MAP, MANUAL_C_STR_LITERALS, ASSIGNING_CLONES, LEGACY_NUMERIC_CONSTANTS, MANUAL_PATTERN_CHAR_COMPARISON, ALLOW_ATTRIBUTES, ALLOW_ATTRIBUTES_WITHOUT_REASON, COLLAPSIBLE_MATCH.
-    ///
-    /// The minimum rust version that the project supports. Defaults to the `rust-version` field in `Cargo.toml`
-    #[default_text = ""]
-    (msrv: Msrv = Msrv::empty()),
+    #[lints(
+        box_collection,
+        enum_variant_names,
+        large_types_passed_by_value,
+        linkedlist,
+        needless_pass_by_ref_mut,
+        option_option,
+        rc_buffer,
+        rc_mutex,
+        redundant_allocation,
+        single_call_fn,
+        trivially_copy_pass_by_ref,
+        unnecessary_box_returns,
+        unnecessary_wraps,
+        unused_self,
+        upper_case_acronyms,
+        vec_box,
+        wrong_self_convention,
+    )]
+    avoid_breaking_exported_api: bool = true,
+    /// The list of types which may not be held across an await point.
+    #[lints(await_holding_invalid_type)]
+    await_holding_invalid_types: Vec<DisallowedPath> = Vec::new(),
     /// DEPRECATED LINT: BLACKLISTED_NAME.
     ///
     /// Use the Disallowed Names lint instead
     #[conf_deprecated("Please use `disallowed-names` instead", disallowed_names)]
-    (blacklisted_names: Vec<String> = Vec::new()),
-    /// Lint: COGNITIVE_COMPLEXITY.
-    ///
+    blacklisted_names: Vec<String> = Vec::new(),
+    /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
+    #[lints(cargo_common_metadata)]
+    cargo_ignore_publish: bool = false,
+    /// Whether to also run the listed lints on private items.
+    #[lints(missing_errors_doc, missing_panics_doc, missing_safety_doc, unnecessary_safety_doc)]
+    check_private_items: bool = false,
     /// The maximum cognitive complexity a function can have
-    (cognitive_complexity_threshold: u64 = 25),
-    /// Lint: EXCESSIVE_NESTING.
-    ///
-    /// The maximum amount of nesting a block can reside in
-    (excessive_nesting_threshold: u64 = 0),
+    #[lints(cognitive_complexity)]
+    cognitive_complexity_threshold: u64 = 25,
     /// DEPRECATED LINT: CYCLOMATIC_COMPLEXITY.
     ///
     /// Use the Cognitive Complexity lint instead.
     #[conf_deprecated("Please use `cognitive-complexity-threshold` instead", cognitive_complexity_threshold)]
-    (cyclomatic_complexity_threshold: u64 = 25),
-    /// Lint: DISALLOWED_NAMES.
-    ///
+    cyclomatic_complexity_threshold: u64 = 25,
+    /// The list of disallowed macros, written as fully qualified paths.
+    #[lints(disallowed_macros)]
+    disallowed_macros: Vec<DisallowedPath> = Vec::new(),
+    /// The list of disallowed methods, written as fully qualified paths.
+    #[lints(disallowed_methods)]
+    disallowed_methods: Vec<DisallowedPath> = Vec::new(),
     /// The list of disallowed names to lint about. NB: `bar` is not here since it has legitimate uses. The value
     /// `".."` can be used as part of the list to indicate that the configured values should be appended to the
     /// default configuration of Clippy. By default, any configuration will replace the default value.
-    (disallowed_names: Vec<String> = DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect()),
-    /// Lint: SEMICOLON_INSIDE_BLOCK.
-    ///
-    /// Whether to lint only if it's multiline.
-    (semicolon_inside_block_ignore_singleline: bool = false),
-    /// Lint: SEMICOLON_OUTSIDE_BLOCK.
-    ///
-    /// Whether to lint only if it's singleline.
-    (semicolon_outside_block_ignore_multiline: bool = false),
-    /// Lint: DOC_MARKDOWN.
-    ///
+    #[lints(disallowed_names)]
+    disallowed_names: Vec<String> = DEFAULT_DISALLOWED_NAMES.iter().map(ToString::to_string).collect(),
+    /// The list of disallowed types, written as fully qualified paths.
+    #[lints(disallowed_types)]
+    disallowed_types: Vec<DisallowedPath> = Vec::new(),
     /// The list of words this lint should not consider as identifiers needing ticks. The value
     /// `".."` can be used as part of the list to indicate, that the configured values should be appended to the
     /// default configuration of Clippy. By default, any configuration will replace the default value. For example:
     /// * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
     /// * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
-    (doc_valid_idents: FxHashSet<String> = DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect()),
-    /// Lint: TOO_MANY_ARGUMENTS.
-    ///
-    /// The maximum number of argument a function or method can have
-    (too_many_arguments_threshold: u64 = 7),
-    /// Lint: TYPE_COMPLEXITY.
-    ///
-    /// The maximum complexity a type can have
-    (type_complexity_threshold: u64 = 250),
-    /// Lint: MANY_SINGLE_CHAR_NAMES.
-    ///
-    /// The maximum number of single char bindings a scope may have
-    (single_char_binding_names_threshold: u64 = 4),
-    /// Lint: BOXED_LOCAL, USELESS_VEC.
-    ///
-    /// The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
-    (too_large_for_stack: u64 = 200),
-    /// Lint: ENUM_VARIANT_NAMES.
-    ///
-    /// The minimum number of enum variants for the lints about variant names to trigger
-    (enum_variant_name_threshold: u64 = 3),
-    /// Lint: STRUCT_FIELD_NAMES.
-    ///
-    /// The minimum number of struct fields for the lints about field names to trigger
-    (struct_field_name_threshold: u64 = 3),
-    /// Lint: LARGE_ENUM_VARIANT.
-    ///
-    /// The maximum size of an enum's variant to avoid box suggestion
-    (enum_variant_size_threshold: u64 = 200),
-    /// Lint: VERBOSE_BIT_MASK.
-    ///
-    /// The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
-    (verbose_bit_mask_threshold: u64 = 1),
-    /// Lint: DECIMAL_LITERAL_REPRESENTATION.
-    ///
-    /// The lower bound for linting decimal literals
-    (literal_representation_threshold: u64 = 16384),
-    /// Lint: TRIVIALLY_COPY_PASS_BY_REF.
-    ///
-    /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by
-    /// reference. By default there is no limit
-    #[default_text = ""]
-    (trivial_copy_size_limit: Option<u64> = None),
-    /// Lint: LARGE_TYPES_PASSED_BY_VALUE.
-    ///
-    /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
-    (pass_by_value_size_limit: u64 = 256),
-    /// Lint: TOO_MANY_LINES.
-    ///
-    /// The maximum number of lines a function or method can have
-    (too_many_lines_threshold: u64 = 100),
-    /// Lint: LARGE_STACK_ARRAYS, LARGE_CONST_ARRAYS.
-    ///
-    /// The maximum allowed size for arrays on the stack
-    (array_size_threshold: u64 = 512_000),
-    /// Lint: LARGE_STACK_FRAMES.
-    ///
-    /// The maximum allowed stack size for functions in bytes
-    (stack_size_threshold: u64 = 512_000),
-    /// Lint: VEC_BOX.
-    ///
-    /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
-    (vec_box_size_threshold: u64 = 4096),
-    /// Lint: TYPE_REPETITION_IN_BOUNDS.
-    ///
-    /// The maximum number of bounds a trait can have to be linted
-    (max_trait_bounds: u64 = 3),
-    /// Lint: STRUCT_EXCESSIVE_BOOLS.
-    ///
-    /// The maximum number of bool fields a struct can have
-    (max_struct_bools: u64 = 3),
-    /// Lint: FN_PARAMS_EXCESSIVE_BOOLS.
-    ///
-    /// The maximum number of bool parameters a function can have
-    (max_fn_params_bools: u64 = 3),
-    /// Lint: WILDCARD_IMPORTS.
-    ///
-    /// Whether to allow certain wildcard imports (prelude, super in tests).
-    (warn_on_all_wildcard_imports: bool = false),
-    /// Lint: DISALLOWED_MACROS.
-    ///
-    /// The list of disallowed macros, written as fully qualified paths.
-    (disallowed_macros: Vec<DisallowedPath> = Vec::new()),
-    /// Lint: DISALLOWED_METHODS.
-    ///
-    /// The list of disallowed methods, written as fully qualified paths.
-    (disallowed_methods: Vec<DisallowedPath> = Vec::new()),
-    /// Lint: DISALLOWED_TYPES.
-    ///
-    /// The list of disallowed types, written as fully qualified paths.
-    (disallowed_types: Vec<DisallowedPath> = Vec::new()),
-    /// Lint: UNREADABLE_LITERAL.
-    ///
-    /// Should the fraction of a decimal be linted to include separators.
-    (unreadable_literal_lint_fractions: bool = true),
-    /// Lint: UPPER_CASE_ACRONYMS.
-    ///
-    /// Enables verbose mode. Triggers if there is more than one uppercase char next to each other
-    (upper_case_acronyms_aggressive: bool = false),
-    /// Lint: MANUAL_LET_ELSE.
-    ///
-    /// Whether the matches should be considered by the lint, and whether there should
-    /// be filtering for common types.
-    (matches_for_let_else: MatchLintBehaviour = MatchLintBehaviour::WellKnownTypes),
-    /// Lint: CARGO_COMMON_METADATA.
-    ///
-    /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
-    (cargo_ignore_publish: bool = false),
-    /// Lint: NONSTANDARD_MACRO_BRACES.
-    ///
-    /// Enforce the named macros always use the braces specified.
-    ///
-    /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
-    /// could be used with a full path two `MacroMatcher`s have to be added one with the full path
-    /// `crate_name::macro_name` and one with just the macro name.
-    (standard_macro_braces: Vec<MacroMatcher> = Vec::new()),
-    /// Lint: MISSING_ENFORCED_IMPORT_RENAMES.
-    ///
-    /// The list of imports to always rename, a fully qualified path followed by the rename.
-    (enforced_import_renames: Vec<Rename> = Vec::new()),
-    /// Lint: DISALLOWED_SCRIPT_IDENTS.
-    ///
-    /// The list of unicode scripts allowed to be used in the scope.
-    (allowed_scripts: Vec<String> = vec!["Latin".to_string()]),
-    /// Lint: NON_SEND_FIELDS_IN_SEND_TY.
-    ///
+    #[lints(doc_markdown)]
+    doc_valid_idents: FxHashSet<String> = DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect(),
     /// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
-    (enable_raw_pointer_heuristic_for_send: bool = true),
-    /// Lint: INDEX_REFUTABLE_SLICE.
-    ///
-    /// When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
-    /// the slice pattern that is suggested. If more elements are necessary, the lint is suppressed.
-    /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
-    (max_suggested_slice_pattern_length: u64 = 3),
-    /// Lint: AWAIT_HOLDING_INVALID_TYPE.
-    (await_holding_invalid_types: Vec<DisallowedPath> = Vec::new()),
-    /// Lint: LARGE_INCLUDE_FILE.
-    ///
-    /// The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
-    (max_include_file_size: u64 = 1_000_000),
-    /// Lint: EXPECT_USED.
-    ///
-    /// Whether `expect` should be allowed in test functions or `#[cfg(test)]`
-    (allow_expect_in_tests: bool = false),
-    /// Lint: UNWRAP_USED.
-    ///
-    /// Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
-    (allow_unwrap_in_tests: bool = false),
-    /// Lint: PANIC.
-    ///
-    /// Whether `panic` should be allowed in test functions or `#[cfg(test)]`
-    (allow_panic_in_tests: bool = false),
-    /// Lint: DBG_MACRO.
-    ///
-    /// Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
-    (allow_dbg_in_tests: bool = false),
-    /// Lint: PRINT_STDOUT, PRINT_STDERR.
-    ///
-    /// Whether print macros (ex. `println!`) should be allowed in test functions or `#[cfg(test)]`
-    (allow_print_in_tests: bool = false),
-    /// Lint: USELESS_VEC.
-    ///
-    /// Whether `useless_vec` should ignore test functions or `#[cfg(test)]`
-    (allow_useless_vec_in_tests: bool = false),
-    /// Lint: RESULT_LARGE_ERR.
-    ///
-    /// The maximum size of the `Err`-variant in a `Result` returned from a function
-    (large_error_threshold: u64 = 128),
-    /// Lint: MUTABLE_KEY_TYPE, IFS_SAME_COND, BORROW_INTERIOR_MUTABLE_CONST, DECLARE_INTERIOR_MUTABLE_CONST.
-    ///
-    /// A list of paths to types that should be treated as if they do not contain interior mutability
-    (ignore_interior_mutability: Vec<String> = Vec::from(["bytes::Bytes".into()])),
-    /// Lint: UNINLINED_FORMAT_ARGS.
-    ///
-    /// Whether to allow mixed uninlined format args, e.g. `format!("{} {}", a, foo.bar)`
-    (allow_mixed_uninlined_format_args: bool = true),
-    /// Lint: INDEXING_SLICING.
-    ///
-    /// Whether to suppress a restriction lint in constant code. In same
-    /// cases the restructured operation might not be unavoidable, as the
-    /// suggested counterparts are unavailable in constant code. This
-    /// configuration will cause restriction lints to trigger even
-    /// if no suggestion can be made.
-    (suppress_restriction_lint_in_const: bool = false),
-    /// Lint: MISSING_DOCS_IN_PRIVATE_ITEMS.
-    ///
-    /// Whether to **only** check for missing documentation in items visible within the current
-    /// crate. For example, `pub(crate)` items.
-    (missing_docs_in_crate_items: bool = false),
-    /// Lint: LARGE_FUTURES.
-    ///
-    /// The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
-    (future_size_threshold: u64 = 16 * 1024),
-    /// Lint: UNNECESSARY_BOX_RETURNS.
-    ///
-    /// The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
-    (unnecessary_box_size: u64 = 128),
-    /// Lint: MODULE_INCEPTION.
-    ///
-    /// Whether to allow module inception if it's not public.
-    (allow_private_module_inception: bool = false),
-    /// Lint: MIN_IDENT_CHARS.
-    ///
-    /// Allowed names below the minimum allowed characters. The value `".."` can be used as part of
-    /// the list to indicate, that the configured values should be appended to the default
-    /// configuration of Clippy. By default, any configuration will replace the default value.
-    (allowed_idents_below_min_chars: FxHashSet<String> =
-        DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string).collect()),
-    /// Lint: MIN_IDENT_CHARS.
-    ///
-    /// Minimum chars an ident can have, anything below or equal to this will be linted.
-    (min_ident_chars_threshold: u64 = 1),
-    /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
-    ///
-    /// Whether to accept a safety comment to be placed above the statement containing the `unsafe` block
-    (accept_comment_above_statement: bool = true),
-    /// Lint: UNDOCUMENTED_UNSAFE_BLOCKS.
-    ///
-    /// Whether to accept a safety comment to be placed above the attributes for the `unsafe` block
-    (accept_comment_above_attributes: bool = true),
-    /// Lint: UNNECESSARY_RAW_STRING_HASHES.
-    ///
-    /// Whether to allow `r#""#` when `r""` can be used
-    (allow_one_hash_in_raw_strings: bool = false),
-    /// Lint: ABSOLUTE_PATHS.
-    ///
-    /// The maximum number of segments a path can have before being linted, anything above this will
-    /// be linted.
-    (absolute_paths_max_segments: u64 = 2),
-    /// Lint: ABSOLUTE_PATHS.
-    ///
-    /// Which crates to allow absolute paths from
-    (absolute_paths_allowed_crates: FxHashSet<String> = FxHashSet::default()),
-    /// Lint: PATH_ENDS_WITH_EXT.
-    ///
-    /// Additional dotfiles (files or directories starting with a dot) to allow
-    (allowed_dotfiles: Vec<String> = Vec::default()),
-    /// Lint: MULTIPLE_CRATE_VERSIONS.
-    ///
-    /// A list of crate names to allow duplicates of
-    (allowed_duplicate_crates: FxHashSet<String> = FxHashSet::default()),
-    /// Lint: EXPLICIT_ITER_LOOP.
-    ///
+    #[lints(non_send_fields_in_send_ty)]
+    enable_raw_pointer_heuristic_for_send: bool = true,
     /// Whether to recommend using implicit into iter for reborrowed values.
     ///
     /// #### Example
@@ -574,77 +452,195 @@ define_Conf! {
     /// for _ in &*rmvec {}
     /// for _ in &mut *rmvec {}
     /// ```
-    (enforce_iter_loop_reborrow: bool = false),
-    /// Lint: MISSING_SAFETY_DOC, UNNECESSARY_SAFETY_DOC, MISSING_PANICS_DOC, MISSING_ERRORS_DOC.
-    ///
-    /// Whether to also run the listed lints on private items.
-    (check_private_items: bool = false),
-    /// Lint: PUB_UNDERSCORE_FIELDS.
-    ///
+    #[lints(explicit_iter_loop)]
+    enforce_iter_loop_reborrow: bool = false,
+    /// The list of imports to always rename, a fully qualified path followed by the rename.
+    #[lints(missing_enforced_import_renames)]
+    enforced_import_renames: Vec<Rename> = Vec::new(),
+    /// The minimum number of enum variants for the lints about variant names to trigger
+    #[lints(enum_variant_names)]
+    enum_variant_name_threshold: u64 = 3,
+    /// The maximum size of an enum's variant to avoid box suggestion
+    #[lints(large_enum_variant)]
+    enum_variant_size_threshold: u64 = 200,
+    /// The maximum amount of nesting a block can reside in
+    #[lints(excessive_nesting)]
+    excessive_nesting_threshold: u64 = 0,
+    /// The maximum byte size a `Future` can have, before it triggers the `clippy::large_futures` lint
+    #[lints(large_futures)]
+    future_size_threshold: u64 = 16 * 1024,
+    /// A list of paths to types that should be treated as if they do not contain interior mutability
+    #[lints(borrow_interior_mutable_const, declare_interior_mutable_const, ifs_same_cond, mutable_key_type)]
+    ignore_interior_mutability: Vec<String> = Vec::from(["bytes::Bytes".into()]),
+    /// The maximum size of the `Err`-variant in a `Result` returned from a function
+    #[lints(result_large_err)]
+    large_error_threshold: u64 = 128,
+    /// The lower bound for linting decimal literals
+    #[lints(decimal_literal_representation)]
+    literal_representation_threshold: u64 = 16384,
+    /// Whether the matches should be considered by the lint, and whether there should
+    /// be filtering for common types.
+    #[lints(manual_let_else)]
+    matches_for_let_else: MatchLintBehaviour = MatchLintBehaviour::WellKnownTypes,
+    /// The maximum number of bool parameters a function can have
+    #[lints(fn_params_excessive_bools)]
+    max_fn_params_bools: u64 = 3,
+    /// The maximum size of a file included via `include_bytes!()` or `include_str!()`, in bytes
+    #[lints(large_include_file)]
+    max_include_file_size: u64 = 1_000_000,
+    /// The maximum number of bool fields a struct can have
+    #[lints(struct_excessive_bools)]
+    max_struct_bools: u64 = 3,
+    /// When Clippy suggests using a slice pattern, this is the maximum number of elements allowed in
+    /// the slice pattern that is suggested. If more elements are necessary, the lint is suppressed.
+    /// For example, `[_, _, _, e, ..]` is a slice pattern with 4 elements.
+    #[lints(index_refutable_slice)]
+    max_suggested_slice_pattern_length: u64 = 3,
+    /// The maximum number of bounds a trait can have to be linted
+    #[lints(type_repetition_in_bounds)]
+    max_trait_bounds: u64 = 3,
+    /// Minimum chars an ident can have, anything below or equal to this will be linted.
+    #[lints(min_ident_chars)]
+    min_ident_chars_threshold: u64 = 1,
+    /// Whether to **only** check for missing documentation in items visible within the current
+    /// crate. For example, `pub(crate)` items.
+    #[lints(missing_docs_in_private_items)]
+    missing_docs_in_crate_items: bool = false,
+    /// The minimum rust version that the project supports. Defaults to the `rust-version` field in `Cargo.toml`
+    #[default_text = "current version"]
+    #[lints(
+        allow_attributes,
+        allow_attributes_without_reason,
+        almost_complete_range,
+        approx_constant,
+        assigning_clones,
+        borrow_as_ptr,
+        cast_abs_to_unsigned,
+        checked_conversions,
+        cloned_instead_of_copied,
+        collapsible_match,
+        collapsible_str_replace,
+        deprecated_cfg_attr,
+        derivable_impls,
+        err_expect,
+        filter_map_next,
+        from_over_into,
+        if_then_some_else_none,
+        index_refutable_slice,
+        iter_kv_map,
+        legacy_numeric_constants,
+        manual_bits,
+        manual_c_str_literals,
+        manual_clamp,
+        manual_hash_one,
+        manual_is_ascii_check,
+        manual_let_else,
+        manual_non_exhaustive,
+        manual_pattern_char_comparison,
+        manual_range_contains,
+        manual_rem_euclid,
+        manual_retain,
+        manual_split_once,
+        manual_str_repeat,
+        manual_strip,
+        manual_try_fold,
+        map_clone,
+        map_unwrap_or,
+        match_like_matches_macro,
+        mem_replace_with_default,
+        missing_const_for_fn,
+        needless_borrow,
+        option_as_ref_deref,
+        option_map_unwrap_or,
+        ptr_as_ptr,
+        redundant_field_names,
+        redundant_static_lifetimes,
+        seek_from_current,
+        seek_rewind,
+        transmute_ptr_to_ref,
+        tuple_array_conversions,
+        type_repetition_in_bounds,
+        unchecked_duration_subtraction,
+        uninlined_format_args,
+        unnecessary_lazy_evaluations,
+        unnested_or_patterns,
+        use_self,
+    )]
+    msrv: Msrv = Msrv::empty(),
+    /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
+    #[lints(large_types_passed_by_value)]
+    pass_by_value_size_limit: u64 = 256,
     /// Lint "public" fields in a struct that are prefixed with an underscore based on their
     /// exported visibility, or whether they are marked as "pub".
-    (pub_underscore_fields_behavior: PubUnderscoreFieldsBehaviour = PubUnderscoreFieldsBehaviour::PubliclyExported),
-    /// Lint: MODULO_ARITHMETIC.
-    ///
-    /// Don't lint when comparing the result of a modulo operation to zero.
-    (allow_comparison_to_zero: bool = true),
-    /// Lint: WILDCARD_IMPORTS.
-    ///
-    /// List of path segments allowed to have wildcard imports.
-    ///
-    /// #### Example
-    ///
-    /// ```toml
-    /// allowed-wildcard-imports = [ "utils", "common" ]
-    /// ```
-    ///
-    /// #### Noteworthy
-    ///
-    /// 1. This configuration has no effects if used with `warn_on_all_wildcard_imports = true`.
-    /// 2. Paths with any segment that containing the word 'prelude'
-    /// are already allowed by default.
-    (allowed_wildcard_imports: FxHashSet<String> = FxHashSet::default()),
-    /// Lint: MODULE_NAME_REPETITIONS.
-    ///
-    /// List of prefixes to allow when determining whether an item's name ends with the module's name.
-    /// If the rest of an item's name is an allowed prefix (e.g. item `ToFoo` or `to_foo` in module `foo`),
-    /// then don't emit a warning.
-    ///
-    /// #### Example
-    ///
-    /// ```toml
-    /// allowed-prefixes = [ "to", "from" ]
-    /// ```
-    ///
-    /// #### Noteworthy
-    ///
-    /// - By default, the following prefixes are allowed: `to`, `as`, `into`, `from`, `try_into` and `try_from`
-    /// - PascalCase variant is included automatically for each snake_case variant (e.g. if `try_into` is included,
-    ///   `TryInto` will also be included)
-    /// - Use `".."` as part of the list to indicate that the configured values should be appended to the
-    /// default configuration of Clippy. By default, any configuration will replace the default value
-    (allowed_prefixes: Vec<String> = DEFAULT_ALLOWED_PREFIXES.iter().map(ToString::to_string).collect()),
-    /// Lint: RENAMED_FUNCTION_PARAMS.
-    ///
-    /// List of trait paths to ignore when checking renamed function parameters.
-    ///
-    /// #### Example
-    ///
-    /// ```toml
-    /// allow-renamed-params-for = [ "std::convert::From" ]
-    /// ```
-    ///
-    /// #### Noteworthy
-    ///
-    /// - By default, the following traits are ignored: `From`, `TryFrom`, `FromStr`
-    /// - `".."` can be used as part of the list to indicate that the configured values should be appended to the
-    /// default configuration of Clippy. By default, any configuration will replace the default value.
-    (allow_renamed_params_for: Vec<String> =
-        DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS.iter().map(ToString::to_string).collect()),
-    /// Lint: MACRO_METAVARS_IN_UNSAFE.
+    #[lints(pub_underscore_fields)]
+    pub_underscore_fields_behavior: PubUnderscoreFieldsBehaviour = PubUnderscoreFieldsBehaviour::PubliclyExported,
+    /// Whether to lint only if it's multiline.
+    #[lints(semicolon_inside_block)]
+    semicolon_inside_block_ignore_singleline: bool = false,
+    /// Whether to lint only if it's singleline.
+    #[lints(semicolon_outside_block)]
+    semicolon_outside_block_ignore_multiline: bool = false,
+    /// The maximum number of single char bindings a scope may have
+    #[lints(many_single_char_names)]
+    single_char_binding_names_threshold: u64 = 4,
+    /// The maximum allowed stack size for functions in bytes
+    #[lints(large_stack_frames)]
+    stack_size_threshold: u64 = 512_000,
+    /// Enforce the named macros always use the braces specified.
     ///
+    /// A `MacroMatcher` can be added like so `{ name = "macro_name", brace = "(" }`. If the macro
+    /// could be used with a full path two `MacroMatcher`s have to be added one with the full path
+    /// `crate_name::macro_name` and one with just the macro name.
+    #[lints(nonstandard_macro_braces)]
+    standard_macro_braces: Vec<MacroMatcher> = Vec::new(),
+    /// The minimum number of struct fields for the lints about field names to trigger
+    #[lints(struct_field_names)]
+    struct_field_name_threshold: u64 = 3,
+    /// Whether to suppress a restriction lint in constant code. In same
+    /// cases the restructured operation might not be unavoidable, as the
+    /// suggested counterparts are unavailable in constant code. This
+    /// configuration will cause restriction lints to trigger even
+    /// if no suggestion can be made.
+    #[lints(indexing_slicing)]
+    suppress_restriction_lint_in_const: bool = false,
+    /// The maximum size of objects (in bytes) that will be linted. Larger objects are ok on the heap
+    #[lints(boxed_local, useless_vec)]
+    too_large_for_stack: u64 = 200,
+    /// The maximum number of argument a function or method can have
+    #[lints(too_many_arguments)]
+    too_many_arguments_threshold: u64 = 7,
+    /// The maximum number of lines a function or method can have
+    #[lints(too_many_lines)]
+    too_many_lines_threshold: u64 = 100,
+    /// The maximum size (in bytes) to consider a `Copy` type for passing by value instead of by
+    /// reference. By default there is no limit
+    #[default_text = "target_pointer_width * 2"]
+    #[lints(trivially_copy_pass_by_ref)]
+    trivial_copy_size_limit: Option<u64> = None,
+    /// The maximum complexity a type can have
+    #[lints(type_complexity)]
+    type_complexity_threshold: u64 = 250,
+    /// The byte size a `T` in `Box<T>` can have, below which it triggers the `clippy::unnecessary_box` lint
+    #[lints(unnecessary_box_returns)]
+    unnecessary_box_size: u64 = 128,
+    /// Should the fraction of a decimal be linted to include separators.
+    #[lints(unreadable_literal)]
+    unreadable_literal_lint_fractions: bool = true,
+    /// Enables verbose mode. Triggers if there is more than one uppercase char next to each other
+    #[lints(upper_case_acronyms)]
+    upper_case_acronyms_aggressive: bool = false,
+    /// The size of the boxed type in bytes, where boxing in a `Vec` is allowed
+    #[lints(vec_box)]
+    vec_box_size_threshold: u64 = 4096,
+    /// The maximum allowed size of a bit mask before suggesting to use 'trailing_zeros'
+    #[lints(verbose_bit_mask)]
+    verbose_bit_mask_threshold: u64 = 1,
+    /// Whether to allow certain wildcard imports (prelude, super in tests).
+    #[lints(wildcard_imports)]
+    warn_on_all_wildcard_imports: bool = false,
     /// Whether to also emit warnings for unsafe blocks with metavariable expansions in **private** macros.
-    (warn_unsafe_macro_metavars_in_private_macros: bool = false),
+    #[lints(macro_metavars_in_unsafe)]
+    warn_unsafe_macro_metavars_in_private_macros: bool = false,
 }
 
 /// Search for the configuration file.
diff --git a/clippy_config/src/lib.rs b/clippy_config/src/lib.rs
index ff7fa7241cb96..d2246f12029b3 100644
--- a/clippy_config/src/lib.rs
+++ b/clippy_config/src/lib.rs
@@ -1,5 +1,4 @@
-#![feature(rustc_private, let_chains)]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
+#![feature(rustc_private, array_windows, let_chains)]
 #![warn(
     trivial_casts,
     trivial_numeric_casts,
diff --git a/clippy_config/src/metadata.rs b/clippy_config/src/metadata.rs
index 400887185e8cf..7cbd92a9b7100 100644
--- a/clippy_config/src/metadata.rs
+++ b/clippy_config/src/metadata.rs
@@ -1,11 +1,12 @@
-use std::fmt::{self, Write};
+use itertools::Itertools;
+use std::fmt;
 
 #[derive(Debug, Clone, Default)]
 pub struct ClippyConfiguration {
     pub name: String,
     pub default: String,
-    pub lints: Vec<String>,
-    pub doc: String,
+    pub lints: &'static [&'static str],
+    pub doc: &'static str,
     pub deprecation_reason: Option<&'static str>,
 }
 
@@ -13,61 +14,23 @@ impl fmt::Display for ClippyConfiguration {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "- `{}`: {}", self.name, self.doc)?;
         if !self.default.is_empty() {
-            write!(f, " (default: `{}`)", self.default)?;
+            write!(f, "\n\n   (default: `{}`)", self.default)?;
         }
         Ok(())
     }
 }
 
 impl ClippyConfiguration {
-    pub fn new(
-        name: &'static str,
-        default: String,
-        doc_comment: &'static str,
-        deprecation_reason: Option<&'static str>,
-    ) -> Self {
-        let (mut lints, doc) = parse_config_field_doc(doc_comment)
-            .unwrap_or_else(|| (vec![], "[ERROR] MALFORMED DOC COMMENT".to_string()));
-
-        lints.sort();
-
-        Self {
-            name: to_kebab(name),
-            lints,
-            doc,
-            default,
-            deprecation_reason,
-        }
-    }
-
     pub fn to_markdown_paragraph(&self) -> String {
-        let mut out = format!(
-            "## `{}`\n{}\n\n",
+        format!(
+            "## `{}`\n{}\n\n**Default Value:** `{}`\n\n---\n**Affected lints:**\n{}\n\n",
             self.name,
-            self.doc
-                .lines()
-                .map(|line| line.strip_prefix("    ").unwrap_or(line))
-                .collect::<Vec<_>>()
-                .join("\n"),
-        );
-
-        if !self.default.is_empty() {
-            write!(out, "**Default Value:** `{}`\n\n", self.default).unwrap();
-        }
-
-        write!(
-            out,
-            "---\n**Affected lints:**\n{}\n\n",
-            self.lints
-                .iter()
-                .map(|name| name.to_string().split_whitespace().next().unwrap().to_string())
-                .map(|name| format!("* [`{name}`](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"))
-                .collect::<Vec<_>>()
-                .join("\n"),
+            self.doc.lines().map(|x| x.strip_prefix(' ').unwrap_or(x)).join("\n"),
+            self.default,
+            self.lints.iter().format_with("\n", |name, f| f(&format_args!(
+                "* [`{name}`](https://rust-lang.github.io/rust-clippy/master/index.html#{name})"
+            ))),
         )
-        .unwrap();
-
-        out
     }
 
     pub fn to_markdown_link(&self) -> String {
@@ -75,47 +38,3 @@ impl ClippyConfiguration {
         format!("[`{}`]: {BOOK_CONFIGS_PATH}#{}", self.name, self.name)
     }
 }
-
-/// This parses the field documentation of the config struct.
-///
-/// ```rust, ignore
-/// parse_config_field_doc(cx, "Lint: LINT_NAME_1, LINT_NAME_2. Papa penguin, papa penguin")
-/// ```
-///
-/// Would yield:
-/// ```rust, ignore
-/// Some(["lint_name_1", "lint_name_2"], "Papa penguin, papa penguin")
-/// ```
-fn parse_config_field_doc(doc_comment: &str) -> Option<(Vec<String>, String)> {
-    const DOC_START: &str = " Lint: ";
-    if doc_comment.starts_with(DOC_START)
-        && let Some(split_pos) = doc_comment.find('.')
-    {
-        let mut doc_comment = doc_comment.to_string();
-        let mut documentation = doc_comment.split_off(split_pos);
-
-        // Extract lints
-        doc_comment.make_ascii_lowercase();
-        let lints: Vec<String> = doc_comment
-            .split_off(DOC_START.len())
-            .lines()
-            .next()
-            .unwrap()
-            .split(", ")
-            .map(str::to_string)
-            .collect();
-
-        // Format documentation correctly
-        // split off leading `.` from lint name list and indent for correct formatting
-        documentation = documentation.trim_start_matches('.').trim().replace("\n ", "\n    ");
-
-        Some((lints, documentation))
-    } else {
-        None
-    }
-}
-
-/// Transforms a given `snake_case_string` to a tasty `kebab-case-string`
-fn to_kebab(config_name: &str) -> String {
-    config_name.replace('_', "-")
-}
diff --git a/clippy_dev/Cargo.toml b/clippy_dev/Cargo.toml
index 4104e7d94f146..a5d72c3a559df 100644
--- a/clippy_dev/Cargo.toml
+++ b/clippy_dev/Cargo.toml
@@ -13,9 +13,6 @@ opener = "0.6"
 shell-escape = "0.1"
 walkdir = "2.3"
 
-[features]
-deny-warnings = []
-
 [package.metadata.rust-analyzer]
 # This package uses #[feature(rustc_private)]
 rustc_private = true
diff --git a/clippy_dev/src/fmt.rs b/clippy_dev/src/fmt.rs
index 2562314418172..5fc4365c6e785 100644
--- a/clippy_dev/src/fmt.rs
+++ b/clippy_dev/src/fmt.rs
@@ -1,30 +1,65 @@
 use crate::clippy_project_root;
 use itertools::Itertools;
+use rustc_lexer::{tokenize, TokenKind};
 use shell_escape::escape;
 use std::ffi::{OsStr, OsString};
-use std::path::Path;
+use std::ops::ControlFlow;
+use std::path::{Path, PathBuf};
 use std::process::{self, Command, Stdio};
 use std::{fs, io};
 use walkdir::WalkDir;
 
-#[derive(Debug)]
-pub enum CliError {
+pub enum Error {
     CommandFailed(String, String),
-    IoError(io::Error),
+    Io(io::Error),
     RustfmtNotInstalled,
-    WalkDirError(walkdir::Error),
+    WalkDir(walkdir::Error),
     IntellijSetupActive,
+    Parse(PathBuf, usize, String),
+    CheckFailed,
 }
 
-impl From<io::Error> for CliError {
+impl From<io::Error> for Error {
     fn from(error: io::Error) -> Self {
-        Self::IoError(error)
+        Self::Io(error)
     }
 }
 
-impl From<walkdir::Error> for CliError {
+impl From<walkdir::Error> for Error {
     fn from(error: walkdir::Error) -> Self {
-        Self::WalkDirError(error)
+        Self::WalkDir(error)
+    }
+}
+
+impl Error {
+    fn display(&self) {
+        match self {
+            Self::CheckFailed => {
+                eprintln!("Formatting check failed!\nRun `cargo dev fmt` to update.");
+            },
+            Self::CommandFailed(command, stderr) => {
+                eprintln!("error: command `{command}` failed!\nstderr: {stderr}");
+            },
+            Self::Io(err) => {
+                eprintln!("error: {err}");
+            },
+            Self::RustfmtNotInstalled => {
+                eprintln!("error: rustfmt nightly is not installed.");
+            },
+            Self::WalkDir(err) => {
+                eprintln!("error: {err}");
+            },
+            Self::IntellijSetupActive => {
+                eprintln!(
+                    "error: a local rustc repo is enabled as path dependency via `cargo dev setup intellij`.\n\
+                    Not formatting because that would format the local repo as well!\n\
+                    Please revert the changes to `Cargo.toml`s with `cargo dev remove intellij`."
+                );
+            },
+            Self::Parse(path, line, msg) => {
+                eprintln!("error parsing `{}:{line}`: {msg}", path.display());
+            },
+        }
     }
 }
 
@@ -34,75 +69,244 @@ struct FmtContext {
     rustfmt_path: String,
 }
 
-// the "main" function of cargo dev fmt
-pub fn run(check: bool, verbose: bool) {
-    fn try_run(context: &FmtContext) -> Result<bool, CliError> {
-        let mut success = true;
-
-        let project_root = clippy_project_root();
-
-        // if we added a local rustc repo as path dependency to clippy for rust analyzer, we do NOT want to
-        // format because rustfmt would also format the entire rustc repo as it is a local
-        // dependency
-        if fs::read_to_string(project_root.join("Cargo.toml"))
-            .expect("Failed to read clippy Cargo.toml")
-            .contains("[target.'cfg(NOT_A_PLATFORM)'.dependencies]")
-        {
-            return Err(CliError::IntellijSetupActive);
-        }
-
-        rustfmt_test(context)?;
+struct ClippyConf<'a> {
+    name: &'a str,
+    attrs: &'a str,
+    lints: Vec<&'a str>,
+    field: &'a str,
+}
 
-        success &= cargo_fmt(context, project_root.as_path())?;
-        success &= cargo_fmt(context, &project_root.join("clippy_dev"))?;
-        success &= cargo_fmt(context, &project_root.join("rustc_tools_util"))?;
-        success &= cargo_fmt(context, &project_root.join("lintcheck"))?;
+fn offset_to_line(text: &str, offset: usize) -> usize {
+    match text.split('\n').try_fold((1usize, 0usize), |(line, pos), s| {
+        let pos = pos + s.len() + 1;
+        if pos > offset {
+            ControlFlow::Break(line)
+        } else {
+            ControlFlow::Continue((line + 1, pos))
+        }
+    }) {
+        ControlFlow::Break(x) | ControlFlow::Continue((x, _)) => x,
+    }
+}
 
-        let chunks = WalkDir::new(project_root.join("tests"))
-            .into_iter()
-            .filter_map(|entry| {
-                let entry = entry.expect("failed to find tests");
-                let path = entry.path();
+/// Formats the configuration list in `clippy_config/src/conf.rs`
+#[expect(clippy::too_many_lines)]
+fn fmt_conf(check: bool) -> Result<(), Error> {
+    #[derive(Clone, Copy)]
+    enum State {
+        Start,
+        Docs,
+        Pound,
+        OpenBracket,
+        Attr(u32),
+        Lints,
+        EndLints,
+        Field,
+    }
 
-                if path.extension() != Some("rs".as_ref()) || entry.file_name() == "ice-3891.rs" {
-                    None
-                } else {
-                    Some(entry.into_path().into_os_string())
-                }
-            })
-            .chunks(250);
+    let path: PathBuf = [
+        clippy_project_root().as_path(),
+        "clippy_config".as_ref(),
+        "src".as_ref(),
+        "conf.rs".as_ref(),
+    ]
+    .into_iter()
+    .collect();
+    let text = fs::read_to_string(&path)?;
 
-        for chunk in &chunks {
-            success &= rustfmt(context, chunk)?;
-        }
+    let (pre, conf) = text
+        .split_once("define_Conf! {\n")
+        .expect("can't find config definition");
+    let (conf, post) = conf.split_once("\n}\n").expect("can't find config definition");
+    let conf_offset = pre.len() + 15;
 
-        Ok(success)
-    }
+    let mut pos = 0u32;
+    let mut attrs_start = 0;
+    let mut attrs_end = 0;
+    let mut field_start = 0;
+    let mut lints = Vec::new();
+    let mut name = "";
+    let mut fields = Vec::new();
+    let mut state = State::Start;
 
-    fn output_err(err: CliError) {
-        match err {
-            CliError::CommandFailed(command, stderr) => {
-                eprintln!("error: A command failed! `{command}`\nstderr: {stderr}");
+    for (i, t) in tokenize(conf)
+        .map(|x| {
+            let start = pos;
+            pos += x.len;
+            (start as usize, x)
+        })
+        .filter(|(_, t)| !matches!(t.kind, TokenKind::Whitespace))
+    {
+        match (state, t.kind) {
+            (State::Start, TokenKind::LineComment { doc_style: Some(_) }) => {
+                attrs_start = i;
+                attrs_end = i + t.len as usize;
+                state = State::Docs;
             },
-            CliError::IoError(err) => {
-                eprintln!("error: {err}");
+            (State::Start, TokenKind::Pound) => {
+                attrs_start = i;
+                attrs_end = i;
+                state = State::Pound;
             },
-            CliError::RustfmtNotInstalled => {
-                eprintln!("error: rustfmt nightly is not installed.");
+            (State::Docs, TokenKind::LineComment { doc_style: Some(_) }) => attrs_end = i + t.len as usize,
+            (State::Docs, TokenKind::Pound) => state = State::Pound,
+            (State::Pound, TokenKind::OpenBracket) => state = State::OpenBracket,
+            (State::OpenBracket, TokenKind::Ident) => {
+                state = if conf[i..i + t.len as usize] == *"lints" {
+                    State::Lints
+                } else {
+                    State::Attr(0)
+                };
             },
-            CliError::WalkDirError(err) => {
-                eprintln!("error: {err}");
+            (State::Attr(0), TokenKind::CloseBracket) => {
+                attrs_end = i + 1;
+                state = State::Docs;
             },
-            CliError::IntellijSetupActive => {
-                eprintln!(
-                    "error: a local rustc repo is enabled as path dependency via `cargo dev setup intellij`.
-Not formatting because that would format the local repo as well!
-Please revert the changes to Cargo.tomls with `cargo dev remove intellij`."
-                );
+            (State::Attr(x), TokenKind::OpenParen | TokenKind::OpenBracket | TokenKind::OpenBrace) => {
+                state = State::Attr(x + 1);
+            },
+            (State::Attr(x), TokenKind::CloseParen | TokenKind::CloseBracket | TokenKind::CloseBrace) => {
+                state = State::Attr(x - 1);
+            },
+            (State::Lints, TokenKind::Ident) => lints.push(&conf[i..i + t.len as usize]),
+            (State::Lints, TokenKind::CloseBracket) => state = State::EndLints,
+            (State::EndLints | State::Docs, TokenKind::Ident) => {
+                field_start = i;
+                name = &conf[i..i + t.len as usize];
+                state = State::Field;
+            },
+            (State::Field, TokenKind::LineComment { doc_style: Some(_) }) => {
+                #[expect(clippy::drain_collect)]
+                fields.push(ClippyConf {
+                    name,
+                    lints: lints.drain(..).collect(),
+                    attrs: &conf[attrs_start..attrs_end],
+                    field: conf[field_start..i].trim_end(),
+                });
+                attrs_start = i;
+                attrs_end = i + t.len as usize;
+                state = State::Docs;
+            },
+            (State::Field, TokenKind::Pound) => {
+                #[expect(clippy::drain_collect)]
+                fields.push(ClippyConf {
+                    name,
+                    lints: lints.drain(..).collect(),
+                    attrs: &conf[attrs_start..attrs_end],
+                    field: conf[field_start..i].trim_end(),
+                });
+                attrs_start = i;
+                attrs_end = i;
+                state = State::Pound;
+            },
+            (State::Field | State::Attr(_), _)
+            | (State::Lints, TokenKind::Comma | TokenKind::OpenParen | TokenKind::CloseParen) => {},
+            _ => {
+                return Err(Error::Parse(
+                    path,
+                    offset_to_line(&text, conf_offset + i),
+                    format!("unexpected token `{}`", &conf[i..i + t.len as usize]),
+                ));
             },
         }
     }
 
+    if !matches!(state, State::Field) {
+        return Err(Error::Parse(
+            path,
+            offset_to_line(&text, conf_offset + conf.len()),
+            "incomplete field".into(),
+        ));
+    }
+    fields.push(ClippyConf {
+        name,
+        lints,
+        attrs: &conf[attrs_start..attrs_end],
+        field: conf[field_start..].trim_end(),
+    });
+
+    for field in &mut fields {
+        field.lints.sort_unstable();
+    }
+    fields.sort_by_key(|x| x.name);
+
+    let new_text = format!(
+        "{pre}define_Conf! {{\n{}}}\n{post}",
+        fields.iter().format_with("", |field, f| {
+            if field.lints.is_empty() {
+                f(&format_args!("    {}\n    {}\n", field.attrs, field.field))
+            } else if field.lints.iter().map(|x| x.len() + 2).sum::<usize>() < 120 - 14 {
+                f(&format_args!(
+                    "    {}\n    #[lints({})]\n    {}\n",
+                    field.attrs,
+                    field.lints.iter().join(", "),
+                    field.field,
+                ))
+            } else {
+                f(&format_args!(
+                    "    {}\n    #[lints({}\n    )]\n    {}\n",
+                    field.attrs,
+                    field
+                        .lints
+                        .iter()
+                        .format_with("", |x, f| f(&format_args!("\n        {x},"))),
+                    field.field,
+                ))
+            }
+        })
+    );
+
+    if text != new_text {
+        if check {
+            return Err(Error::CheckFailed);
+        }
+        fs::write(&path, new_text.as_bytes())?;
+    }
+    Ok(())
+}
+
+fn run_rustfmt(context: &FmtContext) -> Result<(), Error> {
+    let project_root = clippy_project_root();
+
+    // if we added a local rustc repo as path dependency to clippy for rust analyzer, we do NOT want to
+    // format because rustfmt would also format the entire rustc repo as it is a local
+    // dependency
+    if fs::read_to_string(project_root.join("Cargo.toml"))
+        .expect("Failed to read clippy Cargo.toml")
+        .contains("[target.'cfg(NOT_A_PLATFORM)'.dependencies]")
+    {
+        return Err(Error::IntellijSetupActive);
+    }
+
+    check_for_rustfmt(context)?;
+
+    cargo_fmt(context, project_root.as_path())?;
+    cargo_fmt(context, &project_root.join("clippy_dev"))?;
+    cargo_fmt(context, &project_root.join("rustc_tools_util"))?;
+    cargo_fmt(context, &project_root.join("lintcheck"))?;
+
+    let chunks = WalkDir::new(project_root.join("tests"))
+        .into_iter()
+        .filter_map(|entry| {
+            let entry = entry.expect("failed to find tests");
+            let path = entry.path();
+
+            if path.extension() != Some("rs".as_ref()) || entry.file_name() == "ice-3891.rs" {
+                None
+            } else {
+                Some(entry.into_path().into_os_string())
+            }
+        })
+        .chunks(250);
+
+    for chunk in &chunks {
+        rustfmt(context, chunk)?;
+    }
+    Ok(())
+}
+
+// the "main" function of cargo dev fmt
+pub fn run(check: bool, verbose: bool) {
     let output = Command::new("rustup")
         .args(["which", "rustfmt"])
         .stderr(Stdio::inherit())
@@ -120,21 +324,10 @@ Please revert the changes to Cargo.tomls with `cargo dev remove intellij`."
         verbose,
         rustfmt_path,
     };
-    let result = try_run(&context);
-    let code = match result {
-        Ok(true) => 0,
-        Ok(false) => {
-            eprintln!();
-            eprintln!("Formatting check failed.");
-            eprintln!("Run `cargo dev fmt` to update formatting.");
-            1
-        },
-        Err(err) => {
-            output_err(err);
-            1
-        },
-    };
-    process::exit(code);
+    if let Err(e) = run_rustfmt(&context).and_then(|()| fmt_conf(check)) {
+        e.display();
+        process::exit(1);
+    }
 }
 
 fn format_command(program: impl AsRef<OsStr>, dir: impl AsRef<Path>, args: &[impl AsRef<OsStr>]) -> String {
@@ -148,12 +341,12 @@ fn format_command(program: impl AsRef<OsStr>, dir: impl AsRef<Path>, args: &[imp
     )
 }
 
-fn exec(
+fn exec_fmt_command(
     context: &FmtContext,
     program: impl AsRef<OsStr>,
     dir: impl AsRef<Path>,
     args: &[impl AsRef<OsStr>],
-) -> Result<bool, CliError> {
+) -> Result<(), Error> {
     if context.verbose {
         println!("{}", format_command(&program, &dir, args));
     }
@@ -166,28 +359,28 @@ fn exec(
         .unwrap();
     let success = output.status.success();
 
-    if !context.check && !success {
-        let stderr = std::str::from_utf8(&output.stderr).unwrap_or("");
-        return Err(CliError::CommandFailed(
-            format_command(&program, &dir, args),
-            String::from(stderr),
-        ));
+    match (context.check, success) {
+        (_, true) => Ok(()),
+        (true, false) => Err(Error::CheckFailed),
+        (false, false) => {
+            let stderr = std::str::from_utf8(&output.stderr).unwrap_or("");
+            Err(Error::CommandFailed(
+                format_command(&program, &dir, args),
+                String::from(stderr),
+            ))
+        },
     }
-
-    Ok(success)
 }
 
-fn cargo_fmt(context: &FmtContext, path: &Path) -> Result<bool, CliError> {
+fn cargo_fmt(context: &FmtContext, path: &Path) -> Result<(), Error> {
     let mut args = vec!["fmt", "--all"];
     if context.check {
         args.push("--check");
     }
-    let success = exec(context, "cargo", path, &args)?;
-
-    Ok(success)
+    exec_fmt_command(context, "cargo", path, &args)
 }
 
-fn rustfmt_test(context: &FmtContext) -> Result<(), CliError> {
+fn check_for_rustfmt(context: &FmtContext) -> Result<(), Error> {
     let program = "rustfmt";
     let dir = std::env::current_dir()?;
     let args = &["--version"];
@@ -204,23 +397,20 @@ fn rustfmt_test(context: &FmtContext) -> Result<(), CliError> {
         .unwrap_or("")
         .starts_with("error: 'rustfmt' is not installed")
     {
-        Err(CliError::RustfmtNotInstalled)
+        Err(Error::RustfmtNotInstalled)
     } else {
-        Err(CliError::CommandFailed(
+        Err(Error::CommandFailed(
             format_command(program, &dir, args),
             std::str::from_utf8(&output.stderr).unwrap_or("").to_string(),
         ))
     }
 }
 
-fn rustfmt(context: &FmtContext, paths: impl Iterator<Item = OsString>) -> Result<bool, CliError> {
+fn rustfmt(context: &FmtContext, paths: impl Iterator<Item = OsString>) -> Result<(), Error> {
     let mut args = Vec::new();
     if context.check {
         args.push(OsString::from("--check"));
     }
     args.extend(paths);
-
-    let success = exec(context, &context.rustfmt_path, std::env::current_dir()?, &args)?;
-
-    Ok(success)
+    exec_fmt_command(context, &context.rustfmt_path, std::env::current_dir()?, &args)
 }
diff --git a/clippy_dev/src/lib.rs b/clippy_dev/src/lib.rs
index 3aa43dbe23ed6..ad385d5fbd29f 100644
--- a/clippy_dev/src/lib.rs
+++ b/clippy_dev/src/lib.rs
@@ -1,6 +1,5 @@
 #![feature(let_chains)]
 #![feature(rustc_private)]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![warn(
     trivial_casts,
     trivial_numeric_casts,
diff --git a/clippy_dev/src/main.rs b/clippy_dev/src/main.rs
index 366b52b25dfcf..755b04b0b232f 100644
--- a/clippy_dev/src/main.rs
+++ b/clippy_dev/src/main.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 // warn on lints, that are included in `rust-lang/rust`s bootstrap
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
@@ -74,7 +73,7 @@ fn main() {
             new_name,
             uplift,
         } => update_lints::rename(&old_name, new_name.as_ref().unwrap_or(&old_name), uplift),
-        DevCommand::Deprecate { name, reason } => update_lints::deprecate(&name, reason.as_deref()),
+        DevCommand::Deprecate { name, reason } => update_lints::deprecate(&name, &reason),
     }
 }
 
@@ -223,7 +222,7 @@ enum DevCommand {
         name: String,
         #[arg(long, short)]
         /// The reason for deprecation
-        reason: Option<String>,
+        reason: String,
     },
 }
 
diff --git a/clippy_dev/src/serve.rs b/clippy_dev/src/serve.rs
index 4a4261d1a1e63..19560b31fd3e2 100644
--- a/clippy_dev/src/serve.rs
+++ b/clippy_dev/src/serve.rs
@@ -1,10 +1,14 @@
-use std::ffi::OsStr;
-use std::num::ParseIntError;
 use std::path::Path;
 use std::process::Command;
 use std::time::{Duration, SystemTime};
 use std::{env, thread};
 
+#[cfg(windows)]
+const PYTHON: &str = "python";
+
+#[cfg(not(windows))]
+const PYTHON: &str = "python3";
+
 /// # Panics
 ///
 /// Panics if the python commands could not be spawned
@@ -25,7 +29,7 @@ pub fn run(port: u16, lint: Option<String>) -> ! {
         }
         if let Some(url) = url.take() {
             thread::spawn(move || {
-                Command::new("python3")
+                Command::new(PYTHON)
                     .arg("-m")
                     .arg("http.server")
                     .arg(port.to_string())
@@ -58,8 +62,3 @@ fn mtime(path: impl AsRef<Path>) -> SystemTime {
             .unwrap_or(SystemTime::UNIX_EPOCH)
     }
 }
-
-#[allow(clippy::missing_errors_doc)]
-pub fn validate_port(arg: &OsStr) -> Result<(), ParseIntError> {
-    arg.to_string_lossy().parse::<u16>().map(|_| ())
-}
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 45353901c98fd..15578d69c3a9d 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -1,13 +1,12 @@
 use crate::clippy_project_root;
 use aho_corasick::AhoCorasickBuilder;
-use indoc::writedoc;
 use itertools::Itertools;
 use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
 use std::collections::{HashMap, HashSet};
 use std::ffi::OsStr;
 use std::fmt::{self, Write};
 use std::fs::{self, OpenOptions};
-use std::io::{self, Read, Seek, SeekFrom, Write as _};
+use std::io::{self, Read, Seek, Write as _};
 use std::ops::Range;
 use std::path::{Path, PathBuf};
 use walkdir::{DirEntry, WalkDir};
@@ -77,12 +76,8 @@ fn generate_lint_files(
             for lint in usable_lints
                 .iter()
                 .map(|l| &*l.name)
-                .chain(deprecated_lints.iter().map(|l| &*l.name))
-                .chain(
-                    renamed_lints
-                        .iter()
-                        .map(|l| l.old_name.strip_prefix("clippy::").unwrap_or(&l.old_name)),
-                )
+                .chain(deprecated_lints.iter().filter_map(|l| l.name.strip_prefix("clippy::")))
+                .chain(renamed_lints.iter().filter_map(|l| l.old_name.strip_prefix("clippy::")))
                 .sorted()
             {
                 writeln!(res, "[`{lint}`]: {DOCS_LINK}#{lint}").unwrap();
@@ -108,11 +103,6 @@ fn generate_lint_files(
         update_mode,
         &gen_declared_lints(internal_lints.iter(), usable_lints.iter()),
     );
-    process_file(
-        "clippy_lints/src/lib.deprecated.rs",
-        update_mode,
-        &gen_deprecated(deprecated_lints),
-    );
 
     let content = gen_deprecated_lints_test(deprecated_lints);
     process_file("tests/ui/deprecated.rs", update_mode, &content);
@@ -205,7 +195,7 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
             let ext = f.path().extension();
             (ext == Some(OsStr::new("rs")) || ext == Some(OsStr::new("fixed")))
                 && name != Some(OsStr::new("rename.rs"))
-                && name != Some(OsStr::new("renamed_lints.rs"))
+                && name != Some(OsStr::new("deprecated_lints.rs"))
         })
     {
         rewrite_file(file.path(), |s| {
@@ -213,6 +203,19 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
         });
     }
 
+    let version = crate::new_lint::get_stabilization_version();
+    rewrite_file(Path::new("clippy_lints/src/deprecated_lints.rs"), |s| {
+        insert_at_marker(
+            s,
+            "// end renamed lints. used by `cargo dev rename_lint`",
+            &format!(
+                "#[clippy::version = \"{version}\"]\n    \
+                (\"{}\", \"{}\"),\n    ",
+                lint.old_name, lint.new_name,
+            ),
+        )
+    });
+
     renamed_lints.push(lint);
     renamed_lints.sort_by(|lhs, rhs| {
         lhs.new_name
@@ -222,11 +225,6 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
             .then_with(|| lhs.old_name.cmp(&rhs.old_name))
     });
 
-    write_file(
-        Path::new("clippy_lints/src/renamed_lints.rs"),
-        &gen_renamed_lints_list(&renamed_lints),
-    );
-
     if uplift {
         write_file(Path::new("tests/ui/rename.rs"), &gen_renamed_lints_test(&renamed_lints));
         println!(
@@ -293,7 +291,8 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
 
         // Don't change `clippy_utils/src/renamed_lints.rs` here as it would try to edit the lint being
         // renamed.
-        for (_, file) in clippy_lints_src_files().filter(|(rel_path, _)| rel_path != OsStr::new("renamed_lints.rs")) {
+        for (_, file) in clippy_lints_src_files().filter(|(rel_path, _)| rel_path != OsStr::new("deprecated_lints.rs"))
+        {
             rewrite_file(file.path(), |s| replace_ident_like(s, replacements));
         }
 
@@ -304,7 +303,6 @@ pub fn rename(old_name: &str, new_name: &str, uplift: bool) {
     println!("note: `cargo uitest` still needs to be run to update the test results");
 }
 
-const DEFAULT_DEPRECATION_REASON: &str = "default deprecation note";
 /// Runs the `deprecate` command
 ///
 /// This does the following:
@@ -314,33 +312,16 @@ const DEFAULT_DEPRECATION_REASON: &str = "default deprecation note";
 /// # Panics
 ///
 /// If a file path could not read from or written to
-pub fn deprecate(name: &str, reason: Option<&str>) {
-    fn finish(
-        (lints, mut deprecated_lints, renamed_lints): (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>),
-        name: &str,
-        reason: &str,
-    ) {
-        deprecated_lints.push(DeprecatedLint {
-            name: name.to_string(),
-            reason: reason.to_string(),
-            declaration_range: Range::default(),
-        });
-
-        generate_lint_files(UpdateMode::Change, &lints, &deprecated_lints, &renamed_lints);
-        println!("info: `{name}` has successfully been deprecated");
-
-        if reason == DEFAULT_DEPRECATION_REASON {
-            println!("note: the deprecation reason must be updated in `clippy_lints/src/deprecated_lints.rs`");
-        }
-        println!("note: you must run `cargo uitest` to update the test results");
-    }
-
-    let reason = reason.unwrap_or(DEFAULT_DEPRECATION_REASON);
-    let name_lower = name.to_lowercase();
-    let name_upper = name.to_uppercase();
+pub fn deprecate(name: &str, reason: &str) {
+    let prefixed_name = if name.starts_with("clippy::") {
+        name.to_owned()
+    } else {
+        format!("clippy::{name}")
+    };
+    let stripped_name = &prefixed_name[8..];
 
-    let (mut lints, deprecated_lints, renamed_lints) = gather_all();
-    let Some(lint) = lints.iter().find(|l| l.name == name_lower) else {
+    let (mut lints, mut deprecated_lints, renamed_lints) = gather_all();
+    let Some(lint) = lints.iter().find(|l| l.name == stripped_name) else {
         eprintln!("error: failed to find lint `{name}`");
         return;
     };
@@ -357,13 +338,27 @@ pub fn deprecate(name: &str, reason: Option<&str>) {
 
     let deprecated_lints_path = &*clippy_project_root().join("clippy_lints/src/deprecated_lints.rs");
 
-    if remove_lint_declaration(&name_lower, &mod_path, &mut lints).unwrap_or(false) {
-        declare_deprecated(&name_upper, deprecated_lints_path, reason).unwrap();
-        finish((lints, deprecated_lints, renamed_lints), name, reason);
-        return;
-    }
+    if remove_lint_declaration(stripped_name, &mod_path, &mut lints).unwrap_or(false) {
+        let version = crate::new_lint::get_stabilization_version();
+        rewrite_file(deprecated_lints_path, |s| {
+            insert_at_marker(
+                s,
+                "// end deprecated lints. used by `cargo dev deprecate_lint`",
+                &format!("#[clippy::version = \"{version}\"]\n    (\"{prefixed_name}\", \"{reason}\"),\n    ",),
+            )
+        });
+
+        deprecated_lints.push(DeprecatedLint {
+            name: prefixed_name,
+            reason: reason.into(),
+        });
 
-    eprintln!("error: lint not found");
+        generate_lint_files(UpdateMode::Change, &lints, &deprecated_lints, &renamed_lints);
+        println!("info: `{name}` has successfully been deprecated");
+        println!("note: you must run `cargo uitest` to update the test results");
+    } else {
+        eprintln!("error: lint not found");
+    }
 }
 
 fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io::Result<bool> {
@@ -377,14 +372,14 @@ fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io
 
         // Some lints have their own directories, delete them
         if path.is_dir() {
-            fs::remove_dir_all(path).ok();
+            let _ = fs::remove_dir_all(path);
             return;
         }
 
         // Remove all related test files
-        fs::remove_file(path.with_extension("rs")).ok();
-        fs::remove_file(path.with_extension("stderr")).ok();
-        fs::remove_file(path.with_extension("fixed")).ok();
+        let _ = fs::remove_file(path.with_extension("rs"));
+        let _ = fs::remove_file(path.with_extension("stderr"));
+        let _ = fs::remove_file(path.with_extension("fixed"));
     }
 
     fn remove_impl_lint_pass(lint_name_upper: &str, content: &mut String) {
@@ -427,7 +422,7 @@ fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io
                     lint_mod_path.set_file_name(name);
                     lint_mod_path.set_extension("rs");
 
-                    fs::remove_file(lint_mod_path).ok();
+                    let _ = fs::remove_file(lint_mod_path);
                 }
 
                 let mut content =
@@ -465,37 +460,6 @@ fn remove_lint_declaration(name: &str, path: &Path, lints: &mut Vec<Lint>) -> io
     Ok(false)
 }
 
-fn declare_deprecated(name: &str, path: &Path, reason: &str) -> io::Result<()> {
-    let mut file = OpenOptions::new().write(true).open(path)?;
-
-    file.seek(SeekFrom::End(0))?;
-
-    let version = crate::new_lint::get_stabilization_version();
-    let deprecation_reason = if reason == DEFAULT_DEPRECATION_REASON {
-        "TODO"
-    } else {
-        reason
-    };
-
-    writedoc!(
-        file,
-        "
-
-        declare_deprecated_lint! {{
-            /// ### What it does
-            /// Nothing. This lint has been deprecated.
-            ///
-            /// ### Deprecation reason
-            /// {deprecation_reason}
-            #[clippy::version = \"{version}\"]
-            pub {name},
-            \"{reason}\"
-        }}
-
-        "
-    )
-}
-
 /// Replace substrings if they aren't bordered by identifier characters. Returns `None` if there
 /// were no replacements.
 fn replace_ident_like(contents: &str, replacements: &[(&str, &str)]) -> Option<String> {
@@ -604,14 +568,12 @@ impl Lint {
 struct DeprecatedLint {
     name: String,
     reason: String,
-    declaration_range: Range<usize>,
 }
 impl DeprecatedLint {
-    fn new(name: &str, reason: &str, declaration_range: Range<usize>) -> Self {
+    fn new(name: &str, reason: &str) -> Self {
         Self {
-            name: name.to_lowercase(),
+            name: remove_line_splices(name),
             reason: remove_line_splices(reason),
-            declaration_range,
         }
     }
 }
@@ -629,28 +591,6 @@ impl RenamedLint {
     }
 }
 
-/// Generates the `register_removed` code
-#[must_use]
-fn gen_deprecated(lints: &[DeprecatedLint]) -> String {
-    let mut output = GENERATED_FILE_COMMENT.to_string();
-    output.push_str("{\n");
-    for lint in lints {
-        let _: fmt::Result = write!(
-            output,
-            concat!(
-                "    store.register_removed(\n",
-                "        \"clippy::{}\",\n",
-                "        \"{}\",\n",
-                "    );\n"
-            ),
-            lint.name, lint.reason,
-        );
-    }
-    output.push_str("}\n");
-
-    output
-}
-
 /// Generates the code for registering lints
 #[must_use]
 fn gen_declared_lints<'a>(
@@ -680,7 +620,7 @@ fn gen_declared_lints<'a>(
 fn gen_deprecated_lints_test(lints: &[DeprecatedLint]) -> String {
     let mut res: String = GENERATED_FILE_COMMENT.into();
     for lint in lints {
-        writeln!(res, "#![warn(clippy::{})]", lint.name).unwrap();
+        writeln!(res, "#![warn({})] //~ ERROR: lint `{}`", lint.name, lint.name).unwrap();
     }
     res.push_str("\nfn main() {}\n");
     res
@@ -699,27 +639,13 @@ fn gen_renamed_lints_test(lints: &[RenamedLint]) -> String {
     seen_lints.clear();
     for lint in lints {
         if seen_lints.insert(&lint.old_name) {
-            writeln!(res, "#![warn({})]", lint.old_name).unwrap();
+            writeln!(res, "#![warn({})] //~ ERROR: lint `{}`", lint.old_name, lint.old_name).unwrap();
         }
     }
     res.push_str("\nfn main() {}\n");
     res
 }
 
-fn gen_renamed_lints_list(lints: &[RenamedLint]) -> String {
-    const HEADER: &str = "\
-        // This file is managed by `cargo dev rename_lint`. Prefer using that when possible.\n\n\
-        #[rustfmt::skip]\n\
-        pub static RENAMED_LINTS: &[(&str, &str)] = &[\n";
-
-    let mut res = String::from(HEADER);
-    for lint in lints {
-        writeln!(res, "    (\"{}\", \"{}\"),", lint.old_name, lint.new_name).unwrap();
-    }
-    res.push_str("];\n");
-    res
-}
-
 /// Gathers all lints defined in `clippy_lints/src`
 fn gather_all() -> (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>) {
     let mut lints = Vec::with_capacity(1000);
@@ -744,10 +670,10 @@ fn gather_all() -> (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>) {
             module.strip_suffix(".rs").unwrap_or(&module)
         };
 
-        match module {
-            "deprecated_lints" => parse_deprecated_contents(&contents, &mut deprecated_lints),
-            "renamed_lints" => parse_renamed_contents(&contents, &mut renamed_lints),
-            _ => parse_contents(&contents, module, &mut lints),
+        if module == "deprecated_lints" {
+            parse_deprecated_contents(&contents, &mut deprecated_lints, &mut renamed_lints);
+        } else {
+            parse_contents(&contents, module, &mut lints);
         }
     }
     (lints, deprecated_lints, renamed_lints)
@@ -848,54 +774,37 @@ fn parse_contents(contents: &str, module: &str, lints: &mut Vec<Lint>) {
 }
 
 /// Parse a source file looking for `declare_deprecated_lint` macro invocations.
-fn parse_deprecated_contents(contents: &str, lints: &mut Vec<DeprecatedLint>) {
-    let mut offset = 0usize;
-    let mut iter = tokenize(contents).map(|t| {
-        let range = offset..offset + t.len as usize;
-        offset = range.end;
-
-        LintDeclSearchResult {
-            token_kind: t.kind,
-            content: &contents[range.clone()],
-            range,
-        }
-    });
+fn parse_deprecated_contents(contents: &str, deprecated: &mut Vec<DeprecatedLint>, renamed: &mut Vec<RenamedLint>) {
+    let Some((_, contents)) = contents.split_once("\ndeclare_with_version! { DEPRECATED") else {
+        return;
+    };
+    let Some((deprecated_src, renamed_src)) = contents.split_once("\ndeclare_with_version! { RENAMED") else {
+        return;
+    };
 
-    while let Some(LintDeclSearchResult { range, .. }) = iter.find(
-        |LintDeclSearchResult {
-             token_kind, content, ..
-         }| token_kind == &TokenKind::Ident && *content == "declare_deprecated_lint",
-    ) {
-        let start = range.start;
+    for line in deprecated_src.lines() {
+        let mut offset = 0usize;
+        let mut iter = tokenize(line).map(|t| {
+            let range = offset..offset + t.len as usize;
+            offset = range.end;
 
-        let mut iter = iter.by_ref().filter(|LintDeclSearchResult { ref token_kind, .. }| {
-            !matches!(token_kind, TokenKind::Whitespace | TokenKind::LineComment { .. })
+            LintDeclSearchResult {
+                token_kind: t.kind,
+                content: &line[range.clone()],
+                range,
+            }
         });
+
         let (name, reason) = match_tokens!(
             iter,
-            // !{
-            Bang OpenBrace
-            // #[clippy::version = "version"]
-            Pound OpenBracket Ident Colon Colon Ident Eq Literal{..} CloseBracket
-            // pub LINT_NAME,
-            Ident Ident(name) Comma
-            // "description"
-            Literal{kind: LiteralKind::Str{..},..}(reason)
+            // ("old_name",
+            Whitespace OpenParen Literal{kind: LiteralKind::Str{..},..}(name) Comma
+            // "new_name"),
+            Whitespace Literal{kind: LiteralKind::Str{..},..}(reason) CloseParen Comma
         );
-
-        if let Some(LintDeclSearchResult {
-            token_kind: TokenKind::CloseBrace,
-            range,
-            ..
-        }) = iter.next()
-        {
-            lints.push(DeprecatedLint::new(name, reason, start..range.end));
-        }
+        deprecated.push(DeprecatedLint::new(name, reason));
     }
-}
-
-fn parse_renamed_contents(contents: &str, lints: &mut Vec<RenamedLint>) {
-    for line in contents.lines() {
+    for line in renamed_src.lines() {
         let mut offset = 0usize;
         let mut iter = tokenize(line).map(|t| {
             let range = offset..offset + t.len as usize;
@@ -915,7 +824,7 @@ fn parse_renamed_contents(contents: &str, lints: &mut Vec<RenamedLint>) {
             // "new_name"),
             Whitespace Literal{kind: LiteralKind::Str{..},..}(new_name) CloseParen Comma
         );
-        lints.push(RenamedLint::new(old_name, new_name));
+        renamed.push(RenamedLint::new(old_name, new_name));
     }
 }
 
@@ -1015,6 +924,12 @@ fn panic_file(error: io::Error, name: &Path, action: &str) -> ! {
     panic!("failed to {action} file `{}`: {error}", name.display())
 }
 
+fn insert_at_marker(text: &str, marker: &str, new_text: &str) -> Option<String> {
+    let i = text.find(marker)?;
+    let (pre, post) = text.split_at(i);
+    Some([pre, new_text, post].into_iter().collect())
+}
+
 fn rewrite_file(path: &Path, f: impl FnOnce(&str) -> Option<String>) {
     let mut file = OpenOptions::new()
         .write(true)
@@ -1084,31 +999,6 @@ mod tests {
         assert_eq!(expected, result);
     }
 
-    #[test]
-    fn test_parse_deprecated_contents() {
-        static DEPRECATED_CONTENTS: &str = r#"
-            /// some doc comment
-            declare_deprecated_lint! {
-                #[clippy::version = "I'm a version"]
-                pub SHOULD_ASSERT_EQ,
-                "`assert!()` will be more flexible with RFC 2011"
-            }
-        "#;
-
-        let mut result = Vec::new();
-        parse_deprecated_contents(DEPRECATED_CONTENTS, &mut result);
-        for r in &mut result {
-            r.declaration_range = Range::default();
-        }
-
-        let expected = vec![DeprecatedLint::new(
-            "should_assert_eq",
-            "\"`assert!()` will be more flexible with RFC 2011\"",
-            Range::default(),
-        )];
-        assert_eq!(expected, result);
-    }
-
     #[test]
     fn test_usable_lints() {
         let lints = vec![
@@ -1177,34 +1067,4 @@ mod tests {
         );
         assert_eq!(expected, Lint::by_lint_group(lints.into_iter()));
     }
-
-    #[test]
-    fn test_gen_deprecated() {
-        let lints = vec![
-            DeprecatedLint::new(
-                "should_assert_eq",
-                "\"has been superseded by should_assert_eq2\"",
-                Range::default(),
-            ),
-            DeprecatedLint::new("another_deprecated", "\"will be removed\"", Range::default()),
-        ];
-
-        let expected = GENERATED_FILE_COMMENT.to_string()
-            + &[
-                "{",
-                "    store.register_removed(",
-                "        \"clippy::should_assert_eq\",",
-                "        \"has been superseded by should_assert_eq2\",",
-                "    );",
-                "    store.register_removed(",
-                "        \"clippy::another_deprecated\",",
-                "        \"will be removed\",",
-                "    );",
-                "}",
-            ]
-            .join("\n")
-            + "\n";
-
-        assert_eq!(expected, gen_deprecated(&lints));
-    }
 }
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index eb04c006f89fd..99ed93468a01a 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -32,7 +32,6 @@ url = "2.2"
 walkdir = "2.3"
 
 [features]
-deny-warnings = ["clippy_config/deny-warnings", "clippy_utils/deny-warnings"]
 # build clippy with internal lints enabled, off by default
 internal = ["serde_json", "tempfile", "regex"]
 
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index e6d52bcef717c..3b4cc1134802d 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -97,7 +97,7 @@ impl ApproxConstant {
                         cx,
                         APPROX_CONSTANT,
                         e.span,
-                        format!("approximate value of `{module}::consts::{}` found", &name),
+                        format!("approximate value of `{module}::consts::{name}` found"),
                         None,
                         "consider using the constant directly",
                     );
diff --git a/clippy_lints/src/as_conversions.rs b/clippy_lints/src/as_conversions.rs
index cfa25005a05ed..fefd8195f8e7e 100644
--- a/clippy_lints/src/as_conversions.rs
+++ b/clippy_lints/src/as_conversions.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_from_proc_macro;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -52,13 +52,15 @@ impl<'tcx> LateLintPass<'tcx> for AsConversions {
             && !in_external_macro(cx.sess(), expr.span)
             && !is_from_proc_macro(cx, expr)
         {
-            span_lint_and_help(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 AS_CONVERSIONS,
                 expr.span,
                 "using a potentially dangerous silent `as` conversion",
-                None,
-                "consider using a safe wrapper for this conversion",
+                |diag| {
+                    diag.help("consider using a safe wrapper for this conversion");
+                },
             );
         }
     }
diff --git a/clippy_lints/src/asm_syntax.rs b/clippy_lints/src/asm_syntax.rs
index 0db1456d40bfc..69a8eb7d94e74 100644
--- a/clippy_lints/src/asm_syntax.rs
+++ b/clippy_lints/src/asm_syntax.rs
@@ -1,6 +1,6 @@
 use std::fmt;
 
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::{Expr, ExprKind, InlineAsmOptions};
 use rustc_ast::{InlineAsm, Item, ItemKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
@@ -49,14 +49,10 @@ fn check_asm_syntax(
         };
 
         if style == check_for {
-            span_lint_and_help(
-                cx,
-                lint,
-                span,
-                format!("{style} x86 assembly syntax used"),
-                None,
-                format!("use {} x86 assembly syntax", !style),
-            );
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(cx, lint, span, format!("{style} x86 assembly syntax used"), |diag| {
+                diag.help(format!("use {} x86 assembly syntax", !style));
+            });
         }
     }
 }
@@ -98,13 +94,13 @@ declare_lint_pass!(InlineAsmX86IntelSyntax => [INLINE_ASM_X86_INTEL_SYNTAX]);
 impl EarlyLintPass for InlineAsmX86IntelSyntax {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
-            check_asm_syntax(Self::get_lints()[0], cx, inline_asm, expr.span, AsmStyle::Intel);
+            check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, expr.span, AsmStyle::Intel);
         }
     }
 
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
         if let ItemKind::GlobalAsm(inline_asm) = &item.kind {
-            check_asm_syntax(Self::get_lints()[0], cx, inline_asm, item.span, AsmStyle::Intel);
+            check_asm_syntax(INLINE_ASM_X86_INTEL_SYNTAX, cx, inline_asm, item.span, AsmStyle::Intel);
         }
     }
 }
@@ -146,13 +142,13 @@ declare_lint_pass!(InlineAsmX86AttSyntax => [INLINE_ASM_X86_ATT_SYNTAX]);
 impl EarlyLintPass for InlineAsmX86AttSyntax {
     fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
         if let ExprKind::InlineAsm(inline_asm) = &expr.kind {
-            check_asm_syntax(Self::get_lints()[0], cx, inline_asm, expr.span, AsmStyle::Att);
+            check_asm_syntax(INLINE_ASM_X86_ATT_SYNTAX, cx, inline_asm, expr.span, AsmStyle::Att);
         }
     }
 
     fn check_item(&mut self, cx: &EarlyContext<'_>, item: &Item) {
         if let ItemKind::GlobalAsm(inline_asm) = &item.kind {
-            check_asm_syntax(Self::get_lints()[0], cx, inline_asm, item.span, AsmStyle::Att);
+            check_asm_syntax(INLINE_ASM_X86_ATT_SYNTAX, cx, inline_asm, item.span, AsmStyle::Att);
         }
     }
 }
diff --git a/clippy_lints/src/assertions_on_constants.rs b/clippy_lints/src/assertions_on_constants.rs
index ed4cdce8cb886..7eaac80f969f7 100644
--- a/clippy_lints/src/assertions_on_constants.rs
+++ b/clippy_lints/src/assertions_on_constants.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_inside_always_const_context;
 use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
@@ -43,7 +43,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
         let Some((condition, panic_expn)) = find_assert_args(cx, e, macro_call.expn) else {
             return;
         };
-        let Some(Constant::Bool(val)) = constant(cx, cx.typeck_results(), condition) else {
+        let Some(Constant::Bool(val)) = ConstEvalCtxt::new(cx).eval(condition) else {
             return;
         };
 
diff --git a/clippy_lints/src/assertions_on_result_states.rs b/clippy_lints/src/assertions_on_result_states.rs
index 7217686dcca5b..f1cb4a05af86c 100644
--- a/clippy_lints/src/assertions_on_result_states.rs
+++ b/clippy_lints/src/assertions_on_result_states.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::{find_assert_args, root_macro_call_first_node, PanicExpn};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{has_debug_impl, is_copy, is_type_diagnostic_item};
@@ -68,39 +68,28 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnResultStates {
                     return;
                 }
             }
-            let semicolon = if is_expr_final_block_expr(cx.tcx, e) { ";" } else { "" };
-            let mut app = Applicability::MachineApplicable;
-            match method_segment.ident.as_str() {
+            let (message, replacement) = match method_segment.ident.as_str() {
                 "is_ok" if type_suitable_to_unwrap(cx, args.type_at(1)) => {
-                    span_lint_and_sugg(
-                        cx,
-                        ASSERTIONS_ON_RESULT_STATES,
-                        macro_call.span,
-                        "called `assert!` with `Result::is_ok`",
-                        "replace with",
-                        format!(
-                            "{}.unwrap(){semicolon}",
-                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
-                        ),
-                        app,
-                    );
+                    ("called `assert!` with `Result::is_ok`", "unwrap")
                 },
                 "is_err" if type_suitable_to_unwrap(cx, args.type_at(0)) => {
-                    span_lint_and_sugg(
-                        cx,
-                        ASSERTIONS_ON_RESULT_STATES,
-                        macro_call.span,
-                        "called `assert!` with `Result::is_err`",
-                        "replace with",
-                        format!(
-                            "{}.unwrap_err(){semicolon}",
-                            snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
-                        ),
-                        app,
-                    );
+                    ("called `assert!` with `Result::is_err`", "unwrap_err")
                 },
-                _ => (),
+                _ => return,
             };
+            span_lint_and_then(cx, ASSERTIONS_ON_RESULT_STATES, macro_call.span, message, |diag| {
+                let semicolon = if is_expr_final_block_expr(cx.tcx, e) { ";" } else { "" };
+                let mut app = Applicability::MachineApplicable;
+                diag.span_suggestion(
+                    macro_call.span,
+                    "replace with",
+                    format!(
+                        "{}.{replacement}(){semicolon}",
+                        snippet_with_context(cx, recv.span, condition.span.ctxt(), "..", &mut app).0
+                    ),
+                    app,
+                );
+            });
         }
     }
 }
diff --git a/clippy_lints/src/assigning_clones.rs b/clippy_lints/src/assigning_clones.rs
index 03f777600f084..6e336efbb90a2 100644
--- a/clippy_lints/src/assigning_clones.rs
+++ b/clippy_lints/src/assigning_clones.rs
@@ -227,9 +227,22 @@ fn build_sugg<'tcx>(
             match call_kind {
                 CallKind::Method => {
                     let receiver_sugg = if let ExprKind::Unary(hir::UnOp::Deref, ref_expr) = lhs.kind {
-                        // `*lhs = self_expr.clone();` -> `lhs.clone_from(self_expr)`
-                        Sugg::hir_with_applicability(cx, ref_expr, "_", app)
+                        // If `ref_expr` is a reference, we can remove the dereference operator (`*`) to make
+                        // the generated code a bit simpler. In other cases, we don't do this special case, to avoid
+                        // having to deal with Deref (https://github.com/rust-lang/rust-clippy/issues/12437).
+
+                        let ty = cx.typeck_results().expr_ty(ref_expr);
+                        if ty.is_ref() {
+                            // Apply special case, remove `*`
+                            // `*lhs = self_expr.clone();` -> `lhs.clone_from(self_expr)`
+                            Sugg::hir_with_applicability(cx, ref_expr, "_", app)
+                        } else {
+                            // Keep the original lhs
+                            // `*lhs = self_expr.clone();` -> `(*lhs).clone_from(self_expr)`
+                            Sugg::hir_with_applicability(cx, lhs, "_", app)
+                        }
                     } else {
+                        // Keep the original lhs
                         // `lhs = self_expr.clone();` -> `lhs.clone_from(self_expr)`
                         Sugg::hir_with_applicability(cx, lhs, "_", app)
                     }
@@ -249,8 +262,16 @@ fn build_sugg<'tcx>(
                 },
                 CallKind::Ufcs => {
                     let self_sugg = if let ExprKind::Unary(hir::UnOp::Deref, ref_expr) = lhs.kind {
-                        // `*lhs = Clone::clone(self_expr);` -> `Clone::clone_from(lhs, self_expr)`
-                        Sugg::hir_with_applicability(cx, ref_expr, "_", app)
+                        // See special case of removing `*` in method handling above
+                        let ty = cx.typeck_results().expr_ty(ref_expr);
+                        if ty.is_ref() {
+                            // `*lhs = Clone::clone(self_expr);` -> `Clone::clone_from(lhs, self_expr)`
+                            Sugg::hir_with_applicability(cx, ref_expr, "_", app)
+                        } else {
+                            // `*lhs = Clone::clone(self_expr);` -> `Clone::clone_from(&mut *lhs, self_expr)`
+                            // mut_addr_deref is used to avoid unnecessary parentheses around `*lhs`
+                            Sugg::hir_with_applicability(cx, ref_expr, "_", app).mut_addr_deref()
+                        }
                     } else {
                         // `lhs = Clone::clone(self_expr);` -> `Clone::clone_from(&mut lhs, self_expr)`
                         Sugg::hir_with_applicability(cx, lhs, "_", app).mut_addr()
diff --git a/clippy_lints/src/attrs/allow_attributes.rs b/clippy_lints/src/attrs/allow_attributes.rs
index df9994086cd48..a5a7b9f74a693 100644
--- a/clippy_lints/src/attrs/allow_attributes.rs
+++ b/clippy_lints/src/attrs/allow_attributes.rs
@@ -1,5 +1,5 @@
 use super::ALLOW_ATTRIBUTES;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_from_proc_macro;
 use rustc_ast::{AttrStyle, Attribute};
 use rustc_errors::Applicability;
@@ -13,14 +13,14 @@ pub fn check<'cx>(cx: &LateContext<'cx>, attr: &'cx Attribute) {
         && let Some(ident) = attr.ident()
         && !is_from_proc_macro(cx, attr)
     {
-        span_lint_and_sugg(
-            cx,
-            ALLOW_ATTRIBUTES,
-            ident.span,
-            "#[allow] attribute found",
-            "replace it with",
-            "expect".into(),
-            Applicability::MachineApplicable,
-        );
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(cx, ALLOW_ATTRIBUTES, ident.span, "#[allow] attribute found", |diag| {
+            diag.span_suggestion(
+                ident.span,
+                "replace it with",
+                "expect",
+                Applicability::MachineApplicable,
+            );
+        });
     }
 }
diff --git a/clippy_lints/src/attrs/allow_attributes_without_reason.rs b/clippy_lints/src/attrs/allow_attributes_without_reason.rs
index 4b42616a636bc..4ab97118df1d4 100644
--- a/clippy_lints/src/attrs/allow_attributes_without_reason.rs
+++ b/clippy_lints/src/attrs/allow_attributes_without_reason.rs
@@ -1,5 +1,5 @@
 use super::{Attribute, ALLOW_ATTRIBUTES_WITHOUT_REASON};
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_from_proc_macro;
 use rustc_ast::{MetaItemKind, NestedMetaItem};
 use rustc_lint::{LateContext, LintContext};
@@ -21,12 +21,14 @@ pub(super) fn check<'cx>(cx: &LateContext<'cx>, name: Symbol, items: &[NestedMet
         return;
     }
 
-    span_lint_and_help(
+    #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+    span_lint_and_then(
         cx,
         ALLOW_ATTRIBUTES_WITHOUT_REASON,
         attr.span,
         format!("`{}` attribute without specifying a reason", name.as_str()),
-        None,
-        "try adding a reason at the end with `, reason = \"..\"`",
+        |diag| {
+            diag.help("try adding a reason at the end with `, reason = \"..\"`");
+        },
     );
 }
diff --git a/clippy_lints/src/bool_to_int_with_if.rs b/clippy_lints/src/bool_to_int_with_if.rs
index 561ca9bd9866d..612712d16843c 100644
--- a/clippy_lints/src/bool_to_int_with_if.rs
+++ b/clippy_lints/src/bool_to_int_with_if.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{in_constant, is_else_clause};
+use clippy_utils::{is_else_clause, is_in_const_context};
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
@@ -52,7 +52,7 @@ impl<'tcx> LateLintPass<'tcx> for BoolToIntWithIf {
             && let Some(else_lit) = as_int_bool_lit(else_)
             && then_lit != else_lit
             && !expr.span.from_expansion()
-            && !in_constant(cx, expr.hir_id)
+            && !is_in_const_context(cx)
         {
             let ty = cx.typeck_results().expr_ty(then);
             let mut applicability = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index a1c6c0b608f72..a2f48c18170a6 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -477,14 +477,12 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
             cx: self.cx,
         };
         if let Ok(expr) = h2q.run(e) {
-            if h2q.terminals.len() > 8 {
-                // QMC has exponentially slow behavior as the number of terminals increases
-                // 8 is reasonable, it takes approximately 0.2 seconds.
-                // See #825
+            let stats = terminal_stats(&expr);
+            if stats.ops > 7 {
+                // QMC has exponentially slow behavior as the number of ops increases.
+                // See #825, #13206
                 return;
             }
-
-            let stats = terminal_stats(&expr);
             let mut simplified = expr.simplify();
             for simple in Bool::Not(Box::new(expr)).simplify() {
                 match simple {
diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index ff460a3fd8e39..bd3acc06f4b2b 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -1,6 +1,6 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::in_constant;
+use clippy_utils::is_in_const_context;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_isize_or_usize;
@@ -21,7 +21,7 @@ pub(super) fn check(
     cast_to_hir: &rustc_hir::Ty<'_>,
     msrv: &Msrv,
 ) {
-    if !should_lint(cx, expr, cast_from, cast_to, msrv) {
+    if !should_lint(cx, cast_from, cast_to, msrv) {
         return;
     }
 
@@ -70,9 +70,9 @@ pub(super) fn check(
     );
 }
 
-fn should_lint(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>, msrv: &Msrv) -> bool {
+fn should_lint(cx: &LateContext<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>, msrv: &Msrv) -> bool {
     // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
-    if in_constant(cx, expr.hir_id) {
+    if is_in_const_context(cx) {
         return false;
     }
 
diff --git a/clippy_lints/src/casts/cast_nan_to_int.rs b/clippy_lints/src/casts/cast_nan_to_int.rs
index 5bc8692c289f7..464eabe5d9ab7 100644
--- a/clippy_lints/src/casts/cast_nan_to_int.rs
+++ b/clippy_lints/src/casts/cast_nan_to_int.rs
@@ -1,6 +1,6 @@
 use super::CAST_NAN_TO_INT;
 
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_note;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
@@ -20,7 +20,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
 }
 
 fn is_known_nan(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    match constant(cx, cx.typeck_results(), e) {
+    match ConstEvalCtxt::new(cx).eval(e) {
         // FIXME(f16_f128): add these types when nan checks are available on all platforms
         Some(Constant::F64(n)) => n.is_nan(),
         Some(Constant::F32(n)) => n.is_nan(),
diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 7c5acd1a678d7..102fe25fc67b0 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::expr_or_init;
 use clippy_utils::source::snippet;
@@ -15,7 +15,7 @@ use rustc_target::abi::IntegerType;
 use super::{utils, CAST_ENUM_TRUNCATION, CAST_POSSIBLE_TRUNCATION};
 
 fn constant_int(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
-    if let Some(Constant::Int(c)) = constant(cx, cx.typeck_results(), expr) {
+    if let Some(Constant::Int(c)) = ConstEvalCtxt::new(cx).eval(expr) {
         Some(c)
     } else {
         None
diff --git a/clippy_lints/src/casts/cast_sign_loss.rs b/clippy_lints/src/casts/cast_sign_loss.rs
index 8bbd41b0db1ee..9daf237344a4b 100644
--- a/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/clippy_lints/src/casts/cast_sign_loss.rs
@@ -1,7 +1,7 @@
 use std::convert::Infallible;
 use std::ops::ControlFlow;
 
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::visitors::{for_each_expr_without_closures, Descend};
 use clippy_utils::{method_chain_args, sext};
@@ -88,7 +88,7 @@ fn get_const_signed_int_eval<'cx>(
 ) -> Option<i128> {
     let ty = ty.into().unwrap_or_else(|| cx.typeck_results().expr_ty(expr));
 
-    if let Constant::Int(n) = constant(cx, cx.typeck_results(), expr)?
+    if let Constant::Int(n) = ConstEvalCtxt::new(cx).eval(expr)?
         && let ty::Int(ity) = *ty.kind()
     {
         return Some(sext(cx.tcx, n, ity));
@@ -103,7 +103,7 @@ fn get_const_unsigned_int_eval<'cx>(
 ) -> Option<u128> {
     let ty = ty.into().unwrap_or_else(|| cx.typeck_results().expr_ty(expr));
 
-    if let Constant::Int(n) = constant(cx, cx.typeck_results(), expr)?
+    if let Constant::Int(n) = ConstEvalCtxt::new(cx).eval(expr)?
         && let ty::Uint(_ity) = *ty.kind()
     {
         return Some(n);
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_any.rs b/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
index 826589bf303b5..75de53f73ee7a 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
@@ -1,6 +1,6 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
@@ -14,21 +14,24 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         _ => { /* continue to checks */ },
     }
 
-    match cast_from.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => {
-            let mut applicability = Applicability::MaybeIncorrect;
-            let from_snippet = snippet_with_applicability(cx, cast_expr.span, "..", &mut applicability);
+    if let ty::FnDef(..) | ty::FnPtr(_) = cast_from.kind() {
+        let mut applicability = Applicability::MaybeIncorrect;
+        let from_snippet = snippet_with_applicability(cx, cast_expr.span, "..", &mut applicability);
 
-            span_lint_and_sugg(
-                cx,
-                FN_TO_NUMERIC_CAST_ANY,
-                expr.span,
-                format!("casting function pointer `{from_snippet}` to `{cast_to}`"),
-                "did you mean to invoke the function?",
-                format!("{from_snippet}() as {cast_to}"),
-                applicability,
-            );
-        },
-        _ => {},
+        span_lint_and_then(
+            cx,
+            FN_TO_NUMERIC_CAST_ANY,
+            expr.span,
+            format!("casting function pointer `{from_snippet}` to `{cast_to}`"),
+            |diag| {
+                diag.span_suggestion_with_style(
+                    expr.span,
+                    "did you mean to invoke the function?",
+                    format!("{from_snippet}() as {cast_to}"),
+                    applicability,
+                    SuggestionStyle::ShowAlways,
+                );
+            },
+        );
     }
 }
diff --git a/clippy_lints/src/casts/zero_ptr.rs b/clippy_lints/src/casts/zero_ptr.rs
index 5071af5ecb986..3c1c7d2dc3a54 100644
--- a/clippy_lints/src/casts/zero_ptr.rs
+++ b/clippy_lints/src/casts/zero_ptr.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::{in_constant, is_integer_literal, std_or_core};
+use clippy_utils::{is_in_const_context, is_integer_literal, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability, Ty, TyKind};
 use rustc_lint::LateContext;
@@ -10,7 +10,7 @@ use super::ZERO_PTR;
 pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, from: &Expr<'_>, to: &Ty<'_>) {
     if let TyKind::Ptr(ref mut_ty) = to.kind
         && is_integer_literal(from, 0)
-        && !in_constant(cx, from.hir_id)
+        && !is_in_const_context(cx)
         && let Some(std_or_core) = std_or_core(cx)
     {
         let (msg, sugg_fn) = match mut_ty.mutbl {
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 0b1ab5411bf18..1711565fca891 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -4,7 +4,7 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::{in_constant, is_integer_literal, SpanlessEq};
+use clippy_utils::{is_in_const_context, is_integer_literal, SpanlessEq};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -67,7 +67,7 @@ impl<'tcx> LateLintPass<'tcx> for CheckedConversions {
                 _ => return,
             }
             && !in_external_macro(cx.sess(), item.span)
-            && !in_constant(cx, item.hir_id)
+            && !is_in_const_context(cx)
             && self.msrv.meets(msrvs::TRY_FROM)
             && let Some(cv) = match op2 {
                 // todo: check for case signed -> larger unsigned == only x >= 0
diff --git a/clippy_lints/src/comparison_chain.rs b/clippy_lints/src/comparison_chain.rs
index 2c23c0b4f154c..5d78744e9b5e2 100644
--- a/clippy_lints/src/comparison_chain.rs
+++ b/clippy_lints/src/comparison_chain.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{if_sequence, in_constant, is_else_clause, SpanlessEq};
+use clippy_utils::{if_sequence, is_else_clause, is_in_const_context, SpanlessEq};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -68,7 +68,7 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
             return;
         }
 
-        if in_constant(cx, expr.hir_id) {
+        if is_in_const_context(cx) {
             return;
         }
 
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index 27c00948a8f2b..b49a977dbeaf1 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -1,6 +1,6 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use rustc_errors::Applicability;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::source::snippet_with_applicability;
+use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -39,14 +39,24 @@ impl LateLintPass<'_> for CreateDir {
             && let Some(def_id) = cx.qpath_res(path, func.hir_id).opt_def_id()
             && cx.tcx.is_diagnostic_item(sym::fs_create_dir, def_id)
         {
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 CREATE_DIR,
                 expr.span,
                 "calling `std::fs::create_dir` where there may be a better way",
-                "consider calling `std::fs::create_dir_all` instead",
-                format!("create_dir_all({})", snippet(cx, arg.span, "..")),
-                Applicability::MaybeIncorrect,
+                |diag| {
+                    let mut app = Applicability::MaybeIncorrect;
+                    diag.span_suggestion_with_style(
+                        expr.span,
+                        "consider calling `std::fs::create_dir_all` instead",
+                        format!(
+                            "create_dir_all({})",
+                            snippet_with_applicability(cx, arg.span, "..", &mut app)
+                        ),
+                        app,
+                        SuggestionStyle::ShowAlways,
+                    );
+                },
             );
         }
     }
diff --git a/clippy_lints/src/dbg_macro.rs b/clippy_lints/src/dbg_macro.rs
index 788c6f3ada297..93c8fff05e9ed 100644
--- a/clippy_lints/src/dbg_macro.rs
+++ b/clippy_lints/src/dbg_macro.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_in_test;
 use clippy_utils::macros::{macro_backtrace, MacroCall};
 use clippy_utils::source::snippet_with_applicability;
@@ -65,61 +65,67 @@ impl LateLintPass<'_> for DbgMacro {
             // allows `dbg!` in test code if allow-dbg-in-test is set to true in clippy.toml
             !(self.allow_dbg_in_tests && is_in_test(cx.tcx, expr.hir_id))
         {
-            let mut applicability = Applicability::MachineApplicable;
-
-            let (sugg_span, suggestion) = match expr.peel_drop_temps().kind {
-                // dbg!()
-                ExprKind::Block(..) => {
-                    // If the `dbg!` macro is a "free" statement and not contained within other expressions,
-                    // remove the whole statement.
-                    if let Node::Stmt(_) = cx.tcx.parent_hir_node(expr.hir_id)
-                        && let Some(semi_span) = cx.sess().source_map().mac_call_stmt_semi_span(macro_call.span)
-                    {
-                        (macro_call.span.to(semi_span), String::new())
-                    } else {
-                        (macro_call.span, String::from("()"))
-                    }
-                },
-                // dbg!(1)
-                ExprKind::Match(val, ..) => (
-                    macro_call.span,
-                    snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability).to_string(),
-                ),
-                // dbg!(2, 3)
-                ExprKind::Tup(
-                    [
-                        Expr {
-                            kind: ExprKind::Match(first, ..),
-                            ..
-                        },
-                        ..,
-                        Expr {
-                            kind: ExprKind::Match(last, ..),
-                            ..
-                        },
-                    ],
-                ) => {
-                    let snippet = snippet_with_applicability(
-                        cx,
-                        first.span.source_callsite().to(last.span.source_callsite()),
-                        "..",
-                        &mut applicability,
-                    );
-                    (macro_call.span, format!("({snippet})"))
-                },
-                _ => return,
-            };
-
             self.prev_ctxt = cur_syntax_ctxt;
 
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 DBG_MACRO,
-                sugg_span,
+                macro_call.span,
                 "the `dbg!` macro is intended as a debugging tool",
-                "remove the invocation before committing it to a version control system",
-                suggestion,
-                applicability,
+                |diag| {
+                    let mut applicability = Applicability::MachineApplicable;
+
+                    let (sugg_span, suggestion) = match expr.peel_drop_temps().kind {
+                        // dbg!()
+                        ExprKind::Block(..) => {
+                            // If the `dbg!` macro is a "free" statement and not contained within other expressions,
+                            // remove the whole statement.
+                            if let Node::Stmt(_) = cx.tcx.parent_hir_node(expr.hir_id)
+                                && let Some(semi_span) = cx.sess().source_map().mac_call_stmt_semi_span(macro_call.span)
+                            {
+                                (macro_call.span.to(semi_span), String::new())
+                            } else {
+                                (macro_call.span, String::from("()"))
+                            }
+                        },
+                        // dbg!(1)
+                        ExprKind::Match(val, ..) => (
+                            macro_call.span,
+                            snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability)
+                                .to_string(),
+                        ),
+                        // dbg!(2, 3)
+                        ExprKind::Tup(
+                            [
+                                Expr {
+                                    kind: ExprKind::Match(first, ..),
+                                    ..
+                                },
+                                ..,
+                                Expr {
+                                    kind: ExprKind::Match(last, ..),
+                                    ..
+                                },
+                            ],
+                        ) => {
+                            let snippet = snippet_with_applicability(
+                                cx,
+                                first.span.source_callsite().to(last.span.source_callsite()),
+                                "..",
+                                &mut applicability,
+                            );
+                            (macro_call.span, format!("({snippet})"))
+                        },
+                        _ => unreachable!(),
+                    };
+
+                    diag.span_suggestion(
+                        sugg_span,
+                        "remove the invocation before committing it to a version control system",
+                        suggestion,
+                        applicability,
+                    );
+                },
             );
         }
     }
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 69f9eb6842bcd..3fb083dd83310 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -14,8 +14,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::invalid_paths::INVALID_PATHS_INFO,
     #[cfg(feature = "internal")]
-    crate::utils::internal_lints::lint_without_lint_pass::DEFAULT_DEPRECATION_REASON_INFO,
-    #[cfg(feature = "internal")]
     crate::utils::internal_lints::lint_without_lint_pass::DEFAULT_LINT_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::lint_without_lint_pass::INVALID_CLIPPY_VERSION_ATTRIBUTE_INFO,
@@ -741,6 +739,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::unused_async::UNUSED_ASYNC_INFO,
     crate::unused_io_amount::UNUSED_IO_AMOUNT_INFO,
     crate::unused_peekable::UNUSED_PEEKABLE_INFO,
+    crate::unused_result_ok::UNUSED_RESULT_OK_INFO,
     crate::unused_rounding::UNUSED_ROUNDING_INFO,
     crate::unused_self::UNUSED_SELF_INFO,
     crate::unused_unit::UNUSED_UNIT_INFO,
diff --git a/clippy_lints/src/default.rs b/clippy_lints/src/default.rs
index 72fa05be3cc60..0b7279f2b360d 100644
--- a/clippy_lints/src/default.rs
+++ b/clippy_lints/src/default.rs
@@ -221,7 +221,7 @@ impl<'tcx> LateLintPass<'tcx> for Default {
                         .map(ToString::to_string)
                         .collect::<Vec<_>>()
                         .join(", ");
-                    format!("{adt_def_ty_name}::<{}>", &tys_str)
+                    format!("{adt_def_ty_name}::<{tys_str}>")
                 } else {
                     binding_type.to_string()
                 };
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index 9af73db6849f4..a74b3a8c8362c 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -92,20 +92,8 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
             let (suffix, is_float) = match lit_ty.kind() {
                 ty::Int(IntTy::I32) => ("i32", false),
                 ty::Float(FloatTy::F64) => ("f64", true),
-                // Default numeric fallback never results in other types.
                 _ => return,
             };
-
-            let src = if let Some(src) = snippet_opt(self.cx, lit.span) {
-                src
-            } else {
-                match lit.node {
-                    LitKind::Int(src, _) => format!("{src}"),
-                    LitKind::Float(src, _) => format!("{src}"),
-                    _ => return,
-                }
-            };
-            let sugg = numeric_literal::format(&src, Some(suffix), is_float);
             span_lint_hir_and_then(
                 self.cx,
                 DEFAULT_NUMERIC_FALLBACK,
@@ -113,6 +101,17 @@ impl<'a, 'tcx> NumericFallbackVisitor<'a, 'tcx> {
                 lit.span,
                 "default numeric fallback might occur",
                 |diag| {
+                    let src = if let Some(src) = snippet_opt(self.cx, lit.span) {
+                        src
+                    } else {
+                        match lit.node {
+                            LitKind::Int(src, _) => format!("{src}"),
+                            LitKind::Float(src, _) => format!("{src}"),
+                            _ => unreachable!("Default numeric fallback never results in other types"),
+                        }
+                    };
+
+                    let sugg = numeric_literal::format(&src, Some(suffix), is_float);
                     diag.span_suggestion(lit.span, "consider adding suffix", sugg, Applicability::MaybeIncorrect);
                 },
             );
diff --git a/clippy_lints/src/default_union_representation.rs b/clippy_lints/src/default_union_representation.rs
index 3fa9bad0d03da..9f020d3081c40 100644
--- a/clippy_lints/src/default_union_representation.rs
+++ b/clippy_lints/src/default_union_representation.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir::{HirId, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
@@ -56,16 +56,18 @@ impl<'tcx> LateLintPass<'tcx> for DefaultUnionRepresentation {
             && is_union_with_two_non_zst_fields(cx, item)
             && !has_c_repr_attr(cx, item.hir_id())
         {
-            span_lint_and_help(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 DEFAULT_UNION_REPRESENTATION,
                 item.span,
                 "this union has the default representation",
-                None,
-                format!(
-                    "consider annotating `{}` with `#[repr(C)]` to explicitly specify memory layout",
-                    cx.tcx.def_path_str(item.owner_id)
-                ),
+                |diag| {
+                    diag.help(format!(
+                        "consider annotating `{}` with `#[repr(C)]` to explicitly specify memory layout",
+                        cx.tcx.def_path_str(item.owner_id)
+                    ));
+                },
             );
         }
     }
diff --git a/clippy_lints/src/deprecated_lints.rs b/clippy_lints/src/deprecated_lints.rs
index a0900f46f6aa6..0066ed643251a 100644
--- a/clippy_lints/src/deprecated_lints.rs
+++ b/clippy_lints/src/deprecated_lints.rs
@@ -1,243 +1,181 @@
-// NOTE: Entries should be created with `cargo dev deprecate`
-
-/// This struct fakes the `Lint` declaration that is usually created by `declare_lint!`. This
-/// enables the simple extraction of the metadata without changing the current deprecation
-/// declaration.
-pub struct ClippyDeprecatedLint {
-    #[allow(dead_code)]
-    pub desc: &'static str,
-}
-
-#[macro_export]
-macro_rules! declare_deprecated_lint {
-    { $(#[$attr:meta])* pub $name: ident, $reason: literal} => {
-        $(#[$attr])*
-        #[allow(dead_code)]
-        pub static $name: ClippyDeprecatedLint = ClippyDeprecatedLint {
-            desc: $reason
-        };
-    }
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This used to check for `assert!(a == b)` and recommend
-    /// replacement with `assert_eq!(a, b)`, but this is no longer needed after RFC 2011.
+// This file is managed by `cargo dev rename_lint` and `cargo dev deprecate_lint`.
+// Prefer to use those when possible.
+
+macro_rules! declare_with_version {
+    ($name:ident($name_version:ident): &[$ty:ty] = &[$(
+        #[clippy::version = $version:literal]
+        $e:expr,
+    )*]) => {
+        pub static $name: &[$ty] = &[$($e),*];
+        #[allow(unused)]
+        pub static $name_version: &[&str] = &[$($version),*];
+    };
+}
+
+#[rustfmt::skip]
+declare_with_version! { DEPRECATED(DEPRECATED_VERSION): &[(&str, &str)] = &[
     #[clippy::version = "pre 1.29.0"]
-    pub SHOULD_ASSERT_EQ,
-    "`assert!()` will be more flexible with RFC 2011"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This used to check for `Vec::extend`, which was slower than
-    /// `Vec::extend_from_slice`. Thanks to specialization, this is no longer true.
+    ("clippy::should_assert_eq", "`assert!(a == b)` can now print the values the same way `assert_eq!(a, b) can"),
     #[clippy::version = "pre 1.29.0"]
-    pub EXTEND_FROM_SLICE,
-    "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// `Range::step_by(0)` used to be linted since it's
-    /// an infinite iterator, which is better expressed by `iter::repeat`,
-    /// but the method has been removed for `Iterator::step_by` which panics
-    /// if given a zero
+    ("clippy::extend_from_slice", "`Vec::extend_from_slice` is no longer faster than `Vec::extend` due to specialization"),
     #[clippy::version = "pre 1.29.0"]
-    pub RANGE_STEP_BY_ZERO,
-    "`iterator.step_by(0)` panics nowadays"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This used to check for `Vec::as_slice`, which was unstable with good
-    /// stable alternatives. `Vec::as_slice` has now been stabilized.
+    ("clippy::range_step_by_zero", "`Iterator::step_by(0)` now panics and is no longer an infinite iterator"),
     #[clippy::version = "pre 1.29.0"]
-    pub UNSTABLE_AS_SLICE,
-    "`Vec::as_slice` has been stabilized in 1.7"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This used to check for `Vec::as_mut_slice`, which was unstable with good
-    /// stable alternatives. `Vec::as_mut_slice` has now been stabilized.
+    ("clippy::unstable_as_slice", "`Vec::as_slice` is now stable"),
     #[clippy::version = "pre 1.29.0"]
-    pub UNSTABLE_AS_MUT_SLICE,
-    "`Vec::as_mut_slice` has been stabilized in 1.7"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This lint should never have applied to non-pointer types, as transmuting
-    /// between non-pointer types of differing alignment is well-defined behavior (it's semantically
-    /// equivalent to a memcpy). This lint has thus been refactored into two separate lints:
-    /// cast_ptr_alignment and transmute_ptr_to_ptr.
+    ("clippy::unstable_as_mut_slice", "`Vec::as_mut_slice` is now stable"),
     #[clippy::version = "pre 1.29.0"]
-    pub MISALIGNED_TRANSMUTE,
-    "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This lint is too subjective, not having a good reason for being in clippy.
-    /// Additionally, compound assignment operators may be overloaded separately from their non-assigning
-    /// counterparts, so this lint may suggest a change in behavior or the code may not compile.
+    ("clippy::misaligned_transmute", "split into `clippy::cast_ptr_alignment` and `clippy::transmute_ptr_to_ptr`"),
     #[clippy::version = "1.30.0"]
-    pub ASSIGN_OPS,
-    "using compound assignment operators (e.g., `+=`) is harmless"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// The original rule will only lint for `if let`. After
-    /// making it support to lint `match`, naming as `if let` is not suitable for it.
-    /// So, this lint is deprecated.
+    ("clippy::assign_ops", "compound operators are harmless and linting on them is not in scope for clippy"),
     #[clippy::version = "pre 1.29.0"]
-    pub IF_LET_REDUNDANT_PATTERN_MATCHING,
-    "this lint has been changed to redundant_pattern_matching"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This lint used to suggest replacing `let mut vec =
-    /// Vec::with_capacity(n); vec.set_len(n);` with `let vec = vec![0; n];`. The
-    /// replacement has very different performance characteristics so the lint is
-    /// deprecated.
-    #[clippy::version = "pre 1.29.0"]
-    pub UNSAFE_VECTOR_INITIALIZATION,
-    "the replacement suggested by this lint had substantially different behavior"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This lint has been superseded by #[must_use] in rustc.
+    ("clippy::unsafe_vector_initialization", "the suggested alternative could be substantially slower"),
     #[clippy::version = "1.39.0"]
-    pub UNUSED_COLLECT,
-    "`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// Associated-constants are now preferred.
+    ("clippy::unused_collect", "`Iterator::collect` is now marked as `#[must_use]`"),
     #[clippy::version = "1.44.0"]
-    pub REPLACE_CONSTS,
-    "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// The regex! macro does not exist anymore.
+    ("clippy::replace_consts", "`min_value` and `max_value` are now deprecated"),
     #[clippy::version = "1.47.0"]
-    pub REGEX_MACRO,
-    "the regex! macro has been removed from the regex crate in 2018"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This lint has been replaced by `manual_find_map`, a
-    /// more specific lint.
-    #[clippy::version = "1.51.0"]
-    pub FIND_MAP,
-    "this lint has been replaced by `manual_find_map`, a more specific lint"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This lint has been replaced by `manual_filter_map`, a
-    /// more specific lint.
-    #[clippy::version = "1.53.0"]
-    pub FILTER_MAP,
-    "this lint has been replaced by `manual_filter_map`, a more specific lint"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// The `avoid_breaking_exported_api` config option was added, which
-    /// enables the `enum_variant_names` lint for public items.
+    ("clippy::regex_macro", "the `regex!` macro was removed from the regex crate in 2018"),
     #[clippy::version = "1.54.0"]
-    pub PUB_ENUM_VARIANT_NAMES,
-    "set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// The `avoid_breaking_exported_api` config option was added, which
-    /// enables the `wrong_self_conversion` lint for public items.
+    ("clippy::pub_enum_variant_names", "`clippy::enum_variant_names` now covers this case via the `avoid-breaking-exported-api` config"),
     #[clippy::version = "1.54.0"]
-    pub WRONG_PUB_SELF_CONVENTION,
-    "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This lint has been superseded by rustc's own [`unexpected_cfgs`] lint that is able to detect the `#[cfg(features)]` and `#[cfg(tests)]` typos.
-    ///
-    /// [`unexpected_cfgs`]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#unexpected-cfgs
+    ("clippy::wrong_pub_self_convention", "`clippy::wrong_self_convention` now covers this case via the `avoid-breaking-exported-api` config"),
+    // end deprecated lints. used by `cargo dev deprecate_lint`
+]}
+
+#[rustfmt::skip]
+declare_with_version! { RENAMED(RENAMED_VERSION): &[(&str, &str)] = &[
+    #[clippy::version = ""]
+    ("clippy::almost_complete_letter_range", "clippy::almost_complete_range"),
+    #[clippy::version = ""]
+    ("clippy::blacklisted_name", "clippy::disallowed_names"),
+    #[clippy::version = ""]
+    ("clippy::block_in_if_condition_expr", "clippy::blocks_in_conditions"),
+    #[clippy::version = ""]
+    ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_conditions"),
+    #[clippy::version = ""]
+    ("clippy::blocks_in_if_conditions", "clippy::blocks_in_conditions"),
+    #[clippy::version = ""]
+    ("clippy::box_vec", "clippy::box_collection"),
+    #[clippy::version = ""]
+    ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
+    #[clippy::version = ""]
+    ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
+    #[clippy::version = ""]
+    ("clippy::derive_hash_xor_eq", "clippy::derived_hash_with_manual_eq"),
+    #[clippy::version = ""]
+    ("clippy::disallowed_method", "clippy::disallowed_methods"),
+    #[clippy::version = ""]
+    ("clippy::disallowed_type", "clippy::disallowed_types"),
+    #[clippy::version = ""]
+    ("clippy::eval_order_dependence", "clippy::mixed_read_write_in_expression"),
+    #[clippy::version = "1.51.0"]
+    ("clippy::find_map", "clippy::manual_find_map"),
+    #[clippy::version = "1.53.0"]
+    ("clippy::filter_map", "clippy::manual_filter_map"),
+    #[clippy::version = ""]
+    ("clippy::identity_conversion", "clippy::useless_conversion"),
+    #[clippy::version = "pre 1.29.0"]
+    ("clippy::if_let_redundant_pattern_matching", "clippy::redundant_pattern_matching"),
+    #[clippy::version = ""]
+    ("clippy::if_let_some_result", "clippy::match_result_ok"),
+    #[clippy::version = ""]
+    ("clippy::incorrect_clone_impl_on_copy_type", "clippy::non_canonical_clone_impl"),
+    #[clippy::version = ""]
+    ("clippy::incorrect_partial_ord_impl_on_ord_type", "clippy::non_canonical_partial_ord_impl"),
+    #[clippy::version = ""]
+    ("clippy::integer_arithmetic", "clippy::arithmetic_side_effects"),
+    #[clippy::version = ""]
+    ("clippy::logic_bug", "clippy::overly_complex_bool_expr"),
+    #[clippy::version = ""]
+    ("clippy::new_without_default_derive", "clippy::new_without_default"),
+    #[clippy::version = ""]
+    ("clippy::option_and_then_some", "clippy::bind_instead_of_map"),
+    #[clippy::version = ""]
+    ("clippy::option_expect_used", "clippy::expect_used"),
+    #[clippy::version = ""]
+    ("clippy::option_map_unwrap_or", "clippy::map_unwrap_or"),
+    #[clippy::version = ""]
+    ("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or"),
+    #[clippy::version = ""]
+    ("clippy::option_unwrap_used", "clippy::unwrap_used"),
+    #[clippy::version = ""]
+    ("clippy::overflow_check_conditional", "clippy::panicking_overflow_checks"),
+    #[clippy::version = ""]
+    ("clippy::ref_in_deref", "clippy::needless_borrow"),
+    #[clippy::version = ""]
+    ("clippy::result_expect_used", "clippy::expect_used"),
+    #[clippy::version = ""]
+    ("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or"),
+    #[clippy::version = ""]
+    ("clippy::result_unwrap_used", "clippy::unwrap_used"),
+    #[clippy::version = ""]
+    ("clippy::single_char_push_str", "clippy::single_char_add_str"),
+    #[clippy::version = ""]
+    ("clippy::stutter", "clippy::module_name_repetitions"),
+    #[clippy::version = ""]
+    ("clippy::thread_local_initializer_can_be_made_const", "clippy::missing_const_for_thread_local"),
+    #[clippy::version = ""]
+    ("clippy::to_string_in_display", "clippy::recursive_format_impl"),
+    #[clippy::version = ""]
+    ("clippy::unwrap_or_else_default", "clippy::unwrap_or_default"),
+    #[clippy::version = ""]
+    ("clippy::zero_width_space", "clippy::invisible_characters"),
+    #[clippy::version = ""]
+    ("clippy::cast_ref_to_mut", "invalid_reference_casting"),
+    #[clippy::version = ""]
+    ("clippy::clone_double_ref", "suspicious_double_ref_op"),
+    #[clippy::version = ""]
+    ("clippy::cmp_nan", "invalid_nan_comparisons"),
+    #[clippy::version = ""]
+    ("clippy::drop_bounds", "drop_bounds"),
+    #[clippy::version = ""]
+    ("clippy::drop_copy", "dropping_copy_types"),
+    #[clippy::version = ""]
+    ("clippy::drop_ref", "dropping_references"),
+    #[clippy::version = ""]
+    ("clippy::fn_null_check", "useless_ptr_null_checks"),
+    #[clippy::version = ""]
+    ("clippy::for_loop_over_option", "for_loops_over_fallibles"),
+    #[clippy::version = ""]
+    ("clippy::for_loop_over_result", "for_loops_over_fallibles"),
+    #[clippy::version = ""]
+    ("clippy::for_loops_over_fallibles", "for_loops_over_fallibles"),
+    #[clippy::version = ""]
+    ("clippy::forget_copy", "forgetting_copy_types"),
+    #[clippy::version = ""]
+    ("clippy::forget_ref", "forgetting_references"),
+    #[clippy::version = ""]
+    ("clippy::into_iter_on_array", "array_into_iter"),
+    #[clippy::version = ""]
+    ("clippy::invalid_atomic_ordering", "invalid_atomic_ordering"),
+    #[clippy::version = ""]
+    ("clippy::invalid_ref", "invalid_value"),
+    #[clippy::version = ""]
+    ("clippy::invalid_utf8_in_unchecked", "invalid_from_utf8_unchecked"),
+    #[clippy::version = ""]
+    ("clippy::let_underscore_drop", "let_underscore_drop"),
     #[clippy::version = "1.80.0"]
-    pub MAYBE_MISUSED_CFG,
-    "this lint has been replaced by `unexpected_cfgs`"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This lint has been superseded by rustc's own [`unexpected_cfgs`] lint that is able to detect invalid `#[cfg(linux)]` attributes.
-    ///
-    /// [`unexpected_cfgs`]: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#unexpected-cfgs
+    ("clippy::maybe_misused_cfg", "unexpected_cfgs"),
+    #[clippy::version = ""]
+    ("clippy::mem_discriminant_non_enum", "enum_intrinsics_non_enums"),
     #[clippy::version = "1.80.0"]
-    pub MISMATCHED_TARGET_OS,
-    "this lint has been replaced by `unexpected_cfgs`"
-}
+    ("clippy::mismatched_target_os", "unexpected_cfgs"),
+    #[clippy::version = ""]
+    ("clippy::panic_params", "non_fmt_panics"),
+    #[clippy::version = ""]
+    ("clippy::positional_named_format_parameters", "named_arguments_used_positionally"),
+    #[clippy::version = ""]
+    ("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr"),
+    #[clippy::version = ""]
+    ("clippy::undropped_manually_drops", "undropped_manually_drops"),
+    #[clippy::version = ""]
+    ("clippy::unknown_clippy_lints", "unknown_lints"),
+    #[clippy::version = ""]
+    ("clippy::unused_label", "unused_labels"),
+    #[clippy::version = ""]
+    ("clippy::vtable_address_comparisons", "ambiguous_wide_pointer_comparisons"),
+    #[clippy::version = ""]
+    ("clippy::reverse_range_loop", "clippy::reversed_empty_ranges"),
+    // end renamed lints. used by `cargo dev rename_lint`
+]}
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index 253f9959e13e7..d0cb24884686a 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::ty::{implements_trait, is_manually_drop, peel_mid_ty_refs};
+use clippy_utils::ty::{implements_trait, is_manually_drop};
 use clippy_utils::{
     expr_use_ctxt, get_parent_expr, is_block_like, is_lint_allowed, path_to_local, peel_middle_ty_refs, DefinedTy,
     ExprUseNode,
@@ -947,7 +947,7 @@ fn report<'tcx>(
             let (expr_str, _expr_is_macro_call) =
                 snippet_with_context(cx, expr.span, data.first_expr.span.ctxt(), "..", &mut app);
             let ty = typeck.expr_ty(expr);
-            let (_, ref_count) = peel_mid_ty_refs(ty);
+            let (_, ref_count) = peel_middle_ty_refs(ty);
             let deref_str = if ty_changed_count >= ref_count && ref_count != 0 {
                 // a deref call changing &T -> &U requires two deref operators the first time
                 // this occurs. One to remove the reference, a second to call the deref impl.
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 5b6a5b08aa94c..d7b3a7c74f3ce 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -5,7 +5,7 @@ use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::macros::{is_panic, root_macro_call_first_node};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::Visitable;
-use clippy_utils::{in_constant, is_entrypoint_fn, is_trait_impl_item, method_chain_args};
+use clippy_utils::{is_entrypoint_fn, is_trait_impl_item, method_chain_args};
 use pulldown_cmark::Event::{
     Code, DisplayMath, End, FootnoteReference, HardBreak, Html, InlineHtml, InlineMath, Rule, SoftBreak, Start,
     TaskListMarker, Text,
@@ -768,7 +768,7 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                     );
                 }
             },
-            FootnoteReference(text) | Text(text) => {
+            Text(text) => {
                 paragraph_range.end = range.end;
                 let range_ = range.clone();
                 ticks_unbalanced |= text.contains('`')
@@ -812,7 +812,8 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                     }
                     text_to_check.push((text, range, code_level));
                 }
-            },
+            }
+            FootnoteReference(_) => {}
         }
     }
     headers
@@ -857,7 +858,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindPanicUnwrap<'a, 'tcx> {
                     "assert" | "assert_eq" | "assert_ne"
                 )
             {
-                self.is_const = in_constant(self.cx, expr.hir_id);
+                self.is_const = self.cx.tcx.hir().is_inside_const_context(expr.hir_id);
                 self.panic_span = Some(macro_call.span);
             }
         }
diff --git a/clippy_lints/src/drop_forget_ref.rs b/clippy_lints/src/drop_forget_ref.rs
index 4a6ffcd9a7888..c7dd7292a14be 100644
--- a/clippy_lints/src/drop_forget_ref.rs
+++ b/clippy_lints/src/drop_forget_ref.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_must_use_func_call;
 use clippy_utils::ty::{is_copy, is_must_use_ty, is_type_lang_item};
 use rustc_hir::{Arm, Expr, ExprKind, LangItem, Node};
@@ -126,14 +126,14 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetRef {
                 },
                 _ => return,
             };
-            span_lint_and_note(
-                cx,
-                lint,
-                expr.span,
-                msg,
-                note_span,
-                format!("argument has type `{arg_ty}`"),
-            );
+            span_lint_and_then(cx, lint, expr.span, msg, |diag| {
+                let note = format!("argument has type `{arg_ty}`");
+                if let Some(span) = note_span {
+                    diag.span_note(span, note);
+                } else {
+                    diag.note(note);
+                }
+            });
         }
     }
 }
diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs
index 7a6dc46972767..02f9c2c36488d 100644
--- a/clippy_lints/src/else_if_without_else.rs
+++ b/clippy_lints/src/else_if_without_else.rs
@@ -1,6 +1,6 @@
 //! Lint on if expressions with an else if, but without a final else branch.
 
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -54,13 +54,15 @@ impl EarlyLintPass for ElseIfWithoutElse {
             && let ExprKind::If(_, _, None) = els.kind
             && !in_external_macro(cx.sess(), item.span)
         {
-            span_lint_and_help(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 ELSE_IF_WITHOUT_ELSE,
                 els.span,
                 "`if` expression with an `else if`, but without a final `else`",
-                None,
-                "add an `else` block here",
+                |diag| {
+                    diag.help("add an `else` block here");
+                },
             );
         }
     }
diff --git a/clippy_lints/src/empty_drop.rs b/clippy_lints/src/empty_drop.rs
index c5fc72b5e2d8e..b66dd2108fc9b 100644
--- a/clippy_lints/src/empty_drop.rs
+++ b/clippy_lints/src/empty_drop.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::peel_blocks;
 use rustc_errors::Applicability;
 use rustc_hir::{Body, ExprKind, Impl, ImplItemKind, Item, ItemKind, Node};
@@ -50,15 +50,14 @@ impl LateLintPass<'_> for EmptyDrop {
             && block.stmts.is_empty()
             && block.expr.is_none()
         {
-            span_lint_and_sugg(
-                cx,
-                EMPTY_DROP,
-                item.span,
-                "empty drop implementation",
-                "try removing this impl",
-                String::new(),
-                Applicability::MaybeIncorrect,
-            );
+            span_lint_and_then(cx, EMPTY_DROP, item.span, "empty drop implementation", |diag| {
+                diag.span_suggestion_hidden(
+                    item.span,
+                    "try removing this impl",
+                    String::new(),
+                    Applicability::MaybeIncorrect,
+                );
+            });
         }
     }
 }
diff --git a/clippy_lints/src/endian_bytes.rs b/clippy_lints/src/endian_bytes.rs
index 5bba9c562b931..209104c5385c9 100644
--- a/clippy_lints/src/endian_bytes.rs
+++ b/clippy_lints/src/endian_bytes.rs
@@ -7,7 +7,6 @@ use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::Ty;
 use rustc_session::declare_lint_pass;
 use rustc_span::Symbol;
-use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -141,52 +140,6 @@ fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: Prefix
         _ => return,
     };
 
-    let mut help = None;
-
-    'build_help: {
-        // all lints disallowed, don't give help here
-        if [&[lint], other_lints.as_slice()]
-            .concat()
-            .iter()
-            .all(|lint| !lint.allowed(cx, expr))
-        {
-            break 'build_help;
-        }
-
-        // ne_bytes and all other lints allowed
-        if lint.as_name(prefix) == ne && other_lints.iter().all(|lint| lint.allowed(cx, expr)) {
-            help = Some(Cow::Borrowed("specify the desired endianness explicitly"));
-            break 'build_help;
-        }
-
-        // le_bytes where ne_bytes allowed but be_bytes is not, or le_bytes where ne_bytes allowed but
-        // le_bytes is not
-        if (lint.as_name(prefix) == le || lint.as_name(prefix) == be) && LintKind::Host.allowed(cx, expr) {
-            help = Some(Cow::Borrowed("use the native endianness instead"));
-            break 'build_help;
-        }
-
-        let allowed_lints = other_lints.iter().filter(|lint| lint.allowed(cx, expr));
-        let len = allowed_lints.clone().count();
-
-        let mut help_str = "use ".to_owned();
-
-        for (i, lint) in allowed_lints.enumerate() {
-            let only_one = len == 1;
-            if !only_one {
-                help_str.push_str("either of ");
-            }
-
-            help_str.push_str(&format!("`{ty}::{}` ", lint.as_name(prefix)));
-
-            if i != len && !only_one {
-                help_str.push_str("or ");
-            }
-        }
-
-        help = Some(Cow::Owned(help_str + "instead"));
-    }
-
     span_lint_and_then(
         cx,
         lint.as_lint(),
@@ -198,9 +151,47 @@ fn maybe_lint_endian_bytes(cx: &LateContext<'_>, expr: &Expr<'_>, prefix: Prefix
             if prefix == Prefix::To { " method" } else { "" },
         ),
         move |diag| {
-            if let Some(help) = help {
-                diag.help(help);
+            // all lints disallowed, don't give help here
+            if [&[lint], other_lints.as_slice()]
+                .concat()
+                .iter()
+                .all(|lint| !lint.allowed(cx, expr))
+            {
+                return;
+            }
+
+            // ne_bytes and all other lints allowed
+            if lint.as_name(prefix) == ne && other_lints.iter().all(|lint| lint.allowed(cx, expr)) {
+                diag.help("specify the desired endianness explicitly");
+                return;
+            }
+
+            // le_bytes where ne_bytes allowed but be_bytes is not, or le_bytes where ne_bytes allowed but
+            // le_bytes is not
+            if (lint.as_name(prefix) == le || lint.as_name(prefix) == be) && LintKind::Host.allowed(cx, expr) {
+                diag.help("use the native endianness instead");
+                return;
+            }
+
+            let allowed_lints = other_lints.iter().filter(|lint| lint.allowed(cx, expr));
+            let len = allowed_lints.clone().count();
+
+            let mut help_str = "use ".to_owned();
+
+            for (i, lint) in allowed_lints.enumerate() {
+                let only_one = len == 1;
+                if !only_one {
+                    help_str.push_str("either of ");
+                }
+
+                help_str.push_str(&format!("`{ty}::{}` ", lint.as_name(prefix)));
+
+                if i != len && !only_one {
+                    help_str.push_str("or ");
+                }
             }
+            help_str.push_str("instead");
+            diag.help(help_str);
         },
     );
 }
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index 30eb643c42ece..e54cd248ead29 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -51,7 +51,7 @@ impl<'tcx> LateLintPass<'tcx> for UnportableVariant {
                         .const_eval_poly(def_id.to_def_id())
                         .ok()
                         .map(|val| rustc_middle::mir::Const::from_value(val, ty));
-                    if let Some(Constant::Int(val)) = constant.and_then(|c| mir_to_const(cx, c)) {
+                    if let Some(Constant::Int(val)) = constant.and_then(|c| mir_to_const(cx.tcx, c)) {
                         if let ty::Adt(adt, _) = ty.kind() {
                             if adt.is_enum() {
                                 ty = adt.repr().discr_type().to_ty(cx.tcx);
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 0ed7859418bc5..5a7226d590c4d 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -9,8 +9,7 @@ use rustc_hir::{BindingMode, Expr, ExprKind, FnRetTy, Param, PatKind, QPath, Saf
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{
-    self, Binder, ClosureArgs, ClosureKind, FnSig, GenericArg, GenericArgKind, List, Region, RegionKind, Ty, TyCtxt,
-    TypeVisitableExt, TypeckResults,
+    self, Binder, ClosureKind, FnSig, GenericArg, GenericArgKind, List, Region, Ty, TypeVisitableExt, TypeckResults,
 };
 use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
@@ -74,159 +73,184 @@ declare_clippy_lint! {
 declare_lint_pass!(EtaReduction => [REDUNDANT_CLOSURE, REDUNDANT_CLOSURE_FOR_METHOD_CALLS]);
 
 impl<'tcx> LateLintPass<'tcx> for EtaReduction {
-    #[allow(clippy::too_many_lines)]
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        let body = if let ExprKind::Closure(c) = expr.kind
-            && c.fn_decl.inputs.iter().all(|ty| matches!(ty.kind, TyKind::Infer))
-            && matches!(c.fn_decl.output, FnRetTy::DefaultReturn(_))
-            && !expr.span.from_expansion()
-        {
-            cx.tcx.hir().body(c.body)
-        } else {
-            return;
-        };
-
-        if body.value.span.from_expansion() {
-            if body.params.is_empty() {
-                if let Some(VecArgs::Vec(&[])) = VecArgs::hir(cx, body.value) {
-                    // replace `|| vec![]` with `Vec::new`
-                    span_lint_and_sugg(
-                        cx,
-                        REDUNDANT_CLOSURE,
-                        expr.span,
-                        "redundant closure",
-                        "replace the closure with `Vec::new`",
-                        "std::vec::Vec::new".into(),
-                        Applicability::MachineApplicable,
-                    );
-                }
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+        if let ExprKind::MethodCall(_method, receiver, args, _) = expr.kind {
+            for arg in args {
+                check_clousure(cx, Some(receiver), arg);
             }
-            // skip `foo(|| macro!())`
-            return;
         }
+        if let ExprKind::Call(func, args) = expr.kind {
+            check_clousure(cx, None, func);
+            for arg in args {
+                check_clousure(cx, None, arg);
+            }
+        }
+    }
+}
 
-        let typeck = cx.typeck_results();
-        let closure = if let ty::Closure(_, closure_subs) = typeck.expr_ty(expr).kind() {
-            closure_subs.as_closure()
-        } else {
-            return;
-        };
+#[allow(clippy::too_many_lines)]
+fn check_clousure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tcx>>, expr: &Expr<'tcx>) {
+    let body = if let ExprKind::Closure(c) = expr.kind
+        && c.fn_decl.inputs.iter().all(|ty| matches!(ty.kind, TyKind::Infer))
+        && matches!(c.fn_decl.output, FnRetTy::DefaultReturn(_))
+        && !expr.span.from_expansion()
+    {
+        cx.tcx.hir().body(c.body)
+    } else {
+        return;
+    };
 
-        if is_adjusted(cx, body.value) {
-            return;
+    if body.value.span.from_expansion() {
+        if body.params.is_empty() {
+            if let Some(VecArgs::Vec(&[])) = VecArgs::hir(cx, body.value) {
+                // replace `|| vec![]` with `Vec::new`
+                span_lint_and_sugg(
+                    cx,
+                    REDUNDANT_CLOSURE,
+                    expr.span,
+                    "redundant closure",
+                    "replace the closure with `Vec::new`",
+                    "std::vec::Vec::new".into(),
+                    Applicability::MachineApplicable,
+                );
+            }
         }
+        // skip `foo(|| macro!())`
+        return;
+    }
 
-        match body.value.kind {
-            ExprKind::Call(callee, args)
-                if matches!(
-                    callee.kind,
-                    ExprKind::Path(QPath::Resolved(..) | QPath::TypeRelative(..))
-                ) =>
+    if is_adjusted(cx, body.value) {
+        return;
+    }
+
+    let typeck = cx.typeck_results();
+    let closure = if let ty::Closure(_, closure_subs) = typeck.expr_ty(expr).kind() {
+        closure_subs.as_closure()
+    } else {
+        return;
+    };
+    let closure_sig = cx.tcx.signature_unclosure(closure.sig(), Safety::Safe).skip_binder();
+    match body.value.kind {
+        ExprKind::Call(callee, args)
+            if matches!(
+                callee.kind,
+                ExprKind::Path(QPath::Resolved(..) | QPath::TypeRelative(..))
+            ) =>
+        {
+            let callee_ty_raw = typeck.expr_ty(callee);
+            let callee_ty = callee_ty_raw.peel_refs();
+            if matches!(type_diagnostic_name(cx, callee_ty), Some(sym::Arc | sym::Rc))
+                || !check_inputs(typeck, body.params, None, args)
             {
-                let callee_ty_raw = typeck.expr_ty(callee);
-                let callee_ty = callee_ty_raw.peel_refs();
-                if matches!(type_diagnostic_name(cx, callee_ty), Some(sym::Arc | sym::Rc))
-                    || !check_inputs(typeck, body.params, None, args)
-                {
-                    return;
-                }
-                let callee_ty_adjusted = typeck
-                    .expr_adjustments(callee)
-                    .last()
-                    .map_or(callee_ty, |a| a.target.peel_refs());
+                return;
+            }
+            let callee_ty_adjusted = typeck
+                .expr_adjustments(callee)
+                .last()
+                .map_or(callee_ty, |a| a.target.peel_refs());
 
-                let sig = match callee_ty_adjusted.kind() {
-                    ty::FnDef(def, _) => {
-                        // Rewriting `x(|| f())` to `x(f)` where f is marked `#[track_caller]` moves the `Location`
-                        if cx.tcx.has_attr(*def, sym::track_caller) {
-                            return;
-                        }
+            let sig = match callee_ty_adjusted.kind() {
+                ty::FnDef(def, _) => {
+                    // Rewriting `x(|| f())` to `x(f)` where f is marked `#[track_caller]` moves the `Location`
+                    if cx.tcx.has_attr(*def, sym::track_caller) {
+                        return;
+                    }
 
-                        cx.tcx.fn_sig(def).skip_binder().skip_binder()
-                    },
-                    ty::FnPtr(sig) => sig.skip_binder(),
-                    ty::Closure(_, subs) => cx
-                        .tcx
-                        .signature_unclosure(subs.as_closure().sig(), Safety::Safe)
-                        .skip_binder(),
-                    _ => {
-                        if typeck.type_dependent_def_id(body.value.hir_id).is_some()
-                            && let subs = typeck.node_args(body.value.hir_id)
-                            && let output = typeck.expr_ty(body.value)
-                            && let ty::Tuple(tys) = *subs.type_at(1).kind()
-                        {
-                            cx.tcx.mk_fn_sig(tys, output, false, Safety::Safe, Abi::Rust)
-                        } else {
-                            return;
-                        }
-                    },
-                };
-                if check_sig(cx, closure, sig)
-                    && let generic_args = typeck.node_args(callee.hir_id)
-                    // Given some trait fn `fn f() -> ()` and some type `T: Trait`, `T::f` is not
-                    // `'static` unless `T: 'static`. The cast `T::f as fn()` will, however, result
-                    // in a type which is `'static`.
-                    // For now ignore all callee types which reference a type parameter.
-                    && !generic_args.types().any(|t| matches!(t.kind(), ty::Param(_)))
-                {
-                    span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
-                        if let Some(mut snippet) = snippet_opt(cx, callee.span) {
-                            if path_to_local(callee).map_or(false, |l| {
-                                // FIXME: Do we really need this `local_used_in` check?
-                                // Isn't it checking something like... `callee(callee)`?
-                                // If somehow this check is needed, add some test for it,
-                                // 'cuz currently nothing changes after deleting this check.
-                                local_used_in(cx, l, args) || local_used_after_expr(cx, l, expr)
-                            }) {
-                                match cx.tcx.infer_ctxt().build().err_ctxt().type_implements_fn_trait(
-                                    cx.param_env,
-                                    Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
-                                    ty::PredicatePolarity::Positive,
-                                ) {
-                                    // Mutable closure is used after current expr; we cannot consume it.
-                                    Ok((ClosureKind::FnMut, _)) => snippet = format!("&mut {snippet}"),
-                                    Ok((ClosureKind::Fn, _)) if !callee_ty_raw.is_ref() => {
-                                        snippet = format!("&{snippet}");
-                                    },
-                                    _ => (),
-                                }
+                    cx.tcx.fn_sig(def).skip_binder().skip_binder()
+                },
+                ty::FnPtr(sig) => sig.skip_binder(),
+                ty::Closure(_, subs) => cx
+                    .tcx
+                    .signature_unclosure(subs.as_closure().sig(), Safety::Safe)
+                    .skip_binder(),
+                _ => {
+                    if typeck.type_dependent_def_id(body.value.hir_id).is_some()
+                        && let subs = typeck.node_args(body.value.hir_id)
+                        && let output = typeck.expr_ty(body.value)
+                        && let ty::Tuple(tys) = *subs.type_at(1).kind()
+                    {
+                        cx.tcx.mk_fn_sig(tys, output, false, Safety::Safe, Abi::Rust)
+                    } else {
+                        return;
+                    }
+                },
+            };
+            if let Some(outer) = outer_receiver
+                && ty_has_static(sig.output())
+                && let generic_args = typeck.node_args(outer.hir_id)
+                // HACK: Given a closure in `T.method(|| f())`, where `fn f() -> U where U: 'static`, `T.method(f)`
+                // will succeed iff `T: 'static`. But the region of `T` is always erased by `typeck.expr_ty()` when
+                // T is a generic type. For example, return type of `Option<String>::as_deref()` is a generic.
+                // So we have a hack like this.
+                && generic_args.len() > 0
+            {
+                return;
+            }
+            if check_sig(closure_sig, sig)
+                && let generic_args = typeck.node_args(callee.hir_id)
+                // Given some trait fn `fn f() -> ()` and some type `T: Trait`, `T::f` is not
+                // `'static` unless `T: 'static`. The cast `T::f as fn()` will, however, result
+                // in a type which is `'static`.
+                // For now ignore all callee types which reference a type parameter.
+                && !generic_args.types().any(|t| matches!(t.kind(), ty::Param(_)))
+            {
+                span_lint_and_then(cx, REDUNDANT_CLOSURE, expr.span, "redundant closure", |diag| {
+                    if let Some(mut snippet) = snippet_opt(cx, callee.span) {
+                        if path_to_local(callee).map_or(false, |l| {
+                            // FIXME: Do we really need this `local_used_in` check?
+                            // Isn't it checking something like... `callee(callee)`?
+                            // If somehow this check is needed, add some test for it,
+                            // 'cuz currently nothing changes after deleting this check.
+                            local_used_in(cx, l, args) || local_used_after_expr(cx, l, expr)
+                        }) {
+                            match cx.tcx.infer_ctxt().build().err_ctxt().type_implements_fn_trait(
+                                cx.param_env,
+                                Binder::bind_with_vars(callee_ty_adjusted, List::empty()),
+                                ty::PredicatePolarity::Positive,
+                            ) {
+                                // Mutable closure is used after current expr; we cannot consume it.
+                                Ok((ClosureKind::FnMut, _)) => snippet = format!("&mut {snippet}"),
+                                Ok((ClosureKind::Fn, _)) if !callee_ty_raw.is_ref() => {
+                                    snippet = format!("&{snippet}");
+                                },
+                                _ => (),
                             }
-                            diag.span_suggestion(
-                                expr.span,
-                                "replace the closure with the function itself",
-                                snippet,
-                                Applicability::MachineApplicable,
-                            );
                         }
-                    });
-                }
-            },
-            ExprKind::MethodCall(path, self_, args, _) if check_inputs(typeck, body.params, Some(self_), args) => {
-                if let Some(method_def_id) = typeck.type_dependent_def_id(body.value.hir_id)
-                    && !cx.tcx.has_attr(method_def_id, sym::track_caller)
-                    && check_sig(cx, closure, cx.tcx.fn_sig(method_def_id).skip_binder().skip_binder())
-                {
-                    span_lint_and_then(
-                        cx,
-                        REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
-                        expr.span,
-                        "redundant closure",
-                        |diag| {
-                            let args = typeck.node_args(body.value.hir_id);
-                            let caller = self_.hir_id.owner.def_id;
-                            let type_name = get_path_from_caller_to_method_type(cx.tcx, caller, method_def_id, args);
-                            diag.span_suggestion(
-                                expr.span,
-                                "replace the closure with the method itself",
-                                format!("{}::{}", type_name, path.ident.name),
-                                Applicability::MachineApplicable,
-                            );
-                        },
-                    );
-                }
-            },
-            _ => (),
-        }
+                        diag.span_suggestion(
+                            expr.span,
+                            "replace the closure with the function itself",
+                            snippet,
+                            Applicability::MachineApplicable,
+                        );
+                    }
+                });
+            }
+        },
+        ExprKind::MethodCall(path, self_, args, _) if check_inputs(typeck, body.params, Some(self_), args) => {
+            if let Some(method_def_id) = typeck.type_dependent_def_id(body.value.hir_id)
+                && !cx.tcx.has_attr(method_def_id, sym::track_caller)
+                && check_sig(closure_sig, cx.tcx.fn_sig(method_def_id).skip_binder().skip_binder())
+            {
+                span_lint_and_then(
+                    cx,
+                    REDUNDANT_CLOSURE_FOR_METHOD_CALLS,
+                    expr.span,
+                    "redundant closure",
+                    |diag| {
+                        let args = typeck.node_args(body.value.hir_id);
+                        let caller = self_.hir_id.owner.def_id;
+                        let type_name = get_path_from_caller_to_method_type(cx.tcx, caller, method_def_id, args);
+                        diag.span_suggestion(
+                            expr.span,
+                            "replace the closure with the method itself",
+                            format!("{}::{}", type_name, path.ident.name),
+                            Applicability::MachineApplicable,
+                        );
+                    },
+                );
+            }
+        },
+        _ => (),
     }
 }
 
@@ -251,12 +275,8 @@ fn check_inputs(
         })
 }
 
-fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure: ClosureArgs<TyCtxt<'tcx>>, call_sig: FnSig<'_>) -> bool {
-    call_sig.safety == Safety::Safe
-        && !has_late_bound_to_non_late_bound_regions(
-            cx.tcx.signature_unclosure(closure.sig(), Safety::Safe).skip_binder(),
-            call_sig,
-        )
+fn check_sig<'tcx>(closure_sig: FnSig<'tcx>, call_sig: FnSig<'tcx>) -> bool {
+    call_sig.safety == Safety::Safe && !has_late_bound_to_non_late_bound_regions(closure_sig, call_sig)
 }
 
 /// This walks through both signatures and checks for any time a late-bound region is expected by an
@@ -265,7 +285,7 @@ fn check_sig<'tcx>(cx: &LateContext<'tcx>, closure: ClosureArgs<TyCtxt<'tcx>>, c
 /// This is needed because rustc is unable to late bind early-bound regions in a function signature.
 fn has_late_bound_to_non_late_bound_regions(from_sig: FnSig<'_>, to_sig: FnSig<'_>) -> bool {
     fn check_region(from_region: Region<'_>, to_region: Region<'_>) -> bool {
-        matches!(from_region.kind(), RegionKind::ReBound(..)) && !matches!(to_region.kind(), RegionKind::ReBound(..))
+        from_region.is_bound() && !to_region.is_bound()
     }
 
     fn check_subs(from_subs: &[GenericArg<'_>], to_subs: &[GenericArg<'_>]) -> bool {
@@ -318,3 +338,8 @@ fn has_late_bound_to_non_late_bound_regions(from_sig: FnSig<'_>, to_sig: FnSig<'
         .zip(to_sig.inputs_and_output)
         .any(|(from_ty, to_ty)| check_ty(from_ty, to_ty))
 }
+
+fn ty_has_static(ty: Ty<'_>) -> bool {
+    ty.walk()
+        .any(|arg| matches!(arg.unpack(), GenericArgKind::Lifetime(re) if re.is_static()))
+}
diff --git a/clippy_lints/src/exhaustive_items.rs b/clippy_lints/src/exhaustive_items.rs
index 0f4176ec73bb2..9bf3baba4b597 100644
--- a/clippy_lints/src/exhaustive_items.rs
+++ b/clippy_lints/src/exhaustive_items.rs
@@ -88,11 +88,11 @@ impl LateLintPass<'_> for ExhaustiveItems {
             && !attrs.iter().any(|a| a.has_name(sym::non_exhaustive))
             && fields.iter().all(|f| cx.tcx.visibility(f.def_id).is_public())
         {
-            let suggestion_span = item.span.shrink_to_lo();
-            let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
             span_lint_and_then(cx, lint, item.span, msg, |diag| {
+                let suggestion_span = item.span.shrink_to_lo();
+                let indent = " ".repeat(indent_of(cx, item.span).unwrap_or(0));
                 let sugg = format!("#[non_exhaustive]\n{indent}");
-                diag.span_suggestion(
+                diag.span_suggestion_verbose(
                     suggestion_span,
                     "try adding #[non_exhaustive]",
                     sugg,
diff --git a/clippy_lints/src/field_scoped_visibility_modifiers.rs b/clippy_lints/src/field_scoped_visibility_modifiers.rs
index bb74e345703ff..95b8e882da792 100644
--- a/clippy_lints/src/field_scoped_visibility_modifiers.rs
+++ b/clippy_lints/src/field_scoped_visibility_modifiers.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::{Item, ItemKind, VisibilityKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
@@ -62,13 +62,15 @@ impl EarlyLintPass for FieldScopedVisibilityModifiers {
                 // pub(self) is equivalent to not using pub at all, so we ignore it
                 continue;
             }
-            span_lint_and_help(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 FIELD_SCOPED_VISIBILITY_MODIFIERS,
                 field.vis.span,
                 "scoped visibility modifier on a field",
-                None,
-                "consider making the field private and adding a scoped visibility method for it",
+                |diag| {
+                    diag.help("consider making the field private and adding a scoped visibility method for it");
+                },
             );
         }
     }
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index 6adcd2235dc52..f095c1add91f8 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -1,7 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::numeric_literal;
 use rustc_ast::ast::{self, LitFloatType, LitKind};
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, FloatTy};
@@ -105,32 +105,43 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
             if is_whole && !sym_str.contains(['e', 'E']) {
                 // Normalize the literal by stripping the fractional portion
                 if sym_str.split('.').next().unwrap() != float_str {
-                    // If the type suffix is missing the suggestion would be
-                    // incorrectly interpreted as an integer so adding a `.0`
-                    // suffix to prevent that.
-                    if type_suffix.is_none() {
-                        float_str.push_str(".0");
-                    }
-
-                    span_lint_and_sugg(
+                    span_lint_and_then(
                         cx,
                         LOSSY_FLOAT_LITERAL,
                         expr.span,
                         "literal cannot be represented as the underlying type without loss of precision",
-                        "consider changing the type or replacing it with",
-                        numeric_literal::format(&float_str, type_suffix, true),
-                        Applicability::MachineApplicable,
+                        |diag| {
+                            // If the type suffix is missing the suggestion would be
+                            // incorrectly interpreted as an integer so adding a `.0`
+                            // suffix to prevent that.
+                            if type_suffix.is_none() {
+                                float_str.push_str(".0");
+                            }
+                            diag.span_suggestion_with_style(
+                                expr.span,
+                                "consider changing the type or replacing it with",
+                                numeric_literal::format(&float_str, type_suffix, true),
+                                Applicability::MachineApplicable,
+                                SuggestionStyle::ShowAlways,
+                            );
+                        },
                     );
                 }
             } else if digits > max as usize && float_str.len() < sym_str.len() {
-                span_lint_and_sugg(
+                span_lint_and_then(
                     cx,
                     EXCESSIVE_PRECISION,
                     expr.span,
                     "float has excessive precision",
-                    "consider changing the type or truncating it to",
-                    numeric_literal::format(&float_str, type_suffix, true),
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        diag.span_suggestion_with_style(
+                            expr.span,
+                            "consider changing the type or truncating it to",
+                            numeric_literal::format(&float_str, type_suffix, true),
+                            Applicability::MachineApplicable,
+                            SuggestionStyle::ShowAlways,
+                        );
+                    },
                 );
             }
         }
diff --git a/clippy_lints/src/floating_point_arithmetic.rs b/clippy_lints/src/floating_point_arithmetic.rs
index 68bdf88d0a7e4..bf4bcabfe8911 100644
--- a/clippy_lints/src/floating_point_arithmetic.rs
+++ b/clippy_lints/src/floating_point_arithmetic.rs
@@ -1,9 +1,9 @@
 use clippy_utils::consts::Constant::{Int, F32, F64};
-use clippy_utils::consts::{constant, constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::{
-    eq_expr_value, get_parent_expr, higher, in_constant, is_inherent_method_call, is_no_std_crate, numeric_literal,
-    peel_blocks, sugg,
+    eq_expr_value, get_parent_expr, higher, is_in_const_context, is_inherent_method_call, is_no_std_crate,
+    numeric_literal, peel_blocks, sugg,
 };
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, PathSegment, UnOp};
@@ -112,7 +112,7 @@ declare_lint_pass!(FloatingPointArithmetic => [
 // Returns the specialized log method for a given base if base is constant
 // and is one of 2, 10 and e
 fn get_specialized_log_method(cx: &LateContext<'_>, base: &Expr<'_>) -> Option<&'static str> {
-    if let Some(value) = constant(cx, cx.typeck_results(), base) {
+    if let Some(value) = ConstEvalCtxt::new(cx).eval(base) {
         if F32(2.0) == value || F64(2.0) == value {
             return Some("log2");
         } else if F32(10.0) == value || F64(10.0) == value {
@@ -182,10 +182,8 @@ fn check_ln1p(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>) {
         rhs,
     ) = receiver.kind
     {
-        let recv = match (
-            constant(cx, cx.typeck_results(), lhs),
-            constant(cx, cx.typeck_results(), rhs),
-        ) {
+        let ecx = ConstEvalCtxt::new(cx);
+        let recv = match (ecx.eval(lhs), ecx.eval(rhs)) {
             (Some(value), _) if F32(1.0) == value || F64(1.0) == value => rhs,
             (_, Some(value)) if F32(1.0) == value || F64(1.0) == value => lhs,
             _ => return,
@@ -230,7 +228,7 @@ fn get_integer_from_float_constant(value: &Constant<'_>) -> Option<i32> {
 
 fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args: &[Expr<'_>]) {
     // Check receiver
-    if let Some(value) = constant(cx, cx.typeck_results(), receiver) {
+    if let Some(value) = ConstEvalCtxt::new(cx).eval(receiver) {
         if let Some(method) = if F32(f32_consts::E) == value || F64(f64_consts::E) == value {
             Some("exp")
         } else if F32(2.0) == value || F64(2.0) == value {
@@ -251,7 +249,7 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
     }
 
     // Check argument
-    if let Some(value) = constant(cx, cx.typeck_results(), &args[0]) {
+    if let Some(value) = ConstEvalCtxt::new(cx).eval(&args[0]) {
         let (lint, help, suggestion) = if F32(1.0 / 2.0) == value || F64(1.0 / 2.0) == value {
             (
                 SUBOPTIMAL_FLOPS,
@@ -291,7 +289,7 @@ fn check_powf(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args:
 }
 
 fn check_powi(cx: &LateContext<'_>, expr: &Expr<'_>, receiver: &Expr<'_>, args: &[Expr<'_>]) {
-    if let Some(value) = constant(cx, cx.typeck_results(), &args[0]) {
+    if let Some(value) = ConstEvalCtxt::new(cx).eval(&args[0]) {
         if value == Int(2) {
             if let Some(parent) = get_parent_expr(cx, expr) {
                 if let Some(grandparent) = get_parent_expr(cx, parent) {
@@ -397,8 +395,9 @@ fn detect_hypot(cx: &LateContext<'_>, receiver: &Expr<'_>) -> Option<String> {
             ) = &add_rhs.kind
             && lmethod_name.as_str() == "powi"
             && rmethod_name.as_str() == "powi"
-            && let Some(lvalue) = constant(cx, cx.typeck_results(), largs_1)
-            && let Some(rvalue) = constant(cx, cx.typeck_results(), rargs_1)
+            && let ecx = ConstEvalCtxt::new(cx)
+            && let Some(lvalue) = ecx.eval(largs_1)
+            && let Some(rvalue) = ecx.eval(rargs_1)
             && Int(2) == lvalue
             && Int(2) == rvalue
         {
@@ -438,7 +437,7 @@ fn check_expm1(cx: &LateContext<'_>, expr: &Expr<'_>) {
         rhs,
     ) = expr.kind
         && cx.typeck_results().expr_ty(lhs).is_floating_point()
-        && let Some(value) = constant(cx, cx.typeck_results(), rhs)
+        && let Some(value) = ConstEvalCtxt::new(cx).eval(rhs)
         && (F32(1.0) == value || F64(1.0) == value)
         && let ExprKind::MethodCall(path, self_arg, ..) = &lhs.kind
         && cx.typeck_results().expr_ty(self_arg).is_floating_point()
@@ -552,7 +551,7 @@ fn is_testing_negative(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -
 
 /// Returns true iff expr is some zero literal
 fn is_zero(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    match constant_simple(cx, cx.typeck_results(), expr) {
+    match ConstEvalCtxt::new(cx).eval_simple(expr) {
         Some(Int(i)) => i == 0,
         Some(F32(f)) => f == 0.0,
         Some(F64(f)) => f == 0.0,
@@ -696,8 +695,9 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
             mul_lhs,
             mul_rhs,
         ) = &div_lhs.kind
-        && let Some(rvalue) = constant(cx, cx.typeck_results(), div_rhs)
-        && let Some(lvalue) = constant(cx, cx.typeck_results(), mul_rhs)
+        && let ecx = ConstEvalCtxt::new(cx)
+        && let Some(rvalue) = ecx.eval(div_rhs)
+        && let Some(lvalue) = ecx.eval(mul_rhs)
     {
         // TODO: also check for constant values near PI/180 or 180/PI
         if (F32(f32_consts::PI) == rvalue || F64(f64_consts::PI) == rvalue)
@@ -753,7 +753,7 @@ fn check_radians(cx: &LateContext<'_>, expr: &Expr<'_>) {
 impl<'tcx> LateLintPass<'tcx> for FloatingPointArithmetic {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         // All of these operations are currently not const and are in std.
-        if in_constant(cx, expr.hir_id) {
+        if is_in_const_context(cx) {
             return;
         }
 
diff --git a/clippy_lints/src/format_push_string.rs b/clippy_lints/src/format_push_string.rs
index a75538dd329b5..d05c5a01f41ce 100644
--- a/clippy_lints/src/format_push_string.rs
+++ b/clippy_lints/src/format_push_string.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_lang_item;
 use clippy_utils::{higher, match_def_path, paths};
 use rustc_hir::{BinOpKind, Expr, ExprKind, LangItem, MatchSource};
@@ -81,13 +81,15 @@ impl<'tcx> LateLintPass<'tcx> for FormatPushString {
             _ => return,
         };
         if is_format(cx, arg) {
-            span_lint_and_help(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 FORMAT_PUSH_STRING,
                 expr.span,
                 "`format!(..)` appended to existing `String`",
-                None,
-                "consider using `write!` to avoid the extra allocation",
+                |diag| {
+                    diag.help("consider using `write!` to avoid the extra allocation");
+                },
             );
         }
     }
diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 9acb72b2e3729..6ab7bbc2dfc0c 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
-use clippy_utils::{in_constant, is_integer_literal};
+use clippy_utils::{is_in_const_context, is_integer_literal};
 use rustc_errors::Applicability;
 use rustc_hir::{def, Expr, ExprKind, LangItem, PrimTy, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -62,8 +62,8 @@ impl<'tcx> LateLintPass<'tcx> for FromStrRadix10 {
             && matches!(prim_ty, PrimTy::Int(_) | PrimTy::Uint(_))
 
             // do not lint in constant context, because the suggestion won't work.
-            // NB: keep this check until a new `const_trait_impl` is available and stablized.
-            && !in_constant(cx, exp.hir_id)
+            // NB: keep this check until a new `const_trait_impl` is available and stabilized.
+            && !is_in_const_context(cx)
         {
             let expr = if let ExprKind::AddrOf(_, _, expr) = &src.kind {
                 let ty = cx.typeck_results().expr_ty(expr);
diff --git a/clippy_lints/src/if_let_mutex.rs b/clippy_lints/src/if_let_mutex.rs
index b38cc7b36a123..1c52514a330d4 100644
--- a/clippy_lints/src/if_let_mutex.rs
+++ b/clippy_lints/src/if_let_mutex.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::for_each_expr_without_closures;
-use clippy_utils::{higher, SpanlessEq};
+use clippy_utils::{eq_expr_value, higher};
 use core::ops::ControlFlow;
 use rustc_errors::Diag;
 use rustc_hir::{Expr, ExprKind};
@@ -51,53 +51,45 @@ impl<'tcx> LateLintPass<'tcx> for IfLetMutex {
             if_else: Some(if_else),
             ..
         }) = higher::IfLet::hir(cx, expr)
+            && let Some(op_mutex) = for_each_expr_without_closures(let_expr, |e| mutex_lock_call(cx, e, None))
+            && let Some(arm_mutex) =
+                for_each_expr_without_closures((if_then, if_else), |e| mutex_lock_call(cx, e, Some(op_mutex)))
         {
-            let is_mutex_lock = |e: &'tcx Expr<'tcx>| {
-                if let Some(mutex) = is_mutex_lock_call(cx, e) {
-                    ControlFlow::Break(mutex)
-                } else {
-                    ControlFlow::Continue(())
-                }
+            let diag = |diag: &mut Diag<'_, ()>| {
+                diag.span_label(
+                    op_mutex.span,
+                    "this Mutex will remain locked for the entire `if let`-block...",
+                );
+                diag.span_label(
+                    arm_mutex.span,
+                    "... and is tried to lock again here, which will always deadlock.",
+                );
+                diag.help("move the lock call outside of the `if let ...` expression");
             };
-
-            let op_mutex = for_each_expr_without_closures(let_expr, is_mutex_lock);
-            if let Some(op_mutex) = op_mutex {
-                let arm_mutex = for_each_expr_without_closures((if_then, if_else), is_mutex_lock);
-                if let Some(arm_mutex) = arm_mutex
-                    && SpanlessEq::new(cx).eq_expr(op_mutex, arm_mutex)
-                {
-                    let diag = |diag: &mut Diag<'_, ()>| {
-                        diag.span_label(
-                            op_mutex.span,
-                            "this Mutex will remain locked for the entire `if let`-block...",
-                        );
-                        diag.span_label(
-                            arm_mutex.span,
-                            "... and is tried to lock again here, which will always deadlock.",
-                        );
-                        diag.help("move the lock call outside of the `if let ...` expression");
-                    };
-                    span_lint_and_then(
-                        cx,
-                        IF_LET_MUTEX,
-                        expr.span,
-                        "calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock",
-                        diag,
-                    );
-                }
-            }
+            span_lint_and_then(
+                cx,
+                IF_LET_MUTEX,
+                expr.span,
+                "calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock",
+                diag,
+            );
         }
     }
 }
 
-fn is_mutex_lock_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
+fn mutex_lock_call<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    op_mutex: Option<&'tcx Expr<'_>>,
+) -> ControlFlow<&'tcx Expr<'tcx>> {
     if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind
         && path.ident.as_str() == "lock"
         && let ty = cx.typeck_results().expr_ty(self_arg).peel_refs()
         && is_type_diagnostic_item(cx, ty, sym::Mutex)
+        && op_mutex.map_or(true, |op| eq_expr_value(cx, self_arg, op))
     {
-        Some(self_arg)
+        ControlFlow::Break(self_arg)
     } else {
-        None
+        ControlFlow::Continue(())
     }
 }
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index 2f6daeeb90d9d..0ebd8d0c237b6 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -1,7 +1,7 @@
 //! lint on if branches that could be swapped so no `!` operation is necessary
 //! on the condition
 
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_else_clause;
 use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
@@ -49,7 +49,7 @@ declare_clippy_lint! {
 declare_lint_pass!(IfNotElse => [IF_NOT_ELSE]);
 
 fn is_zero_const(expr: &Expr<'_>, cx: &LateContext<'_>) -> bool {
-    if let Some(value) = constant_simple(cx, cx.typeck_results(), expr) {
+    if let Some(value) = ConstEvalCtxt::new(cx).eval_simple(expr) {
         return Constant::Int(0) == value;
     }
     false
diff --git a/clippy_lints/src/if_then_some_else_none.rs b/clippy_lints/src/if_then_some_else_none.rs
index 39ea16b05d1ad..0bca53c1536de 100644
--- a/clippy_lints/src/if_then_some_else_none.rs
+++ b/clippy_lints/src/if_then_some_else_none.rs
@@ -1,10 +1,12 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{contains_return, higher, in_constant, is_else_clause, is_res_lang_ctor, path_res, peel_blocks};
+use clippy_utils::{
+    contains_return, higher, is_else_clause, is_in_const_context, is_res_lang_ctor, path_res, peel_blocks,
+};
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
@@ -76,37 +78,44 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             && is_res_lang_ctor(cx, path_res(cx, then_call), OptionSome)
             && is_res_lang_ctor(cx, path_res(cx, peel_blocks(els)), OptionNone)
             && !is_else_clause(cx.tcx, expr)
-            && !in_constant(cx, expr.hir_id)
+            && !is_in_const_context(cx)
             && !in_external_macro(cx.sess(), expr.span)
             && self.msrv.meets(msrvs::BOOL_THEN)
             && !contains_return(then_block.stmts)
         {
-            let mut app = Applicability::Unspecified;
-            let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app)
-                .maybe_par()
-                .to_string();
-            let arg_snip = snippet_with_context(cx, then_arg.span, ctxt, "[body]", &mut app).0;
-            let mut method_body = if then_block.stmts.is_empty() {
-                arg_snip.into_owned()
-            } else {
-                format!("{{ /* snippet */ {arg_snip} }}")
-            };
             let method_name = if switch_to_eager_eval(cx, expr) && self.msrv.meets(msrvs::BOOL_THEN_SOME) {
                 "then_some"
             } else {
-                method_body.insert_str(0, "|| ");
                 "then"
             };
 
-            let help =
-                format!("consider using `bool::{method_name}` like: `{cond_snip}.{method_name}({method_body})`",);
-            span_lint_and_help(
+            span_lint_and_then(
                 cx,
                 IF_THEN_SOME_ELSE_NONE,
                 expr.span,
                 format!("this could be simplified with `bool::{method_name}`"),
-                None,
-                help,
+                |diag| {
+                    let mut app = Applicability::Unspecified;
+                    let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app)
+                        .maybe_par()
+                        .to_string();
+                    let arg_snip = snippet_with_context(cx, then_arg.span, ctxt, "[body]", &mut app).0;
+                    let method_body = if let Some(first_stmt) = then_block.stmts.first() {
+                        let (block_snippet, _) =
+                            snippet_with_context(cx, first_stmt.span.until(then_arg.span), ctxt, "..", &mut app);
+                        let closure = if method_name == "then" { "|| " } else { "" };
+                        format!("{closure} {{ {block_snippet}; {arg_snip} }}")
+                    } else {
+                        arg_snip.into_owned()
+                    };
+
+                    diag.span_suggestion(
+                        expr.span,
+                        "try",
+                        format!("{cond_snip}.{method_name}({method_body})"),
+                        app,
+                    );
+                },
             );
         }
     }
diff --git a/clippy_lints/src/implicit_hasher.rs b/clippy_lints/src/implicit_hasher.rs
index 344a04e6e7e82..e56f33f8dcfe2 100644
--- a/clippy_lints/src/implicit_hasher.rs
+++ b/clippy_lints/src/implicit_hasher.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 use std::collections::BTreeMap;
 
-use rustc_errors::Diag;
+use rustc_errors::{Applicability, Diag};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_inf, walk_ty, Visitor};
 use rustc_hir::{Body, Expr, ExprKind, GenericArg, Item, ItemKind, QPath, TyKind};
@@ -13,7 +13,7 @@ use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, IntoSpan, SpanRangeExt};
 use clippy_utils::ty::is_type_diagnostic_item;
 
@@ -77,33 +77,32 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher {
                 &generics_snip[1..generics_snip.len() - 1]
             };
 
-            multispan_sugg(
-                diag,
-                "consider adding a type parameter",
-                vec![
-                    (
-                        generics_suggestion_span,
-                        format!(
-                            "<{generics_snip}{}S: ::std::hash::BuildHasher{}>",
-                            if generics_snip.is_empty() { "" } else { ", " },
-                            if vis.suggestions.is_empty() {
-                                ""
-                            } else {
-                                // request users to add `Default` bound so that generic constructors can be used
-                                " + Default"
-                            },
-                        ),
-                    ),
-                    (
-                        target.span(),
-                        format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
+            let mut suggestions = vec![
+                (
+                    generics_suggestion_span,
+                    format!(
+                        "<{generics_snip}{}S: ::std::hash::BuildHasher{}>",
+                        if generics_snip.is_empty() { "" } else { ", " },
+                        if vis.suggestions.is_empty() {
+                            ""
+                        } else {
+                            // request users to add `Default` bound so that generic constructors can be used
+                            " + Default"
+                        },
                     ),
-                ],
+                ),
+                (
+                    target.span(),
+                    format!("{}<{}, S>", target.type_name(), target.type_arguments(),),
+                ),
+            ];
+            suggestions.extend(vis.suggestions);
+
+            diag.multipart_suggestion(
+                "add a type parameter for `BuildHasher`",
+                suggestions,
+                Applicability::MaybeIncorrect,
             );
-
-            if !vis.suggestions.is_empty() {
-                multispan_sugg(diag, "...and use generic constructor", vis.suggestions);
-            }
         }
 
         if !cx.effective_visibilities.is_exported(item.owner_id.def_id) {
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index a102b434cfabb..b926e1e62ba0c 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::{snippet_with_applicability, snippet_with_context, wal
 use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{get_async_fn_body, is_async_fn, is_from_proc_macro};
 use core::ops::ControlFlow;
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, FnRetTy, HirId};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -45,8 +45,6 @@ declare_clippy_lint! {
 declare_lint_pass!(ImplicitReturn => [IMPLICIT_RETURN]);
 
 fn lint_return(cx: &LateContext<'_>, emission_place: HirId, span: Span) {
-    let mut app = Applicability::MachineApplicable;
-    let snip = snippet_with_applicability(cx, span, "..", &mut app);
     span_lint_hir_and_then(
         cx,
         IMPLICIT_RETURN,
@@ -54,14 +52,20 @@ fn lint_return(cx: &LateContext<'_>, emission_place: HirId, span: Span) {
         span,
         "missing `return` statement",
         |diag| {
-            diag.span_suggestion(span, "add `return` as shown", format!("return {snip}"), app);
+            let mut app = Applicability::MachineApplicable;
+            let snip = snippet_with_applicability(cx, span, "..", &mut app);
+            diag.span_suggestion_with_style(
+                span,
+                "add `return` as shown",
+                format!("return {snip}"),
+                app,
+                SuggestionStyle::ShowAlways,
+            );
         },
     );
 }
 
 fn lint_break(cx: &LateContext<'_>, emission_place: HirId, break_span: Span, expr_span: Span) {
-    let mut app = Applicability::MachineApplicable;
-    let snip = snippet_with_context(cx, expr_span, break_span.ctxt(), "..", &mut app).0;
     span_lint_hir_and_then(
         cx,
         IMPLICIT_RETURN,
@@ -69,11 +73,14 @@ fn lint_break(cx: &LateContext<'_>, emission_place: HirId, break_span: Span, exp
         break_span,
         "missing `return` statement",
         |diag| {
-            diag.span_suggestion(
+            let mut app = Applicability::MachineApplicable;
+            let snip = snippet_with_context(cx, expr_span, break_span.ctxt(), "..", &mut app).0;
+            diag.span_suggestion_with_style(
                 break_span,
                 "change `break` to `return` as shown",
                 format!("return {snip}"),
                 app,
+                SuggestionStyle::ShowAlways,
             );
         },
     );
diff --git a/clippy_lints/src/implicit_saturating_add.rs b/clippy_lints/src/implicit_saturating_add.rs
index f225c6e7f049f..dd5908553e59b 100644
--- a/clippy_lints/src/implicit_saturating_add.rs
+++ b/clippy_lints/src/implicit_saturating_add.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_context;
@@ -117,11 +117,11 @@ fn get_int_max(ty: Ty<'_>) -> Option<u128> {
 
 fn get_const<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> Option<(u128, BinOpKind, &'tcx Expr<'tcx>)> {
     if let ExprKind::Binary(op, l, r) = expr.kind {
-        let tr = cx.typeck_results();
-        if let Some(Constant::Int(c)) = constant(cx, tr, r) {
+        let ecx = ConstEvalCtxt::new(cx);
+        if let Some(Constant::Int(c)) = ecx.eval(r) {
             return Some((c, op.node, l));
         };
-        if let Some(Constant::Int(c)) = constant(cx, tr, l) {
+        if let Some(Constant::Int(c)) = ecx.eval(l) {
             return Some((c, invert_op(op.node)?, r));
         }
     }
diff --git a/clippy_lints/src/incompatible_msrv.rs b/clippy_lints/src/incompatible_msrv.rs
index 12ca6d43b27bc..0ef5b803a89d6 100644
--- a/clippy_lints/src/incompatible_msrv.rs
+++ b/clippy_lints/src/incompatible_msrv.rs
@@ -55,7 +55,6 @@ impl IncompatibleMsrv {
         }
     }
 
-    #[allow(clippy::cast_lossless)]
     fn get_def_id_version(&mut self, tcx: TyCtxt<'_>, def_id: DefId) -> RustcVersion {
         if let Some(version) = self.is_above_msrv.get(&def_id) {
             return *version;
@@ -67,9 +66,9 @@ impl IncompatibleMsrv {
                     since: StableSince::Version(version),
                     ..
                 } => Some(RustcVersion::new(
-                    version.major as _,
-                    version.minor as _,
-                    version.patch as _,
+                    version.major.into(),
+                    version.minor.into(),
+                    version.patch.into(),
                 )),
                 _ => None,
             }) {
diff --git a/clippy_lints/src/index_refutable_slice.rs b/clippy_lints/src/index_refutable_slice.rs
index 526b4e1fba0e9..2f9661c9ea385 100644
--- a/clippy_lints/src/index_refutable_slice.rs
+++ b/clippy_lints/src/index_refutable_slice.rs
@@ -1,6 +1,6 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLet;
 use clippy_utils::ty::is_copy;
@@ -246,7 +246,7 @@ impl<'a, 'tcx> Visitor<'tcx> for SliceIndexLintingVisitor<'a, 'tcx> {
                 && let parent_id = cx.tcx.parent_hir_id(expr.hir_id)
                 && let hir::Node::Expr(parent_expr) = cx.tcx.hir_node(parent_id)
                 && let hir::ExprKind::Index(_, index_expr, _) = parent_expr.kind
-                && let Some(Constant::Int(index_value)) = constant(cx, cx.typeck_results(), index_expr)
+                && let Some(Constant::Int(index_value)) = ConstEvalCtxt::new(cx).eval(index_expr)
                 && let Ok(index_value) = index_value.try_into()
                 && index_value < max_suggested_slice
 
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 6729c7c8d1018..3ac50b8f1fba5 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -1,7 +1,7 @@
 //! lint on indexing and slicing operations
 
 use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::ty::{deref_chain, get_adt_inherent_method};
 use clippy_utils::{higher, is_from_proc_macro};
@@ -70,8 +70,6 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     /// ```no_run
-    /// # #![allow(unused)]
-    ///
     /// # let x = vec![0; 5];
     /// # let y = [0, 1, 2, 3];
     /// x.get(2);
@@ -179,7 +177,7 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
                         return;
                     }
                     // Index is a constant uint.
-                    if let Some(constant) = constant(cx, cx.typeck_results(), index) {
+                    if let Some(constant) = ConstEvalCtxt::new(cx).eval(index) {
                         // only `usize` index is legal in rust array index
                         // leave other type to rustc
                         if let Constant::Int(off) = constant
@@ -217,14 +215,15 @@ impl<'tcx> LateLintPass<'tcx> for IndexingSlicing {
 /// Returns a tuple of options with the start and end (exclusive) values of
 /// the range. If the start or end is not constant, None is returned.
 fn to_const_range(cx: &LateContext<'_>, range: higher::Range<'_>, array_size: u128) -> (Option<u128>, Option<u128>) {
-    let s = range.start.map(|expr| constant(cx, cx.typeck_results(), expr));
+    let ecx = ConstEvalCtxt::new(cx);
+    let s = range.start.map(|expr| ecx.eval(expr));
     let start = match s {
         Some(Some(Constant::Int(x))) => Some(x),
         Some(_) => None,
         None => Some(0),
     };
 
-    let e = range.end.map(|expr| constant(cx, cx.typeck_results(), expr));
+    let e = range.end.map(|expr| ecx.eval(expr));
     let end = match e {
         Some(Some(Constant::Int(x))) => {
             if range.limits == RangeLimits::Closed {
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index fa7e7f6b76d16..676d50c4951b1 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -41,7 +41,6 @@ declare_clippy_lint! {
     /// ### Example
     /// ```no_run
     /// let infinite_iter = 0..;
-    /// # #[allow(unused)]
     /// [0..].iter().zip(infinite_iter.take_while(|x| *x > 5));
     /// ```
     #[clippy::version = "pre 1.29.0"]
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 0d3786dad4b1e..9eed7aa924339 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -1,6 +1,6 @@
 //! lint on inherent implementations
 
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_lint_allowed;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::LocalDefId;
@@ -105,13 +105,14 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
         // `TyCtxt::crate_inherent_impls` doesn't have a defined order. Sort the lint output first.
         lint_spans.sort_by_key(|x| x.0.lo());
         for (span, first_span) in lint_spans {
-            span_lint_and_note(
+            span_lint_and_then(
                 cx,
                 MULTIPLE_INHERENT_IMPL,
                 span,
                 "multiple implementations of this structure",
-                Some(first_span),
-                "first implementation here",
+                |diag| {
+                    diag.span_note(first_span, "first implementation here");
+                },
             );
         }
     }
diff --git a/clippy_lints/src/invalid_upcast_comparisons.rs b/clippy_lints/src/invalid_upcast_comparisons.rs
index 30f2285bdd235..1929fbded3b56 100644
--- a/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -7,7 +7,7 @@ use rustc_span::Span;
 
 use clippy_utils::comparisons;
 use clippy_utils::comparisons::Rel;
-use clippy_utils::consts::{constant_full_int, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, FullInt};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::source::snippet;
 
@@ -95,7 +95,7 @@ fn upcast_comparison_bounds_err<'tcx>(
     invert: bool,
 ) {
     if let Some((lb, ub)) = lhs_bounds {
-        if let Some(norm_rhs_val) = constant_full_int(cx, cx.typeck_results(), rhs) {
+        if let Some(norm_rhs_val) = ConstEvalCtxt::new(cx).eval_full_int(rhs) {
             if rel == Rel::Eq || rel == Rel::Ne {
                 if norm_rhs_val < lb || norm_rhs_val > ub {
                     err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
diff --git a/clippy_lints/src/large_include_file.rs b/clippy_lints/src/large_include_file.rs
index c67da689aaee0..f2f841dcec33d 100644
--- a/clippy_lints/src/large_include_file.rs
+++ b/clippy_lints/src/large_include_file.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::root_macro_call_first_node;
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
@@ -66,16 +66,18 @@ impl LateLintPass<'_> for LargeIncludeFile {
             && (cx.tcx.is_diagnostic_item(sym::include_bytes_macro, macro_call.def_id)
                 || cx.tcx.is_diagnostic_item(sym::include_str_macro, macro_call.def_id))
         {
-            span_lint_and_note(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 LARGE_INCLUDE_FILE,
                 expr.span.source_callsite(),
                 "attempted to include a large file",
-                None,
-                format!(
-                    "the configuration allows a maximum size of {} bytes",
-                    self.max_file_size
-                ),
+                |diag| {
+                    diag.note(format!(
+                        "the configuration allows a maximum size of {} bytes",
+                        self.max_file_size
+                    ));
+                },
             );
         }
     }
diff --git a/clippy_lints/src/let_underscore.rs b/clippy_lints/src/let_underscore.rs
index 8fa63f3e8fde0..b522c22a44d70 100644
--- a/clippy_lints/src/let_underscore.rs
+++ b/clippy_lints/src/let_underscore.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::{implements_trait, is_must_use_ty, match_type};
 use clippy_utils::{is_from_proc_macro, is_must_use_func_call, paths};
 use rustc_hir::{LetStmt, LocalSource, PatKind};
@@ -149,43 +149,53 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                 GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
             });
             if contains_sync_guard {
-                span_lint_and_help(
+                #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                span_lint_and_then(
                     cx,
                     LET_UNDERSCORE_LOCK,
                     local.span,
                     "non-binding `let` on a synchronization lock",
-                    None,
-                    "consider using an underscore-prefixed named \
-                            binding or dropping explicitly with `std::mem::drop`",
+                    |diag| {
+                        diag.help(
+                            "consider using an underscore-prefixed named \
+                                binding or dropping explicitly with `std::mem::drop`",
+                        );
+                    },
                 );
             } else if let Some(future_trait_def_id) = cx.tcx.lang_items().future_trait()
                 && implements_trait(cx, cx.typeck_results().expr_ty(init), future_trait_def_id, &[])
             {
-                span_lint_and_help(
+                #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                span_lint_and_then(
                     cx,
                     LET_UNDERSCORE_FUTURE,
                     local.span,
                     "non-binding `let` on a future",
-                    None,
-                    "consider awaiting the future or dropping explicitly with `std::mem::drop`",
+                    |diag| {
+                        diag.help("consider awaiting the future or dropping explicitly with `std::mem::drop`");
+                    },
                 );
             } else if is_must_use_ty(cx, cx.typeck_results().expr_ty(init)) {
-                span_lint_and_help(
+                #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                span_lint_and_then(
                     cx,
                     LET_UNDERSCORE_MUST_USE,
                     local.span,
                     "non-binding `let` on an expression with `#[must_use]` type",
-                    None,
-                    "consider explicitly using expression value",
+                    |diag| {
+                        diag.help("consider explicitly using expression value");
+                    },
                 );
             } else if is_must_use_func_call(cx, init) {
-                span_lint_and_help(
+                #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                span_lint_and_then(
                     cx,
                     LET_UNDERSCORE_MUST_USE,
                     local.span,
                     "non-binding `let` on a result of a `#[must_use]` function",
-                    None,
-                    "consider explicitly using function result",
+                    |diag| {
+                        diag.help("consider explicitly using function result");
+                    },
                 );
             }
 
@@ -204,18 +214,22 @@ impl<'tcx> LateLintPass<'tcx> for LetUnderscore {
                     return;
                 }
 
-                span_lint_and_help(
+                span_lint_and_then(
                     cx,
                     LET_UNDERSCORE_UNTYPED,
                     local.span,
                     "non-binding `let` without a type annotation",
-                    Some(Span::new(
-                        local.pat.span.hi(),
-                        local.pat.span.hi() + BytePos(1),
-                        local.pat.span.ctxt(),
-                        local.pat.span.parent(),
-                    )),
-                    "consider adding a type annotation",
+                    |diag| {
+                        diag.span_help(
+                            Span::new(
+                                local.pat.span.hi(),
+                                local.pat.span.hi() + BytePos(1),
+                                local.pat.span.ctxt(),
+                                local.pat.span.parent(),
+                            ),
+                            "consider adding a type annotation",
+                        );
+                    },
                 );
             }
         }
diff --git a/clippy_lints/src/lib.deprecated.rs b/clippy_lints/src/lib.deprecated.rs
deleted file mode 100644
index 0d21261822dd0..0000000000000
--- a/clippy_lints/src/lib.deprecated.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-// This file was generated by `cargo dev update_lints`.
-// Use that command to update this file and do not edit by hand.
-// Manual edits will be overwritten.
-
-{
-    store.register_removed(
-        "clippy::should_assert_eq",
-        "`assert!()` will be more flexible with RFC 2011",
-    );
-    store.register_removed(
-        "clippy::extend_from_slice",
-        "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice",
-    );
-    store.register_removed(
-        "clippy::range_step_by_zero",
-        "`iterator.step_by(0)` panics nowadays",
-    );
-    store.register_removed(
-        "clippy::unstable_as_slice",
-        "`Vec::as_slice` has been stabilized in 1.7",
-    );
-    store.register_removed(
-        "clippy::unstable_as_mut_slice",
-        "`Vec::as_mut_slice` has been stabilized in 1.7",
-    );
-    store.register_removed(
-        "clippy::misaligned_transmute",
-        "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr",
-    );
-    store.register_removed(
-        "clippy::assign_ops",
-        "using compound assignment operators (e.g., `+=`) is harmless",
-    );
-    store.register_removed(
-        "clippy::if_let_redundant_pattern_matching",
-        "this lint has been changed to redundant_pattern_matching",
-    );
-    store.register_removed(
-        "clippy::unsafe_vector_initialization",
-        "the replacement suggested by this lint had substantially different behavior",
-    );
-    store.register_removed(
-        "clippy::unused_collect",
-        "`collect` has been marked as #[must_use] in rustc and that covers all cases of this lint",
-    );
-    store.register_removed(
-        "clippy::replace_consts",
-        "associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants",
-    );
-    store.register_removed(
-        "clippy::regex_macro",
-        "the regex! macro has been removed from the regex crate in 2018",
-    );
-    store.register_removed(
-        "clippy::find_map",
-        "this lint has been replaced by `manual_find_map`, a more specific lint",
-    );
-    store.register_removed(
-        "clippy::filter_map",
-        "this lint has been replaced by `manual_filter_map`, a more specific lint",
-    );
-    store.register_removed(
-        "clippy::pub_enum_variant_names",
-        "set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items",
-    );
-    store.register_removed(
-        "clippy::wrong_pub_self_convention",
-        "set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items",
-    );
-    store.register_removed(
-        "clippy::maybe_misused_cfg",
-        "this lint has been replaced by `unexpected_cfgs`",
-    );
-    store.register_removed(
-        "clippy::mismatched_target_os",
-        "this lint has been replaced by `unexpected_cfgs`",
-    );
-}
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index a388b6b2eaab3..ce13a9afef5b0 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -13,7 +13,6 @@
 #![feature(stmt_expr_attributes)]
 #![feature(unwrap_infallible)]
 #![recursion_limit = "512"]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![allow(
     clippy::missing_docs_in_private_items,
     clippy::must_use_candidate,
@@ -64,13 +63,11 @@ extern crate clippy_utils;
 #[macro_use]
 extern crate declare_clippy_lint;
 
-#[cfg(feature = "internal")]
-pub mod deprecated_lints;
 #[cfg_attr(feature = "internal", allow(clippy::missing_clippy_version_attribute))]
 mod utils;
 
 mod declared_lints;
-mod renamed_lints;
+mod deprecated_lints;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
 mod absolute_paths;
@@ -372,6 +369,7 @@ mod unsafe_removed_from_name;
 mod unused_async;
 mod unused_io_amount;
 mod unused_peekable;
+mod unused_result_ok;
 mod unused_rounding;
 mod unused_self;
 mod unused_unit;
@@ -495,7 +493,7 @@ pub fn explain(name: &str) -> i32 {
         // Check if the lint has configuration
         let mut mdconf = get_configuration_metadata();
         let name = name.to_ascii_lowercase();
-        mdconf.retain(|cconf| cconf.lints.contains(&name));
+        mdconf.retain(|cconf| cconf.lints.contains(&&*name));
         if !mdconf.is_empty() {
             println!("### Configuration for {}:\n", info.lint.name_lower());
             for conf in mdconf {
@@ -531,10 +529,14 @@ fn register_categories(store: &mut rustc_lint::LintStore) {
 /// Used in `./src/driver.rs`.
 #[expect(clippy::too_many_lines)]
 pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
-    register_removed_non_tool_lints(store);
     register_categories(store);
 
-    include!("lib.deprecated.rs");
+    for (old_name, new_name) in deprecated_lints::RENAMED {
+        store.register_renamed(old_name, new_name);
+    }
+    for (name, reason) in deprecated_lints::DEPRECATED {
+        store.register_removed(name, reason);
+    }
 
     #[cfg(feature = "internal")]
     {
@@ -669,6 +671,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(missing_doc::MissingDoc::new(conf)));
     store.register_late_pass(|_| Box::new(missing_inline::MissingInline));
     store.register_late_pass(move |_| Box::new(exhaustive_items::ExhaustiveItems));
+    store.register_late_pass(|_| Box::new(unused_result_ok::UnusedResultOk));
     store.register_late_pass(|_| Box::new(match_result_ok::MatchResultOk));
     store.register_late_pass(|_| Box::new(partialeq_ne_impl::PartialEqNeImpl));
     store.register_late_pass(|_| Box::new(unused_io_amount::UnusedIoAmount));
@@ -818,7 +821,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(manual_retain::ManualRetain::new(conf)));
     store.register_late_pass(move |_| Box::new(manual_rotate::ManualRotate));
     store.register_late_pass(move |_| Box::new(operators::Operators::new(conf)));
-    store.register_late_pass(|_| Box::<std_instead_of_core::StdReexports>::default());
+    store.register_late_pass(move |_| Box::new(std_instead_of_core::StdReexports::new(conf)));
     store.register_late_pass(move |_| Box::new(instant_subtraction::InstantSubtraction::new(conf)));
     store.register_late_pass(|_| Box::new(partialeq_to_none::PartialeqToNone));
     store.register_late_pass(move |_| Box::new(manual_clamp::ManualClamp::new(conf)));
@@ -907,68 +910,8 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(macro_metavars_in_unsafe::ExprMetavarsInUnsafe::new(conf)));
     store.register_late_pass(move |_| Box::new(string_patterns::StringPatterns::new(conf)));
     store.register_early_pass(|| Box::new(field_scoped_visibility_modifiers::FieldScopedVisibilityModifiers));
-    store.register_late_pass(|_| Box::new(set_contains_or_insert::HashsetInsertAfterContains));
+    store.register_late_pass(|_| Box::new(set_contains_or_insert::SetContainsOrInsert));
     store.register_early_pass(|| Box::new(byte_char_slices::ByteCharSlice));
     store.register_early_pass(|| Box::new(cfg_not_test::CfgNotTest));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
-
-#[rustfmt::skip]
-fn register_removed_non_tool_lints(store: &mut rustc_lint::LintStore) {
-    store.register_removed(
-        "should_assert_eq",
-        "`assert!()` will be more flexible with RFC 2011",
-    );
-    store.register_removed(
-        "extend_from_slice",
-        "`.extend_from_slice(_)` is a faster way to extend a Vec by a slice",
-    );
-    store.register_removed(
-        "range_step_by_zero",
-        "`iterator.step_by(0)` panics nowadays",
-    );
-    store.register_removed(
-        "unstable_as_slice",
-        "`Vec::as_slice` has been stabilized in 1.7",
-    );
-    store.register_removed(
-        "unstable_as_mut_slice",
-        "`Vec::as_mut_slice` has been stabilized in 1.7",
-    );
-    store.register_removed(
-        "misaligned_transmute",
-        "this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr",
-    );
-    store.register_removed(
-        "assign_ops",
-        "using compound assignment operators (e.g., `+=`) is harmless",
-    );
-    store.register_removed(
-        "if_let_redundant_pattern_matching",
-        "this lint has been changed to redundant_pattern_matching",
-    );
-    store.register_removed(
-        "unsafe_vector_initialization",
-        "the replacement suggested by this lint had substantially different behavior",
-    );
-    store.register_removed(
-        "reverse_range_loop",
-        "this lint is now included in reversed_empty_ranges",
-    );
-}
-
-/// Register renamed lints.
-///
-/// Used in `./src/driver.rs`.
-pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
-    for (old_name, new_name) in renamed_lints::RENAMED_LINTS {
-        ls.register_renamed(old_name, new_name);
-    }
-}
-
-// only exists to let the dogfood integration test works.
-// Don't run clippy as an executable directly
-#[allow(dead_code)]
-fn main() {
-    panic!("Please use the cargo-clippy executable");
-}
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index b685d1dad1a75..259e4d6c08fb7 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -2,13 +2,13 @@
 //! floating-point literal expressions.
 
 use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::numeric_literal::{NumericLiteral, Radix};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Expr, ExprKind, LitKind};
 use rustc_ast::token;
 use rustc_errors::Applicability;
-use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_session::impl_lint_pass;
 use rustc_span::Span;
@@ -159,63 +159,39 @@ enum WarningType {
 }
 
 impl WarningType {
-    fn display(&self, suggested_format: String, cx: &EarlyContext<'_>, span: Span) {
+    fn lint_and_text(&self) -> (&'static Lint, &'static str, &'static str) {
         match self {
-            Self::MistypedLiteralSuffix => span_lint_and_sugg(
-                cx,
+            Self::MistypedLiteralSuffix => (
                 MISTYPED_LITERAL_SUFFIXES,
-                span,
                 "mistyped literal suffix",
                 "did you mean to write",
-                suggested_format,
-                Applicability::MaybeIncorrect,
             ),
-            Self::UnreadableLiteral => span_lint_and_sugg(
-                cx,
-                UNREADABLE_LITERAL,
-                span,
-                "long literal lacking separators",
-                "consider",
-                suggested_format,
-                Applicability::MachineApplicable,
-            ),
-            Self::LargeDigitGroups => span_lint_and_sugg(
-                cx,
-                LARGE_DIGIT_GROUPS,
-                span,
-                "digit groups should be smaller",
-                "consider",
-                suggested_format,
-                Applicability::MachineApplicable,
-            ),
-            Self::InconsistentDigitGrouping => span_lint_and_sugg(
-                cx,
+            Self::UnreadableLiteral => (UNREADABLE_LITERAL, "long literal lacking separators", "consider"),
+            Self::LargeDigitGroups => (LARGE_DIGIT_GROUPS, "digit groups should be smaller", "consider"),
+            Self::InconsistentDigitGrouping => (
                 INCONSISTENT_DIGIT_GROUPING,
-                span,
                 "digits grouped inconsistently by underscores",
                 "consider",
-                suggested_format,
-                Applicability::MachineApplicable,
             ),
-            Self::DecimalRepresentation => span_lint_and_sugg(
-                cx,
+            Self::DecimalRepresentation => (
                 DECIMAL_LITERAL_REPRESENTATION,
-                span,
                 "integer literal has a better hexadecimal representation",
                 "consider",
-                suggested_format,
-                Applicability::MachineApplicable,
             ),
-            Self::UnusualByteGroupings => span_lint_and_sugg(
-                cx,
+            Self::UnusualByteGroupings => (
                 UNUSUAL_BYTE_GROUPINGS,
-                span,
                 "digits of hex, binary or octal literal not in groups of equal size",
                 "consider",
-                suggested_format,
-                Applicability::MachineApplicable,
             ),
-        };
+        }
+    }
+
+    fn display(&self, num_lit: &NumericLiteral<'_>, cx: &EarlyContext<'_>, span: Span) {
+        let (lint, message, try_msg) = self.lint_and_text();
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(cx, lint, span, message, |diag| {
+            diag.span_suggestion(span, try_msg, num_lit.format(), Applicability::MaybeIncorrect);
+        });
     }
 }
 
@@ -293,7 +269,7 @@ impl LiteralDigitGrouping {
                     WarningType::DecimalRepresentation | WarningType::MistypedLiteralSuffix => true,
                 };
                 if should_warn {
-                    warning_type.display(num_lit.format(), cx, span);
+                    warning_type.display(&num_lit, cx, span);
                 }
             }
         }
@@ -346,11 +322,14 @@ impl LiteralDigitGrouping {
                 }
             }
             *part = main_part;
-            let mut sugg = num_lit.format();
-            sugg.push('_');
-            sugg.push(missing_char);
-            sugg.push_str(last_group);
-            WarningType::MistypedLiteralSuffix.display(sugg, cx, span);
+            let (lint, message, try_msg) = WarningType::MistypedLiteralSuffix.lint_and_text();
+            span_lint_and_then(cx, lint, span, message, |diag| {
+                let mut sugg = num_lit.format();
+                sugg.push('_');
+                sugg.push(missing_char);
+                sugg.push_str(last_group);
+                diag.span_suggestion(span, try_msg, sugg, Applicability::MaybeIncorrect);
+            });
             false
         } else {
             true
@@ -471,7 +450,7 @@ impl DecimalLiteralRepresentation {
             let hex = format!("{val:#X}");
             let num_lit = NumericLiteral::new(&hex, num_lit.suffix, false);
             let _: Result<(), ()> = Self::do_lint(num_lit.integer).map_err(|warning_type| {
-                warning_type.display(num_lit.format(), cx, span);
+                warning_type.display(&num_lit, cx, span);
             });
         }
     }
diff --git a/clippy_lints/src/loops/explicit_counter_loop.rs b/clippy_lints/src/loops/explicit_counter_loop.rs
index f0ee64d714e05..73a23615c2dc7 100644
--- a/clippy_lints/src/loops/explicit_counter_loop.rs
+++ b/clippy_lints/src/loops/explicit_counter_loop.rs
@@ -2,6 +2,7 @@ use super::{make_iterator_snippet, IncrementVisitor, InitializeVisitor, EXPLICIT
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{get_enclosing_block, is_integer_const};
+use rustc_ast::Label;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_block, walk_expr};
 use rustc_hir::{Expr, Pat};
@@ -17,6 +18,7 @@ pub(super) fn check<'tcx>(
     arg: &'tcx Expr<'_>,
     body: &'tcx Expr<'_>,
     expr: &'tcx Expr<'_>,
+    label: Option<Label>,
 ) {
     // Look for variables that are incremented once per loop iteration.
     let mut increment_visitor = IncrementVisitor::new(cx);
@@ -34,7 +36,7 @@ pub(super) fn check<'tcx>(
             {
                 let mut applicability = Applicability::MaybeIncorrect;
                 let span = expr.span.with_hi(arg.span.hi());
-
+                let loop_label = label.map_or(String::new(), |l| format!("{}: ", l.ident.name));
                 let int_name = match ty.map(Ty::kind) {
                     // usize or inferred
                     Some(ty::Uint(UintTy::Usize)) | None => {
@@ -45,7 +47,7 @@ pub(super) fn check<'tcx>(
                             format!("the variable `{name}` is used as a loop counter"),
                             "consider using",
                             format!(
-                                "for ({name}, {}) in {}.enumerate()",
+                                "{loop_label}for ({name}, {}) in {}.enumerate()",
                                 snippet_with_applicability(cx, pat.span, "item", &mut applicability),
                                 make_iterator_snippet(cx, arg, &mut applicability),
                             ),
@@ -68,7 +70,7 @@ pub(super) fn check<'tcx>(
                             span,
                             "consider using",
                             format!(
-                                "for ({name}, {}) in (0_{int_name}..).zip({})",
+                                "{loop_label}for ({name}, {}) in (0_{int_name}..).zip({})",
                                 snippet_with_applicability(cx, pat.span, "item", &mut applicability),
                                 make_iterator_snippet(cx, arg, &mut applicability),
                             ),
diff --git a/clippy_lints/src/loops/for_kv_map.rs b/clippy_lints/src/loops/for_kv_map.rs
index 6922533fbe9d3..185d834becafc 100644
--- a/clippy_lints/src/loops/for_kv_map.rs
+++ b/clippy_lints/src/loops/for_kv_map.rs
@@ -1,8 +1,9 @@
 use super::FOR_KV_MAP;
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{pat_is_wild, sugg};
+use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, Mutability, Pat, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
@@ -40,13 +41,13 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>, arg: &'tcx
                     format!("you seem to want to iterate on a map's {kind}s"),
                     |diag| {
                         let map = sugg::Sugg::hir(cx, arg, "map");
-                        multispan_sugg(
-                            diag,
+                        diag.multipart_suggestion(
                             "use the corresponding method",
                             vec![
                                 (pat_span, snippet(cx, new_pat_span, kind).into_owned()),
                                 (arg_span, format!("{}.{kind}s{mutbl}()", map.maybe_par())),
                             ],
+                            Applicability::MachineApplicable,
                         );
                     },
                 );
diff --git a/clippy_lints/src/loops/manual_while_let_some.rs b/clippy_lints/src/loops/manual_while_let_some.rs
index b00a082bb8cf9..57434f3554443 100644
--- a/clippy_lints/src/loops/manual_while_let_some.rs
+++ b/clippy_lints/src/loops/manual_while_let_some.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::{match_def_path, paths, SpanlessEq};
 use rustc_errors::Applicability;
@@ -38,11 +38,10 @@ fn report_lint(cx: &LateContext<'_>, pop_span: Span, pop_stmt_kind: PopStmt<'_>,
             };
 
             let loop_replacement = format!("while let Some({}) = {}.pop()", pat, snippet(cx, receiver_span, ".."));
-            multispan_sugg_with_applicability(
-                diag,
+            diag.multipart_suggestion(
                 "consider using a `while..let` loop",
+                vec![(loop_span, loop_replacement), (pop_span, pop_replacement)],
                 Applicability::MachineApplicable,
-                [(loop_span, loop_replacement), (pop_span, pop_replacement)],
             );
         },
     );
diff --git a/clippy_lints/src/loops/mod.rs b/clippy_lints/src/loops/mod.rs
index 7c2a8098af287..92ccc0cc0a15e 100644
--- a/clippy_lints/src/loops/mod.rs
+++ b/clippy_lints/src/loops/mod.rs
@@ -25,6 +25,7 @@ mod while_let_on_iterator;
 use clippy_config::msrvs::Msrv;
 use clippy_config::Conf;
 use clippy_utils::higher;
+use rustc_ast::Label;
 use rustc_hir::{Expr, ExprKind, LoopSource, Pat};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
@@ -448,7 +449,7 @@ declare_clippy_lint! {
     #[clippy::version = "1.80.0"]
     pub WHILE_FLOAT,
     nursery,
-    "while loops comaparing floating point values"
+    "while loops comparing floating point values"
 }
 
 declare_clippy_lint! {
@@ -760,6 +761,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
             body,
             loop_id,
             span,
+            label,
         }) = for_loop
         {
             // we don't want to check expanded macros
@@ -768,7 +770,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
             if body.span.from_expansion() {
                 return;
             }
-            self.check_for_loop(cx, pat, arg, body, expr, span);
+            self.check_for_loop(cx, pat, arg, body, expr, span, label);
             if let ExprKind::Block(block, _) = body.kind {
                 never_loop::check(cx, block, loop_id, span, for_loop.as_ref());
             }
@@ -808,6 +810,7 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
 }
 
 impl Loops {
+    #[allow(clippy::too_many_arguments)]
     fn check_for_loop<'tcx>(
         &self,
         cx: &LateContext<'tcx>,
@@ -816,11 +819,12 @@ impl Loops {
         body: &'tcx Expr<'_>,
         expr: &'tcx Expr<'_>,
         span: Span,
+        label: Option<Label>,
     ) {
         let is_manual_memcpy_triggered = manual_memcpy::check(cx, pat, arg, body, expr);
         if !is_manual_memcpy_triggered {
             needless_range_loop::check(cx, pat, arg, body, expr);
-            explicit_counter_loop::check(cx, pat, arg, body, expr);
+            explicit_counter_loop::check(cx, pat, arg, body, expr, label);
         }
         self.check_for_loop_arg(cx, pat, arg);
         for_kv_map::check(cx, pat, arg, body);
diff --git a/clippy_lints/src/loops/needless_range_loop.rs b/clippy_lints/src/loops/needless_range_loop.rs
index de7ec81bc0108..e18e4374667de 100644
--- a/clippy_lints/src/loops/needless_range_loop.rs
+++ b/clippy_lints/src/loops/needless_range_loop.rs
@@ -1,11 +1,12 @@
 use super::NEEDLESS_RANGE_LOOP;
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::has_iter_method;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{contains_name, higher, is_integer_const, sugg, SpanlessEq};
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{BinOpKind, BorrowKind, Closure, Expr, ExprKind, HirId, Mutability, Pat, PatKind, QPath};
@@ -145,8 +146,7 @@ pub(super) fn check<'tcx>(
                         arg.span,
                         format!("the loop variable `{}` is used to index `{indexed}`", ident.name),
                         |diag| {
-                            multispan_sugg(
-                                diag,
+                            diag.multipart_suggestion(
                                 "consider using an iterator and enumerate()",
                                 vec![
                                     (pat.span, format!("({}, <item>)", ident.name)),
@@ -155,6 +155,7 @@ pub(super) fn check<'tcx>(
                                         format!("{indexed}.{method}().enumerate(){method_1}{method_2}"),
                                     ),
                                 ],
+                                Applicability::HasPlaceholders,
                             );
                         },
                     );
@@ -171,10 +172,10 @@ pub(super) fn check<'tcx>(
                         arg.span,
                         format!("the loop variable `{}` is only used to index `{indexed}`", ident.name),
                         |diag| {
-                            multispan_sugg(
-                                diag,
+                            diag.multipart_suggestion(
                                 "consider using an iterator",
                                 vec![(pat.span, "<item>".to_string()), (arg.span, repl)],
+                                Applicability::HasPlaceholders,
                             );
                         },
                     );
diff --git a/clippy_lints/src/loops/unused_enumerate_index.rs b/clippy_lints/src/loops/unused_enumerate_index.rs
index 40ccfec02be58..51e21aa9734ed 100644
--- a/clippy_lints/src/loops/unused_enumerate_index.rs
+++ b/clippy_lints/src/loops/unused_enumerate_index.rs
@@ -1,7 +1,8 @@
 use super::UNUSED_ENUMERATE_INDEX;
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::{pat_is_wild, sugg};
+use rustc_errors::Applicability;
 use rustc_hir::def::DefKind;
 use rustc_hir::{Expr, ExprKind, Pat, PatKind};
 use rustc_lint::LateContext;
@@ -28,13 +29,13 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, pat: &Pat<'tcx>, arg: &Expr<'_
             "you seem to use `.enumerate()` and immediately discard the index",
             |diag| {
                 let base_iter = sugg::Sugg::hir(cx, self_arg, "base iter");
-                multispan_sugg(
-                    diag,
+                diag.multipart_suggestion(
                     "remove the `.enumerate()` call",
                     vec![
                         (pat.span, snippet(cx, elem.span, "..").into_owned()),
                         (arg.span, base_iter.to_string()),
                     ],
+                    Applicability::MachineApplicable,
                 );
             },
         );
diff --git a/clippy_lints/src/loops/while_immutable_condition.rs b/clippy_lints/src/loops/while_immutable_condition.rs
index e7b3a2c4973cf..cc1bd5929d0fc 100644
--- a/clippy_lints/src/loops/while_immutable_condition.rs
+++ b/clippy_lints/src/loops/while_immutable_condition.rs
@@ -1,5 +1,5 @@
 use super::WHILE_IMMUTABLE_CONDITION;
-use clippy_utils::consts::constant;
+use clippy_utils::consts::ConstEvalCtxt;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::usage::mutated_variables;
 use rustc_hir::def::{DefKind, Res};
@@ -10,7 +10,7 @@ use rustc_lint::LateContext;
 use std::ops::ControlFlow;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'tcx Expr<'_>) {
-    if constant(cx, cx.typeck_results(), cond).is_some() {
+    if ConstEvalCtxt::new(cx).eval(cond).is_some() {
         // A pure constant condition (e.g., `while false`) is not linted.
         return;
     }
diff --git a/clippy_lints/src/loops/while_let_on_iterator.rs b/clippy_lints/src/loops/while_let_on_iterator.rs
index 194dd4752f91b..c171fa1c622af 100644
--- a/clippy_lints/src/loops/while_let_on_iterator.rs
+++ b/clippy_lints/src/loops/while_let_on_iterator.rs
@@ -14,7 +14,7 @@ use rustc_span::symbol::sym;
 use rustc_span::Symbol;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-    if let Some(higher::WhileLet { if_then, let_pat, let_expr, .. }) = higher::WhileLet::hir(expr)
+    if let Some(higher::WhileLet { if_then, let_pat, let_expr, label, .. }) = higher::WhileLet::hir(expr)
         // check for `Some(..)` pattern
         && let PatKind::TupleStruct(ref pat_path, some_pat, _) = let_pat.kind
         && is_res_lang_ctor(cx, cx.qpath_res(pat_path, let_pat.hir_id), LangItem::OptionSome)
@@ -27,6 +27,9 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         && !uses_iter(cx, &iter_expr_struct, if_then)
     {
         let mut applicability = Applicability::MachineApplicable;
+
+        let loop_label = label.map_or(String::new(), |l| format!("{}: ", l.ident.name));
+
         let loop_var = if let Some(some_pat) = some_pat.first() {
             if is_refutable(cx, some_pat) {
                 // Refutable patterns don't work with for loops.
@@ -57,7 +60,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
             expr.span.with_hi(let_expr.span.hi()),
             "this loop could be written as a `for` loop",
             "try",
-            format!("for {loop_var} in {iterator}{by_ref}"),
+            format!("{loop_label}for {loop_var} in {iterator}{by_ref}"),
             applicability,
         );
     }
diff --git a/clippy_lints/src/manual_clamp.rs b/clippy_lints/src/manual_clamp.rs
index a79ad018a042f..4123c933660bc 100644
--- a/clippy_lints/src/manual_clamp.rs
+++ b/clippy_lints/src/manual_clamp.rs
@@ -1,13 +1,13 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::higher::If;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::is_const_evaluatable;
 use clippy_utils::{
-    eq_expr_value, in_constant, is_diag_trait_item, is_trait_method, path_res, path_to_local_id, peel_blocks,
+    eq_expr_value, is_diag_trait_item, is_in_const_context, is_trait_method, path_res, path_to_local_id, peel_blocks,
     peel_blocks_with_stmt, MaybePath,
 };
 use itertools::Itertools;
@@ -122,8 +122,9 @@ impl<'tcx> ClampSuggestion<'tcx> {
         if max_type != min_type {
             return false;
         }
-        if let Some(max) = constant(cx, cx.typeck_results(), self.params.max)
-            && let Some(min) = constant(cx, cx.typeck_results(), self.params.min)
+        let ecx = ConstEvalCtxt::new(cx);
+        if let Some(max) = ecx.eval(self.params.max)
+            && let Some(min) = ecx.eval(self.params.min)
             && let Some(ord) = Constant::partial_cmp(cx.tcx, max_type, &min, &max)
         {
             ord != Ordering::Greater
@@ -146,7 +147,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualClamp {
         if !self.msrv.meets(msrvs::CLAMP) {
             return;
         }
-        if !expr.span.from_expansion() && !in_constant(cx, expr.hir_id) {
+        if !expr.span.from_expansion() && !is_in_const_context(cx) {
             let suggestion = is_if_elseif_else_pattern(cx, expr)
                 .or_else(|| is_max_min_pattern(cx, expr))
                 .or_else(|| is_call_max_min_pattern(cx, expr))
@@ -159,7 +160,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualClamp {
     }
 
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
-        if !self.msrv.meets(msrvs::CLAMP) || in_constant(cx, block.hir_id) {
+        if !self.msrv.meets(msrvs::CLAMP) || is_in_const_context(cx) {
             return;
         }
         for suggestion in is_two_if_pattern(cx, block) {
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index 03416ba96de73..6bdc79129a9bc 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::{is_from_proc_macro, path_to_local};
@@ -95,8 +95,9 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
                     || cx.tcx.features().declared(sym!(const_float_classify))
             )
             && let [first, second, const_1, const_2] = exprs
-            && let Some(const_1) = constant(cx, cx.typeck_results(), const_1)
-            && let Some(const_2) = constant(cx, cx.typeck_results(), const_2)
+            && let ecx = ConstEvalCtxt::new(cx)
+            && let Some(const_1) = ecx.eval(const_1)
+            && let Some(const_2) = ecx.eval(const_2)
             && path_to_local(first).is_some_and(|f| path_to_local(second).is_some_and(|s| f == s))
             // The actual infinity check, we also allow `NEG_INFINITY` before` INFINITY` just in
             // case somebody does that for some reason
diff --git a/clippy_lints/src/manual_is_ascii_check.rs b/clippy_lints/src/manual_is_ascii_check.rs
index a9f21d34e4cee..31c37c3bc3b14 100644
--- a/clippy_lints/src/manual_is_ascii_check.rs
+++ b/clippy_lints/src/manual_is_ascii_check.rs
@@ -3,7 +3,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::matching_root_macro_call;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{higher, in_constant, path_to_local, peel_ref_operators};
+use clippy_utils::{higher, is_in_const_context, path_to_local, peel_ref_operators};
 use rustc_ast::ast::RangeLimits;
 use rustc_ast::LitKind::{Byte, Char};
 use rustc_errors::Applicability;
@@ -95,7 +95,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
             return;
         }
 
-        if in_constant(cx, expr.hir_id) && !self.msrv.meets(msrvs::IS_ASCII_DIGIT_CONST) {
+        if is_in_const_context(cx) && !self.msrv.meets(msrvs::IS_ASCII_DIGIT_CONST) {
             return;
         }
 
diff --git a/clippy_lints/src/manual_rem_euclid.rs b/clippy_lints/src/manual_rem_euclid.rs
index 78a750f0dcd04..6cf5d272d7d82 100644
--- a/clippy_lints/src/manual_rem_euclid.rs
+++ b/clippy_lints/src/manual_rem_euclid.rs
@@ -1,9 +1,9 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
-use clippy_utils::consts::{constant_full_int, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::{in_constant, path_to_local};
+use clippy_utils::{is_in_const_context, path_to_local};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -62,7 +62,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             && add_rhs.span.ctxt() == ctxt
             && !in_external_macro(cx.sess(), expr.span)
             && self.msrv.meets(msrvs::REM_EUCLID)
-            && (self.msrv.meets(msrvs::REM_EUCLID_CONST) || !in_constant(cx, expr.hir_id))
+            && (self.msrv.meets(msrvs::REM_EUCLID_CONST) || !is_in_const_context(cx))
             && let Some(const1) = check_for_unsigned_int_constant(cx, rem_rhs)
             && let Some((const2, add_other)) = check_for_either_unsigned_int_constant(cx, add_lhs, add_rhs)
             && let ExprKind::Binary(rem2_op, rem2_lhs, rem2_rhs) = add_other.kind
@@ -117,7 +117,7 @@ fn check_for_either_unsigned_int_constant<'a>(
 }
 
 fn check_for_unsigned_int_constant<'a>(cx: &'a LateContext<'_>, expr: &'a Expr<'_>) -> Option<u128> {
-    let int_const = constant_full_int(cx, cx.typeck_results(), expr)?;
+    let int_const = ConstEvalCtxt::new(cx).eval_full_int(expr)?;
     match int_const {
         FullInt::S(s) => s.try_into().ok(),
         FullInt::U(u) => Some(u),
diff --git a/clippy_lints/src/manual_rotate.rs b/clippy_lints/src/manual_rotate.rs
index a517a4d507526..07537fc65c08c 100644
--- a/clippy_lints/src/manual_rotate.rs
+++ b/clippy_lints/src/manual_rotate.rs
@@ -1,6 +1,6 @@
 use std::fmt::Display;
 
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg;
 use rustc_errors::Applicability;
@@ -66,7 +66,7 @@ fn parse_shift<'tcx>(
             BinOpKind::Shr => ShiftDirection::Right,
             _ => return None,
         };
-        let const_expr = constant(cx, cx.typeck_results(), r)?;
+        let const_expr = ConstEvalCtxt::new(cx).eval(r)?;
         if let Constant::Int(shift) = const_expr {
             return Some((dir, shift, l));
         }
diff --git a/clippy_lints/src/manual_slice_size_calculation.rs b/clippy_lints/src/manual_slice_size_calculation.rs
index 429ee2637c2fa..b24a0f4695a6c 100644
--- a/clippy_lints/src/manual_slice_size_calculation.rs
+++ b/clippy_lints/src/manual_slice_size_calculation.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::{expr_or_init, in_constant, std_or_core};
+use clippy_utils::{expr_or_init, is_in_const_context, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -44,7 +44,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualSliceSizeCalculation {
             && BinOpKind::Mul == op.node
             && !expr.span.from_expansion()
             // Does not apply inside const because size_of_val is not cost in stable.
-            && !in_constant(cx, expr.hir_id)
+            && !is_in_const_context(cx)
             && let Some(receiver) = simplify(cx, left, right)
         {
             let ctxt = expr.span.ctxt();
diff --git a/clippy_lints/src/manual_strip.rs b/clippy_lints/src/manual_strip.rs
index 686ecccf8294c..85cabd2800a65 100644
--- a/clippy_lints/src/manual_strip.rs
+++ b/clippy_lints/src/manual_strip.rs
@@ -1,11 +1,12 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::usage::mutated_variables;
 use clippy_utils::{eq_expr_value, higher, match_def_path, paths};
 use rustc_ast::ast::LitKind;
+use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind};
@@ -14,6 +15,7 @@ use rustc_middle::ty;
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::Span;
+use std::iter;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -108,19 +110,19 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                     format!("stripping a {kind_word} manually"),
                     |diag| {
                         diag.span_note(test_span, format!("the {kind_word} was tested here"));
-                        multispan_sugg(
-                            diag,
+                        diag.multipart_suggestion(
                             format!("try using the `strip_{kind_word}` method"),
-                            vec![(
+                            iter::once((
                                 test_span,
                                 format!(
                                     "if let Some(<stripped>) = {}.strip_{kind_word}({}) ",
                                     snippet(cx, target_arg.span, ".."),
                                     snippet(cx, pattern.span, "..")
                                 ),
-                            )]
-                            .into_iter()
-                            .chain(strippings.into_iter().map(|span| (span, "<stripped>".into()))),
+                            ))
+                            .chain(strippings.into_iter().map(|span| (span, "<stripped>".into())))
+                            .collect(),
+                            Applicability::HasPlaceholders,
                         );
                     },
                 );
@@ -145,7 +147,7 @@ fn len_arg<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<&'tcx E
 
 // Returns the length of the `expr` if it's a constant string or char.
 fn constant_length(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<u128> {
-    let value = constant(cx, cx.typeck_results(), expr)?;
+    let value = ConstEvalCtxt::new(cx).eval(expr)?;
     match value {
         Constant::Str(value) => Some(value.len() as u128),
         Constant::Char(value) => Some(value.len_utf8() as u128),
@@ -183,9 +185,9 @@ fn peel_ref<'a>(expr: &'a Expr<'_>) -> &'a Expr<'a> {
     }
 }
 
-// Find expressions where `target` is stripped using the length of `pattern`.
-// We'll suggest replacing these expressions with the result of the `strip_{prefix,suffix}`
-// method.
+/// Find expressions where `target` is stripped using the length of `pattern`.
+/// We'll suggest replacing these expressions with the result of the `strip_{prefix,suffix}`
+/// method.
 fn find_stripping<'tcx>(
     cx: &LateContext<'tcx>,
     strip_kind: StripKind,
diff --git a/clippy_lints/src/manual_unwrap_or_default.rs b/clippy_lints/src/manual_unwrap_or_default.rs
index f1acc4b217480..8f8390b6f3f9e 100644
--- a/clippy_lints/src/manual_unwrap_or_default.rs
+++ b/clippy_lints/src/manual_unwrap_or_default.rs
@@ -10,7 +10,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher::IfLetOrMatch;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
-use clippy_utils::{in_constant, is_default_equivalent, peel_blocks, span_contains_comment};
+use clippy_utils::{is_default_equivalent, is_in_const_context, peel_blocks, span_contains_comment};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -174,7 +174,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualUnwrapOrDefault {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let Some(if_let_or_match) = IfLetOrMatch::parse(cx, expr)
             && !expr.span.from_expansion()
-            && !in_constant(cx, expr.hir_id)
+            && !is_in_const_context(cx)
         {
             handle(cx, if_let_or_match, expr);
         }
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
index 85a08f81c2f34..2d4c8daf5cb66 100644
--- a/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::constant_simple;
+use clippy_utils::consts::ConstEvalCtxt;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -69,7 +69,7 @@ fn check_and_lint<'tcx>(
         && let Some(ty_name) = find_type_name(cx, ty)
         && let Some(or_body_snippet) = snippet_opt(cx, else_expr.span)
         && let Some(indent) = indent_of(cx, expr.span)
-        && constant_simple(cx, cx.typeck_results(), else_expr).is_some()
+        && ConstEvalCtxt::new(cx).eval_simple(else_expr).is_some()
     {
         lint(cx, expr, let_expr, ty_name, or_body_snippet, indent);
     }
diff --git a/clippy_lints/src/matches/match_ref_pats.rs b/clippy_lints/src/matches/match_ref_pats.rs
index aba4c85c59e28..5445ee1f04296 100644
--- a/clippy_lints/src/matches/match_ref_pats.rs
+++ b/clippy_lints/src/matches/match_ref_pats.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, walk_span_to_context};
 use clippy_utils::sugg::Sugg;
 use core::iter::once;
@@ -54,7 +54,11 @@ where
 
     span_lint_and_then(cx, MATCH_REF_PATS, expr.span, title, |diag| {
         if !expr.span.from_expansion() {
-            multispan_sugg(diag, msg, first_sugg.chain(remaining_suggs));
+            diag.multipart_suggestion(
+                msg,
+                first_sugg.chain(remaining_suggs).collect(),
+                Applicability::MachineApplicable,
+            );
         }
     });
 }
diff --git a/clippy_lints/src/matches/match_wild_enum.rs b/clippy_lints/src/matches/match_wild_enum.rs
index 8d22ceb47f859..91e40e4275c07 100644
--- a/clippy_lints/src/matches/match_wild_enum.rs
+++ b/clippy_lints/src/matches/match_wild_enum.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{is_refutable, peel_hir_pat_refs, recurse_or_patterns};
 use rustc_errors::Applicability;
@@ -148,23 +148,27 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>]) {
             Applicability::MaybeIncorrect,
         ),
         variants => {
-            let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
-            let message = if adt_def.is_variant_list_non_exhaustive() || has_external_hidden {
-                suggestions.push("_".into());
-                "wildcard matches known variants and will also match future added variants"
+            let (message, add_wildcard) = if adt_def.is_variant_list_non_exhaustive() || has_external_hidden {
+                (
+                    "wildcard matches known variants and will also match future added variants",
+                    true,
+                )
             } else {
-                "wildcard match will also match any future added variants"
+                ("wildcard match will also match any future added variants", false)
             };
 
-            span_lint_and_sugg(
-                cx,
-                WILDCARD_ENUM_MATCH_ARM,
-                wildcard_span,
-                message,
-                "try",
-                suggestions.join(" | "),
-                Applicability::MaybeIncorrect,
-            );
+            span_lint_and_then(cx, WILDCARD_ENUM_MATCH_ARM, wildcard_span, message, |diag| {
+                let mut suggestions: Vec<_> = variants.iter().copied().map(format_suggestion).collect();
+                if add_wildcard {
+                    suggestions.push("_".into());
+                }
+                diag.span_suggestion(
+                    wildcard_span,
+                    "try",
+                    suggestions.join(" | "),
+                    Applicability::MaybeIncorrect,
+                );
+            });
         },
     };
 }
@@ -176,9 +180,8 @@ enum CommonPrefixSearcher<'a> {
 }
 impl<'a> CommonPrefixSearcher<'a> {
     fn with_path(&mut self, path: &'a [PathSegment<'a>]) {
-        match path {
-            [path @ .., _] => self.with_prefix(path),
-            [] => (),
+        if let [path @ .., _] = path {
+            self.with_prefix(path);
         }
     }
 
diff --git a/clippy_lints/src/matches/match_wild_err_arm.rs b/clippy_lints/src/matches/match_wild_err_arm.rs
index 310675d01a204..d0d2025878e48 100644
--- a/clippy_lints/src/matches/match_wild_err_arm.rs
+++ b/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_note;
 use clippy_utils::macros::{is_panic, root_macro_call};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::is_local_used;
-use clippy_utils::{in_constant, is_wild, peel_blocks_with_stmt};
+use clippy_utils::{is_in_const_context, is_wild, peel_blocks_with_stmt};
 use rustc_hir::{Arm, Expr, PatKind};
 use rustc_lint::LateContext;
 use rustc_span::symbol::{kw, sym};
@@ -11,7 +11,7 @@ use super::MATCH_WILD_ERR_ARM;
 
 pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'tcx>]) {
     // `unwrap`/`expect` is not (yet) const, so we want to allow this in const contexts for now
-    if in_constant(cx, ex.hir_id) {
+    if is_in_const_context(cx) {
         return;
     }
 
diff --git a/clippy_lints/src/matches/mod.rs b/clippy_lints/src/matches/mod.rs
index cec3504ed8d09..cf5377e0725dd 100644
--- a/clippy_lints/src/matches/mod.rs
+++ b/clippy_lints/src/matches/mod.rs
@@ -27,7 +27,7 @@ mod wild_in_or_pats;
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
 use clippy_utils::source::walk_span_to_context;
-use clippy_utils::{higher, in_constant, is_direct_expn_of, is_span_match, span_contains_cfg};
+use clippy_utils::{higher, is_direct_expn_of, is_in_const_context, is_span_match, span_contains_cfg};
 use rustc_hir::{Arm, Expr, ExprKind, LetStmt, MatchSource, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -1069,7 +1069,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     match_str_case_mismatch::check(cx, ex, arms);
                     redundant_guards::check(cx, arms, &self.msrv);
 
-                    if !in_constant(cx, expr.hir_id) {
+                    if !is_in_const_context(cx) {
                         manual_unwrap_or::check_match(cx, expr, ex, arms);
                         manual_map::check_match(cx, expr, ex, arms);
                         manual_filter::check_match(cx, ex, arms, expr);
@@ -1098,7 +1098,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                             else_expr,
                         );
                     }
-                    if !in_constant(cx, expr.hir_id) {
+                    if !is_in_const_context(cx) {
                         manual_unwrap_or::check_if_let(
                             cx,
                             expr,
diff --git a/clippy_lints/src/matches/overlapping_arms.rs b/clippy_lints/src/matches/overlapping_arms.rs
index 45b375dbe3d72..71f211be925bf 100644
--- a/clippy_lints/src/matches/overlapping_arms.rs
+++ b/clippy_lints/src/matches/overlapping_arms.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, constant_full_int, mir_to_const, FullInt};
+use clippy_utils::consts::{mir_to_const, ConstEvalCtxt, FullInt};
 use clippy_utils::diagnostics::span_lint_and_note;
 use core::cmp::Ordering;
 use rustc_hir::{Arm, Expr, PatKind, RangeEnd};
@@ -33,22 +33,20 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
         .filter_map(|arm| {
             if let Arm { pat, guard: None, .. } = *arm {
                 if let PatKind::Range(ref lhs, ref rhs, range_end) = pat.kind {
-                    let lhs_const = match lhs {
-                        Some(lhs) => constant(cx, cx.typeck_results(), lhs)?,
-                        None => {
-                            let min_val_const = ty.numeric_min_val(cx.tcx)?;
-                            mir_to_const(cx, mir::Const::from_ty_const(min_val_const, ty, cx.tcx))?
-                        },
+                    let lhs_const = if let Some(lhs) = lhs {
+                        ConstEvalCtxt::new(cx).eval(lhs)?
+                    } else {
+                        let min_val_const = ty.numeric_min_val(cx.tcx)?;
+                        mir_to_const(cx.tcx, mir::Const::from_ty_const(min_val_const, ty, cx.tcx))?
                     };
-                    let rhs_const = match rhs {
-                        Some(rhs) => constant(cx, cx.typeck_results(), rhs)?,
-                        None => {
-                            let max_val_const = ty.numeric_max_val(cx.tcx)?;
-                            mir_to_const(cx, mir::Const::from_ty_const(max_val_const, ty, cx.tcx))?
-                        },
+                    let rhs_const = if let Some(rhs) = rhs {
+                        ConstEvalCtxt::new(cx).eval(rhs)?
+                    } else {
+                        let max_val_const = ty.numeric_max_val(cx.tcx)?;
+                        mir_to_const(cx.tcx, mir::Const::from_ty_const(max_val_const, ty, cx.tcx))?
                     };
-                    let lhs_val = lhs_const.int_value(cx, ty)?;
-                    let rhs_val = rhs_const.int_value(cx, ty)?;
+                    let lhs_val = lhs_const.int_value(cx.tcx, ty)?;
+                    let rhs_val = rhs_const.int_value(cx.tcx, ty)?;
                     let rhs_bound = match range_end {
                         RangeEnd::Included => EndBound::Included(rhs_val),
                         RangeEnd::Excluded => EndBound::Excluded(rhs_val),
@@ -60,7 +58,7 @@ fn all_ranges<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], ty: Ty<'tcx>)
                 }
 
                 if let PatKind::Lit(value) = pat.kind {
-                    let value = constant_full_int(cx, cx.typeck_results(), value)?;
+                    let value = ConstEvalCtxt::new(cx).eval_full_int(value)?;
                     return Some(SpannedRange {
                         span: pat.span,
                         node: (value, EndBound::Included(value)),
diff --git a/clippy_lints/src/matches/redundant_guards.rs b/clippy_lints/src/matches/redundant_guards.rs
index c2c0fbf439d51..8222c3057f73e 100644
--- a/clippy_lints/src/matches/redundant_guards.rs
+++ b/clippy_lints/src/matches/redundant_guards.rs
@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::matching_root_macro_call;
 use clippy_utils::source::snippet;
 use clippy_utils::visitors::{for_each_expr_without_closures, is_local_used};
-use clippy_utils::{in_constant, path_to_local};
+use clippy_utils::{is_in_const_context, path_to_local};
 use rustc_ast::{BorrowKind, LitKind};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -116,7 +116,7 @@ fn check_method_calls<'tcx>(
         // `s if s.is_empty()` becomes ""
         // `arr if arr.is_empty()` becomes []
 
-        if ty.is_str() && !in_constant(cx, if_expr.hir_id) {
+        if ty.is_str() && !is_in_const_context(cx) {
             r#""""#.into()
         } else if slice_like {
             "[]".into()
diff --git a/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs b/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
index 316b2f63e4eaa..2154cd5b24a54 100644
--- a/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
+++ b/clippy_lints/src/matches/rest_pat_in_fully_bound_struct.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir::{Pat, PatKind, QPath};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
@@ -15,13 +15,15 @@ pub(crate) fn check(cx: &LateContext<'_>, pat: &Pat<'_>) {
         && fields.len() == def.non_enum_variant().fields.len()
         && !def.non_enum_variant().is_field_list_non_exhaustive()
     {
-        span_lint_and_help(
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(
             cx,
             REST_PAT_IN_FULLY_BOUND_STRUCTS,
             pat.span,
             "unnecessary use of `..` pattern in struct binding. All fields were already bound",
-            None,
-            "consider removing `..` from this binding",
+            |diag| {
+                diag.help("consider removing `..` from this binding");
+            },
         );
     }
 }
diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 99fdbcff890b4..24dea03601c5f 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -1,12 +1,17 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{expr_block, snippet, SpanRangeExt};
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item, peel_mid_ty_refs};
-use clippy_utils::{is_lint_allowed, is_unit_expr, is_wild, peel_blocks, peel_hir_pat_refs, peel_n_hir_expr_refs};
-use core::cmp::max;
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{
+    is_lint_allowed, is_unit_expr, peel_blocks, peel_hir_pat_refs, peel_middle_ty_refs, peel_n_hir_expr_refs,
+};
+use core::ops::ControlFlow;
+use rustc_arena::DroplessArena;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, BindingMode, Block, Expr, ExprKind, Pat, PatKind};
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::intravisit::{walk_pat, Visitor};
+use rustc_hir::{Arm, Expr, ExprKind, HirId, Pat, PatKind, QPath};
 use rustc_lint::LateContext;
-use rustc_middle::ty::{self, Ty};
+use rustc_middle::ty::{self, AdtDef, ParamEnv, TyCtxt, TypeckResults, VariantDef};
 use rustc_span::{sym, Span};
 
 use super::{MATCH_BOOL, SINGLE_MATCH, SINGLE_MATCH_ELSE};
@@ -27,52 +32,58 @@ fn empty_arm_has_comment(cx: &LateContext<'_>, span: Span) -> bool {
 }
 
 #[rustfmt::skip]
-pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
-        if expr.span.from_expansion() {
-            // Don't lint match expressions present in
-            // macro_rules! block
-            return;
-        }
-        if let PatKind::Or(..) = arms[0].pat.kind {
-            // don't lint for or patterns for now, this makes
-            // the lint noisy in unnecessary situations
-            return;
-        }
-        let els = arms[1].body;
-        let els = if is_unit_expr(peel_blocks(els)) && !empty_arm_has_comment(cx, els.span) {
+pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &'tcx Expr<'_>, arms: &'tcx [Arm<'_>], expr: &'tcx Expr<'_>) {
+    if let [arm1, arm2] = arms
+        && arm1.guard.is_none()
+        && arm2.guard.is_none()
+        && !expr.span.from_expansion()
+        // don't lint for or patterns for now, this makes
+        // the lint noisy in unnecessary situations
+        && !matches!(arm1.pat.kind, PatKind::Or(..))
+    {
+        let els = if is_unit_expr(peel_blocks(arm2.body)) && !empty_arm_has_comment(cx, arm2.body.span) {
             None
-        } else if let ExprKind::Block(Block { stmts, expr: block_expr, .. }, _) = els.kind {
-            if stmts.len() == 1 && block_expr.is_none() || stmts.is_empty() && block_expr.is_some() {
+        } else if let ExprKind::Block(block, _) = arm2.body.kind {
+            if matches!((block.stmts, block.expr), ([], Some(_)) | ([_], None)) {
                 // single statement/expr "else" block, don't lint
                 return;
             }
             // block with 2+ statements or 1 expr and 1+ statement
-            Some(els)
+            Some(arm2.body)
         } else {
             // not a block or an empty block w/ comments, don't lint
             return;
         };
 
-        let ty = cx.typeck_results().expr_ty(ex);
-        if (*ty.kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id)) &&
-            (check_single_pattern(arms) || check_opt_like(cx, arms, ty)) {
-            report_single_pattern(cx, ex, arms, expr, els);
+        let typeck = cx.typeck_results();
+        if *typeck.expr_ty(ex).peel_refs().kind() != ty::Bool || is_lint_allowed(cx, MATCH_BOOL, ex.hir_id) {
+            let mut v = PatVisitor {
+                typeck,
+                has_enum: false,
+            };
+            if v.visit_pat(arm2.pat).is_break() {
+                return;
+            }
+            if v.has_enum {
+                let cx = PatCtxt {
+                    tcx: cx.tcx,
+                    param_env: cx.param_env,
+                    typeck,
+                    arena: DroplessArena::default(),
+                };
+                let mut state = PatState::Other;
+                if !(state.add_pat(&cx, arm2.pat) || state.add_pat(&cx, arm1.pat)) {
+                    // Don't lint if the pattern contains an enum which doesn't have a wild match.
+                    return;
+                }
+            }
+
+            report_single_pattern(cx, ex, arm1, expr, els);
         }
     }
 }
 
-fn check_single_pattern(arms: &[Arm<'_>]) -> bool {
-    is_wild(arms[1].pat)
-}
-
-fn report_single_pattern(
-    cx: &LateContext<'_>,
-    ex: &Expr<'_>,
-    arms: &[Arm<'_>],
-    expr: &Expr<'_>,
-    els: Option<&Expr<'_>>,
-) {
+fn report_single_pattern(cx: &LateContext<'_>, ex: &Expr<'_>, arm: &Arm<'_>, expr: &Expr<'_>, els: Option<&Expr<'_>>) {
     let lint = if els.is_some() { SINGLE_MATCH_ELSE } else { SINGLE_MATCH };
     let ctxt = expr.span.ctxt();
     let mut app = Applicability::MachineApplicable;
@@ -80,9 +91,9 @@ fn report_single_pattern(
         format!(" else {}", expr_block(cx, els, ctxt, "..", Some(expr.span), &mut app))
     });
 
-    let (pat, pat_ref_count) = peel_hir_pat_refs(arms[0].pat);
+    let (pat, pat_ref_count) = peel_hir_pat_refs(arm.pat);
     let (msg, sugg) = if let PatKind::Path(_) | PatKind::Lit(_) = pat.kind
-        && let (ty, ty_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(ex))
+        && let (ty, ty_ref_count) = peel_middle_ty_refs(cx.typeck_results().expr_ty(ex))
         && let Some(spe_trait_id) = cx.tcx.lang_items().structural_peq_trait()
         && let Some(pe_trait_id) = cx.tcx.lang_items().eq_trait()
         && (ty.is_integral()
@@ -114,17 +125,17 @@ fn report_single_pattern(
             snippet(cx, ex.span, ".."),
             // PartialEq for different reference counts may not exist.
             "&".repeat(ref_count_diff),
-            snippet(cx, arms[0].pat.span, ".."),
-            expr_block(cx, arms[0].body, ctxt, "..", Some(expr.span), &mut app),
+            snippet(cx, arm.pat.span, ".."),
+            expr_block(cx, arm.body, ctxt, "..", Some(expr.span), &mut app),
         );
         (msg, sugg)
     } else {
         let msg = "you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`";
         let sugg = format!(
             "if let {} = {} {}{els_str}",
-            snippet(cx, arms[0].pat.span, ".."),
+            snippet(cx, arm.pat.span, ".."),
             snippet(cx, ex.span, ".."),
-            expr_block(cx, arms[0].body, ctxt, "..", Some(expr.span), &mut app),
+            expr_block(cx, arm.body, ctxt, "..", Some(expr.span), &mut app),
         );
         (msg, sugg)
     };
@@ -132,106 +143,227 @@ fn report_single_pattern(
     span_lint_and_sugg(cx, lint, expr.span, msg, "try", sugg, app);
 }
 
-fn check_opt_like<'a>(cx: &LateContext<'a>, arms: &[Arm<'_>], ty: Ty<'a>) -> bool {
-    // We don't want to lint if the second arm contains an enum which could
-    // have more variants in the future.
-    form_exhaustive_matches(cx, ty, arms[0].pat, arms[1].pat)
+struct PatVisitor<'tcx> {
+    typeck: &'tcx TypeckResults<'tcx>,
+    has_enum: bool,
 }
-
-/// Returns `true` if all of the types in the pattern are enums which we know
-/// won't be expanded in the future
-fn pat_in_candidate_enum<'a>(cx: &LateContext<'a>, ty: Ty<'a>, pat: &Pat<'_>) -> bool {
-    let mut paths_and_types = Vec::new();
-    collect_pat_paths(&mut paths_and_types, cx, pat, ty);
-    paths_and_types.iter().all(|ty| in_candidate_enum(cx, *ty))
+impl<'tcx> Visitor<'tcx> for PatVisitor<'tcx> {
+    type Result = ControlFlow<()>;
+    fn visit_pat(&mut self, pat: &'tcx Pat<'_>) -> Self::Result {
+        if matches!(pat.kind, PatKind::Binding(..)) {
+            ControlFlow::Break(())
+        } else {
+            self.has_enum |= self.typeck.pat_ty(pat).ty_adt_def().map_or(false, AdtDef::is_enum);
+            walk_pat(self, pat)
+        }
+    }
 }
 
-/// Returns `true` if the given type is an enum we know won't be expanded in the future
-fn in_candidate_enum(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    // list of candidate `Enum`s we know will never get any more members
-    let candidates = [sym::Cow, sym::Option, sym::Result];
+/// The context needed to manipulate a `PatState`.
+struct PatCtxt<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    param_env: ParamEnv<'tcx>,
+    typeck: &'tcx TypeckResults<'tcx>,
+    arena: DroplessArena,
+}
 
-    for candidate_ty in candidates {
-        if is_type_diagnostic_item(cx, ty, candidate_ty) {
-            return true;
+/// State for tracking whether a match can become non-exhaustive by adding a variant to a contained
+/// enum.
+///
+/// This treats certain std enums as if they will never be extended.
+enum PatState<'a> {
+    /// Either a wild match or an uninteresting type. Uninteresting types include:
+    /// * builtin types (e.g. `i32` or `!`)
+    /// * A struct/tuple/array containing only uninteresting types.
+    /// * A std enum containing only uninteresting types.
+    Wild,
+    /// A std enum we know won't be extended. Tracks the states of each variant separately.
+    ///
+    /// This is not used for `Option` since it uses the current pattern to track it's state.
+    StdEnum(&'a mut [PatState<'a>]),
+    /// Either the initial state for a pattern or a non-std enum. There is currently no need to
+    /// distinguish these cases.
+    ///
+    /// For non-std enums there's no need to track the state of sub-patterns as the state of just
+    /// this pattern on it's own is enough for linting. Consider two cases:
+    /// * This enum has no wild match. This case alone is enough to determine we can lint.
+    /// * This enum has a wild match and therefore all sub-patterns also have a wild match.
+    ///
+    /// In both cases the sub patterns are not needed to determine whether to lint.
+    Other,
+}
+impl<'a> PatState<'a> {
+    /// Adds a set of patterns as a product type to the current state. Returns whether or not the
+    /// current state is a wild match after the merge.
+    fn add_product_pat<'tcx>(
+        &mut self,
+        cx: &'a PatCtxt<'tcx>,
+        pats: impl IntoIterator<Item = &'tcx Pat<'tcx>>,
+    ) -> bool {
+        // Ideally this would actually keep track of the state separately for each pattern. Doing so would
+        // require implementing something similar to exhaustiveness checking which is a significant increase
+        // in complexity.
+        //
+        // For now treat this as a wild match only if all the sub-patterns are wild
+        let is_wild = pats.into_iter().all(|p| {
+            let mut state = Self::Other;
+            state.add_pat(cx, p)
+        });
+        if is_wild {
+            *self = Self::Wild;
         }
+        is_wild
     }
-    false
-}
 
-/// Collects types from the given pattern
-fn collect_pat_paths<'a>(acc: &mut Vec<Ty<'a>>, cx: &LateContext<'a>, pat: &Pat<'_>, ty: Ty<'a>) {
-    match pat.kind {
-        PatKind::Tuple(inner, _) => inner.iter().for_each(|p| {
-            let p_ty = cx.typeck_results().pat_ty(p);
-            collect_pat_paths(acc, cx, p, p_ty);
-        }),
-        PatKind::TupleStruct(..) | PatKind::Binding(BindingMode::NONE, .., None) | PatKind::Path(_) => {
-            acc.push(ty);
-        },
-        _ => {},
+    /// Attempts to get the state for the enum variant, initializing the current state if necessary.
+    fn get_std_enum_variant<'tcx>(
+        &mut self,
+        cx: &'a PatCtxt<'tcx>,
+        adt: AdtDef<'tcx>,
+        path: &'tcx QPath<'_>,
+        hir_id: HirId,
+    ) -> Option<(&mut Self, &'tcx VariantDef)> {
+        let states = match self {
+            Self::Wild => return None,
+            Self::Other => {
+                *self = Self::StdEnum(cx.arena.alloc_from_iter((0..adt.variants().len()).map(|_| Self::Other)));
+                let Self::StdEnum(x) = self else {
+                    unreachable!();
+                };
+                x
+            },
+            Self::StdEnum(x) => x,
+        };
+        let i = match cx.typeck.qpath_res(path, hir_id) {
+            Res::Def(DefKind::Ctor(..), id) => adt.variant_index_with_ctor_id(id),
+            Res::Def(DefKind::Variant, id) => adt.variant_index_with_id(id),
+            _ => return None,
+        };
+        Some((&mut states[i.as_usize()], adt.variant(i)))
     }
-}
 
-/// Returns true if the given arm of pattern matching contains wildcard patterns.
-fn contains_only_wilds(pat: &Pat<'_>) -> bool {
-    match pat.kind {
-        PatKind::Wild => true,
-        PatKind::Tuple(inner, _) | PatKind::TupleStruct(_, inner, ..) => inner.iter().all(contains_only_wilds),
-        _ => false,
+    fn check_all_wild_enum(&mut self) -> bool {
+        if let Self::StdEnum(states) = self
+            && states.iter().all(|s| matches!(s, Self::Wild))
+        {
+            *self = Self::Wild;
+            true
+        } else {
+            false
+        }
     }
-}
 
-/// Returns true if the given patterns forms only exhaustive matches that don't contain enum
-/// patterns without a wildcard.
-fn form_exhaustive_matches<'a>(cx: &LateContext<'a>, ty: Ty<'a>, left: &Pat<'_>, right: &Pat<'_>) -> bool {
-    match (&left.kind, &right.kind) {
-        (PatKind::Wild, _) | (_, PatKind::Wild) => true,
-        (PatKind::Tuple(left_in, left_pos), PatKind::Tuple(right_in, right_pos)) => {
-            // We don't actually know the position and the presence of the `..` (dotdot) operator
-            // in the arms, so we need to evaluate the correct offsets here in order to iterate in
-            // both arms at the same time.
-            let left_pos = left_pos.as_opt_usize();
-            let right_pos = right_pos.as_opt_usize();
-            let len = max(
-                left_in.len() + usize::from(left_pos.is_some()),
-                right_in.len() + usize::from(right_pos.is_some()),
-            );
-            let mut left_pos = left_pos.unwrap_or(usize::MAX);
-            let mut right_pos = right_pos.unwrap_or(usize::MAX);
-            let mut left_dot_space = 0;
-            let mut right_dot_space = 0;
-            for i in 0..len {
-                let mut found_dotdot = false;
-                if i == left_pos {
-                    left_dot_space += 1;
-                    if left_dot_space < len - left_in.len() {
-                        left_pos += 1;
-                    }
-                    found_dotdot = true;
-                }
-                if i == right_pos {
-                    right_dot_space += 1;
-                    if right_dot_space < len - right_in.len() {
-                        right_pos += 1;
-                    }
-                    found_dotdot = true;
-                }
-                if found_dotdot {
-                    continue;
+    #[expect(clippy::similar_names)]
+    fn add_struct_pats<'tcx>(
+        &mut self,
+        cx: &'a PatCtxt<'tcx>,
+        pat: &'tcx Pat<'tcx>,
+        path: &'tcx QPath<'tcx>,
+        single_pat: Option<&'tcx Pat<'tcx>>,
+        pats: impl IntoIterator<Item = &'tcx Pat<'tcx>>,
+    ) -> bool {
+        let ty::Adt(adt, _) = *cx.typeck.pat_ty(pat).kind() else {
+            // Should never happen
+            *self = Self::Wild;
+            return true;
+        };
+        if adt.is_struct() {
+            return if let Some(pat) = single_pat
+                && adt.non_enum_variant().fields.len() == 1
+            {
+                self.add_pat(cx, pat)
+            } else {
+                self.add_product_pat(cx, pats)
+            };
+        }
+        match cx.tcx.get_diagnostic_name(adt.did()) {
+            Some(sym::Option) => {
+                if let Some(pat) = single_pat {
+                    self.add_pat(cx, pat)
+                } else {
+                    *self = Self::Wild;
+                    true
                 }
-                if !contains_only_wilds(&left_in[i - left_dot_space])
-                    && !contains_only_wilds(&right_in[i - right_dot_space])
+            },
+            Some(sym::Result | sym::Cow) => {
+                let Some((state, variant)) = self.get_std_enum_variant(cx, adt, path, pat.hir_id) else {
+                    return matches!(self, Self::Wild);
+                };
+                let is_wild = if let Some(pat) = single_pat
+                    && variant.fields.len() == 1
                 {
-                    return false;
-                }
-            }
-            true
-        },
-        (PatKind::TupleStruct(..), PatKind::Path(_)) => pat_in_candidate_enum(cx, ty, right),
-        (PatKind::TupleStruct(..), PatKind::TupleStruct(_, inner, _)) => {
-            pat_in_candidate_enum(cx, ty, right) && inner.iter().all(contains_only_wilds)
-        },
-        _ => false,
+                    state.add_pat(cx, pat)
+                } else {
+                    state.add_product_pat(cx, pats)
+                };
+                is_wild && self.check_all_wild_enum()
+            },
+            _ => matches!(self, Self::Wild),
+        }
+    }
+
+    /// Adds the pattern into the current state. Returns whether or not the current state is a wild
+    /// match after the merge.
+    #[expect(clippy::similar_names)]
+    fn add_pat<'tcx>(&mut self, cx: &'a PatCtxt<'tcx>, pat: &'tcx Pat<'_>) -> bool {
+        match pat.kind {
+            PatKind::Path(_)
+                if match *cx.typeck.pat_ty(pat).peel_refs().kind() {
+                    ty::Adt(adt, _) => adt.is_enum() || (adt.is_struct() && !adt.non_enum_variant().fields.is_empty()),
+                    ty::Tuple(tys) => !tys.is_empty(),
+                    ty::Array(_, len) => len.try_eval_target_usize(cx.tcx, cx.param_env) != Some(1),
+                    ty::Slice(..) => true,
+                    _ => false,
+                } =>
+            {
+                matches!(self, Self::Wild)
+            },
+
+            // Patterns for things which can only contain a single sub-pattern.
+            PatKind::Binding(_, _, _, Some(pat)) | PatKind::Ref(pat, _) | PatKind::Box(pat) | PatKind::Deref(pat) => {
+                self.add_pat(cx, pat)
+            },
+            PatKind::Tuple([sub_pat], pos)
+                if pos.as_opt_usize().is_none() || cx.typeck.pat_ty(pat).tuple_fields().len() == 1 =>
+            {
+                self.add_pat(cx, sub_pat)
+            },
+            PatKind::Slice([sub_pat], _, []) | PatKind::Slice([], _, [sub_pat])
+                if let ty::Array(_, len) = *cx.typeck.pat_ty(pat).kind()
+                    && len.try_eval_target_usize(cx.tcx, cx.param_env) == Some(1) =>
+            {
+                self.add_pat(cx, sub_pat)
+            },
+
+            PatKind::Or(pats) => pats.iter().any(|p| self.add_pat(cx, p)),
+            PatKind::Tuple(pats, _) => self.add_product_pat(cx, pats),
+            PatKind::Slice(head, _, tail) => self.add_product_pat(cx, head.iter().chain(tail)),
+
+            PatKind::TupleStruct(ref path, pats, _) => self.add_struct_pats(
+                cx,
+                pat,
+                path,
+                if let [pat] = pats { Some(pat) } else { None },
+                pats.iter(),
+            ),
+            PatKind::Struct(ref path, pats, _) => self.add_struct_pats(
+                cx,
+                pat,
+                path,
+                if let [pat] = pats { Some(pat.pat) } else { None },
+                pats.iter().map(|p| p.pat),
+            ),
+
+            PatKind::Wild
+            | PatKind::Binding(_, _, _, None)
+            | PatKind::Lit(_)
+            | PatKind::Range(..)
+            | PatKind::Path(_)
+            | PatKind::Never
+            | PatKind::Err(_) => {
+                *self = PatState::Wild;
+                true
+            },
+        }
     }
 }
diff --git a/clippy_lints/src/matches/try_err.rs b/clippy_lints/src/matches/try_err.rs
index dd489fc250b7b..b7ffa8b8a7814 100644
--- a/clippy_lints/src/matches/try_err.rs
+++ b/clippy_lints/src/matches/try_err.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res};
@@ -48,29 +48,28 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, scrutine
             return;
         };
 
-        let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
-        let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt());
-        let mut applicability = Applicability::MachineApplicable;
-        let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability);
-        let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
-            "" // already returns
-        } else {
-            "return "
-        };
-        let suggestion = if err_ty == expr_err_ty {
-            format!("{ret_prefix}{prefix}{origin_snippet}{suffix}")
-        } else {
-            format!("{ret_prefix}{prefix}{origin_snippet}.into(){suffix}")
-        };
-
-        span_lint_and_sugg(
+        span_lint_and_then(
             cx,
             TRY_ERR,
             expr.span,
             "returning an `Err(_)` with the `?` operator",
-            "try",
-            suggestion,
-            applicability,
+            |diag| {
+                let expr_err_ty = cx.typeck_results().expr_ty(err_arg);
+                let span = hygiene::walk_chain(err_arg.span, try_arg.span.ctxt());
+                let mut applicability = Applicability::MachineApplicable;
+                let origin_snippet = snippet_with_applicability(cx, span, "_", &mut applicability);
+                let ret_prefix = if get_parent_expr(cx, expr).map_or(false, |e| matches!(e.kind, ExprKind::Ret(_))) {
+                    "" // already returns
+                } else {
+                    "return "
+                };
+                let suggestion = if err_ty == expr_err_ty {
+                    format!("{ret_prefix}{prefix}{origin_snippet}{suffix}")
+                } else {
+                    format!("{ret_prefix}{prefix}{origin_snippet}.into(){suffix}")
+                };
+                diag.span_suggestion(expr.span, "try", suggestion, applicability);
+            },
         );
     }
 }
diff --git a/clippy_lints/src/methods/bind_instead_of_map.rs b/clippy_lints/src/methods/bind_instead_of_map.rs
index 20f3722e173ad..2a8a5fcc3b6f9 100644
--- a/clippy_lints/src/methods/bind_instead_of_map.rs
+++ b/clippy_lints/src/methods/bind_instead_of_map.rs
@@ -1,5 +1,5 @@
 use super::{contains_return, BIND_INSTEAD_OF_MAP};
-use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::peel_blocks;
 use clippy_utils::source::{snippet, snippet_with_context};
 use clippy_utils::visitors::find_all_ret_expressions;
@@ -136,15 +136,16 @@ impl BindInsteadOfMap {
             return false;
         };
         span_lint_and_then(cx, BIND_INSTEAD_OF_MAP, expr.span, msg, |diag| {
-            multispan_sugg_with_applicability(
-                diag,
-                "try",
+            diag.multipart_suggestion(
+                format!("use `{}` instead", self.good_method_name),
+                std::iter::once((span, self.good_method_name.into()))
+                    .chain(
+                        suggs
+                            .into_iter()
+                            .map(|(span1, span2)| (span1, snippet(cx, span2, "_").into())),
+                    )
+                    .collect(),
                 Applicability::MachineApplicable,
-                std::iter::once((span, self.good_method_name.into())).chain(
-                    suggs
-                        .into_iter()
-                        .map(|(span1, span2)| (span1, snippet(cx, span2, "_").into())),
-                ),
             );
         });
         true
diff --git a/clippy_lints/src/methods/clone_on_ref_ptr.rs b/clippy_lints/src/methods/clone_on_ref_ptr.rs
index 926bd06bacbd2..e0826b53004b6 100644
--- a/clippy_lints/src/methods/clone_on_ref_ptr.rs
+++ b/clippy_lints/src/methods/clone_on_ref_ptr.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_context;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -29,19 +29,22 @@ pub(super) fn check(
             sym::RcWeak | sym::ArcWeak => "Weak",
             _ => return,
         };
-
-        // Sometimes unnecessary ::<_> after Rc/Arc/Weak
-        let mut app = Applicability::Unspecified;
-        let snippet = snippet_with_context(cx, receiver.span, expr.span.ctxt(), "..", &mut app).0;
-
-        span_lint_and_sugg(
+        span_lint_and_then(
             cx,
             CLONE_ON_REF_PTR,
             expr.span,
             "using `.clone()` on a ref-counted pointer",
-            "try",
-            format!("{caller_type}::<{}>::clone(&{snippet})", subst.type_at(0)),
-            app,
+            |diag| {
+                // Sometimes unnecessary ::<_> after Rc/Arc/Weak
+                let mut app = Applicability::Unspecified;
+                let snippet = snippet_with_context(cx, receiver.span, expr.span.ctxt(), "..", &mut app).0;
+                diag.span_suggestion(
+                    expr.span,
+                    "try",
+                    format!("{caller_type}::<{}>::clone(&{snippet})", subst.type_at(0)),
+                    app,
+                );
+            },
         );
     }
 }
diff --git a/clippy_lints/src/methods/filetype_is_file.rs b/clippy_lints/src/methods/filetype_is_file.rs
index eab536b88a5b3..2ab0401947c4c 100644
--- a/clippy_lints/src/methods/filetype_is_file.rs
+++ b/clippy_lints/src/methods/filetype_is_file.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_parent_expr;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir as hir;
@@ -33,6 +33,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
         span = expr.span;
     }
     let lint_msg = format!("`{lint_unary}FileType::is_file()` only {verb} regular files");
-    let help_msg = format!("use `{help_unary}FileType::is_dir()` instead");
-    span_lint_and_help(cx, FILETYPE_IS_FILE, span, lint_msg, None, help_msg);
+
+    #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+    span_lint_and_then(cx, FILETYPE_IS_FILE, span, lint_msg, |diag| {
+        diag.help(format!("use `{help_unary}FileType::is_dir()` instead"));
+    });
 }
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index 455274a442854..c6285c87a2636 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -1,5 +1,5 @@
 use super::utils::derefs_to_slice;
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -19,9 +19,7 @@ pub(super) fn check<'tcx>(
 ) {
     // Note: we don't want to lint `get_mut().unwrap` for `HashMap` or `BTreeMap`,
     // because they do not implement `IndexMut`
-    let mut applicability = Applicability::MachineApplicable;
     let expr_ty = cx.typeck_results().expr_ty(recv);
-    let get_args_str = snippet_with_applicability(cx, get_arg.span, "..", &mut applicability);
     let caller_type = if derefs_to_slice(cx, recv, expr_ty).is_some() {
         "slice"
     } else if is_type_diagnostic_item(cx, expr_ty, sym::Vec) {
@@ -58,24 +56,34 @@ pub(super) fn check<'tcx>(
     };
 
     let mut_str = if is_mut { "_mut" } else { "" };
-    let borrow_str = if !needs_ref {
-        ""
-    } else if is_mut {
-        "&mut "
-    } else {
-        "&"
-    };
 
-    span_lint_and_sugg(
+    span_lint_and_then(
         cx,
         GET_UNWRAP,
         span,
-        format!("called `.get{mut_str}().unwrap()` on a {caller_type}. Using `[]` is more clear and more concise"),
-        "try",
-        format!(
-            "{borrow_str}{}[{get_args_str}]",
-            snippet_with_applicability(cx, recv.span, "..", &mut applicability)
-        ),
-        applicability,
+        format!("called `.get{mut_str}().unwrap()` on a {caller_type}"),
+        |diag| {
+            let mut applicability = Applicability::MachineApplicable;
+            let get_args_str = snippet_with_applicability(cx, get_arg.span, "..", &mut applicability);
+
+            let borrow_str = if !needs_ref {
+                ""
+            } else if is_mut {
+                "&mut "
+            } else {
+                "&"
+            };
+
+            diag.span_suggestion_with_style(
+                span,
+                "using `[]` is clearer and more concise",
+                format!(
+                    "{borrow_str}{}[{get_args_str}]",
+                    snippet_with_applicability(cx, recv.span, "..", &mut applicability)
+                ),
+                applicability,
+                rustc_errors::SuggestionStyle::ShowAlways,
+            );
+        },
     );
 }
diff --git a/clippy_lints/src/methods/implicit_clone.rs b/clippy_lints/src/methods/implicit_clone.rs
index c510cd915d0c9..519091406ccf3 100644
--- a/clippy_lints/src/methods/implicit_clone.rs
+++ b/clippy_lints/src/methods/implicit_clone.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::{implements_trait, peel_mid_ty_refs};
-use clippy_utils::{is_diag_item_method, is_diag_trait_item};
+use clippy_utils::ty::implements_trait;
+use clippy_utils::{is_diag_item_method, is_diag_trait_item, peel_middle_ty_refs};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -14,7 +14,7 @@ pub fn check(cx: &LateContext<'_>, method_name: &str, expr: &hir::Expr<'_>, recv
         && is_clone_like(cx, method_name, method_def_id)
         && let return_type = cx.typeck_results().expr_ty(expr)
         && let input_type = cx.typeck_results().expr_ty(recv)
-        && let (input_type, ref_count) = peel_mid_ty_refs(input_type)
+        && let (input_type, ref_count) = peel_middle_ty_refs(input_type)
         && !(ref_count > 0 && is_diag_trait_item(cx, method_def_id, sym::ToOwned))
         && let Some(ty_name) = input_type.ty_adt_def().map(|adt_def| cx.tcx.item_name(adt_def.did()))
         && return_type == input_type
diff --git a/clippy_lints/src/methods/is_digit_ascii_radix.rs b/clippy_lints/src/methods/is_digit_ascii_radix.rs
index 210e4ae0a7bc0..22d896433f07a 100644
--- a/clippy_lints/src/methods/is_digit_ascii_radix.rs
+++ b/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -2,7 +2,7 @@
 
 use super::IS_DIGIT_ASCII_RADIX;
 use clippy_config::msrvs::{self, Msrv};
-use clippy_utils::consts::{constant_full_int, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use rustc_errors::Applicability;
@@ -24,7 +24,7 @@ pub(super) fn check<'tcx>(
         return;
     }
 
-    if let Some(radix_val) = constant_full_int(cx, cx.typeck_results(), radix) {
+    if let Some(radix_val) = ConstEvalCtxt::new(cx).eval_full_int(radix) {
         let (num, replacement) = match radix_val {
             FullInt::S(10) | FullInt::U(10) => (10, "is_ascii_digit"),
             FullInt::S(16) | FullInt::U(16) => (16, "is_ascii_hexdigit"),
diff --git a/clippy_lints/src/methods/is_empty.rs b/clippy_lints/src/methods/is_empty.rs
index d921b7ea14f5d..cc82f6cfd6384 100644
--- a/clippy_lints/src/methods/is_empty.rs
+++ b/clippy_lints/src/methods/is_empty.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::constant_is_empty;
+use clippy_utils::consts::ConstEvalCtxt;
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{find_binding_init, path_to_local};
 use rustc_hir::{Expr, HirId};
@@ -18,7 +18,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, receiver: &Expr<'_
     if !receiver.span.eq_ctxt(init_expr.span) {
         return;
     }
-    if let Some(init_is_empty) = constant_is_empty(cx, init_expr) {
+    if let Some(init_is_empty) = ConstEvalCtxt::new(cx).eval_is_empty(init_expr) {
         span_lint(
             cx,
             CONST_IS_EMPTY,
diff --git a/clippy_lints/src/methods/iter_kv_map.rs b/clippy_lints/src/methods/iter_kv_map.rs
index 05e77386128f9..33de3b87abc82 100644
--- a/clippy_lints/src/methods/iter_kv_map.rs
+++ b/clippy_lints/src/methods/iter_kv_map.rs
@@ -1,15 +1,12 @@
-#![allow(unused_imports)]
-
 use super::ITER_KV_MAP;
 use clippy_config::msrvs::{self, Msrv};
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::{snippet, snippet_with_applicability};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::pat_is_wild;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{pat_is_wild, sugg};
-use rustc_hir::{BindingMode, Body, BorrowKind, ByRef, Expr, ExprKind, Mutability, Pat, PatKind};
-use rustc_lint::{LateContext, LintContext};
-use rustc_middle::ty;
-use rustc_span::{sym, Span};
+use rustc_hir::{Body, Expr, ExprKind, PatKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
 
 /// lint use of:
 ///
diff --git a/clippy_lints/src/methods/iter_nth_zero.rs b/clippy_lints/src/methods/iter_nth_zero.rs
index 262a57ab591a6..9ff6eaa348710 100644
--- a/clippy_lints/src/methods/iter_nth_zero.rs
+++ b/clippy_lints/src/methods/iter_nth_zero.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{is_lang_item_or_ctor, is_trait_method};
@@ -14,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr
     if let OwnerNode::Item(item) = cx.tcx.hir_owner_node(cx.tcx.hir().get_parent_item(expr.hir_id))
         && let def_id = item.owner_id.to_def_id()
         && is_trait_method(cx, expr, sym::Iterator)
-        && let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), arg)
+        && let Some(Constant::Int(0)) = ConstEvalCtxt::new(cx).eval(arg)
         && !is_lang_item_or_ctor(cx, def_id, LangItem::IteratorNext)
     {
         let mut app = Applicability::MachineApplicable;
diff --git a/clippy_lints/src/methods/iter_skip_zero.rs b/clippy_lints/src/methods/iter_skip_zero.rs
index 6b696b42a6931..39e440e784f6d 100644
--- a/clippy_lints/src/methods/iter_skip_zero.rs
+++ b/clippy_lints/src/methods/iter_skip_zero.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{is_from_proc_macro, is_trait_method};
 use rustc_errors::Applicability;
@@ -11,7 +11,7 @@ use super::ITER_SKIP_ZERO;
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg_expr: &Expr<'_>) {
     if !expr.span.from_expansion()
         && is_trait_method(cx, expr, sym::Iterator)
-        && let Some(arg) = constant(cx, cx.typeck_results(), arg_expr).and_then(|constant| {
+        && let Some(arg) = ConstEvalCtxt::new(cx).eval(arg_expr).and_then(|constant| {
             if let Constant::Int(arg) = constant {
                 Some(arg)
             } else {
diff --git a/clippy_lints/src/methods/iterator_step_by_zero.rs b/clippy_lints/src/methods/iterator_step_by_zero.rs
index b631cd00cda43..9b358235a40df 100644
--- a/clippy_lints/src/methods/iterator_step_by_zero.rs
+++ b/clippy_lints/src/methods/iterator_step_by_zero.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_trait_method;
 use rustc_hir as hir;
@@ -9,7 +9,7 @@ use super::ITERATOR_STEP_BY_ZERO;
 
 pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &hir::Expr<'_>, arg: &'tcx hir::Expr<'_>) {
     if is_trait_method(cx, expr, sym::Iterator) {
-        if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), arg) {
+        if let Some(Constant::Int(0)) = ConstEvalCtxt::new(cx).eval(arg) {
             span_lint(
                 cx,
                 ITERATOR_STEP_BY_ZERO,
diff --git a/clippy_lints/src/methods/map_clone.rs b/clippy_lints/src/methods/map_clone.rs
index a5ba5e5d8918c..08ce7e204dd27 100644
--- a/clippy_lints/src/methods/map_clone.rs
+++ b/clippy_lints/src/methods/map_clone.rs
@@ -2,10 +2,10 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, should_call_clone_as_function};
-use clippy_utils::{is_diag_trait_item, match_def_path, paths, peel_blocks};
+use clippy_utils::{is_diag_trait_item, peel_blocks};
 use rustc_errors::Applicability;
-use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir, LangItem};
 use rustc_lint::LateContext;
 use rustc_middle::mir::Mutability;
 use rustc_middle::ty;
@@ -114,7 +114,7 @@ fn handle_path(
     recv: &hir::Expr<'_>,
 ) {
     if let Some(path_def_id) = cx.qpath_res(qpath, arg.hir_id).opt_def_id()
-        && match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
+        && cx.tcx.lang_items().get(LangItem::CloneFn) == Some(path_def_id)
     {
         // The `copied` and `cloned` methods are only available on `&T` and `&mut T` in `Option`
         // and `Result`.
diff --git a/clippy_lints/src/methods/map_err_ignore.rs b/clippy_lints/src/methods/map_err_ignore.rs
index fbb83c8ce5635..162f0ac564d7d 100644
--- a/clippy_lints/src/methods/map_err_ignore.rs
+++ b/clippy_lints/src/methods/map_err_ignore.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir::{CaptureBy, Closure, Expr, ExprKind, PatKind};
 use rustc_lint::LateContext;
@@ -22,13 +22,17 @@ pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, arg: &Expr<'_>) {
     {
         // span the area of the closure capture and warn that the
         // original error will be thrown away
-        span_lint_and_help(
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(
             cx,
             MAP_ERR_IGNORE,
             fn_decl_span,
             "`map_err(|_|...` wildcard pattern discards the original error",
-            None,
-            "consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)",
+            |diag| {
+                diag.help(
+                    "consider storing the original error as a source in the new error, or silence this warning using an ignored identifier (`.map_err(|_foo| ...`)",
+                );
+            },
         );
     }
 }
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index aa4cad9342a17..1d7b10fe8f045 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -133,7 +133,7 @@ mod zst_offset;
 
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::macros::FormatArgsStorage;
 use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
@@ -749,7 +749,6 @@ declare_clippy_lint! {
     ///
      /// ### Example
     /// ```no_run
-    /// # #![allow(unused)]
     /// (0_i32..10)
     ///     .filter(|n| n.checked_add(1).is_some())
     ///     .map(|n| n.checked_add(1).unwrap());
@@ -757,7 +756,6 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     /// ```no_run
-    /// # #[allow(unused)]
     /// (0_i32..10).filter_map(|n| n.checked_add(1));
     /// ```
     #[clippy::version = "1.51.0"]
@@ -850,7 +848,6 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```no_run
-    /// # #![allow(unused)]
     /// let vec = vec![1];
     /// vec.iter().find(|x| **x == 0).is_some();
     ///
@@ -862,7 +859,6 @@ declare_clippy_lint! {
     /// let vec = vec![1];
     /// vec.iter().any(|x| *x == 0);
     ///
-    /// # #[allow(unused)]
     /// !"hello world".contains("world");
     /// ```
     #[clippy::version = "pre 1.29.0"]
@@ -1505,7 +1501,6 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```no_run
-    /// # #[allow(unused)]
     /// (0..3).fold(false, |acc, x| acc || x > 2);
     /// ```
     ///
@@ -1897,7 +1892,9 @@ declare_clippy_lint! {
     /// trait.
     ///
     /// ### Why is this bad?
-    /// It is recommended style to use collect. See
+    /// If it's needed to create a collection from the contents of an iterator, the `Iterator::collect(_)`
+    /// method is preferred. However, when it's needed to specify the container type,
+    /// `Vec::from_iter(_)` can be more readable than using a turbofish (e.g. `_.collect::<Vec<_>>()`). See
     /// [FromIterator documentation](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)
     ///
     /// ### Example
@@ -1916,6 +1913,14 @@ declare_clippy_lint! {
     ///
     /// assert_eq!(v, vec![5, 5, 5, 5, 5]);
     /// ```
+    /// but prefer to use
+    /// ```no_run
+    /// let numbers: Vec<i32> = FromIterator::from_iter(1..=5);
+    /// ```
+    /// instead of
+    /// ```no_run
+    /// let numbers = (1..=5).collect::<Vec<_>>();
+    /// ```
     #[clippy::version = "1.49.0"]
     pub FROM_ITER_INSTEAD_OF_COLLECT,
     pedantic,
@@ -2008,13 +2013,11 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```no_run
-    /// # #[allow(unused)]
     /// "Hello".bytes().nth(3);
     /// ```
     ///
     /// Use instead:
     /// ```no_run
-    /// # #[allow(unused)]
     /// "Hello".as_bytes().get(3);
     /// ```
     #[clippy::version = "1.52.0"]
@@ -2059,7 +2062,6 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```no_run
-    /// # #![allow(unused)]
     /// let some_vec = vec![0, 1, 2, 3];
     ///
     /// some_vec.iter().count();
@@ -3656,7 +3658,6 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```no_run
-    /// # #![allow(unused)]
     /// let owned_string = "This is a string".to_owned();
     /// owned_string.as_str().as_bytes()
     /// # ;
@@ -3664,7 +3665,6 @@ declare_clippy_lint! {
     ///
     /// Use instead:
     /// ```no_run
-    /// # #![allow(unused)]
     /// let owned_string = "This is a string".to_owned();
     /// owned_string.as_bytes()
     /// # ;
@@ -4915,13 +4915,13 @@ impl Methods {
                     str_split::check(cx, expr, recv, arg);
                 },
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
-                    if let Some(Constant::Int(count)) = constant(cx, cx.typeck_results(), count_arg) {
+                    if let Some(Constant::Int(count)) = ConstEvalCtxt::new(cx).eval(count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
                         str_splitn::check(cx, name, expr, recv, pat_arg, count, &self.msrv);
                     }
                 },
                 ("splitn_mut" | "rsplitn_mut", [count_arg, _]) => {
-                    if let Some(Constant::Int(count)) = constant(cx, cx.typeck_results(), count_arg) {
+                    if let Some(Constant::Int(count)) = ConstEvalCtxt::new(cx).eval(count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
                     }
                 },
diff --git a/clippy_lints/src/methods/open_options.rs b/clippy_lints/src/methods/open_options.rs
index d425b505a760c..cbeb48b6cc376 100644
--- a/clippy_lints/src/methods/open_options.rs
+++ b/clippy_lints/src/methods/open_options.rs
@@ -151,7 +151,7 @@ fn check_open_options(cx: &LateContext<'_>, settings: &[(OpenOption, Argument, S
                 cx,
                 NONSENSICAL_OPEN_OPTIONS,
                 prev_span,
-                format!("the method `{}` is called more than once", &option),
+                format!("the method `{option}` is called more than once"),
             );
         }
     }
diff --git a/clippy_lints/src/methods/repeat_once.rs b/clippy_lints/src/methods/repeat_once.rs
index bb4cdd2a6fa10..7837517ed5d8a 100644
--- a/clippy_lints/src/methods/repeat_once.rs
+++ b/clippy_lints/src/methods/repeat_once.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_lang_item;
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(
     recv: &'tcx Expr<'_>,
     repeat_arg: &'tcx Expr<'_>,
 ) {
-    if constant(cx, cx.typeck_results(), repeat_arg) == Some(Constant::Int(1)) {
+    if ConstEvalCtxt::new(cx).eval(repeat_arg) == Some(Constant::Int(1)) {
         let ty = cx.typeck_results().expr_ty(recv).peel_refs();
         if ty.is_str() {
             span_lint_and_sugg(
diff --git a/clippy_lints/src/methods/str_splitn.rs b/clippy_lints/src/methods/str_splitn.rs
index 4f42fb73547a7..12cabd43cb1b2 100644
--- a/clippy_lints/src/methods/str_splitn.rs
+++ b/clippy_lints/src/methods/str_splitn.rs
@@ -1,5 +1,5 @@
 use clippy_config::msrvs::{self, Msrv};
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::usage::local_used_after_expr;
@@ -301,7 +301,7 @@ fn parse_iter_usage<'tcx>(
                     };
                 },
                 ("nth" | "skip", [idx_expr]) if cx.tcx.trait_of_item(did) == Some(iter_id) => {
-                    if let Some(Constant::Int(idx)) = constant(cx, cx.typeck_results(), idx_expr) {
+                    if let Some(Constant::Int(idx)) = ConstEvalCtxt::new(cx).eval(idx_expr) {
                         let span = if name.ident.as_str() == "nth" {
                             e.span
                         } else if let Some((_, Node::Expr(next_expr))) = iter.next()
diff --git a/clippy_lints/src/methods/unnecessary_min_or_max.rs b/clippy_lints/src/methods/unnecessary_min_or_max.rs
index 78851d4122f12..86c0a6322b666 100644
--- a/clippy_lints/src/methods/unnecessary_min_or_max.rs
+++ b/clippy_lints/src/methods/unnecessary_min_or_max.rs
@@ -3,7 +3,7 @@ use std::cmp::Ordering;
 use super::UNNECESSARY_MIN_OR_MAX;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 
-use clippy_utils::consts::{constant, constant_with_source, Constant, ConstantSource, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, Constant, ConstantSource, FullInt};
 use clippy_utils::source::snippet;
 
 use rustc_errors::Applicability;
@@ -20,10 +20,9 @@ pub(super) fn check<'tcx>(
     arg: &'tcx Expr<'_>,
 ) {
     let typeck_results = cx.typeck_results();
-    if let Some((left, ConstantSource::Local | ConstantSource::CoreConstant)) =
-        constant_with_source(cx, typeck_results, recv)
-        && let Some((right, ConstantSource::Local | ConstantSource::CoreConstant)) =
-            constant_with_source(cx, typeck_results, arg)
+    let ecx = ConstEvalCtxt::with_env(cx.tcx, cx.param_env, typeck_results);
+    if let Some((left, ConstantSource::Local | ConstantSource::CoreConstant)) = ecx.eval_with_source(recv)
+        && let Some((right, ConstantSource::Local | ConstantSource::CoreConstant)) = ecx.eval_with_source(arg)
     {
         let Some(ord) = Constant::partial_cmp(cx.tcx, typeck_results.expr_ty(recv), &left, &right) else {
             return;
@@ -78,9 +77,9 @@ enum Extrema {
 fn detect_extrema<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<Extrema> {
     let ty = cx.typeck_results().expr_ty(expr);
 
-    let cv = constant(cx, cx.typeck_results(), expr)?;
+    let cv = ConstEvalCtxt::new(cx).eval(expr)?;
 
-    match (cv.int_value(cx, ty)?, ty.kind()) {
+    match (cv.int_value(cx.tcx, ty)?, ty.kind()) {
         (FullInt::S(i), &ty::Int(ity)) if i == i128::MIN >> (128 - ity.bit_width()?) => Some(Extrema::Minimum),
         (FullInt::S(i), &ty::Int(ity)) if i == i128::MAX >> (128 - ity.bit_width()?) => Some(Extrema::Maximum),
         (FullInt::U(i), &ty::Uint(uty)) if i == u128::MAX >> (128 - uty.bit_width()?) => Some(Extrema::Maximum),
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index 5d899415d7728..fed2b128dcf30 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -3,12 +3,11 @@ use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_opt};
-use clippy_utils::ty::{
-    get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, is_type_lang_item, peel_mid_ty_refs,
-};
+use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, is_type_lang_item};
 use clippy_utils::visitors::find_all_ret_expressions;
 use clippy_utils::{
-    fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, match_def_path, paths, return_ty,
+    fn_def_id, get_parent_expr, is_diag_item_method, is_diag_trait_item, match_def_path, paths, peel_middle_ty_refs,
+    return_ty,
 };
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -120,8 +119,8 @@ fn check_addr_of_expr(
                 },
             ] = adjustments[..]
         && let receiver_ty = cx.typeck_results().expr_ty(receiver)
-        && let (target_ty, n_target_refs) = peel_mid_ty_refs(*target_ty)
-        && let (receiver_ty, n_receiver_refs) = peel_mid_ty_refs(receiver_ty)
+        && let (target_ty, n_target_refs) = peel_middle_ty_refs(*target_ty)
+        && let (receiver_ty, n_receiver_refs) = peel_middle_ty_refs(receiver_ty)
         // Only flag cases satisfying at least one of the following three conditions:
         // * the referent and receiver types are distinct
         // * the referent/receiver type is a copyable array
@@ -382,7 +381,7 @@ fn check_other_call_arg<'tcx>(
         && let fn_sig = cx.tcx.fn_sig(callee_def_id).instantiate_identity().skip_binder()
         && let Some(i) = recv.into_iter().chain(call_args).position(|arg| arg.hir_id == maybe_arg.hir_id)
         && let Some(input) = fn_sig.inputs().get(i)
-        && let (input, n_refs) = peel_mid_ty_refs(*input)
+        && let (input, n_refs) = peel_middle_ty_refs(*input)
         && let (trait_predicates, _) = get_input_traits_and_projections(cx, callee_def_id, input)
         && let Some(sized_def_id) = cx.tcx.lang_items().sized_trait()
         && let [trait_predicate] = trait_predicates
diff --git a/clippy_lints/src/methods/unused_enumerate_index.rs b/clippy_lints/src/methods/unused_enumerate_index.rs
index 8b8a965b9f0c9..3004d9c4233a7 100644
--- a/clippy_lints/src/methods/unused_enumerate_index.rs
+++ b/clippy_lints/src/methods/unused_enumerate_index.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_hir_and_then};
+use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::{snippet, snippet_opt};
 use clippy_utils::{expr_or_init, is_trait_method, pat_is_wild};
 use rustc_errors::Applicability;
@@ -97,10 +97,8 @@ pub(super) fn check(cx: &LateContext<'_>, call_expr: &Expr<'_>, recv: &Expr<'_>,
             enumerate_span,
             "you seem to use `.enumerate()` and immediately discard the index",
             |diag| {
-                multispan_sugg_with_applicability(
-                    diag,
+                diag.multipart_suggestion(
                     "remove the `.enumerate()` call",
-                    Applicability::MachineApplicable,
                     vec![
                         (closure_param.span, new_closure_param),
                         (
@@ -108,6 +106,7 @@ pub(super) fn check(cx: &LateContext<'_>, call_expr: &Expr<'_>, recv: &Expr<'_>,
                             String::new(),
                         ),
                     ],
+                    Applicability::MachineApplicable,
                 );
             },
         );
diff --git a/clippy_lints/src/methods/useless_asref.rs b/clippy_lints/src/methods/useless_asref.rs
index ae2b6e6347eb0..ebad4ae6ee95d 100644
--- a/clippy_lints/src/methods/useless_asref.rs
+++ b/clippy_lints/src/methods/useless_asref.rs
@@ -2,10 +2,10 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{should_call_clone_as_function, walk_ptrs_ty_depth};
 use clippy_utils::{
-    get_parent_expr, is_diag_trait_item, match_def_path, path_to_local_id, paths, peel_blocks, strip_pat_refs,
+    get_parent_expr, is_diag_trait_item, match_def_path, path_to_local_id, peel_blocks, strip_pat_refs,
 };
 use rustc_errors::Applicability;
-use rustc_hir as hir;
+use rustc_hir::{self as hir, LangItem};
 use rustc_lint::LateContext;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor};
@@ -104,7 +104,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str,
 fn check_qpath(cx: &LateContext<'_>, qpath: hir::QPath<'_>, hir_id: hir::HirId) -> bool {
     // We check it's calling the `clone` method of the `Clone` trait.
     if let Some(path_def_id) = cx.qpath_res(&qpath, hir_id).opt_def_id() {
-        match_def_path(cx, path_def_id, &paths::CLONE_TRAIT_METHOD)
+        cx.tcx.lang_items().get(LangItem::CloneFn) == Some(path_def_id)
     } else {
         false
     }
diff --git a/clippy_lints/src/methods/verbose_file_reads.rs b/clippy_lints/src/methods/verbose_file_reads.rs
index 181b413a18288..8ed61637eca21 100644
--- a/clippy_lints/src/methods/verbose_file_reads.rs
+++ b/clippy_lints/src/methods/verbose_file_reads.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_trait_method;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir::{Expr, ExprKind, QPath};
@@ -23,6 +23,9 @@ pub(super) fn check<'tcx>(
         && matches!(recv.kind, ExprKind::Path(QPath::Resolved(None, _)))
         && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(recv).peel_refs(), sym::File)
     {
-        span_lint_and_help(cx, VERBOSE_FILE_READS, expr.span, msg, None, help);
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(cx, VERBOSE_FILE_READS, expr.span, msg, |diag| {
+            diag.help(help);
+        });
     }
 }
diff --git a/clippy_lints/src/methods/wrong_self_convention.rs b/clippy_lints/src/methods/wrong_self_convention.rs
index 28068c6347325..7384e534ed7d7 100644
--- a/clippy_lints/src/methods/wrong_self_convention.rs
+++ b/clippy_lints/src/methods/wrong_self_convention.rs
@@ -127,7 +127,7 @@ pub(super) fn check<'tcx>(
                         .collect::<Vec<_>>()
                         .join(" and ");
 
-                    format!("methods with the following characteristics: ({})", &s)
+                    format!("methods with the following characteristics: ({s})")
                 } else {
                     format!("methods called {}", &conventions[0])
                 }
diff --git a/clippy_lints/src/minmax.rs b/clippy_lints/src/minmax.rs
index c3fbca1d560e6..e95864c6db8b5 100644
--- a/clippy_lints/src/minmax.rs
+++ b/clippy_lints/src/minmax.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_trait_method;
 use rustc_hir::{Expr, ExprKind};
@@ -106,15 +106,11 @@ fn fetch_const<'a, 'tcx>(
     if args.next().is_some() {
         return None;
     }
-    constant_simple(cx, cx.typeck_results(), first_arg).map_or_else(
-        || constant_simple(cx, cx.typeck_results(), second_arg).map(|c| (m, c, first_arg)),
-        |c| {
-            if constant_simple(cx, cx.typeck_results(), second_arg).is_none() {
-                // otherwise ignore
-                Some((m, c, second_arg))
-            } else {
-                None
-            }
-        },
-    )
+    let ecx = ConstEvalCtxt::new(cx);
+    match (ecx.eval_simple(first_arg), ecx.eval_simple(second_arg)) {
+        (Some(c), None) => Some((m, c, second_arg)),
+        (None, Some(c)) => Some((m, c, first_arg)),
+        // otherwise ignore
+        _ => None,
+    }
 }
diff --git a/clippy_lints/src/misc_early/literal_suffix.rs b/clippy_lints/src/misc_early/literal_suffix.rs
index e0a5e401a50aa..22467999cd8d5 100644
--- a/clippy_lints/src/misc_early/literal_suffix.rs
+++ b/clippy_lints/src/misc_early/literal_suffix.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;
 use rustc_span::Span;
@@ -12,24 +12,36 @@ pub(super) fn check(cx: &EarlyContext<'_>, lit_span: Span, lit_snip: &str, suffi
     // Do not lint when literal is unsuffixed.
     if !suffix.is_empty() {
         if lit_snip.as_bytes()[maybe_last_sep_idx] == b'_' {
-            span_lint_and_sugg(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 SEPARATED_LITERAL_SUFFIX,
                 lit_span,
                 format!("{sugg_type} type suffix should not be separated by an underscore"),
-                "remove the underscore",
-                format!("{}{suffix}", &lit_snip[..maybe_last_sep_idx]),
-                Applicability::MachineApplicable,
+                |diag| {
+                    diag.span_suggestion(
+                        lit_span,
+                        "remove the underscore",
+                        format!("{}{suffix}", &lit_snip[..maybe_last_sep_idx]),
+                        Applicability::MachineApplicable,
+                    );
+                },
             );
         } else {
-            span_lint_and_sugg(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 UNSEPARATED_LITERAL_SUFFIX,
                 lit_span,
                 format!("{sugg_type} type suffix should be separated by an underscore"),
-                "add an underscore",
-                format!("{}_{suffix}", &lit_snip[..=maybe_last_sep_idx]),
-                Applicability::MachineApplicable,
+                |diag| {
+                    diag.span_suggestion(
+                        lit_span,
+                        "add an underscore",
+                        format!("{}_{suffix}", &lit_snip[..=maybe_last_sep_idx]),
+                        Applicability::MachineApplicable,
+                    );
+                },
             );
         }
     }
diff --git a/clippy_lints/src/misc_early/unneeded_field_pattern.rs b/clippy_lints/src/misc_early/unneeded_field_pattern.rs
index cb305cf5582d1..6db03adf44ac9 100644
--- a/clippy_lints/src/misc_early/unneeded_field_pattern.rs
+++ b/clippy_lints/src/misc_early/unneeded_field_pattern.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Pat, PatKind};
 use rustc_lint::EarlyContext;
@@ -21,13 +21,15 @@ pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
             }
         }
         if !pfields.is_empty() && wilds == pfields.len() {
-            span_lint_and_help(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 UNNEEDED_FIELD_PATTERN,
                 pat.span,
                 "all the struct fields are matched to a wildcard pattern, consider using `..`",
-                None,
-                format!("try with `{type_name} {{ .. }}` instead"),
+                |diag| {
+                    diag.help(format!("try with `{type_name} {{ .. }}` instead"));
+                },
             );
             return;
         }
@@ -56,14 +58,15 @@ pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
                             }
                         }
 
-                        span_lint_and_help(
+                        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                        span_lint_and_then(
                             cx,
                             UNNEEDED_FIELD_PATTERN,
                             field.span,
-                            "you matched a field with a wildcard pattern, consider using `..` \
-                             instead",
-                            None,
-                            format!("try with `{type_name} {{ {}, .. }}`", normal[..].join(", ")),
+                            "you matched a field with a wildcard pattern, consider using `..` instead",
+                            |diag| {
+                                diag.help(format!("try with `{type_name} {{ {}, .. }}`", normal[..].join(", ")));
+                            },
                         );
                     }
                 }
diff --git a/clippy_lints/src/missing_assert_message.rs b/clippy_lints/src/missing_assert_message.rs
index 935ed48dacc50..a9ea11f4c2b06 100644
--- a/clippy_lints/src/missing_assert_message.rs
+++ b/clippy_lints/src/missing_assert_message.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_in_test;
 use clippy_utils::macros::{find_assert_args, find_assert_eq_args, root_macro_call_first_node, PanicExpn};
 use rustc_hir::Expr;
@@ -79,13 +79,15 @@ impl<'tcx> LateLintPass<'tcx> for MissingAssertMessage {
         };
 
         if let PanicExpn::Empty = panic_expn {
-            span_lint_and_help(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 MISSING_ASSERT_MESSAGE,
                 macro_call.span,
                 "assert without any message",
-                None,
-                "consider describing why the failing assert is problematic",
+                |diag| {
+                    diag.help("consider describing why the failing assert is problematic");
+                },
             );
         }
     }
diff --git a/clippy_lints/src/missing_const_for_fn.rs b/clippy_lints/src/missing_const_for_fn.rs
index 68c158330ab53..052d738b2e79e 100644
--- a/clippy_lints/src/missing_const_for_fn.rs
+++ b/clippy_lints/src/missing_const_for_fn.rs
@@ -186,7 +186,7 @@ fn already_const(header: hir::FnHeader) -> bool {
 fn could_be_const_with_abi(cx: &LateContext<'_>, msrv: &Msrv, abi: Abi) -> bool {
     match abi {
         Abi::Rust => true,
-        // `const extern "C"` was stablized after 1.62.0
+        // `const extern "C"` was stabilized after 1.62.0
         Abi::C { unwind: false } => msrv.meets(msrvs::CONST_EXTERN_FN),
         // Rest ABIs are still unstable and need the `const_extern_fn` feature enabled.
         _ => cx.tcx.features().const_extern_fn,
diff --git a/clippy_lints/src/missing_trait_methods.rs b/clippy_lints/src/missing_trait_methods.rs
index 85029a5e6a0d4..7ee746365d102 100644
--- a/clippy_lints/src/missing_trait_methods.rs
+++ b/clippy_lints/src/missing_trait_methods.rs
@@ -1,10 +1,9 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_lint_allowed;
 use clippy_utils::macros::span_is_local;
-use rustc_hir::def_id::DefIdMap;
+use rustc_hir::def_id::DefIdSet;
 use rustc_hir::{Impl, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::AssocItem;
 use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
@@ -68,33 +67,26 @@ impl<'tcx> LateLintPass<'tcx> for MissingTraitMethods {
             }) = item.kind
             && let Some(trait_id) = trait_ref.trait_def_id()
         {
-            let mut provided: DefIdMap<&AssocItem> = cx
-                .tcx
-                .provided_trait_methods(trait_id)
-                .map(|assoc| (assoc.def_id, assoc))
+            let trait_item_ids: DefIdSet = items
+                .iter()
+                .filter_map(|impl_item| impl_item.trait_item_def_id)
                 .collect();
 
-            for impl_item in *items {
-                if let Some(def_id) = impl_item.trait_item_def_id {
-                    provided.remove(&def_id);
-                }
+            for assoc in cx
+                .tcx
+                .provided_trait_methods(trait_id)
+                .filter(|assoc| !trait_item_ids.contains(&assoc.def_id))
+            {
+                span_lint_and_then(
+                    cx,
+                    MISSING_TRAIT_METHODS,
+                    cx.tcx.def_span(item.owner_id),
+                    format!("missing trait method provided by default: `{}`", assoc.name),
+                    |diag| {
+                        diag.span_help(cx.tcx.def_span(assoc.def_id), "implement the method");
+                    },
+                );
             }
-
-            cx.tcx.with_stable_hashing_context(|hcx| {
-                for assoc in provided.values_sorted(&hcx, true) {
-                    let source_map = cx.tcx.sess.source_map();
-                    let definition_span = source_map.guess_head_span(cx.tcx.def_span(assoc.def_id));
-
-                    span_lint_and_help(
-                        cx,
-                        MISSING_TRAIT_METHODS,
-                        source_map.guess_head_span(item.span),
-                        format!("missing trait method provided by default: `{}`", assoc.name),
-                        Some(definition_span),
-                        "implement the method",
-                    );
-                }
-            });
         }
     }
 }
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 9c5a8a0cfcdfa..6964d8c8dbb33 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::{get_parent_expr, path_to_local, path_to_local_id};
 use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, HirId, LetStmt, Node, Stmt, StmtKind};
@@ -324,13 +324,17 @@ impl<'a, 'tcx> Visitor<'tcx> for ReadVisitor<'a, 'tcx> {
         if path_to_local_id(expr, self.var) {
             // Check that this is a read, not a write.
             if !is_in_assignment_position(self.cx, expr) {
-                span_lint_and_note(
+                span_lint_and_then(
                     self.cx,
                     MIXED_READ_WRITE_IN_EXPRESSION,
                     expr.span,
                     format!("unsequenced read of `{}`", self.cx.tcx.hir().name(self.var)),
-                    Some(self.write_expr.span),
-                    "whether read occurs before this write depends on evaluation order",
+                    |diag| {
+                        diag.span_note(
+                            self.write_expr.span,
+                            "whether read occurs before this write depends on evaluation order",
+                        );
+                    },
                 );
             }
         }
diff --git a/clippy_lints/src/module_style.rs b/clippy_lints/src/module_style.rs
index 305499f9da43c..e9c5f64a2550d 100644
--- a/clippy_lints/src/module_style.rs
+++ b/clippy_lints/src/module_style.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
@@ -121,17 +121,18 @@ impl EarlyLintPass for ModStyle {
         for folder in &folder_segments {
             if !mod_folders.contains(folder) {
                 if let Some((file, path)) = file_map.get(folder) {
-                    let mut correct = path.to_path_buf();
-                    correct.pop();
-                    correct.push(folder);
-                    correct.push("mod.rs");
-                    span_lint_and_help(
+                    span_lint_and_then(
                         cx,
                         SELF_NAMED_MODULE_FILES,
                         Span::new(file.start_pos, file.start_pos, SyntaxContext::root(), None),
                         format!("`mod.rs` files are required, found `{}`", path.display()),
-                        None,
-                        format!("move `{}` to `{}`", path.display(), correct.display(),),
+                        |diag| {
+                            let mut correct = path.to_path_buf();
+                            correct.pop();
+                            correct.push(folder);
+                            correct.push("mod.rs");
+                            diag.help(format!("move `{}` to `{}`", path.display(), correct.display(),));
+                        },
                     );
                 }
             }
@@ -161,17 +162,18 @@ fn process_paths_for_mod_files<'a>(
 /// for code-sharing between tests.
 fn check_self_named_mod_exists(cx: &EarlyContext<'_>, path: &Path, file: &SourceFile) {
     if path.ends_with("mod.rs") && !path.starts_with("tests") {
-        let mut mod_file = path.to_path_buf();
-        mod_file.pop();
-        mod_file.set_extension("rs");
-
-        span_lint_and_help(
+        span_lint_and_then(
             cx,
             MOD_MODULE_FILES,
             Span::new(file.start_pos, file.start_pos, SyntaxContext::root(), None),
             format!("`mod.rs` files are not allowed, found `{}`", path.display()),
-            None,
-            format!("move `{}` to `{}`", path.display(), mod_file.display()),
+            |diag| {
+                let mut mod_file = path.to_path_buf();
+                mod_file.pop();
+                mod_file.set_extension("rs");
+
+                diag.help(format!("move `{}` to `{}`", path.display(), mod_file.display()));
+            },
         );
     }
 }
diff --git a/clippy_lints/src/needless_borrows_for_generic_args.rs b/clippy_lints/src/needless_borrows_for_generic_args.rs
index 67f9b52c352e6..32e7fde03b2c8 100644
--- a/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -1,7 +1,7 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::mir::PossibleBorrowerMap;
+use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exactly_once, PossibleBorrowerMap};
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::{implements_trait, is_copy};
 use clippy_utils::{expr_use_ctxt, peel_n_hir_expr_refs, DefinedTy, ExprUseNode};
@@ -12,6 +12,7 @@ use rustc_hir::{Body, Expr, ExprKind, Mutability, Path, QPath};
 use rustc_index::bit_set::BitSet;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::mir::{Rvalue, StatementKind};
 use rustc_middle::ty::{
     self, ClauseKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, ParamTy, ProjectionPredicate, Ty,
 };
@@ -107,6 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> {
             }
             && let count = needless_borrow_count(
                 cx,
+                &mut self.possible_borrowers,
                 fn_id,
                 cx.typeck_results().node_args(hir_id),
                 i,
@@ -155,9 +157,14 @@ fn path_has_args(p: &QPath<'_>) -> bool {
 /// The following constraints will be checked:
 /// * The borrowed expression meets all the generic type's constraints.
 /// * The generic type appears only once in the functions signature.
-/// * The borrowed value is Copy itself OR not a variable (created by a function call)
+/// * The borrowed value is:
+///   - `Copy` itself, or
+///   - the only use of a mutable reference, or
+///   - not a variable (created by a function call)
+#[expect(clippy::too_many_arguments)]
 fn needless_borrow_count<'tcx>(
     cx: &LateContext<'tcx>,
+    possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
     fn_id: DefId,
     callee_args: ty::GenericArgsRef<'tcx>,
     arg_index: usize,
@@ -232,9 +239,9 @@ fn needless_borrow_count<'tcx>(
 
         let referent_ty = cx.typeck_results().expr_ty(referent);
 
-        if (!is_copy(cx, referent_ty) && !referent_ty.is_ref())
-            && let ExprKind::AddrOf(_, _, inner) = reference.kind
-            && !matches!(inner.kind, ExprKind::Call(..) | ExprKind::MethodCall(..))
+        if !(is_copy(cx, referent_ty)
+            || referent_ty.is_ref() && referent_used_exactly_once(cx, possible_borrowers, reference)
+            || matches!(referent.kind, ExprKind::Call(..) | ExprKind::MethodCall(..)))
         {
             return false;
         }
@@ -337,6 +344,37 @@ fn is_mixed_projection_predicate<'tcx>(
     }
 }
 
+fn referent_used_exactly_once<'tcx>(
+    cx: &LateContext<'tcx>,
+    possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
+    reference: &Expr<'tcx>,
+) -> bool {
+    if let Some(mir) = enclosing_mir(cx.tcx, reference.hir_id)
+        && let Some(local) = expr_local(cx.tcx, reference)
+        && let [location] = *local_assignments(mir, local).as_slice()
+        && let block_data = &mir.basic_blocks[location.block]
+        && let Some(statement) = block_data.statements.get(location.statement_index)
+        && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) = statement.kind
+        && !place.is_indirect_first_projection()
+    {
+        let body_owner_local_def_id = cx.tcx.hir().enclosing_body_owner(reference.hir_id);
+        if possible_borrowers
+            .last()
+            .map_or(true, |&(local_def_id, _)| local_def_id != body_owner_local_def_id)
+        {
+            possible_borrowers.push((body_owner_local_def_id, PossibleBorrowerMap::new(cx, mir)));
+        }
+        let possible_borrower = &mut possible_borrowers.last_mut().unwrap().1;
+        // If `only_borrowers` were used here, the `copyable_iterator::warn` test would fail. The reason is
+        // that `PossibleBorrowerVisitor::visit_terminator` considers `place.local` a possible borrower of
+        // itself. See the comment in that method for an explanation as to why.
+        possible_borrower.bounded_borrowers(&[local], &[local, place.local], place.local, location)
+            && used_exactly_once(mir, place.local).unwrap_or(false)
+    } else {
+        false
+    }
+}
+
 // Iteratively replaces `param_ty` with `new_ty` in `args`, and similarly for each resulting
 // projected type that is a type parameter. Returns `false` if replacing the types would have an
 // effect on the function signature beyond substituting `new_ty` for `param_ty`.
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index f2e00cef7e9ff..a0bbf6b14b217 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_self;
 use clippy_utils::ptr::get_spans;
 use clippy_utils::source::{snippet, snippet_opt};
@@ -278,9 +278,12 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                         }
                     }
 
-                    let spans = vec![(input.span, format!("&{}", snippet(cx, input.span, "_")))];
-
-                    multispan_sugg(diag, "consider taking a reference instead", spans);
+                    diag.span_suggestion(
+                        input.span,
+                        "consider taking a reference instead",
+                        format!("&{}", snippet(cx, input.span, "_")),
+                        Applicability::MaybeIncorrect,
+                    );
                 };
 
                 span_lint_and_then(
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 9d326c06eff65..8232e69db3917 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -273,7 +273,7 @@ fn check_unnecessary_operation(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
             }
             let snippet =
                 if let (Some(arr), Some(func)) = (snippet_opt(cx, reduced[0].span), snippet_opt(cx, reduced[1].span)) {
-                    format!("assert!({}.len() > {});", &arr, &func)
+                    format!("assert!({arr}.len() > {func});")
                 } else {
                     return;
                 };
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 15bb328b4465a..6915cd4061551 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -6,7 +6,7 @@ use std::ptr;
 
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::in_constant;
+use clippy_utils::is_in_const_context;
 use clippy_utils::macros::macro_backtrace;
 use clippy_utils::ty::{implements_trait, InteriorMut};
 use rustc_hir::def::{DefKind, Res};
@@ -406,7 +406,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst<'tcx> {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if let ExprKind::Path(qpath) = &expr.kind {
             // Only lint if we use the const item inside a function.
-            if in_constant(cx, expr.hir_id) {
+            if is_in_const_context(cx) {
                 return;
             }
 
diff --git a/clippy_lints/src/only_used_in_recursion.rs b/clippy_lints/src/only_used_in_recursion.rs
index 8b8aabe7accc6..aadd729f32a45 100644
--- a/clippy_lints/src/only_used_in_recursion.rs
+++ b/clippy_lints/src/only_used_in_recursion.rs
@@ -243,7 +243,6 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
                 owner_id,
                 ..
             }) => {
-                #[allow(trivial_casts)]
                 if let Node::Item(item) = cx.tcx.parent_hir_node(owner_id.into())
                     && let Some(trait_ref) = cx
                         .tcx
diff --git a/clippy_lints/src/operators/absurd_extreme_comparisons.rs b/clippy_lints/src/operators/absurd_extreme_comparisons.rs
index 9769da6d3e9b1..a0de5ea711ca0 100644
--- a/clippy_lints/src/operators/absurd_extreme_comparisons.rs
+++ b/clippy_lints/src/operators/absurd_extreme_comparisons.rs
@@ -3,7 +3,7 @@ use rustc_lint::LateContext;
 use rustc_middle::ty;
 
 use clippy_utils::comparisons::{normalize_comparison, Rel};
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_isize_or_usize;
@@ -121,7 +121,7 @@ fn detect_absurd_comparison<'tcx>(
 fn detect_extreme_expr<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<ExtremeExpr<'tcx>> {
     let ty = cx.typeck_results().expr_ty(expr);
 
-    let cv = constant(cx, cx.typeck_results(), expr)?;
+    let cv = ConstEvalCtxt::new(cx).eval(expr)?;
 
     let which = match (ty.kind(), cv) {
         (&ty::Bool, Constant::Bool(false)) | (&ty::Uint(_), Constant::Int(0)) => ExtremeType::Minimum,
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index a7e381be743d5..bc71a4790b9d4 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -1,6 +1,6 @@
 use super::ARITHMETIC_SIDE_EFFECTS;
 use clippy_config::Conf;
-use clippy_utils::consts::{constant, constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{expr_or_init, is_from_proc_macro, is_lint_allowed, peel_hir_expr_refs, peel_hir_expr_unary};
@@ -162,7 +162,7 @@ impl ArithmeticSideEffects {
         {
             return Some(n.get());
         }
-        if let Some(Constant::Int(n)) = constant(cx, cx.typeck_results(), expr) {
+        if let Some(Constant::Int(n)) = ConstEvalCtxt::new(cx).eval(expr) {
             return Some(n);
         }
         None
@@ -200,7 +200,7 @@ impl ArithmeticSideEffects {
         lhs: &'tcx hir::Expr<'_>,
         rhs: &'tcx hir::Expr<'_>,
     ) {
-        if constant_simple(cx, cx.typeck_results(), expr).is_some() {
+        if ConstEvalCtxt::new(cx).eval_simple(expr).is_some() {
             return;
         }
         if !matches!(
@@ -280,7 +280,7 @@ impl ArithmeticSideEffects {
         let Some(arg) = args.first() else {
             return;
         };
-        if constant_simple(cx, cx.typeck_results(), receiver).is_some() {
+        if ConstEvalCtxt::new(cx).eval_simple(receiver).is_some() {
             return;
         }
         let instance_ty = cx.typeck_results().expr_ty(receiver);
@@ -308,7 +308,7 @@ impl ArithmeticSideEffects {
         let hir::UnOp::Neg = un_op else {
             return;
         };
-        if constant(cx, cx.typeck_results(), un_expr).is_some() {
+        if ConstEvalCtxt::new(cx).eval(un_expr).is_some() {
             return;
         }
         let ty = cx.typeck_results().expr_ty(expr).peel_refs();
diff --git a/clippy_lints/src/operators/bit_mask.rs b/clippy_lints/src/operators/bit_mask.rs
index 545e680ce0de5..4414056a467ca 100644
--- a/clippy_lints/src/operators/bit_mask.rs
+++ b/clippy_lints/src/operators/bit_mask.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -166,7 +166,7 @@ fn check_ineffective_gt(cx: &LateContext<'_>, span: Span, m: u128, c: u128, op:
 }
 
 fn fetch_int_literal(cx: &LateContext<'_>, lit: &Expr<'_>) -> Option<u128> {
-    match constant(cx, cx.typeck_results(), lit)? {
+    match ConstEvalCtxt::new(cx).eval(lit)? {
         Constant::Int(n) => Some(n),
         _ => None,
     }
diff --git a/clippy_lints/src/operators/const_comparisons.rs b/clippy_lints/src/operators/const_comparisons.rs
index 7bf9b8ef866a2..c131752439628 100644
--- a/clippy_lints/src/operators/const_comparisons.rs
+++ b/clippy_lints/src/operators/const_comparisons.rs
@@ -2,7 +2,7 @@
 
 use std::cmp::Ordering;
 
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::layout::HasTyCtxt;
@@ -20,13 +20,14 @@ use super::{IMPOSSIBLE_COMPARISONS, REDUNDANT_COMPARISONS};
 // Flip yoda conditionals, turnings expressions like `42 < x` into `x > 42`
 fn comparison_to_const<'tcx>(
     cx: &LateContext<'tcx>,
-    typeck: &TypeckResults<'tcx>,
+    typeck: &'tcx TypeckResults<'tcx>,
     expr: &'tcx Expr<'tcx>,
 ) -> Option<(CmpOp, &'tcx Expr<'tcx>, &'tcx Expr<'tcx>, Constant<'tcx>, Ty<'tcx>)> {
     if let ExprKind::Binary(operator, left, right) = expr.kind
         && let Ok(cmp_op) = CmpOp::try_from(operator.node)
     {
-        match (constant(cx, typeck, left), constant(cx, typeck, right)) {
+        let ecx = ConstEvalCtxt::with_env(cx.tcx, cx.param_env, typeck);
+        match (ecx.eval(left), ecx.eval(right)) {
             (Some(_), Some(_)) => None,
             (_, Some(con)) => Some((cmp_op, left, right, con, typeck.expr_ty(right))),
             (Some(con), _) => Some((cmp_op.reverse(), right, left, con, typeck.expr_ty(left))),
diff --git a/clippy_lints/src/operators/duration_subsec.rs b/clippy_lints/src/operators/duration_subsec.rs
index ca3112ce5c468..e3029f8438e5f 100644
--- a/clippy_lints/src/operators/duration_subsec.rs
+++ b/clippy_lints/src/operators/duration_subsec.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::is_type_diagnostic_item;
@@ -19,7 +19,7 @@ pub(crate) fn check<'tcx>(
     if op == BinOpKind::Div
         && let ExprKind::MethodCall(method_path, self_arg, [], _) = left.kind
         && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(self_arg).peel_refs(), sym::Duration)
-        && let Some(Constant::Int(divisor)) = constant(cx, cx.typeck_results(), right)
+        && let Some(Constant::Int(divisor)) = ConstEvalCtxt::new(cx).eval(right)
     {
         let suggested_fn = match (method_path.ident.as_str(), divisor) {
             ("subsec_micros", 1_000) | ("subsec_nanos", 1_000_000) => "subsec_millis",
diff --git a/clippy_lints/src/operators/erasing_op.rs b/clippy_lints/src/operators/erasing_op.rs
index 066e08f3bd4ca..24bfe2b050bb5 100644
--- a/clippy_lints/src/operators/erasing_op.rs
+++ b/clippy_lints/src/operators/erasing_op.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::same_type_and_consts;
 
@@ -34,12 +34,12 @@ fn different_types(tck: &TypeckResults<'_>, input: &Expr<'_>, output: &Expr<'_>)
 
 fn check_op<'tcx>(
     cx: &LateContext<'tcx>,
-    tck: &TypeckResults<'tcx>,
+    tck: &'tcx TypeckResults<'tcx>,
     op: &Expr<'tcx>,
     other: &Expr<'tcx>,
     parent: &Expr<'tcx>,
 ) {
-    if constant_simple(cx, tck, op) == Some(Constant::Int(0)) {
+    if ConstEvalCtxt::with_env(cx.tcx, cx.param_env, tck).eval_simple(op) == Some(Constant::Int(0)) {
         if different_types(tck, other, parent) {
             return;
         }
diff --git a/clippy_lints/src/operators/float_cmp.rs b/clippy_lints/src/operators/float_cmp.rs
index 0e5b440c50f27..df6e67455965e 100644
--- a/clippy_lints/src/operators/float_cmp.rs
+++ b/clippy_lints/src/operators/float_cmp.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_with_source, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_item_name;
 use clippy_utils::sugg::Sugg;
@@ -17,12 +17,14 @@ pub(crate) fn check<'tcx>(
     right: &'tcx Expr<'_>,
 ) {
     if (op == BinOpKind::Eq || op == BinOpKind::Ne) && is_float(cx, left) {
-        let left_is_local = match constant_with_source(cx, cx.typeck_results(), left) {
+        let typeck = cx.typeck_results();
+        let ecx = ConstEvalCtxt::with_env(cx.tcx, cx.param_env, typeck);
+        let left_is_local = match ecx.eval_with_source(left) {
             Some((c, s)) if !is_allowed(&c) => s.is_local(),
             Some(_) => return,
             None => true,
         };
-        let right_is_local = match constant_with_source(cx, cx.typeck_results(), right) {
+        let right_is_local = match ecx.eval_with_source(right) {
             Some((c, s)) if !is_allowed(&c) => s.is_local(),
             Some(_) => return,
             None => true,
diff --git a/clippy_lints/src/operators/identity_op.rs b/clippy_lints/src/operators/identity_op.rs
index 0879dcd9bcdf6..830be50c8ba4f 100644
--- a/clippy_lints/src/operators/identity_op.rs
+++ b/clippy_lints/src/operators/identity_op.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_full_int, constant_simple, Constant, FullInt};
+use clippy_utils::consts::{ConstEvalCtxt, Constant, FullInt};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{clip, peel_hir_expr_refs, unsext};
@@ -184,14 +184,13 @@ fn is_allowed(cx: &LateContext<'_>, cmp: BinOpKind, left: &Expr<'_>, right: &Exp
         && cx.typeck_results().expr_ty(right).peel_refs().is_integral()
         // `1 << 0` is a common pattern in bit manipulation code
         && !(cmp == BinOpKind::Shl
-            && constant_simple(cx, cx.typeck_results(), right) == Some(Constant::Int(0))
-            && constant_simple(cx, cx.typeck_results(), left) == Some(Constant::Int(1)))
+            && ConstEvalCtxt::new(cx).eval_simple(right) == Some(Constant::Int(0))
+            && ConstEvalCtxt::new(cx).eval_simple(left) == Some(Constant::Int(1)))
 }
 
 fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span: Span, arg: Span) {
-    let lhs_const = constant_full_int(cx, cx.typeck_results(), left);
-    let rhs_const = constant_full_int(cx, cx.typeck_results(), right);
-    if match (lhs_const, rhs_const) {
+    let ecx = ConstEvalCtxt::new(cx);
+    if match (ecx.eval_full_int(left), ecx.eval_full_int(right)) {
         (Some(FullInt::S(lv)), Some(FullInt::S(rv))) => lv.abs() < rv.abs(),
         (Some(FullInt::U(lv)), Some(FullInt::U(rv))) => lv < rv,
         _ => return,
@@ -201,7 +200,7 @@ fn check_remainder(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>, span
 }
 
 fn check_op(cx: &LateContext<'_>, e: &Expr<'_>, m: i8, span: Span, arg: Span, parens: Parens, is_erased: bool) -> bool {
-    if let Some(Constant::Int(v)) = constant_simple(cx, cx.typeck_results(), e).map(Constant::peel_refs) {
+    if let Some(Constant::Int(v)) = ConstEvalCtxt::new(cx).eval_simple(e).map(Constant::peel_refs) {
         let check = match *cx.typeck_results().expr_ty(e).peel_refs().kind() {
             ty::Int(ity) => unsext(cx.tcx, -1_i128, ity),
             ty::Uint(uty) => clip(cx.tcx, !0, uty),
diff --git a/clippy_lints/src/operators/integer_division.rs b/clippy_lints/src/operators/integer_division.rs
index 631d10f4a72e9..76eba7327cff6 100644
--- a/clippy_lints/src/operators/integer_division.rs
+++ b/clippy_lints/src/operators/integer_division.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
 
@@ -15,13 +15,9 @@ pub(crate) fn check<'tcx>(
         && cx.typeck_results().expr_ty(left).is_integral()
         && cx.typeck_results().expr_ty(right).is_integral()
     {
-        span_lint_and_help(
-            cx,
-            INTEGER_DIVISION,
-            expr.span,
-            "integer division",
-            None,
-            "division of integers may cause loss of precision. consider using floats",
-        );
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(cx, INTEGER_DIVISION, expr.span, "integer division", |diag| {
+            diag.help("division of integers may cause loss of precision. consider using floats");
+        });
     }
 }
diff --git a/clippy_lints/src/operators/modulo_arithmetic.rs b/clippy_lints/src/operators/modulo_arithmetic.rs
index d65fffac5a828..c83bdda347a66 100644
--- a/clippy_lints/src/operators/modulo_arithmetic.rs
+++ b/clippy_lints/src/operators/modulo_arithmetic.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sext;
 use rustc_hir::{BinOpKind, Expr, ExprKind, Node};
@@ -42,15 +42,11 @@ fn used_in_comparison_with_zero(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     };
 
     if op.node == BinOpKind::Eq || op.node == BinOpKind::Ne {
-        if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), rhs) {
-            return true;
-        }
-        if let Some(Constant::Int(0)) = constant(cx, cx.typeck_results(), lhs) {
-            return true;
-        }
+        let ecx = ConstEvalCtxt::new(cx);
+        matches!(ecx.eval(lhs), Some(Constant::Int(0))) || matches!(ecx.eval(rhs), Some(Constant::Int(0)))
+    } else {
+        false
     }
-
-    false
 }
 
 struct OperandInfo {
@@ -60,7 +56,7 @@ struct OperandInfo {
 }
 
 fn analyze_operand(operand: &Expr<'_>, cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<OperandInfo> {
-    match constant(cx, cx.typeck_results(), operand) {
+    match ConstEvalCtxt::new(cx).eval(operand) {
         Some(Constant::Int(v)) => match *cx.typeck_results().expr_ty(expr).kind() {
             ty::Int(ity) => {
                 let value = sext(cx.tcx, v, ity);
diff --git a/clippy_lints/src/operators/numeric_arithmetic.rs b/clippy_lints/src/operators/numeric_arithmetic.rs
index ea933168cfd5d..565294bb40a82 100644
--- a/clippy_lints/src/operators/numeric_arithmetic.rs
+++ b/clippy_lints/src/operators/numeric_arithmetic.rs
@@ -1,5 +1,5 @@
 use super::FLOAT_ARITHMETIC;
-use clippy_utils::consts::constant_simple;
+use clippy_utils::consts::ConstEvalCtxt;
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
 use rustc_lint::LateContext;
@@ -55,7 +55,7 @@ impl Context {
             return;
         }
         let ty = cx.typeck_results().expr_ty(arg);
-        if constant_simple(cx, cx.typeck_results(), expr).is_none() && ty.is_floating_point() {
+        if ConstEvalCtxt::new(cx).eval_simple(expr).is_none() && ty.is_floating_point() {
             span_lint(cx, FLOAT_ARITHMETIC, expr.span, "floating-point arithmetic detected");
             self.expr_id = Some(expr.hir_id);
         }
diff --git a/clippy_lints/src/operators/op_ref.rs b/clippy_lints/src/operators/op_ref.rs
index c2b27c9b2298a..82b9d10fbeb1d 100644
--- a/clippy_lints/src/operators/op_ref.rs
+++ b/clippy_lints/src/operators/op_ref.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{multispan_sugg, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_enclosing_block;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::{implements_trait, is_copy};
@@ -64,10 +64,10 @@ pub(crate) fn check<'tcx>(
                         |diag| {
                             let lsnip = snippet(cx, l.span, "...").to_string();
                             let rsnip = snippet(cx, r.span, "...").to_string();
-                            multispan_sugg(
-                                diag,
+                            diag.multipart_suggestion(
                                 "use the values directly",
                                 vec![(left.span, lsnip), (right.span, rsnip)],
+                                Applicability::MachineApplicable,
                             );
                         },
                     );
diff --git a/clippy_lints/src/option_if_let_else.rs b/clippy_lints/src/option_if_let_else.rs
index d4906328ccb93..ae02d22512e31 100644
--- a/clippy_lints/src/option_if_let_else.rs
+++ b/clippy_lints/src/option_if_let_else.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    can_move_expr_to_closure, eager_or_lazy, higher, in_constant, is_else_clause, is_res_lang_ctor, peel_blocks,
-    peel_hir_expr_while, CaptureKind,
+    can_move_expr_to_closure, eager_or_lazy, higher, is_else_clause, is_in_const_context, is_res_lang_ctor,
+    peel_blocks, peel_hir_expr_while, CaptureKind,
 };
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -294,7 +294,7 @@ fn is_none_or_err_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
 impl<'tcx> LateLintPass<'tcx> for OptionIfLetElse {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
         // Don't lint macros and constants
-        if expr.span.from_expansion() || in_constant(cx, expr.hir_id) {
+        if expr.span.from_expansion() || is_in_const_context(cx) {
             return;
         }
 
diff --git a/clippy_lints/src/partial_pub_fields.rs b/clippy_lints/src/partial_pub_fields.rs
index 2d20cbea698f2..267e2067e101a 100644
--- a/clippy_lints/src/partial_pub_fields.rs
+++ b/clippy_lints/src/partial_pub_fields.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::{Item, ItemKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
@@ -57,24 +57,16 @@ impl EarlyLintPass for PartialPubFields {
 
         for field in fields {
             if all_priv && field.vis.kind.is_pub() {
-                span_lint_and_help(
-                    cx,
-                    PARTIAL_PUB_FIELDS,
-                    field.vis.span,
-                    msg,
-                    None,
-                    "consider using private field here",
-                );
+                #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                span_lint_and_then(cx, PARTIAL_PUB_FIELDS, field.vis.span, msg, |diag| {
+                    diag.help("consider using private field here");
+                });
                 return;
             } else if all_pub && !field.vis.kind.is_pub() {
-                span_lint_and_help(
-                    cx,
-                    PARTIAL_PUB_FIELDS,
-                    field.vis.span,
-                    msg,
-                    None,
-                    "consider using public field here",
-                );
+                #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                span_lint_and_then(cx, PARTIAL_PUB_FIELDS, field.vis.span, msg, |diag| {
+                    diag.help("consider using public field here");
+                });
                 return;
             }
         }
diff --git a/clippy_lints/src/pathbuf_init_then_push.rs b/clippy_lints/src/pathbuf_init_then_push.rs
index 0008f154ae3a8..18bfb588a1187 100644
--- a/clippy_lints/src/pathbuf_init_then_push.rs
+++ b/clippy_lints/src/pathbuf_init_then_push.rs
@@ -21,8 +21,8 @@ declare_clippy_lint! {
     /// `PathBuf::from` instead.
     ///
     /// ### Known problems
-    /// `.join()` introduces an implicit `clone()`. `PathBuf::from` can alternativly be
-    /// used when the `PathBuf` is newly constructed. This will avoild the implicit clone.
+    /// `.join()` introduces an implicit `clone()`. `PathBuf::from` can alternatively be
+    /// used when the `PathBuf` is newly constructed. This will avoid the implicit clone.
     ///
     /// ### Example
     /// ```rust
diff --git a/clippy_lints/src/pattern_type_mismatch.rs b/clippy_lints/src/pattern_type_mismatch.rs
index 9661a57b8b95c..c1296b04387a0 100644
--- a/clippy_lints/src/pattern_type_mismatch.rs
+++ b/clippy_lints/src/pattern_type_mismatch.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir::{
     intravisit, Body, Expr, ExprKind, FnDecl, LetExpr, LocalSource, Mutability, Pat, PatKind, Stmt, StmtKind,
 };
@@ -133,23 +133,25 @@ enum DerefPossible {
 fn apply_lint(cx: &LateContext<'_>, pat: &Pat<'_>, deref_possible: DerefPossible) -> bool {
     let maybe_mismatch = find_first_mismatch(cx, pat);
     if let Some((span, mutability, level)) = maybe_mismatch {
-        span_lint_and_help(
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(
             cx,
             PATTERN_TYPE_MISMATCH,
             span,
             "type of pattern does not match the expression type",
-            None,
-            format!(
-                "{}explicitly match against a `{}` pattern and adjust the enclosed variable bindings",
-                match (deref_possible, level) {
-                    (DerefPossible::Possible, Level::Top) => "use `*` to dereference the match expression or ",
-                    _ => "",
-                },
-                match mutability {
-                    Mutability::Mut => "&mut _",
-                    Mutability::Not => "&_",
-                },
-            ),
+            |diag| {
+                diag.help(format!(
+                    "{}explicitly match against a `{}` pattern and adjust the enclosed variable bindings",
+                    match (deref_possible, level) {
+                        (DerefPossible::Possible, Level::Top) => "use `*` to dereference the match expression or ",
+                        _ => "",
+                    },
+                    match mutability {
+                        Mutability::Mut => "&mut _",
+                        Mutability::Not => "&_",
+                    },
+                ));
+            },
         );
         true
     } else {
diff --git a/clippy_lints/src/pub_use.rs b/clippy_lints/src/pub_use.rs
index ab8f8a1689dc3..5b973a79eae36 100644
--- a/clippy_lints/src/pub_use.rs
+++ b/clippy_lints/src/pub_use.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::{Item, ItemKind, VisibilityKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
@@ -42,14 +42,10 @@ impl EarlyLintPass for PubUse {
         if let ItemKind::Use(_) = item.kind
             && let VisibilityKind::Public = item.vis.kind
         {
-            span_lint_and_help(
-                cx,
-                PUB_USE,
-                item.span,
-                "using `pub use`",
-                None,
-                "move the exported item to a public module instead",
-            );
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(cx, PUB_USE, item.span, "using `pub use`", |diag| {
+                diag.help("move the exported item to a public module instead");
+            });
         }
     }
 }
diff --git a/clippy_lints/src/question_mark.rs b/clippy_lints/src/question_mark.rs
index ef6b4d3aeab27..e1e3ded2c795d 100644
--- a/clippy_lints/src/question_mark.rs
+++ b/clippy_lints/src/question_mark.rs
@@ -7,7 +7,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use clippy_utils::{
-    eq_expr_value, higher, in_constant, is_else_clause, is_lint_allowed, is_path_lang_item, is_res_lang_ctor,
+    eq_expr_value, higher, is_else_clause, is_in_const_context, is_lint_allowed, is_path_lang_item, is_res_lang_ctor,
     pat_and_expr_can_be_question_mark, path_to_local, path_to_local_id, peel_blocks, peel_blocks_with_stmt,
     span_contains_comment,
 };
@@ -346,15 +346,13 @@ impl<'tcx> LateLintPass<'tcx> for QuestionMark {
             return;
         }
 
-        if !self.inside_try_block() && !in_constant(cx, stmt.hir_id) {
+        if !self.inside_try_block() && !is_in_const_context(cx) {
             check_let_some_else_return_none(cx, stmt);
         }
         self.check_manual_let_else(cx, stmt);
     }
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !self.inside_try_block()
-            && !in_constant(cx, expr.hir_id)
-            && is_lint_allowed(cx, QUESTION_MARK_USED, expr.hir_id)
+        if !self.inside_try_block() && !is_in_const_context(cx) && is_lint_allowed(cx, QUESTION_MARK_USED, expr.hir_id)
         {
             check_is_none_or_err_and_early_return(cx, expr);
             check_if_let_some_or_err_and_early_return(cx, expr);
diff --git a/clippy_lints/src/question_mark_used.rs b/clippy_lints/src/question_mark_used.rs
index f5e6cb804da17..0a974bf9d2f71 100644
--- a/clippy_lints/src/question_mark_used.rs
+++ b/clippy_lints/src/question_mark_used.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 
 use clippy_utils::macros::span_is_local;
 use rustc_hir::{Expr, ExprKind, MatchSource};
@@ -39,13 +39,15 @@ impl<'tcx> LateLintPass<'tcx> for QuestionMarkUsed {
                 return;
             }
 
-            span_lint_and_help(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 QUESTION_MARK_USED,
                 expr.span,
                 "question mark operator was used",
-                None,
-                "consider using a custom macro or match expression",
+                |diag| {
+                    diag.help("consider using a custom macro or match expression");
+                },
             );
         }
     }
diff --git a/clippy_lints/src/ranges.rs b/clippy_lints/src/ranges.rs
index 829fb58bc652b..81189fe517c00 100644
--- a/clippy_lints/src/ranges.rs
+++ b/clippy_lints/src/ranges.rs
@@ -1,10 +1,10 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability, SpanRangeExt};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{get_parent_expr, higher, in_constant, is_integer_const, path_to_local};
+use clippy_utils::{get_parent_expr, higher, is_in_const_context, is_integer_const, path_to_local};
 use rustc_ast::ast::RangeLimits;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, HirId};
@@ -202,7 +202,7 @@ fn check_possible_range_contains(
     expr: &Expr<'_>,
     span: Span,
 ) {
-    if in_constant(cx, expr.hir_id) {
+    if is_in_const_context(cx) {
         return;
     }
 
@@ -319,7 +319,7 @@ fn check_range_bounds<'a, 'tcx>(cx: &'a LateContext<'tcx>, ex: &'a Expr<'_>) ->
             _ => return None,
         };
         if let Some(id) = path_to_local(l) {
-            if let Some(c) = constant(cx, cx.typeck_results(), r) {
+            if let Some(c) = ConstEvalCtxt::new(cx).eval(r) {
                 return Some(RangeBounds {
                     val: c,
                     expr: r,
@@ -331,7 +331,7 @@ fn check_range_bounds<'a, 'tcx>(cx: &'a LateContext<'tcx>, ex: &'a Expr<'_>) ->
                 });
             }
         } else if let Some(id) = path_to_local(r) {
-            if let Some(c) = constant(cx, cx.typeck_results(), l) {
+            if let Some(c) = ConstEvalCtxt::new(cx).eval(l) {
                 return Some(RangeBounds {
                     val: c,
                     expr: l,
@@ -451,8 +451,9 @@ fn check_reversed_empty_range(cx: &LateContext<'_>, expr: &Expr<'_>) {
     }) = higher::Range::hir(expr)
         && let ty = cx.typeck_results().expr_ty(start)
         && let ty::Int(_) | ty::Uint(_) = ty.kind()
-        && let Some(start_idx) = constant(cx, cx.typeck_results(), start)
-        && let Some(end_idx) = constant(cx, cx.typeck_results(), end)
+        && let ecx = ConstEvalCtxt::new(cx)
+        && let Some(start_idx) = ecx.eval(start)
+        && let Some(end_idx) = ecx.eval(end)
         && let Some(ordering) = Constant::partial_cmp(cx.tcx, ty, &start_idx, &end_idx)
         && is_empty_range(limits, ordering)
     {
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index 3416a93e3c4ac..a1231c082e68a 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -96,7 +96,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
             let (fn_def_id, arg, arg_ty, clone_ret) =
                 unwrap_or_continue!(is_call_with_ref_arg(cx, mir, &terminator.kind));
 
-            let from_borrow = match_def_path(cx, fn_def_id, &paths::CLONE_TRAIT_METHOD)
+            let from_borrow = cx.tcx.lang_items().get(LangItem::CloneFn) == Some(fn_def_id)
                 || cx.tcx.is_diagnostic_item(sym::to_owned_method, fn_def_id)
                 || (cx.tcx.is_diagnostic_item(sym::to_string_method, fn_def_id)
                     && is_type_lang_item(cx, arg_ty, LangItem::String));
diff --git a/clippy_lints/src/redundant_slicing.rs b/clippy_lints/src/redundant_slicing.rs
index 82f22ad693d78..1c10e84d3caf6 100644
--- a/clippy_lints/src/redundant_slicing.rs
+++ b/clippy_lints/src/redundant_slicing.rs
@@ -1,7 +1,7 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::get_parent_expr;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_context;
-use clippy_utils::ty::{is_type_lang_item, peel_mid_ty_refs};
+use clippy_utils::ty::is_type_lang_item;
+use clippy_utils::{get_parent_expr, peel_middle_ty_refs};
 use rustc_ast::util::parser::PREC_PREFIX;
 use rustc_errors::Applicability;
 use rustc_hir::{BorrowKind, Expr, ExprKind, LangItem, Mutability};
@@ -82,13 +82,12 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
             && let ExprKind::Index(indexed, range, _) = addressee.kind
             && is_type_lang_item(cx, cx.typeck_results().expr_ty_adjusted(range), LangItem::RangeFull)
         {
-            let (expr_ty, expr_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(expr));
-            let (indexed_ty, indexed_ref_count) = peel_mid_ty_refs(cx.typeck_results().expr_ty(indexed));
+            let (expr_ty, expr_ref_count) = peel_middle_ty_refs(cx.typeck_results().expr_ty(expr));
+            let (indexed_ty, indexed_ref_count) = peel_middle_ty_refs(cx.typeck_results().expr_ty(indexed));
             let parent_expr = get_parent_expr(cx, expr);
             let needs_parens_for_prefix = parent_expr.map_or(false, |parent| parent.precedence().order() > PREC_PREFIX);
-            let mut app = Applicability::MachineApplicable;
 
-            let ((lint, msg), help, sugg) = if expr_ty == indexed_ty {
+            if expr_ty == indexed_ty {
                 if expr_ref_count > indexed_ref_count {
                     // Indexing takes self by reference and can't return a reference to that
                     // reference as it's a local variable. The only way this could happen is if
@@ -99,7 +98,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                 }
                 let deref_count = indexed_ref_count - expr_ref_count;
 
-                let (lint, reborrow_str, help_str) = if mutability == Mutability::Mut {
+                let ((lint, msg), reborrow_str, help_msg) = if mutability == Mutability::Mut {
                     // The slice was used to reborrow the mutable reference.
                     (DEREF_BY_SLICING_LINT, "&mut *", "reborrow the original value instead")
                 } else if matches!(
@@ -113,8 +112,11 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                         a.kind,
                         Adjust::Borrow(AutoBorrow::Ref(_, AutoBorrowMutability::Mut { .. }))
                     )
-                }) {
-                    // The slice was used to make a temporary reference.
+                }) || (matches!(
+                    cx.typeck_results().expr_ty(indexed).ref_mutability(),
+                    Some(Mutability::Mut)
+                ) && mutability == Mutability::Not)
+                {
                     (DEREF_BY_SLICING_LINT, "&*", "reborrow the original value instead")
                 } else if deref_count != 0 {
                     (DEREF_BY_SLICING_LINT, "", "dereference the original value instead")
@@ -122,38 +124,36 @@ impl<'tcx> LateLintPass<'tcx> for RedundantSlicing {
                     (REDUNDANT_SLICING_LINT, "", "use the original value instead")
                 };
 
-                let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
-                let sugg = if (deref_count != 0 || !reborrow_str.is_empty()) && needs_parens_for_prefix {
-                    format!("({reborrow_str}{}{snip})", "*".repeat(deref_count))
-                } else {
-                    format!("{reborrow_str}{}{snip}", "*".repeat(deref_count))
-                };
-
-                (lint, help_str, sugg)
+                span_lint_and_then(cx, lint, expr.span, msg, |diag| {
+                    let mut app = Applicability::MachineApplicable;
+                    let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
+                    let sugg = if (deref_count != 0 || !reborrow_str.is_empty()) && needs_parens_for_prefix {
+                        format!("({reborrow_str}{}{snip})", "*".repeat(deref_count))
+                    } else {
+                        format!("{reborrow_str}{}{snip}", "*".repeat(deref_count))
+                    };
+                    diag.span_suggestion(expr.span, help_msg, sugg, app);
+                });
             } else if let Some(target_id) = cx.tcx.lang_items().deref_target() {
                 if let Ok(deref_ty) = cx.tcx.try_normalize_erasing_regions(
                     cx.param_env,
                     Ty::new_projection_from_args(cx.tcx, target_id, cx.tcx.mk_args(&[GenericArg::from(indexed_ty)])),
                 ) {
                     if deref_ty == expr_ty {
-                        let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
-                        let sugg = if needs_parens_for_prefix {
-                            format!("(&{}{}*{snip})", mutability.prefix_str(), "*".repeat(indexed_ref_count))
-                        } else {
-                            format!("&{}{}*{snip}", mutability.prefix_str(), "*".repeat(indexed_ref_count))
-                        };
-                        (DEREF_BY_SLICING_LINT, "dereference the original value instead", sugg)
-                    } else {
-                        return;
+                        let (lint, msg) = DEREF_BY_SLICING_LINT;
+                        span_lint_and_then(cx, lint, expr.span, msg, |diag| {
+                            let mut app = Applicability::MachineApplicable;
+                            let snip = snippet_with_context(cx, indexed.span, ctxt, "..", &mut app).0;
+                            let sugg = if needs_parens_for_prefix {
+                                format!("(&{}{}*{snip})", mutability.prefix_str(), "*".repeat(indexed_ref_count))
+                            } else {
+                                format!("&{}{}*{snip}", mutability.prefix_str(), "*".repeat(indexed_ref_count))
+                            };
+                            diag.span_suggestion(expr.span, "dereference the original value instead", sugg, app);
+                        });
                     }
-                } else {
-                    return;
                 }
-            } else {
-                return;
-            };
-
-            span_lint_and_sugg(cx, lint, expr.span, msg, help, sugg, app);
+            }
         }
     }
 }
diff --git a/clippy_lints/src/ref_patterns.rs b/clippy_lints/src/ref_patterns.rs
index 467038523b496..002c6c41d52ba 100644
--- a/clippy_lints/src/ref_patterns.rs
+++ b/clippy_lints/src/ref_patterns.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::{BindingMode, Pat, PatKind};
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
@@ -33,14 +33,10 @@ impl EarlyLintPass for RefPatterns {
         if let PatKind::Ident(BindingMode::REF, _, _) = pat.kind
             && !pat.span.from_expansion()
         {
-            span_lint_and_help(
-                cx,
-                REF_PATTERNS,
-                pat.span,
-                "usage of ref pattern",
-                None,
-                "consider using `&` for clarity instead",
-            );
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(cx, REF_PATTERNS, pat.span, "usage of ref pattern", |diag| {
+                diag.help("consider using `&` for clarity instead");
+            });
         }
     }
 }
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 8cacb646f5148..95014b230431c 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -1,6 +1,6 @@
 use std::fmt::Display;
 
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::source::snippet_opt;
 use clippy_utils::{def_path_def_ids, path_def_id, paths};
@@ -148,7 +148,7 @@ fn lint_syntax_error(cx: &LateContext<'_>, error: &regex_syntax::Error, unescape
 }
 
 fn const_str<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> Option<String> {
-    constant(cx, cx.typeck_results(), e).and_then(|c| match c {
+    ConstEvalCtxt::new(cx).eval(e).and_then(|c| match c {
         Constant::Str(s) => Some(s),
         _ => None,
     })
diff --git a/clippy_lints/src/renamed_lints.rs b/clippy_lints/src/renamed_lints.rs
deleted file mode 100644
index 8e999f3e89af3..0000000000000
--- a/clippy_lints/src/renamed_lints.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-// This file is managed by `cargo dev rename_lint`. Prefer using that when possible.
-
-#[rustfmt::skip]
-pub static RENAMED_LINTS: &[(&str, &str)] = &[
-    ("clippy::almost_complete_letter_range", "clippy::almost_complete_range"),
-    ("clippy::blacklisted_name", "clippy::disallowed_names"),
-    ("clippy::block_in_if_condition_expr", "clippy::blocks_in_conditions"),
-    ("clippy::block_in_if_condition_stmt", "clippy::blocks_in_conditions"),
-    ("clippy::blocks_in_if_conditions", "clippy::blocks_in_conditions"),
-    ("clippy::box_vec", "clippy::box_collection"),
-    ("clippy::const_static_lifetime", "clippy::redundant_static_lifetimes"),
-    ("clippy::cyclomatic_complexity", "clippy::cognitive_complexity"),
-    ("clippy::derive_hash_xor_eq", "clippy::derived_hash_with_manual_eq"),
-    ("clippy::disallowed_method", "clippy::disallowed_methods"),
-    ("clippy::disallowed_type", "clippy::disallowed_types"),
-    ("clippy::eval_order_dependence", "clippy::mixed_read_write_in_expression"),
-    ("clippy::identity_conversion", "clippy::useless_conversion"),
-    ("clippy::if_let_some_result", "clippy::match_result_ok"),
-    ("clippy::incorrect_clone_impl_on_copy_type", "clippy::non_canonical_clone_impl"),
-    ("clippy::incorrect_partial_ord_impl_on_ord_type", "clippy::non_canonical_partial_ord_impl"),
-    ("clippy::integer_arithmetic", "clippy::arithmetic_side_effects"),
-    ("clippy::logic_bug", "clippy::overly_complex_bool_expr"),
-    ("clippy::new_without_default_derive", "clippy::new_without_default"),
-    ("clippy::option_and_then_some", "clippy::bind_instead_of_map"),
-    ("clippy::option_expect_used", "clippy::expect_used"),
-    ("clippy::option_map_unwrap_or", "clippy::map_unwrap_or"),
-    ("clippy::option_map_unwrap_or_else", "clippy::map_unwrap_or"),
-    ("clippy::option_unwrap_used", "clippy::unwrap_used"),
-    ("clippy::overflow_check_conditional", "clippy::panicking_overflow_checks"),
-    ("clippy::ref_in_deref", "clippy::needless_borrow"),
-    ("clippy::result_expect_used", "clippy::expect_used"),
-    ("clippy::result_map_unwrap_or_else", "clippy::map_unwrap_or"),
-    ("clippy::result_unwrap_used", "clippy::unwrap_used"),
-    ("clippy::single_char_push_str", "clippy::single_char_add_str"),
-    ("clippy::stutter", "clippy::module_name_repetitions"),
-    ("clippy::thread_local_initializer_can_be_made_const", "clippy::missing_const_for_thread_local"),
-    ("clippy::to_string_in_display", "clippy::recursive_format_impl"),
-    ("clippy::unwrap_or_else_default", "clippy::unwrap_or_default"),
-    ("clippy::zero_width_space", "clippy::invisible_characters"),
-    ("clippy::cast_ref_to_mut", "invalid_reference_casting"),
-    ("clippy::clone_double_ref", "suspicious_double_ref_op"),
-    ("clippy::cmp_nan", "invalid_nan_comparisons"),
-    ("clippy::drop_bounds", "drop_bounds"),
-    ("clippy::drop_copy", "dropping_copy_types"),
-    ("clippy::drop_ref", "dropping_references"),
-    ("clippy::fn_null_check", "useless_ptr_null_checks"),
-    ("clippy::for_loop_over_option", "for_loops_over_fallibles"),
-    ("clippy::for_loop_over_result", "for_loops_over_fallibles"),
-    ("clippy::for_loops_over_fallibles", "for_loops_over_fallibles"),
-    ("clippy::forget_copy", "forgetting_copy_types"),
-    ("clippy::forget_ref", "forgetting_references"),
-    ("clippy::into_iter_on_array", "array_into_iter"),
-    ("clippy::invalid_atomic_ordering", "invalid_atomic_ordering"),
-    ("clippy::invalid_ref", "invalid_value"),
-    ("clippy::invalid_utf8_in_unchecked", "invalid_from_utf8_unchecked"),
-    ("clippy::let_underscore_drop", "let_underscore_drop"),
-    ("clippy::mem_discriminant_non_enum", "enum_intrinsics_non_enums"),
-    ("clippy::panic_params", "non_fmt_panics"),
-    ("clippy::positional_named_format_parameters", "named_arguments_used_positionally"),
-    ("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr"),
-    ("clippy::undropped_manually_drops", "undropped_manually_drops"),
-    ("clippy::unknown_clippy_lints", "unknown_lints"),
-    ("clippy::unused_label", "unused_labels"),
-    ("clippy::vtable_address_comparisons", "ambiguous_wide_pointer_comparisons"),
-];
diff --git a/clippy_lints/src/repeat_vec_with_capacity.rs b/clippy_lints/src/repeat_vec_with_capacity.rs
index 792d8fc88f0bb..678681ea4252d 100644
--- a/clippy_lints/src/repeat_vec_with_capacity.rs
+++ b/clippy_lints/src/repeat_vec_with_capacity.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::macros::matching_root_macro_call;
@@ -69,7 +69,7 @@ fn check_vec_macro(cx: &LateContext<'_>, expr: &Expr<'_>) {
         && let Some(VecArgs::Repeat(repeat_expr, len_expr)) = VecArgs::hir(cx, expr)
         && fn_def_id(cx, repeat_expr).is_some_and(|did| match_def_path(cx, did, &paths::VEC_WITH_CAPACITY))
         && !len_expr.span.from_expansion()
-        && let Some(Constant::Int(2..)) = constant(cx, cx.typeck_results(), expr_or_init(cx, len_expr))
+        && let Some(Constant::Int(2..)) = ConstEvalCtxt::new(cx).eval(expr_or_init(cx, len_expr))
     {
         emit_lint(
             cx,
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 8ced47b48a43d..13016cdadb072 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -395,7 +395,7 @@ fn check_final_expr<'tcx>(
             // Returns may be used to turn an expression into a statement in rustc's AST.
             // This allows the addition of attributes, like `#[allow]` (See: clippy#9361)
             // `#[expect(clippy::needless_return)]` needs to be handled separatly to
-            // actually fullfil the expectation (clippy::#12998)
+            // actually fulfill the expectation (clippy::#12998)
             match cx.tcx.hir().attrs(expr.hir_id) {
                 [] => {},
                 [attr] => {
diff --git a/clippy_lints/src/semicolon_block.rs b/clippy_lints/src/semicolon_block.rs
index 7615c21276d69..09f1c11235291 100644
--- a/clippy_lints/src/semicolon_block.rs
+++ b/clippy_lints/src/semicolon_block.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_utils::diagnostics::{multispan_sugg_with_applicability, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -92,11 +92,10 @@ impl SemicolonBlock {
             semi_span,
             "consider moving the `;` inside the block for consistent formatting",
             |diag| {
-                multispan_sugg_with_applicability(
-                    diag,
+                diag.multipart_suggestion(
                     "put the `;` here",
+                    vec![(remove_span, String::new()), (insert_span, ";".to_owned())],
                     Applicability::MachineApplicable,
-                    [(remove_span, String::new()), (insert_span, ";".to_owned())],
                 );
             },
         );
@@ -124,11 +123,10 @@ impl SemicolonBlock {
             block.span,
             "consider moving the `;` outside the block for consistent formatting",
             |diag| {
-                multispan_sugg_with_applicability(
-                    diag,
+                diag.multipart_suggestion(
                     "put the `;` here",
+                    vec![(remove_span, String::new()), (insert_span, ";".to_owned())],
                     Applicability::MachineApplicable,
-                    [(remove_span, String::new()), (insert_span, ";".to_owned())],
                 );
             },
         );
diff --git a/clippy_lints/src/set_contains_or_insert.rs b/clippy_lints/src/set_contains_or_insert.rs
index 5e65b9fa5171d..e6fe76493974a 100644
--- a/clippy_lints/src/set_contains_or_insert.rs
+++ b/clippy_lints/src/set_contains_or_insert.rs
@@ -12,8 +12,8 @@ use rustc_span::{sym, Span};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `contains` to see if a value is not
-    /// present on `HashSet` followed by a `insert`.
+    /// Checks for usage of `contains` to see if a value is not present
+    /// in a set like `HashSet` or `BTreeSet`, followed by an `insert`.
     ///
     /// ### Why is this bad?
     /// Using just `insert` and checking the returned `bool` is more efficient.
@@ -45,12 +45,12 @@ declare_clippy_lint! {
     #[clippy::version = "1.80.0"]
     pub SET_CONTAINS_OR_INSERT,
     nursery,
-    "call to `HashSet::contains` followed by `HashSet::insert`"
+    "call to `<set>::contains` followed by `<set>::insert`"
 }
 
-declare_lint_pass!(HashsetInsertAfterContains => [SET_CONTAINS_OR_INSERT]);
+declare_lint_pass!(SetContainsOrInsert => [SET_CONTAINS_OR_INSERT]);
 
-impl<'tcx> LateLintPass<'tcx> for HashsetInsertAfterContains {
+impl<'tcx> LateLintPass<'tcx> for SetContainsOrInsert {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
         if !expr.span.from_expansion()
             && let Some(higher::If {
@@ -58,14 +58,14 @@ impl<'tcx> LateLintPass<'tcx> for HashsetInsertAfterContains {
                 then: then_expr,
                 ..
             }) = higher::If::hir(expr)
-            && let Some(contains_expr) = try_parse_op_call(cx, cond_expr, sym!(contains))//try_parse_contains(cx, cond_expr)
+            && let Some((contains_expr, sym)) = try_parse_op_call(cx, cond_expr, sym!(contains))//try_parse_contains(cx, cond_expr)
             && let Some(insert_expr) = find_insert_calls(cx, &contains_expr, then_expr)
         {
             span_lint(
                 cx,
                 SET_CONTAINS_OR_INSERT,
                 vec![contains_expr.span, insert_expr.span],
-                "usage of `HashSet::insert` after `HashSet::contains`",
+                format!("usage of `{sym}::insert` after `{sym}::contains`"),
             );
         }
     }
@@ -77,7 +77,11 @@ struct OpExpr<'tcx> {
     span: Span,
 }
 
-fn try_parse_op_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, symbol: Symbol) -> Option<OpExpr<'tcx>> {
+fn try_parse_op_call<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    symbol: Symbol,
+) -> Option<(OpExpr<'tcx>, Symbol)> {
     let expr = peel_hir_expr_while(expr, |e| {
         if let ExprKind::Unary(UnOp::Not, e) = e.kind {
             Some(e)
@@ -97,11 +101,12 @@ fn try_parse_op_call<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, symbol:
         });
         let receiver = receiver.peel_borrows();
         let receiver_ty = cx.typeck_results().expr_ty(receiver).peel_refs();
-        if value.span.eq_ctxt(expr.span)
-            && is_type_diagnostic_item(cx, receiver_ty, sym::HashSet)
-            && path.ident.name == symbol
-        {
-            return Some(OpExpr { receiver, value, span });
+        if value.span.eq_ctxt(expr.span) && path.ident.name == symbol {
+            for sym in &[sym::HashSet, sym::BTreeSet] {
+                if is_type_diagnostic_item(cx, receiver_ty, *sym) {
+                    return Some((OpExpr { receiver, value, span }, *sym));
+                }
+            }
         }
     }
     None
@@ -113,7 +118,7 @@ fn find_insert_calls<'tcx>(
     expr: &'tcx Expr<'_>,
 ) -> Option<OpExpr<'tcx>> {
     for_each_expr(cx, expr, |e| {
-        if let Some(insert_expr) = try_parse_op_call(cx, e, sym!(insert))
+        if let Some((insert_expr, _)) = try_parse_op_call(cx, e, sym!(insert))
             && SpanlessEq::new(cx).eq_expr(contains_expr.receiver, insert_expr.receiver)
             && SpanlessEq::new(cx).eq_expr(contains_expr.value, insert_expr.value)
         {
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
index 80f5fd0b49441..7ae0310b6d996 100644
--- a/clippy_lints/src/shadow.rs
+++ b/clippy_lints/src/shadow.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
 use clippy_utils::visitors::is_local_used;
 use rustc_data_structures::fx::FxHashMap;
@@ -194,14 +194,9 @@ fn lint_shadow(cx: &LateContext<'_>, pat: &Pat<'_>, shadowed: HirId, span: Span)
             (SHADOW_UNRELATED, msg)
         },
     };
-    span_lint_and_note(
-        cx,
-        lint,
-        span,
-        msg,
-        Some(cx.tcx.hir().span(shadowed)),
-        "previous binding is here",
-    );
+    span_lint_and_then(cx, lint, span, msg, |diag| {
+        diag.span_note(cx.tcx.hir().span(shadowed), "previous binding is here");
+    });
 }
 
 /// Returns true if the expression is a simple transformation of a local binding such as `&x`
diff --git a/clippy_lints/src/single_char_lifetime_names.rs b/clippy_lints/src/single_char_lifetime_names.rs
index 72feb977c3104..d92b890950a3f 100644
--- a/clippy_lints/src/single_char_lifetime_names.rs
+++ b/clippy_lints/src/single_char_lifetime_names.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::{GenericParam, GenericParamKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
@@ -48,13 +48,15 @@ impl EarlyLintPass for SingleCharLifetimeNames {
 
         if let GenericParamKind::Lifetime = param.kind {
             if !param.is_placeholder && param.ident.as_str().len() <= 2 {
-                span_lint_and_help(
+                #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                span_lint_and_then(
                     ctx,
                     SINGLE_CHAR_LIFETIME_NAMES,
                     param.ident.span,
                     "single-character lifetime names are likely uninformative",
-                    None,
-                    "use a more informative name",
+                    |diag| {
+                        diag.help("use a more informative name");
+                    },
                 );
             }
         }
diff --git a/clippy_lints/src/size_of_ref.rs b/clippy_lints/src/size_of_ref.rs
index 8d7f12af86e8a..b3d32a6d7d84c 100644
--- a/clippy_lints/src/size_of_ref.rs
+++ b/clippy_lints/src/size_of_ref.rs
@@ -1,6 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::path_def_id;
-use clippy_utils::ty::peel_mid_ty_refs;
+use clippy_utils::{path_def_id, peel_middle_ty_refs};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -60,7 +59,7 @@ impl LateLintPass<'_> for SizeOfRef {
             && let Some(def_id) = path_def_id(cx, path)
             && cx.tcx.is_diagnostic_item(sym::mem_size_of_val, def_id)
             && let arg_ty = cx.typeck_results().expr_ty(arg)
-            && peel_mid_ty_refs(arg_ty).1 > 1
+            && peel_middle_ty_refs(arg_ty).1 > 1
         {
             span_lint_and_help(
                 cx,
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index 12b70075a3d5e..974e21df817a8 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -1,11 +1,15 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_config::msrvs::Msrv;
+use clippy_config::Conf;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_from_proc_macro;
+use rustc_attr::{StabilityLevel, StableSince};
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{HirId, Path, PathSegment};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
+use rustc_semver::RustcVersion;
 use rustc_session::impl_lint_pass;
 use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
@@ -66,6 +70,10 @@ declare_clippy_lint! {
     /// imported from core to ensure disabling `alloc` does not cause the crate to fail to compile. This lint
     /// is also useful for crates migrating to become `no_std` compatible.
     ///
+    /// ### Known problems
+    /// The lint is only partially aware of the required MSRV for items that were originally in `std` but moved
+    /// to `core`.
+    ///
     /// ### Example
     /// ```no_run
     /// # extern crate alloc;
@@ -81,20 +89,30 @@ declare_clippy_lint! {
     "type is imported from alloc when available in core"
 }
 
-#[derive(Default)]
 pub struct StdReexports {
     // Paths which can be either a module or a macro (e.g. `std::env`) will cause this check to happen
     // twice. First for the mod, second for the macro. This is used to avoid the lint reporting for the macro
     // when the path could be also be used to access the module.
     prev_span: Span,
+    msrv: Msrv,
 }
+
+impl StdReexports {
+    pub fn new(conf: &'static Conf) -> Self {
+        Self {
+            prev_span: Span::default(),
+            msrv: conf.msrv.clone(),
+        }
+    }
+}
+
 impl_lint_pass!(StdReexports => [STD_INSTEAD_OF_CORE, STD_INSTEAD_OF_ALLOC, ALLOC_INSTEAD_OF_CORE]);
 
 impl<'tcx> LateLintPass<'tcx> for StdReexports {
     fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, _: HirId) {
         if let Res::Def(_, def_id) = path.res
             && let Some(first_segment) = get_first_segment(path)
-            && is_stable(cx, def_id)
+            && is_stable(cx, def_id, &self.msrv)
             && !in_external_macro(cx.sess(), path.span)
             && !is_from_proc_macro(cx, &first_segment.ident)
         {
@@ -118,19 +136,27 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
                 _ => return,
             };
             if first_segment.ident.span != self.prev_span {
-                span_lint_and_sugg(
+                #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                span_lint_and_then(
                     cx,
                     lint,
                     first_segment.ident.span,
                     format!("used import from `{used_mod}` instead of `{replace_with}`"),
-                    format!("consider importing the item from `{replace_with}`"),
-                    replace_with.to_string(),
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        diag.span_suggestion(
+                            first_segment.ident.span,
+                            format!("consider importing the item from `{replace_with}`"),
+                            replace_with.to_string(),
+                            Applicability::MachineApplicable,
+                        );
+                    },
                 );
                 self.prev_span = first_segment.ident.span;
             }
         }
     }
+
+    extract_msrv_attr!(LateContext);
 }
 
 /// Returns the first named segment of a [`Path`].
@@ -146,16 +172,29 @@ fn get_first_segment<'tcx>(path: &Path<'tcx>) -> Option<&'tcx PathSegment<'tcx>>
     }
 }
 
-/// Checks if all ancestors of `def_id` are stable, to avoid linting
-/// [unstable moves](https://github.com/rust-lang/rust/pull/95956)
-fn is_stable(cx: &LateContext<'_>, mut def_id: DefId) -> bool {
+/// Checks if all ancestors of `def_id` meet `msrv` to avoid linting [unstable moves](https://github.com/rust-lang/rust/pull/95956)
+/// or now stable moves that were once unstable.
+///
+/// Does not catch individually moved items
+fn is_stable(cx: &LateContext<'_>, mut def_id: DefId, msrv: &Msrv) -> bool {
     loop {
-        if cx
-            .tcx
-            .lookup_stability(def_id)
-            .map_or(false, |stability| stability.is_unstable())
+        if let Some(stability) = cx.tcx.lookup_stability(def_id)
+            && let StabilityLevel::Stable {
+                since,
+                allowed_through_unstable_modules: false,
+            } = stability.level
         {
-            return false;
+            let stable = match since {
+                StableSince::Version(v) => {
+                    msrv.meets(RustcVersion::new(v.major.into(), v.minor.into(), v.patch.into()))
+                },
+                StableSince::Current => msrv.current().is_none(),
+                StableSince::Err => false,
+            };
+
+            if !stable {
+                return false;
+            }
         }
 
         match cx.tcx.opt_parent(def_id) {
diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index 7da661485abfc..cfc387886dc01 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_and_sugg};
+use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::ty::is_type_lang_item;
 use clippy_utils::{
@@ -399,17 +399,16 @@ impl<'tcx> LateLintPass<'tcx> for StrToString {
             && let ty::Ref(_, ty, ..) = ty.kind()
             && ty.is_str()
         {
-            let mut applicability = Applicability::MachineApplicable;
-            let snippet = snippet_with_applicability(cx, self_arg.span, "..", &mut applicability);
-
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 STR_TO_STRING,
                 expr.span,
                 "`to_string()` called on a `&str`",
-                "try",
-                format!("{snippet}.to_owned()"),
-                applicability,
+                |diag| {
+                    let mut applicability = Applicability::MachineApplicable;
+                    let snippet = snippet_with_applicability(cx, self_arg.span, "..", &mut applicability);
+                    diag.span_suggestion(expr.span, "try", format!("{snippet}.to_owned()"), applicability);
+                },
             );
         }
     }
@@ -455,13 +454,15 @@ impl<'tcx> LateLintPass<'tcx> for StringToString {
             && let ty = cx.typeck_results().expr_ty(self_arg)
             && is_type_lang_item(cx, ty, LangItem::String)
         {
-            span_lint_and_help(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 STRING_TO_STRING,
                 expr.span,
                 "`to_string()` called on a `String`",
-                None,
-                "consider using `.clone()`",
+                |diag| {
+                    diag.help("consider using `.clone()`");
+                },
             );
         }
     }
diff --git a/clippy_lints/src/suspicious_xor_used_as_pow.rs b/clippy_lints/src/suspicious_xor_used_as_pow.rs
index d150a5f858aa3..d1d822a553260 100644
--- a/clippy_lints/src/suspicious_xor_used_as_pow.rs
+++ b/clippy_lints/src/suspicious_xor_used_as_pow.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::numeric_literal::NumericLiteral;
 use clippy_utils::source::snippet;
 use rustc_ast::LitKind;
@@ -43,14 +43,19 @@ impl LateLintPass<'_> for ConfusingXorAndPow {
             && NumericLiteral::from_lit_kind(&snippet(cx, lit_right.span, ".."), &lit_right.node)
                 .is_some_and(|x| x.is_decimal())
         {
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 SUSPICIOUS_XOR_USED_AS_POW,
                 expr.span,
                 "`^` is not the exponentiation operator",
-                "did you mean to write",
-                format!("{}.pow({})", lit_left.node, lit_right.node),
-                Applicability::MaybeIncorrect,
+                |diag| {
+                    diag.span_suggestion_verbose(
+                        expr.span,
+                        "did you mean to write",
+                        format!("{}.pow({})", lit_left.node, lit_right.node),
+                        Applicability::MaybeIncorrect,
+                    );
+                },
             );
         }
     }
diff --git a/clippy_lints/src/swap.rs b/clippy_lints/src/swap.rs
index 93bad86580975..197011cde3a1a 100644
--- a/clippy_lints/src/swap.rs
+++ b/clippy_lints/src/swap.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::{snippet_indent, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_type_diagnostic_item;
 
-use clippy_utils::{can_mut_borrow_both, eq_expr_value, in_constant, std_or_core};
+use clippy_utils::{can_mut_borrow_both, eq_expr_value, is_in_const_context, std_or_core};
 use itertools::Itertools;
 
 use rustc_hir::intravisit::{walk_expr, Visitor};
@@ -170,7 +170,7 @@ fn generate_swap_warning<'tcx>(
 
 /// Implementation of the `MANUAL_SWAP` lint.
 fn check_manual_swap<'tcx>(cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
-    if in_constant(cx, block.hir_id) {
+    if is_in_const_context(cx) {
         return;
     }
 
diff --git a/clippy_lints/src/tests_outside_test_module.rs b/clippy_lints/src/tests_outside_test_module.rs
index 58e42892c41de..25d0a16e2ab45 100644
--- a/clippy_lints/src/tests_outside_test_module.rs
+++ b/clippy_lints/src/tests_outside_test_module.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{is_in_cfg_test, is_in_test_function};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl};
@@ -61,13 +61,15 @@ impl LateLintPass<'_> for TestsOutsideTestModule {
             && is_in_test_function(cx.tcx, body.id().hir_id)
             && !is_in_cfg_test(cx.tcx, body.id().hir_id)
         {
-            span_lint_and_note(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 TESTS_OUTSIDE_TEST_MODULE,
                 sp,
                 "this function marked with #[test] is outside a #[cfg(test)] module",
-                None,
-                "move it to a testing module marked with #[cfg(test)]",
+                |diag| {
+                    diag.note("move it to a testing module marked with #[cfg(test)]");
+                },
             );
         }
     }
diff --git a/clippy_lints/src/transmute/mod.rs b/clippy_lints/src/transmute/mod.rs
index 9c6813a54b943..373bf61d8ff94 100644
--- a/clippy_lints/src/transmute/mod.rs
+++ b/clippy_lints/src/transmute/mod.rs
@@ -21,7 +21,7 @@ mod wrong_transmute;
 
 use clippy_config::msrvs::Msrv;
 use clippy_config::Conf;
-use clippy_utils::in_constant;
+use clippy_utils::is_in_const_context;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
@@ -595,7 +595,7 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
             // - from/to bits (https://github.com/rust-lang/rust/issues/73736)
             // - dereferencing raw pointers (https://github.com/rust-lang/rust/issues/51911)
             // - char conversions (https://github.com/rust-lang/rust/issues/89259)
-            let const_context = in_constant(cx, e.hir_id);
+            let const_context = is_in_const_context(cx);
 
             let (from_ty, from_ty_adjusted) = match cx.typeck_results().expr_adjustments(arg) {
                 [] => (cx.typeck_results().expr_ty(arg), false),
diff --git a/clippy_lints/src/transmute/transmute_null_to_fn.rs b/clippy_lints/src/transmute/transmute_null_to_fn.rs
index b26365e34ab94..7acf3be51fb7e 100644
--- a/clippy_lints/src/transmute/transmute_null_to_fn.rs
+++ b/clippy_lints/src/transmute/transmute_null_to_fn.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
 use rustc_hir::{Expr, ExprKind};
@@ -33,10 +33,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
         // Catching:
         // transmute over constants that resolve to `null`.
         ExprKind::Path(ref _qpath)
-            if matches!(
-                constant(cx, cx.typeck_results(), casts_peeled),
-                Some(Constant::RawPtr(0))
-            ) =>
+            if matches!(ConstEvalCtxt::new(cx).eval(casts_peeled), Some(Constant::RawPtr(0))) =>
         {
             lint_expr(cx, expr);
             true
diff --git a/clippy_lints/src/transmute/transmuting_null.rs b/clippy_lints/src/transmute/transmuting_null.rs
index 471bd44b5d5ee..544014bd32b30 100644
--- a/clippy_lints/src/transmute/transmuting_null.rs
+++ b/clippy_lints/src/transmute/transmuting_null.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::{is_integer_literal, is_path_diagnostic_item};
 use rustc_hir::{Expr, ExprKind};
@@ -17,7 +17,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
 
     // Catching transmute over constants that resolve to `null`.
     if let ExprKind::Path(ref _qpath) = arg.kind
-        && let Some(Constant::RawPtr(0)) = constant(cx, cx.typeck_results(), arg)
+        && let Some(Constant::RawPtr(0)) = ConstEvalCtxt::new(cx).eval(arg)
     {
         span_lint(cx, TRANSMUTING_NULL, expr.span, LINT_MSG);
         return true;
diff --git a/clippy_lints/src/types/borrowed_box.rs b/clippy_lints/src/types/borrowed_box.rs
index 83cc9f2d8df23..2fcfc71a8c768 100644
--- a/clippy_lints/src/types/borrowed_box.rs
+++ b/clippy_lints/src/types/borrowed_box.rs
@@ -48,15 +48,15 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
                 let inner_snippet = snippet(cx, inner.span, "..");
                 let suggestion = match &inner.kind {
                     TyKind::TraitObject(bounds, lt_bound, _) if bounds.len() > 1 || !lt_bound.is_elided() => {
-                        format!("&{ltopt}({})", &inner_snippet)
+                        format!("&{ltopt}({inner_snippet})")
                     },
                     TyKind::Path(qpath)
                         if get_bounds_if_impl_trait(cx, qpath, inner.hir_id)
                             .map_or(false, |bounds| bounds.len() > 1) =>
                     {
-                        format!("&{ltopt}({})", &inner_snippet)
+                        format!("&{ltopt}({inner_snippet})")
                     },
-                    _ => format!("&{ltopt}{}", &inner_snippet),
+                    _ => format!("&{ltopt}{inner_snippet}"),
                 };
                 span_lint_and_sugg(
                     cx,
@@ -82,16 +82,14 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, lt: &Lifetime, m
 // Returns true if given type is `Any` trait.
 fn is_any_trait(cx: &LateContext<'_>, t: &hir::Ty<'_>) -> bool {
     if let TyKind::TraitObject(traits, ..) = t.kind {
-        return traits
-            .iter()
-            .any(|(bound, _)| {
-                if let Some(trait_did) = bound.trait_ref.trait_def_id()
-                    && cx.tcx.is_diagnostic_item(sym::Any, trait_did)
-                {
-                    return true;
-                }
-                false
-            });
+        return traits.iter().any(|(bound, _)| {
+            if let Some(trait_did) = bound.trait_ref.trait_def_id()
+                && cx.tcx.is_diagnostic_item(sym::Any, trait_did)
+            {
+                return true;
+            }
+            false
+        });
     }
 
     false
diff --git a/clippy_lints/src/types/rc_buffer.rs b/clippy_lints/src/types/rc_buffer.rs
index f6c2d8d5a5ed9..d691f1878b11b 100644
--- a/clippy_lints/src/types/rc_buffer.rs
+++ b/clippy_lints/src/types/rc_buffer.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_errors::Applicability;
@@ -13,14 +13,15 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
     let app = Applicability::Unspecified;
     if cx.tcx.is_diagnostic_item(sym::Rc, def_id) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
-            span_lint_and_sugg(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 RC_BUFFER,
                 hir_ty.span,
                 "usage of `Rc<T>` when T is a buffer type",
-                "try",
-                format!("Rc<{alternate}>"),
-                app,
+                |diag| {
+                    diag.span_suggestion(hir_ty.span, "try", format!("Rc<{alternate}>"), app);
+                },
             );
         } else {
             let Some(ty) = qpath_generic_tys(qpath).next() else {
@@ -35,31 +36,37 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 Some(ty) => ty.span,
                 None => return false,
             };
-            let mut applicability = app;
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 RC_BUFFER,
                 hir_ty.span,
                 "usage of `Rc<T>` when T is a buffer type",
-                "try",
-                format!(
-                    "Rc<[{}]>",
-                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-                ),
-                app,
+                |diag| {
+                    let mut applicability = app;
+                    diag.span_suggestion(
+                        hir_ty.span,
+                        "try",
+                        format!(
+                            "Rc<[{}]>",
+                            snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                        ),
+                        app,
+                    );
+                },
             );
             return true;
         }
     } else if cx.tcx.is_diagnostic_item(sym::Arc, def_id) {
         if let Some(alternate) = match_buffer_type(cx, qpath) {
-            span_lint_and_sugg(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 RC_BUFFER,
                 hir_ty.span,
                 "usage of `Arc<T>` when T is a buffer type",
-                "try",
-                format!("Arc<{alternate}>"),
-                app,
+                |diag| {
+                    diag.span_suggestion(hir_ty.span, "try", format!("Arc<{alternate}>"), app);
+                },
             );
         } else if let Some(ty) = qpath_generic_tys(qpath).next() {
             let Some(id) = path_def_id(cx, ty) else { return false };
@@ -71,18 +78,23 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
                 Some(ty) => ty.span,
                 None => return false,
             };
-            let mut applicability = app;
-            span_lint_and_sugg(
+            span_lint_and_then(
                 cx,
                 RC_BUFFER,
                 hir_ty.span,
                 "usage of `Arc<T>` when T is a buffer type",
-                "try",
-                format!(
-                    "Arc<[{}]>",
-                    snippet_with_applicability(cx, inner_span, "..", &mut applicability)
-                ),
-                app,
+                |diag| {
+                    let mut applicability = app;
+                    diag.span_suggestion(
+                        hir_ty.span,
+                        "try",
+                        format!(
+                            "Arc<[{}]>",
+                            snippet_with_applicability(cx, inner_span, "..", &mut applicability)
+                        ),
+                        app,
+                    );
+                },
             );
             return true;
         }
diff --git a/clippy_lints/src/types/rc_mutex.rs b/clippy_lints/src/types/rc_mutex.rs
index afc319217042f..7b13debc01ef8 100644
--- a/clippy_lints/src/types/rc_mutex.rs
+++ b/clippy_lints/src/types/rc_mutex.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{path_def_id, qpath_generic_tys};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{self as hir, QPath};
@@ -13,14 +13,10 @@ pub(super) fn check(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, qpath: &QPath<'_
         && let Some(id) = path_def_id(cx, arg)
         && cx.tcx.is_diagnostic_item(sym::Mutex, id)
     {
-        span_lint_and_help(
-            cx,
-            RC_MUTEX,
-            hir_ty.span,
-            "usage of `Rc<Mutex<_>>`",
-            None,
-            "consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead",
-        );
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(cx, RC_MUTEX, hir_ty.span, "usage of `Rc<Mutex<_>>`", |diag| {
+            diag.help("consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead");
+        });
         return true;
     }
 
diff --git a/clippy_lints/src/undocumented_unsafe_blocks.rs b/clippy_lints/src/undocumented_unsafe_blocks.rs
index 3ab30bf5dba7d..f51c5f74d9930 100644
--- a/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -1,7 +1,7 @@
 use std::ops::ControlFlow;
 
 use clippy_config::Conf;
-use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_lint_allowed;
 use clippy_utils::source::walk_span_to_context;
 use clippy_utils::visitors::{for_each_expr, Descend};
@@ -129,13 +129,15 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
                 block.span
             };
 
-            span_lint_and_help(
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
                 cx,
                 UNDOCUMENTED_UNSAFE_BLOCKS,
                 span,
                 "unsafe block missing a safety comment",
-                None,
-                "consider adding a safety comment on the preceding line",
+                |diag| {
+                    diag.help("consider adding a safety comment on the preceding line");
+                },
             );
         }
 
@@ -145,13 +147,14 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
             && let HasSafetyComment::Yes(pos) = stmt_has_safety_comment(cx, tail.span, tail.hir_id)
             && let Some(help_span) = expr_has_unnecessary_safety_comment(cx, tail, pos)
         {
-            span_lint_and_help(
+            span_lint_and_then(
                 cx,
                 UNNECESSARY_SAFETY_COMMENT,
                 tail.span,
                 "expression has unnecessary safety comment",
-                Some(help_span),
-                "consider removing the safety comment",
+                |diag| {
+                    diag.span_help(help_span, "consider removing the safety comment");
+                },
             );
         }
     }
@@ -168,13 +171,14 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
             && let HasSafetyComment::Yes(pos) = stmt_has_safety_comment(cx, stmt.span, stmt.hir_id)
             && let Some(help_span) = expr_has_unnecessary_safety_comment(cx, expr, pos)
         {
-            span_lint_and_help(
+            span_lint_and_then(
                 cx,
                 UNNECESSARY_SAFETY_COMMENT,
                 stmt.span,
                 "statement has unnecessary safety comment",
-                Some(help_span),
-                "consider removing the safety comment",
+                |diag| {
+                    diag.span_help(help_span, "consider removing the safety comment");
+                },
             );
         }
     }
@@ -210,13 +214,15 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
                         item.span
                     };
 
-                    span_lint_and_help(
+                    #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                    span_lint_and_then(
                         cx,
                         UNDOCUMENTED_UNSAFE_BLOCKS,
                         span,
                         "unsafe impl missing a safety comment",
-                        None,
-                        "consider adding a safety comment on the preceding line",
+                        |diag| {
+                            diag.help("consider adding a safety comment on the preceding line");
+                        },
                     );
                 }
             },
@@ -225,13 +231,14 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
                 if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
                     let (span, help_span) = mk_spans(pos);
 
-                    span_lint_and_help(
+                    span_lint_and_then(
                         cx,
                         UNNECESSARY_SAFETY_COMMENT,
                         span,
                         "impl has unnecessary safety comment",
-                        Some(help_span),
-                        "consider removing the safety comment",
+                        |diag| {
+                            diag.span_help(help_span, "consider removing the safety comment");
+                        },
                     );
                 }
             },
@@ -246,13 +253,14 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
                     ) {
                         let (span, help_span) = mk_spans(pos);
 
-                        span_lint_and_help(
+                        span_lint_and_then(
                             cx,
                             UNNECESSARY_SAFETY_COMMENT,
                             span,
                             format!("{} has unnecessary safety comment", item.kind.descr()),
-                            Some(help_span),
-                            "consider removing the safety comment",
+                            |diag| {
+                                diag.span_help(help_span, "consider removing the safety comment");
+                            },
                         );
                     }
                 }
@@ -263,13 +271,14 @@ impl<'tcx> LateLintPass<'tcx> for UndocumentedUnsafeBlocks {
                 if !is_lint_allowed(cx, UNNECESSARY_SAFETY_COMMENT, item.hir_id()) {
                     let (span, help_span) = mk_spans(pos);
 
-                    span_lint_and_help(
+                    span_lint_and_then(
                         cx,
                         UNNECESSARY_SAFETY_COMMENT,
                         span,
                         format!("{} has unnecessary safety comment", item.kind.descr()),
-                        Some(help_span),
-                        "consider removing the safety comment",
+                        |diag| {
+                            diag.span_help(help_span, "consider removing the safety comment");
+                        },
                     );
                 }
             },
diff --git a/clippy_lints/src/unicode.rs b/clippy_lints/src/unicode.rs
index d42697b31d1f2..e1fc644e4ceeb 100644
--- a/clippy_lints/src/unicode.rs
+++ b/clippy_lints/src/unicode.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_lint_allowed;
 use clippy_utils::macros::span_is_local;
 use clippy_utils::source::snippet;
@@ -105,45 +105,51 @@ fn check_str(cx: &LateContext<'_>, span: Span, id: HirId) {
 
     let string = snippet(cx, span, "");
     if string.chars().any(|c| ['\u{200B}', '\u{ad}', '\u{2060}'].contains(&c)) {
-        span_lint_and_sugg(
-            cx,
-            INVISIBLE_CHARACTERS,
-            span,
-            "invisible character detected",
-            "consider replacing the string with",
-            string
-                .replace('\u{200B}', "\\u{200B}")
-                .replace('\u{ad}', "\\u{AD}")
-                .replace('\u{2060}', "\\u{2060}"),
-            Applicability::MachineApplicable,
-        );
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(cx, INVISIBLE_CHARACTERS, span, "invisible character detected", |diag| {
+            diag.span_suggestion(
+                span,
+                "consider replacing the string with",
+                string
+                    .replace('\u{200B}', "\\u{200B}")
+                    .replace('\u{ad}', "\\u{AD}")
+                    .replace('\u{2060}', "\\u{2060}"),
+                Applicability::MachineApplicable,
+            );
+        });
     }
 
     if string.chars().any(|c| c as u32 > 0x7F) {
-        span_lint_and_sugg(
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(
             cx,
             NON_ASCII_LITERAL,
             span,
             "literal non-ASCII character detected",
-            "consider replacing the string with",
-            if is_lint_allowed(cx, UNICODE_NOT_NFC, id) {
-                escape(string.chars())
-            } else {
-                escape(string.nfc())
+            |diag| {
+                diag.span_suggestion(
+                    span,
+                    "consider replacing the string with",
+                    if is_lint_allowed(cx, UNICODE_NOT_NFC, id) {
+                        escape(string.chars())
+                    } else {
+                        escape(string.nfc())
+                    },
+                    Applicability::MachineApplicable,
+                );
             },
-            Applicability::MachineApplicable,
         );
     }
 
     if is_lint_allowed(cx, NON_ASCII_LITERAL, id) && string.chars().zip(string.nfc()).any(|(a, b)| a != b) {
-        span_lint_and_sugg(
-            cx,
-            UNICODE_NOT_NFC,
-            span,
-            "non-NFC Unicode sequence detected",
-            "consider replacing the string with",
-            string.nfc().collect::<String>(),
-            Applicability::MachineApplicable,
-        );
+        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+        span_lint_and_then(cx, UNICODE_NOT_NFC, span, "non-NFC Unicode sequence detected", |diag| {
+            diag.span_suggestion(
+                span,
+                "consider replacing the string with",
+                string.nfc().collect::<String>(),
+                Applicability::MachineApplicable,
+            );
+        });
     }
 }
diff --git a/clippy_lints/src/unused_result_ok.rs b/clippy_lints/src/unused_result_ok.rs
new file mode 100644
index 0000000000000..297288db0a56b
--- /dev/null
+++ b/clippy_lints/src/unused_result_ok.rs
@@ -0,0 +1,59 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_with_context;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_errors::Applicability;
+use rustc_hir::{ExprKind, Stmt, StmtKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_middle::lint::in_external_macro;
+use rustc_session::declare_lint_pass;
+use rustc_span::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for calls to `Result::ok()` without using the returned `Option`.
+    ///
+    /// ### Why is this bad?
+    /// Using `Result::ok()` may look like the result is checked like `unwrap` or `expect` would do
+    /// but it only silences the warning caused by `#[must_use]` on the `Result`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # fn some_function() -> Result<(), ()> { Ok(()) }
+    /// some_function().ok();
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # fn some_function() -> Result<(), ()> { Ok(()) }
+    /// let _ = some_function();
+    /// ```
+    #[clippy::version = "1.70.0"]
+    pub UNUSED_RESULT_OK,
+    restriction,
+    "Use of `.ok()` to silence `Result`'s `#[must_use]` is misleading. Use `let _ =` instead."
+}
+declare_lint_pass!(UnusedResultOk => [UNUSED_RESULT_OK]);
+
+impl LateLintPass<'_> for UnusedResultOk {
+    fn check_stmt(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) {
+        if let StmtKind::Semi(expr) = stmt.kind
+            && let ExprKind::MethodCall(ok_path, recv, [], ..) = expr.kind //check is expr.ok() has type Result<T,E>.ok(, _)
+            && ok_path.ident.as_str() == "ok"
+            && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result)
+            && !in_external_macro(cx.sess(), stmt.span)
+        {
+            let ctxt = expr.span.ctxt();
+            let mut applicability = Applicability::MaybeIncorrect;
+            let snippet = snippet_with_context(cx, recv.span, ctxt, "", &mut applicability).0;
+            let sugg = format!("let _ = {snippet}");
+            span_lint_and_sugg(
+                cx,
+                UNUSED_RESULT_OK,
+                expr.span,
+                "ignoring a result with `.ok()` is misleading",
+                "consider using `let _ =` and removing the call to `.ok()` instead",
+                sugg,
+                applicability,
+            );
+        }
+    }
+}
diff --git a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
index b017a6bf665c5..7c2e23995c1d3 100644
--- a/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
+++ b/clippy_lints/src/utils/internal_lints/interning_defined_symbol.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::match_type;
@@ -93,7 +93,7 @@ impl<'tcx> LateLintPass<'tcx> for InterningDefinedSymbol {
         if let ExprKind::Call(func, [arg]) = &expr.kind
             && let ty::FnDef(def_id, _) = cx.typeck_results().expr_ty(func).kind()
             && match_def_path(cx, *def_id, &paths::SYMBOL_INTERN)
-            && let Some(Constant::Str(arg)) = constant_simple(cx, cx.typeck_results(), arg)
+            && let Some(Constant::Str(arg)) = ConstEvalCtxt::new(cx).eval_simple(arg)
             && let value = Symbol::intern(&arg).as_u32()
             && let Some(&def_id) = self.symbol_map.get(&value)
         {
@@ -199,7 +199,7 @@ impl InterningDefinedSymbol {
             });
         }
         // is a string constant
-        if let Some(Constant::Str(s)) = constant_simple(cx, cx.typeck_results(), expr) {
+        if let Some(Constant::Str(s)) = ConstEvalCtxt::new(cx).eval_simple(expr) {
             let value = Symbol::intern(&s).as_u32();
             // ...which matches a symbol constant
             if let Some(&def_id) = self.symbol_map.get(&value) {
diff --git a/clippy_lints/src/utils/internal_lints/invalid_paths.rs b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
index 980437259c3e9..0ffcb433481e4 100644
--- a/clippy_lints/src/utils/internal_lints/invalid_paths.rs
+++ b/clippy_lints/src/utils/internal_lints/invalid_paths.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::def_path_res;
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir as hir;
@@ -32,9 +32,9 @@ impl<'tcx> LateLintPass<'tcx> for InvalidPaths {
         let mod_name = &cx.tcx.item_name(local_def_id.to_def_id());
         if mod_name.as_str() == "paths"
             && let hir::ItemKind::Const(.., body_id) = item.kind
-            && let body = cx.tcx.hir().body(body_id)
-            && let typeck_results = cx.tcx.typeck_body(body_id)
-            && let Some(Constant::Vec(path)) = constant_simple(cx, typeck_results, body.value)
+            && let Some(Constant::Vec(path)) =
+                ConstEvalCtxt::with_env(cx.tcx, cx.tcx.param_env(item.owner_id), cx.tcx.typeck(item.owner_id))
+                    .eval_simple(cx.tcx.hir().body(body_id).value)
             && let Some(path) = path
                 .iter()
                 .map(|x| {
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index 84f84781e7126..df342e48d637f 100644
--- a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -1,4 +1,3 @@
-use crate::utils::internal_lints::metadata_collector::is_deprecated_lint;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::{is_lint_allowed, match_def_path, paths};
@@ -87,82 +86,32 @@ declare_clippy_lint! {
     "found clippy lint without `clippy::version` attribute"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for cases of an auto-generated deprecated lint without an updated reason,
-    /// i.e. `"default deprecation note"`.
-    ///
-    /// ### Why is this bad?
-    /// Indicates that the documentation is incomplete.
-    ///
-    /// ### Example
-    /// ```rust,ignore
-    /// declare_deprecated_lint! {
-    ///     /// ### What it does
-    ///     /// Nothing. This lint has been deprecated.
-    ///     ///
-    ///     /// ### Deprecation reason
-    ///     /// TODO
-    ///     #[clippy::version = "1.63.0"]
-    ///     pub COOL_LINT,
-    ///     "default deprecation note"
-    /// }
-    /// ```
-    ///
-    /// Use instead:
-    /// ```rust,ignore
-    /// declare_deprecated_lint! {
-    ///     /// ### What it does
-    ///     /// Nothing. This lint has been deprecated.
-    ///     ///
-    ///     /// ### Deprecation reason
-    ///     /// This lint has been replaced by `cooler_lint`
-    ///     #[clippy::version = "1.63.0"]
-    ///     pub COOL_LINT,
-    ///     "this lint has been replaced by `cooler_lint`"
-    /// }
-    /// ```
-    pub DEFAULT_DEPRECATION_REASON,
-    internal,
-    "found 'default deprecation note' in a deprecated lint declaration"
-}
-
 #[derive(Clone, Debug, Default)]
 pub struct LintWithoutLintPass {
     declared_lints: FxHashMap<Symbol, Span>,
     registered_lints: FxHashSet<Symbol>,
 }
 
-impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE, DEFAULT_DEPRECATION_REASON]);
+impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE]);
 
 impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
-        if is_lint_allowed(cx, DEFAULT_LINT, item.hir_id())
-            || is_lint_allowed(cx, DEFAULT_DEPRECATION_REASON, item.hir_id())
-        {
+        if is_lint_allowed(cx, DEFAULT_LINT, item.hir_id()) {
             return;
         }
 
         if let hir::ItemKind::Static(ty, Mutability::Not, body_id) = item.kind {
-            let is_lint_ref_ty = is_lint_ref_type(cx, ty);
-            if is_deprecated_lint(cx, ty) || is_lint_ref_ty {
+            if is_lint_ref_type(cx, ty) {
                 check_invalid_clippy_version_attribute(cx, item);
 
                 let expr = &cx.tcx.hir().body(body_id).value;
-                let fields;
-                if is_lint_ref_ty {
-                    if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind
-                        && let ExprKind::Struct(_, struct_fields, _) = inner_exp.kind
-                    {
-                        fields = struct_fields;
-                    } else {
-                        return;
-                    }
-                } else if let ExprKind::Struct(_, struct_fields, _) = expr.kind {
-                    fields = struct_fields;
+                let fields = if let ExprKind::AddrOf(_, _, inner_exp) = expr.kind
+                    && let ExprKind::Struct(_, struct_fields, _) = inner_exp.kind
+                {
+                    struct_fields
                 } else {
                     return;
-                }
+                };
 
                 let field = fields
                     .iter()
@@ -175,25 +124,15 @@ impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
                 }) = field.expr.kind
                 {
                     let sym_str = sym.as_str();
-                    if is_lint_ref_ty {
-                        if sym_str == "default lint description" {
-                            span_lint(
-                                cx,
-                                DEFAULT_LINT,
-                                item.span,
-                                format!("the lint `{}` has the default lint description", item.ident.name),
-                            );
-                        }
-
-                        self.declared_lints.insert(item.ident.name, item.span);
-                    } else if sym_str == "default deprecation note" {
+                    if sym_str == "default lint description" {
                         span_lint(
                             cx,
-                            DEFAULT_DEPRECATION_REASON,
+                            DEFAULT_LINT,
                             item.span,
-                            format!("the lint `{}` has the default deprecation reason", item.ident.name),
+                            format!("the lint `{}` has the default lint description", item.ident.name),
                         );
                     }
+                    self.declared_lints.insert(item.ident.name, item.span);
                 }
             }
         } else if let Some(macro_call) = root_macro_call_first_node(cx, item) {
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 1c149f2045629..57f45aa3e4851 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -7,13 +7,12 @@
 //! during any comparison or mapping. (Please take care of this, it's not fun to spend time on such
 //! a simple mistake)
 
-use crate::renamed_lints::RENAMED_LINTS;
 use crate::utils::internal_lints::lint_without_lint_pass::{extract_clippy_version_value, is_lint_ref_type};
 use clippy_config::{get_configuration_metadata, ClippyConfiguration};
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
-use clippy_utils::{last_path_segment, match_def_path, match_function_call, match_path, paths};
+use clippy_utils::{last_path_segment, match_function_call, match_path, paths};
 use itertools::Itertools;
 use rustc_ast as ast;
 use rustc_data_structures::fx::FxHashMap;
@@ -85,11 +84,6 @@ const SUGGESTION_DIAG_METHODS: [(&str, bool); 9] = [
     ("tool_only_multipart_suggestion", true),
     ("span_suggestions", true),
 ];
-const SUGGESTION_FUNCTIONS: [&[&str]; 2] = [
-    &["clippy_utils", "diagnostics", "multispan_sugg"],
-    &["clippy_utils", "diagnostics", "multispan_sugg_with_applicability"],
-];
-const DEPRECATED_LINT_TYPE: [&str; 3] = ["clippy_lints", "deprecated_lints", "ClippyDeprecatedLint"];
 
 /// The index of the applicability name of `paths::APPLICABILITY_VALUES`
 const APPLICABILITY_NAME_INDEX: usize = 2;
@@ -165,9 +159,9 @@ impl MetadataCollector {
     fn get_lint_configs(&self, lint_name: &str) -> Option<String> {
         self.config
             .iter()
-            .filter(|config| config.lints.iter().any(|lint| lint == lint_name))
+            .filter(|config| config.lints.iter().any(|&lint| lint == lint_name))
             .map(ToString::to_string)
-            .reduce(|acc, x| acc + &x)
+            .reduce(|acc, x| acc + "\n\n" + &x)
             .map(|configurations| {
                 format!(
                     r#"
@@ -216,6 +210,13 @@ impl Drop for MetadataCollector {
 
         let mut applicability_info = std::mem::take(&mut self.applicability_info);
 
+        // Add deprecated lints
+        self.lints.extend(
+            crate::deprecated_lints::DEPRECATED
+                .iter()
+                .zip(crate::deprecated_lints::DEPRECATED_VERSION)
+                .filter_map(|((lint, reason), version)| LintMetadata::new_deprecated(lint, reason, version)),
+        );
         // Mapping the final data
         let mut lints = std::mem::take(&mut self.lints).into_sorted_vec();
         for x in &mut lints {
@@ -261,7 +262,7 @@ Please use that command to update the file and do not edit it by hand.
 #[derive(Debug, Clone, Serialize, PartialEq, Eq, PartialOrd, Ord)]
 struct LintMetadata {
     id: String,
-    id_span: SerializableSpan,
+    id_span: Option<SerializableSpan>,
     group: String,
     level: String,
     docs: String,
@@ -285,7 +286,7 @@ impl LintMetadata {
     ) -> Self {
         Self {
             id,
-            id_span,
+            id_span: Some(id_span),
             group,
             level: level.to_string(),
             version,
@@ -294,6 +295,29 @@ impl LintMetadata {
             former_ids: BTreeSet::new(),
         }
     }
+
+    fn new_deprecated(name: &str, reason: &str, version: &str) -> Option<Self> {
+        // The reason starts with a lowercase letter and end without a period.
+        // This needs to be fixed for the website.
+        let mut reason = reason.to_owned();
+        if let Some(reason) = reason.get_mut(0..1) {
+            reason.make_ascii_uppercase();
+        }
+        name.strip_prefix("clippy::").map(|name| Self {
+            id: name.into(),
+            id_span: None,
+            group: DEPRECATED_LINT_GROUP_STR.into(),
+            level: DEPRECATED_LINT_LEVEL.into(),
+            version: version.into(),
+            docs: format!(
+                "### What it does\n\n\
+                Nothing. This lint has been deprecated\n\n\
+                ### Deprecation reason\n\n{reason}.\n",
+            ),
+            applicability: None,
+            former_ids: BTreeSet::new(),
+        })
+    }
 }
 
 fn replace_produces(lint_name: &str, docs: &mut String, clippy_project_root: &Path) {
@@ -564,24 +588,6 @@ impl<'hir> LateLintPass<'hir> for MetadataCollector {
                     raw_docs,
                 ));
             }
-
-            if is_deprecated_lint(cx, ty)
-                // disallow check
-                && let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase()
-                // Metadata the little we can get from a deprecated lint
-                && let Some(raw_docs) = extract_attr_docs_or_lint(cx, item)
-            {
-                let version = get_lint_version(cx, item);
-
-                self.lints.push(LintMetadata::new(
-                    lint_name,
-                    SerializableSpan::from_item(cx, item),
-                    DEPRECATED_LINT_GROUP_STR.to_string(),
-                    DEPRECATED_LINT_LEVEL,
-                    version,
-                    raw_docs,
-                ));
-            }
         }
     }
 
@@ -684,6 +690,11 @@ fn cleanup_docs(docs_collection: &Vec<String>) -> String {
                     .find(|&s| !matches!(s, "" | "ignore" | "no_run" | "should_panic"))
                     // if no language is present, fill in "rust"
                     .unwrap_or("rust");
+                let len_diff = line.len() - line.trim_start().len();
+                if len_diff != 0 {
+                    // We put back the indentation.
+                    docs.push_str(&line[..len_diff]);
+                }
                 docs.push_str("```");
                 docs.push_str(lang);
 
@@ -766,16 +777,6 @@ fn get_lint_level_from_group(lint_group: &str) -> Option<&'static str> {
         .find_map(|(group_name, group_level)| (*group_name == lint_group).then_some(*group_level))
 }
 
-pub(super) fn is_deprecated_lint(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
-    if let hir::TyKind::Path(ref path) = ty.kind {
-        if let hir::def::Res::Def(DefKind::Struct, def_id) = cx.qpath_res(path, ty.hir_id) {
-            return match_def_path(cx, def_id, &DEPRECATED_LINT_TYPE);
-        }
-    }
-
-    false
-}
-
 fn collect_renames(lints: &mut Vec<LintMetadata>) {
     for lint in lints {
         let mut collected = String::new();
@@ -783,7 +784,7 @@ fn collect_renames(lints: &mut Vec<LintMetadata>) {
 
         loop {
             if let Some(lint_name) = names.pop() {
-                for (k, v) in RENAMED_LINTS {
+                for (k, v) in crate::deprecated_lints::RENAMED {
                     if let Some(name) = v.strip_prefix(CLIPPY_LINT_GROUP_PREFIX)
                         && name == lint_name
                         && let Some(past_name) = k.strip_prefix(CLIPPY_LINT_GROUP_PREFIX)
@@ -1055,33 +1056,21 @@ impl<'a, 'hir> Visitor<'hir> for IsMultiSpanScanner<'a, 'hir> {
             return;
         }
 
-        match &expr.kind {
-            ExprKind::Call(fn_expr, _args) => {
-                let found_function = SUGGESTION_FUNCTIONS
-                    .iter()
-                    .any(|func_path| match_function_call(self.cx, fn_expr, func_path).is_some());
-                if found_function {
-                    // These functions are all multi part suggestions
-                    self.add_single_span_suggestion();
-                }
-            },
-            ExprKind::MethodCall(path, recv, _, _arg_span) => {
-                let (self_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(recv));
-                if match_type(self.cx, self_ty, &paths::DIAG) {
-                    let called_method = path.ident.name.as_str().to_string();
-                    for (method_name, is_multi_part) in &SUGGESTION_DIAG_METHODS {
-                        if *method_name == called_method {
-                            if *is_multi_part {
-                                self.add_multi_part_suggestion();
-                            } else {
-                                self.add_single_span_suggestion();
-                            }
-                            break;
+        if let ExprKind::MethodCall(path, recv, _, _arg_span) = &expr.kind {
+            let (self_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(recv));
+            if match_type(self.cx, self_ty, &paths::DIAG) {
+                let called_method = path.ident.name.as_str().to_string();
+                for (method_name, is_multi_part) in &SUGGESTION_DIAG_METHODS {
+                    if *method_name == called_method {
+                        if *is_multi_part {
+                            self.add_multi_part_suggestion();
+                        } else {
+                            self.add_single_span_suggestion();
                         }
+                        break;
                     }
                 }
-            },
-            _ => {},
+            }
         }
 
         intravisit::walk_expr(self, expr);
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index a831234906bfc..228db14d1b7c3 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -3,7 +3,7 @@ use std::ops::ControlFlow;
 
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
-use clippy_utils::consts::{constant, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::source::snippet_opt;
 use clippy_utils::ty::is_copy;
@@ -159,7 +159,7 @@ impl UselessVec {
 
         let snippet = match *vec_args {
             higher::VecArgs::Repeat(elem, len) => {
-                if let Some(Constant::Int(len_constant)) = constant(cx, cx.typeck_results(), len) {
+                if let Some(Constant::Int(len_constant)) = ConstEvalCtxt::new(cx).eval(len) {
                     // vec![ty; N] works when ty is Clone, [ty; N] requires it to be Copy also
                     if !is_copy(cx, cx.typeck_results().expr_ty(elem)) {
                         return;
diff --git a/clippy_lints/src/visibility.rs b/clippy_lints/src/visibility.rs
index 11dcceca7abb1..63f3a5d7f8305 100644
--- a/clippy_lints/src/visibility.rs
+++ b/clippy_lints/src/visibility.rs
@@ -1,4 +1,4 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{Item, VisibilityKind};
 use rustc_errors::Applicability;
@@ -85,14 +85,19 @@ impl EarlyLintPass for Visibility {
             if **path == kw::SelfLower
                 && let Some(false) = is_from_proc_macro(cx, item.vis.span)
             {
-                span_lint_and_sugg(
+                span_lint_and_then(
                     cx,
                     NEEDLESS_PUB_SELF,
                     item.vis.span,
                     format!("unnecessary `pub({}self)`", if *shorthand { "" } else { "in " }),
-                    "remove it",
-                    String::new(),
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        diag.span_suggestion_hidden(
+                            item.vis.span,
+                            "remove it",
+                            String::new(),
+                            Applicability::MachineApplicable,
+                        );
+                    },
                 );
             }
 
@@ -101,14 +106,20 @@ impl EarlyLintPass for Visibility {
                 && let [.., last] = &*path.segments
                 && let Some(false) = is_from_proc_macro(cx, item.vis.span)
             {
-                span_lint_and_sugg(
+                #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                span_lint_and_then(
                     cx,
                     PUB_WITHOUT_SHORTHAND,
                     item.vis.span,
                     "usage of `pub` with `in`",
-                    "remove it",
-                    format!("pub({})", last.ident),
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        diag.span_suggestion(
+                            item.vis.span,
+                            "remove it",
+                            format!("pub({})", last.ident),
+                            Applicability::MachineApplicable,
+                        );
+                    },
                 );
             }
 
@@ -116,14 +127,20 @@ impl EarlyLintPass for Visibility {
                 && let [.., last] = &*path.segments
                 && let Some(false) = is_from_proc_macro(cx, item.vis.span)
             {
-                span_lint_and_sugg(
+                #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+                span_lint_and_then(
                     cx,
                     PUB_WITH_SHORTHAND,
                     item.vis.span,
                     "usage of `pub` without `in`",
-                    "add it",
-                    format!("pub(in {})", last.ident),
-                    Applicability::MachineApplicable,
+                    |diag| {
+                        diag.span_suggestion(
+                            item.vis.span,
+                            "add it",
+                            format!("pub(in {})", last.ident),
+                            Applicability::MachineApplicable,
+                        );
+                    },
                 );
             }
         }
diff --git a/clippy_lints/src/zero_div_zero.rs b/clippy_lints/src/zero_div_zero.rs
index 60d8a13d3599d..5eb207a0aedb0 100644
--- a/clippy_lints/src/zero_div_zero.rs
+++ b/clippy_lints/src/zero_div_zero.rs
@@ -1,4 +1,4 @@
-use clippy_utils::consts::{constant_simple, Constant};
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -36,8 +36,9 @@ impl<'tcx> LateLintPass<'tcx> for ZeroDiv {
             // TODO - constant_simple does not fold many operations involving floats.
             // That's probably fine for this lint - it's pretty unlikely that someone would
             // do something like 0.0/(2.0 - 2.0), but it would be nice to warn on that case too.
-            && let Some(lhs_value) = constant_simple(cx, cx.typeck_results(), left)
-            && let Some(rhs_value) = constant_simple(cx, cx.typeck_results(), right)
+            && let ecx = ConstEvalCtxt::new(cx)
+            && let Some(lhs_value) = ecx.eval_simple(left)
+            && let Some(rhs_value) = ecx.eval_simple(right)
             // FIXME(f16_f128): add these types when eq is available on all platforms
             && (Constant::F32(0.0) == lhs_value || Constant::F64(0.0) == lhs_value)
             && (Constant::F32(0.0) == rhs_value || Constant::F64(0.0) == rhs_value)
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index f0c64fdd573ca..9fefd94d339be 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -12,9 +12,6 @@ rustc-semver = "1.1"
 # FIXME(f16_f128): remove when no longer needed for parsing
 rustc_apfloat = "0.2.0"
 
-[features]
-deny-warnings = ["clippy_config/deny-warnings"]
-
 [package.metadata.rust-analyzer]
 # This crate uses #[feature(rustc_private)]
 rustc_private = true
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index de6ccfe476fb0..e907e4058e5a2 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -14,12 +14,13 @@ use rustc_lexer::tokenize;
 use rustc_lint::LateContext;
 use rustc_middle::mir::interpret::{alloc_range, Scalar};
 use rustc_middle::mir::ConstValue;
-use rustc_middle::ty::{self, EarlyBinder, FloatTy, GenericArgsRef, IntTy, List, ScalarInt, Ty, TyCtxt, UintTy};
+use rustc_middle::ty::{self, FloatTy, IntTy, ParamEnv, ScalarInt, Ty, TyCtxt, TypeckResults, UintTy};
 use rustc_middle::{bug, mir, span_bug};
 use rustc_span::def_id::DefId;
-use rustc_span::symbol::{Ident, Symbol};
+use rustc_span::symbol::Ident;
 use rustc_span::{sym, SyntaxContext};
 use rustc_target::abi::Size;
+use std::cell::Cell;
 use std::cmp::Ordering;
 use std::hash::{Hash, Hasher};
 use std::iter;
@@ -263,10 +264,10 @@ impl<'tcx> Constant<'tcx> {
     }
 
     /// Returns the integer value or `None` if `self` or `val_type` is not integer type.
-    pub fn int_value(&self, cx: &LateContext<'_>, val_type: Ty<'_>) -> Option<FullInt> {
+    pub fn int_value(&self, tcx: TyCtxt<'_>, val_type: Ty<'_>) -> Option<FullInt> {
         if let Constant::Int(const_int) = *self {
             match *val_type.kind() {
-                ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
+                ty::Int(ity) => Some(FullInt::S(sext(tcx, const_int, ity))),
                 ty::Uint(_) => Some(FullInt::U(const_int)),
                 _ => None,
             }
@@ -322,6 +323,7 @@ pub fn lit_to_mir_constant<'tcx>(lit: &LitKind, ty: Option<Ty<'tcx>>) -> Constan
 }
 
 /// The source of a constant value.
+#[derive(Clone, Copy)]
 pub enum ConstantSource {
     /// The value is determined solely from the expression.
     Local,
@@ -331,54 +333,11 @@ pub enum ConstantSource {
     CoreConstant,
 }
 impl ConstantSource {
-    pub fn is_local(&self) -> bool {
+    pub fn is_local(self) -> bool {
         matches!(self, Self::Local)
     }
 }
 
-/// Attempts to check whether the expression is a constant representing an empty slice, str, array,
-/// etc…
-pub fn constant_is_empty(lcx: &LateContext<'_>, e: &Expr<'_>) -> Option<bool> {
-    ConstEvalLateContext::new(lcx, lcx.typeck_results()).expr_is_empty(e)
-}
-
-/// Attempts to evaluate the expression as a constant.
-pub fn constant<'tcx>(
-    lcx: &LateContext<'tcx>,
-    typeck_results: &ty::TypeckResults<'tcx>,
-    e: &Expr<'_>,
-) -> Option<Constant<'tcx>> {
-    ConstEvalLateContext::new(lcx, typeck_results).expr(e)
-}
-
-/// Attempts to evaluate the expression as a constant.
-pub fn constant_with_source<'tcx>(
-    lcx: &LateContext<'tcx>,
-    typeck_results: &ty::TypeckResults<'tcx>,
-    e: &Expr<'_>,
-) -> Option<(Constant<'tcx>, ConstantSource)> {
-    let mut ctxt = ConstEvalLateContext::new(lcx, typeck_results);
-    let res = ctxt.expr(e);
-    res.map(|x| (x, ctxt.source))
-}
-
-/// Attempts to evaluate an expression only if its value is not dependent on other items.
-pub fn constant_simple<'tcx>(
-    lcx: &LateContext<'tcx>,
-    typeck_results: &ty::TypeckResults<'tcx>,
-    e: &Expr<'_>,
-) -> Option<Constant<'tcx>> {
-    constant_with_source(lcx, typeck_results, e).and_then(|(c, s)| s.is_local().then_some(c))
-}
-
-pub fn constant_full_int<'tcx>(
-    lcx: &LateContext<'tcx>,
-    typeck_results: &ty::TypeckResults<'tcx>,
-    e: &Expr<'_>,
-) -> Option<FullInt> {
-    constant_simple(lcx, typeck_results, e)?.int_value(lcx, typeck_results.expr_ty(e))
-}
-
 #[derive(Copy, Clone, Debug, Eq)]
 pub enum FullInt {
     S(i128),
@@ -417,44 +376,87 @@ impl Ord for FullInt {
     }
 }
 
-pub struct ConstEvalLateContext<'a, 'tcx> {
-    lcx: &'a LateContext<'tcx>,
-    typeck_results: &'a ty::TypeckResults<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-    source: ConstantSource,
-    args: GenericArgsRef<'tcx>,
+/// The context required to evaluate a constant expression.
+///
+/// This is currently limited to constant folding and reading the value of named constants.
+pub struct ConstEvalCtxt<'tcx> {
+    tcx: TyCtxt<'tcx>,
+    param_env: ParamEnv<'tcx>,
+    typeck: &'tcx TypeckResults<'tcx>,
+    source: Cell<ConstantSource>,
 }
 
-impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
-    pub fn new(lcx: &'a LateContext<'tcx>, typeck_results: &'a ty::TypeckResults<'tcx>) -> Self {
+impl<'tcx> ConstEvalCtxt<'tcx> {
+    /// Creates the evaluation context from the lint context. This requires the lint context to be
+    /// in a body (i.e. `cx.enclosing_body.is_some()`).
+    pub fn new(cx: &LateContext<'tcx>) -> Self {
+        Self {
+            tcx: cx.tcx,
+            param_env: cx.param_env,
+            typeck: cx.typeck_results(),
+            source: Cell::new(ConstantSource::Local),
+        }
+    }
+
+    /// Creates an evaluation context.
+    pub fn with_env(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, typeck: &'tcx TypeckResults<'tcx>) -> Self {
         Self {
-            lcx,
-            typeck_results,
-            param_env: lcx.param_env,
-            source: ConstantSource::Local,
-            args: List::empty(),
+            tcx,
+            param_env,
+            typeck,
+            source: Cell::new(ConstantSource::Local),
+        }
+    }
+
+    /// Attempts to evaluate the expression and returns both the value and whether it's dependant on
+    /// other items.
+    pub fn eval_with_source(&self, e: &Expr<'_>) -> Option<(Constant<'tcx>, ConstantSource)> {
+        self.source.set(ConstantSource::Local);
+        self.expr(e).map(|c| (c, self.source.get()))
+    }
+
+    /// Attempts to evaluate the expression.
+    pub fn eval(&self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
+        self.expr(e)
+    }
+
+    /// Attempts to evaluate the expression without accessing other items.
+    pub fn eval_simple(&self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
+        match self.eval_with_source(e) {
+            Some((x, ConstantSource::Local)) => Some(x),
+            _ => None,
+        }
+    }
+
+    /// Attempts to evaluate the expression as an integer without accessing other items.
+    pub fn eval_full_int(&self, e: &Expr<'_>) -> Option<FullInt> {
+        match self.eval_with_source(e) {
+            Some((x, ConstantSource::Local)) => x.int_value(self.tcx, self.typeck.expr_ty(e)),
+            _ => None,
         }
     }
 
     /// Simple constant folding: Insert an expression, get a constant or none.
-    pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
+    fn expr(&self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
         match e.kind {
-            ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr(self.lcx.tcx.hir().body(body).value),
+            ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr(self.tcx.hir().body(body).value),
             ExprKind::DropTemps(e) => self.expr(e),
             ExprKind::Path(ref qpath) => {
-                let is_core_crate = if let Some(def_id) = self.lcx.qpath_res(qpath, e.hir_id()).opt_def_id() {
-                    self.lcx.tcx.crate_name(def_id.krate) == sym::core
+                let is_core_crate = if let Some(def_id) = self.typeck.qpath_res(qpath, e.hir_id()).opt_def_id() {
+                    self.tcx.crate_name(def_id.krate) == sym::core
                 } else {
                     false
                 };
-                self.fetch_path_and_apply(qpath, e.hir_id, self.typeck_results.expr_ty(e), |this, result| {
-                    let result = mir_to_const(this.lcx, result)?;
+                self.fetch_path_and_apply(qpath, e.hir_id, self.typeck.expr_ty(e), |self_, result| {
+                    let result = mir_to_const(self_.tcx, result)?;
                     // If source is already Constant we wouldn't want to override it with CoreConstant
-                    this.source = if is_core_crate && !matches!(this.source, ConstantSource::Constant) {
-                        ConstantSource::CoreConstant
-                    } else {
-                        ConstantSource::Constant
-                    };
+                    self_.source.set(
+                        if is_core_crate && !matches!(self_.source.get(), ConstantSource::Constant) {
+                            ConstantSource::CoreConstant
+                        } else {
+                            ConstantSource::Constant
+                        },
+                    );
                     Some(result)
                 })
             },
@@ -463,21 +465,21 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                 if is_direct_expn_of(e.span, "cfg").is_some() {
                     None
                 } else {
-                    Some(lit_to_mir_constant(&lit.node, self.typeck_results.expr_ty_opt(e)))
+                    Some(lit_to_mir_constant(&lit.node, self.typeck.expr_ty_opt(e)))
                 }
             },
             ExprKind::Array(vec) => self.multi(vec).map(Constant::Vec),
             ExprKind::Tup(tup) => self.multi(tup).map(Constant::Tuple),
             ExprKind::Repeat(value, _) => {
-                let n = match self.typeck_results.expr_ty(e).kind() {
-                    ty::Array(_, n) => n.try_eval_target_usize(self.lcx.tcx, self.lcx.param_env)?,
+                let n = match self.typeck.expr_ty(e).kind() {
+                    ty::Array(_, n) => n.try_eval_target_usize(self.tcx, self.param_env)?,
                     _ => span_bug!(e.span, "typeck error"),
                 };
                 self.expr(value).map(|v| Constant::Repeat(Box::new(v), n))
             },
             ExprKind::Unary(op, operand) => self.expr(operand).and_then(|o| match op {
-                UnOp::Not => self.constant_not(&o, self.typeck_results.expr_ty(e)),
-                UnOp::Neg => self.constant_negate(&o, self.typeck_results.expr_ty(e)),
+                UnOp::Not => self.constant_not(&o, self.typeck.expr_ty(e)),
+                UnOp::Neg => self.constant_negate(&o, self.typeck.expr_ty(e)),
                 UnOp::Deref => Some(if let Constant::Ref(r) = o { *r } else { o }),
             }),
             ExprKind::If(cond, then, ref otherwise) => self.ifthenelse(cond, then, *otherwise),
@@ -486,21 +488,16 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                 // We only handle a few const functions for now.
                 if args.is_empty()
                     && let ExprKind::Path(qpath) = &callee.kind
-                    && let res = self.typeck_results.qpath_res(qpath, callee.hir_id)
-                    && let Some(def_id) = res.opt_def_id()
-                    && let def_path = self.lcx.get_def_path(def_id)
-                    && let def_path = def_path.iter().take(4).map(Symbol::as_str).collect::<Vec<_>>()
-                    && let ["core", "num", int_impl, "max_value"] = *def_path
+                    && let Some(did) = self.typeck.qpath_res(qpath, callee.hir_id).opt_def_id()
                 {
-                    let value = match int_impl {
-                        "<impl i8>" => i8::MAX as u128,
-                        "<impl i16>" => i16::MAX as u128,
-                        "<impl i32>" => i32::MAX as u128,
-                        "<impl i64>" => i64::MAX as u128,
-                        "<impl i128>" => i128::MAX as u128,
-                        _ => return None,
-                    };
-                    Some(Constant::Int(value))
+                    match self.tcx.get_diagnostic_name(did) {
+                        Some(sym::i8_legacy_fn_max_value) => Some(Constant::Int(i8::MAX as u128)),
+                        Some(sym::i16_legacy_fn_max_value) => Some(Constant::Int(i16::MAX as u128)),
+                        Some(sym::i32_legacy_fn_max_value) => Some(Constant::Int(i32::MAX as u128)),
+                        Some(sym::i64_legacy_fn_max_value) => Some(Constant::Int(i64::MAX as u128)),
+                        Some(sym::i128_legacy_fn_max_value) => Some(Constant::Int(i128::MAX as u128)),
+                        _ => None,
+                    }
                 } else {
                     None
                 }
@@ -512,9 +509,9 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                 if let Some(Constant::Adt(constant)) = &self.expr(local_expr)
                     && let ty::Adt(adt_def, _) = constant.ty().kind()
                     && adt_def.is_struct()
-                    && let Some(desired_field) = field_of_struct(*adt_def, self.lcx, *constant, field)
+                    && let Some(desired_field) = field_of_struct(*adt_def, self.tcx, *constant, field)
                 {
-                    mir_to_const(self.lcx, desired_field)
+                    mir_to_const(self.tcx, desired_field)
                 } else {
                     result
                 }
@@ -526,21 +523,21 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
     /// Simple constant folding to determine if an expression is an empty slice, str, array, …
     /// `None` will be returned if the constness cannot be determined, or if the resolution
     /// leaves the local crate.
-    pub fn expr_is_empty(&mut self, e: &Expr<'_>) -> Option<bool> {
+    pub fn eval_is_empty(&self, e: &Expr<'_>) -> Option<bool> {
         match e.kind {
-            ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr_is_empty(self.lcx.tcx.hir().body(body).value),
-            ExprKind::DropTemps(e) => self.expr_is_empty(e),
+            ExprKind::ConstBlock(ConstBlock { body, .. }) => self.eval_is_empty(self.tcx.hir().body(body).value),
+            ExprKind::DropTemps(e) => self.eval_is_empty(e),
             ExprKind::Path(ref qpath) => {
                 if !self
-                    .typeck_results
+                    .typeck
                     .qpath_res(qpath, e.hir_id)
                     .opt_def_id()
                     .is_some_and(DefId::is_local)
                 {
                     return None;
                 }
-                self.fetch_path_and_apply(qpath, e.hir_id, self.typeck_results.expr_ty(e), |this, result| {
-                    mir_is_empty(this.lcx, result)
+                self.fetch_path_and_apply(qpath, e.hir_id, self.typeck.expr_ty(e), |self_, result| {
+                    mir_is_empty(self_.tcx, result)
                 })
             },
             ExprKind::Lit(lit) => {
@@ -556,8 +553,8 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
             },
             ExprKind::Array(vec) => self.multi(vec).map(|v| v.is_empty()),
             ExprKind::Repeat(..) => {
-                if let ty::Array(_, n) = self.typeck_results.expr_ty(e).kind() {
-                    Some(n.try_eval_target_usize(self.lcx.tcx, self.lcx.param_env)? == 0)
+                if let ty::Array(_, n) = self.typeck.expr_ty(e).kind() {
+                    Some(n.try_eval_target_usize(self.tcx, self.param_env)? == 0)
                 } else {
                     span_bug!(e.span, "typeck error");
                 }
@@ -574,8 +571,8 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
             Int(value) => {
                 let value = !value;
                 match *ty.kind() {
-                    ty::Int(ity) => Some(Int(unsext(self.lcx.tcx, value as i128, ity))),
-                    ty::Uint(ity) => Some(Int(clip(self.lcx.tcx, value, ity))),
+                    ty::Int(ity) => Some(Int(unsext(self.tcx, value as i128, ity))),
+                    ty::Uint(ity) => Some(Int(clip(self.tcx, value, ity))),
                     _ => None,
                 }
             },
@@ -590,7 +587,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                 let ty::Int(ity) = *ty.kind() else { return None };
                 let (min, _) = ity.min_max()?;
                 // sign extend
-                let value = sext(self.lcx.tcx, value, ity);
+                let value = sext(self.tcx, value, ity);
 
                 // Applying unary - to the most negative value of any signed integer type panics.
                 if value == min {
@@ -599,7 +596,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
 
                 let value = value.checked_neg()?;
                 // clear unused bits
-                Some(Int(unsext(self.lcx.tcx, value, ity)))
+                Some(Int(unsext(self.tcx, value, ity)))
             },
             F32(f) => Some(F32(-f)),
             F64(f) => Some(F64(-f)),
@@ -609,21 +606,21 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
 
     /// Create `Some(Vec![..])` of all constants, unless there is any
     /// non-constant part.
-    fn multi(&mut self, vec: &[Expr<'_>]) -> Option<Vec<Constant<'tcx>>> {
+    fn multi(&self, vec: &[Expr<'_>]) -> Option<Vec<Constant<'tcx>>> {
         vec.iter().map(|elem| self.expr(elem)).collect::<Option<_>>()
     }
 
     /// Lookup a possibly constant expression from an `ExprKind::Path` and apply a function on it.
-    fn fetch_path_and_apply<T, F>(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>, f: F) -> Option<T>
+    fn fetch_path_and_apply<T, F>(&self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>, f: F) -> Option<T>
     where
-        F: FnOnce(&mut Self, mir::Const<'tcx>) -> Option<T>,
+        F: FnOnce(&Self, mir::Const<'tcx>) -> Option<T>,
     {
-        let res = self.typeck_results.qpath_res(qpath, id);
+        let res = self.typeck.qpath_res(qpath, id);
         match res {
             Res::Def(DefKind::Const | DefKind::AssocConst, def_id) => {
                 // Check if this constant is based on `cfg!(..)`,
                 // which is NOT constant for our purposes.
-                if let Some(node) = self.lcx.tcx.hir().get_if_local(def_id)
+                if let Some(node) = self.tcx.hir().get_if_local(def_id)
                     && let Node::Item(Item {
                         kind: ItemKind::Const(.., body_id),
                         ..
@@ -632,20 +629,14 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                         kind: ExprKind::Lit(_),
                         span,
                         ..
-                    }) = self.lcx.tcx.hir_node(body_id.hir_id)
+                    }) = self.tcx.hir_node(body_id.hir_id)
                     && is_direct_expn_of(*span, "cfg").is_some()
                 {
                     return None;
                 }
 
-                let args = self.typeck_results.node_args(id);
-                let args = if self.args.is_empty() {
-                    args
-                } else {
-                    EarlyBinder::bind(args).instantiate(self.lcx.tcx, self.args)
-                };
+                let args = self.typeck.node_args(id);
                 let result = self
-                    .lcx
                     .tcx
                     .const_eval_resolve(self.param_env, mir::UnevaluatedConst::new(def_id, args), qpath.span())
                     .ok()
@@ -656,7 +647,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
         }
     }
 
-    fn index(&mut self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant<'tcx>> {
+    fn index(&self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant<'tcx>> {
         let lhs = self.expr(lhs);
         let index = self.expr(index);
 
@@ -685,8 +676,8 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
         }
     }
 
-    /// A block can only yield a constant if it only has one constant expression.
-    fn block(&mut self, block: &Block<'_>) -> Option<Constant<'tcx>> {
+    /// A block can only yield a constant if it has exactly one constant expression.
+    fn block(&self, block: &Block<'_>) -> Option<Constant<'tcx>> {
         if block.stmts.is_empty()
             && let Some(expr) = block.expr
         {
@@ -696,7 +687,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                 if let Some(expr_span) = walk_span_to_context(expr.span, span.ctxt)
                     && let expr_lo = expr_span.lo()
                     && expr_lo >= span.lo
-                    && let Some(src) = (span.lo..expr_lo).get_source_text(self.lcx)
+                    && let Some(src) = (span.lo..expr_lo).get_source_text(&self.tcx)
                     && let Some(src) = src.as_str()
                 {
                     use rustc_lexer::TokenKind::{BlockComment, LineComment, OpenBrace, Semi, Whitespace};
@@ -705,11 +696,11 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                         .filter(|t| !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi))
                         .eq([OpenBrace])
                     {
-                        self.source = ConstantSource::Constant;
+                        self.source.set(ConstantSource::Constant);
                     }
                 } else {
                     // Unable to access the source. Assume a non-local dependency.
-                    self.source = ConstantSource::Constant;
+                    self.source.set(ConstantSource::Constant);
                 }
             }
 
@@ -719,7 +710,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
         }
     }
 
-    fn ifthenelse(&mut self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant<'tcx>> {
+    fn ifthenelse(&self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant<'tcx>> {
         if let Some(Constant::Bool(b)) = self.expr(cond) {
             if b {
                 self.expr(then)
@@ -731,16 +722,16 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
         }
     }
 
-    fn binop(&mut self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant<'tcx>> {
+    fn binop(&self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant<'tcx>> {
         let l = self.expr(left)?;
         let r = self.expr(right);
         match (l, r) {
-            (Constant::Int(l), Some(Constant::Int(r))) => match *self.typeck_results.expr_ty_opt(left)?.kind() {
+            (Constant::Int(l), Some(Constant::Int(r))) => match *self.typeck.expr_ty_opt(left)?.kind() {
                 ty::Int(ity) => {
                     let (ty_min_value, _) = ity.min_max()?;
                     let bits = ity.bits();
-                    let l = sext(self.lcx.tcx, l, ity);
-                    let r = sext(self.lcx.tcx, r, ity);
+                    let l = sext(self.tcx, l, ity);
+                    let r = sext(self.tcx, r, ity);
 
                     // Using / or %, where the left-hand argument is the smallest integer of a signed integer type and
                     // the right-hand argument is -1 always panics, even with overflow-checks disabled
@@ -751,7 +742,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
                         return None;
                     }
 
-                    let zext = |n: i128| Constant::Int(unsext(self.lcx.tcx, n, ity));
+                    let zext = |n: i128| Constant::Int(unsext(self.tcx, n, ity));
                     match op.node {
                         // When +, * or binary - create a value greater than the maximum value, or less than
                         // the minimum value that can be stored, it panics.
@@ -845,7 +836,7 @@ impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
     }
 }
 
-pub fn mir_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Option<Constant<'tcx>> {
+pub fn mir_to_const<'tcx>(tcx: TyCtxt<'tcx>, result: mir::Const<'tcx>) -> Option<Constant<'tcx>> {
     let mir::Const::Val(val, _) = result else {
         // We only work on evaluated consts.
         return None;
@@ -863,13 +854,13 @@ pub fn mir_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) ->
             _ => None,
         },
         (_, ty::Ref(_, inner_ty, _)) if matches!(inner_ty.kind(), ty::Str) => {
-            let data = val.try_get_slice_bytes_for_diagnostics(lcx.tcx)?;
+            let data = val.try_get_slice_bytes_for_diagnostics(tcx)?;
             String::from_utf8(data.to_owned()).ok().map(Constant::Str)
         },
         (_, ty::Adt(adt_def, _)) if adt_def.is_struct() => Some(Constant::Adt(result)),
         (ConstValue::Indirect { alloc_id, offset }, ty::Array(sub_type, len)) => {
-            let alloc = lcx.tcx.global_alloc(alloc_id).unwrap_memory().inner();
-            let len = len.try_to_target_usize(lcx.tcx)?;
+            let alloc = tcx.global_alloc(alloc_id).unwrap_memory().inner();
+            let len = len.try_to_target_usize(tcx)?;
             let ty::Float(flt) = sub_type.kind() else {
                 return None;
             };
@@ -877,7 +868,7 @@ pub fn mir_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) ->
             let mut res = Vec::new();
             for idx in 0..len {
                 let range = alloc_range(offset + size * idx, size);
-                let val = alloc.read_scalar(&lcx.tcx, range, /* read_provenance */ false).ok()?;
+                let val = alloc.read_scalar(&tcx, range, /* read_provenance */ false).ok()?;
                 res.push(match flt {
                     FloatTy::F16 => Constant::F16(f16::from_bits(val.to_u16().ok()?)),
                     FloatTy::F32 => Constant::F32(f32::from_bits(val.to_u32().ok()?)),
@@ -891,7 +882,7 @@ pub fn mir_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) ->
     }
 }
 
-fn mir_is_empty<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Option<bool> {
+fn mir_is_empty<'tcx>(tcx: TyCtxt<'tcx>, result: mir::Const<'tcx>) -> Option<bool> {
     let mir::Const::Val(val, _) = result else {
         // We only work on evaluated consts.
         return None;
@@ -902,26 +893,26 @@ fn mir_is_empty<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Opti
                 if let ConstValue::Indirect { alloc_id, offset } = val {
                     // Get the length from the slice, using the same formula as
                     // [`ConstValue::try_get_slice_bytes_for_diagnostics`].
-                    let a = lcx.tcx.global_alloc(alloc_id).unwrap_memory().inner();
-                    let ptr_size = lcx.tcx.data_layout.pointer_size;
+                    let a = tcx.global_alloc(alloc_id).unwrap_memory().inner();
+                    let ptr_size = tcx.data_layout.pointer_size;
                     if a.size() < offset + 2 * ptr_size {
                         // (partially) dangling reference
                         return None;
                     }
                     let len = a
-                        .read_scalar(&lcx.tcx, alloc_range(offset + ptr_size, ptr_size), false)
+                        .read_scalar(&tcx, alloc_range(offset + ptr_size, ptr_size), false)
                         .ok()?
-                        .to_target_usize(&lcx.tcx)
+                        .to_target_usize(&tcx)
                         .ok()?;
                     Some(len == 0)
                 } else {
                     None
                 }
             },
-            ty::Array(_, len) => Some(len.try_to_target_usize(lcx.tcx)? == 0),
+            ty::Array(_, len) => Some(len.try_to_target_usize(tcx)? == 0),
             _ => None,
         },
-        (ConstValue::Indirect { .. }, ty::Array(_, len)) => Some(len.try_to_target_usize(lcx.tcx)? == 0),
+        (ConstValue::Indirect { .. }, ty::Array(_, len)) => Some(len.try_to_target_usize(tcx)? == 0),
         (ConstValue::ZeroSized, _) => Some(true),
         _ => None,
     }
@@ -929,12 +920,12 @@ fn mir_is_empty<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Opti
 
 fn field_of_struct<'tcx>(
     adt_def: ty::AdtDef<'tcx>,
-    lcx: &LateContext<'tcx>,
+    tcx: TyCtxt<'tcx>,
     result: mir::Const<'tcx>,
     field: &Ident,
 ) -> Option<mir::Const<'tcx>> {
     if let mir::Const::Val(result, ty) = result
-        && let Some(dc) = lcx.tcx.try_destructure_mir_constant_for_user_output(result, ty)
+        && let Some(dc) = tcx.try_destructure_mir_constant_for_user_output(result, ty)
         && let Some(dc_variant) = dc.variant
         && let Some(variant) = adt_def.variants().get(dc_variant)
         && let Some(field_idx) = variant.fields.iter().position(|el| el.name == field.name)
diff --git a/clippy_utils/src/diagnostics.rs b/clippy_utils/src/diagnostics.rs
index 0641d37cd9a67..4877fb65d37d7 100644
--- a/clippy_utils/src/diagnostics.rs
+++ b/clippy_utils/src/diagnostics.rs
@@ -330,32 +330,3 @@ pub fn span_lint_and_sugg<T: LintContext>(
         diag.span_suggestion(sp, help.into(), sugg, applicability);
     });
 }
-
-/// Create a suggestion made from several `span → replacement`.
-///
-/// Note: in the JSON format (used by `compiletest_rs`), the help message will
-/// appear once per
-/// replacement. In human-readable format though, it only appears once before
-/// the whole suggestion.
-pub fn multispan_sugg<I>(diag: &mut Diag<'_, ()>, help_msg: impl Into<SubdiagMessage>, sugg: I)
-where
-    I: IntoIterator<Item = (Span, String)>,
-{
-    multispan_sugg_with_applicability(diag, help_msg, Applicability::Unspecified, sugg);
-}
-
-/// Create a suggestion made from several `span → replacement`.
-///
-/// rustfix currently doesn't support the automatic application of suggestions with
-/// multiple spans. This is tracked in issue [rustfix#141](https://github.com/rust-lang/rustfix/issues/141).
-/// Suggestions with multiple spans will be silently ignored.
-pub fn multispan_sugg_with_applicability<I>(
-    diag: &mut Diag<'_, ()>,
-    help_msg: impl Into<SubdiagMessage>,
-    applicability: Applicability,
-    sugg: I,
-) where
-    I: IntoIterator<Item = (Span, String)>,
-{
-    diag.multipart_suggestion(help_msg.into(), sugg.into_iter().collect(), applicability);
-}
diff --git a/clippy_utils/src/eager_or_lazy.rs b/clippy_utils/src/eager_or_lazy.rs
index 6c40029a9de70..a6dd12a28c5bc 100644
--- a/clippy_utils/src/eager_or_lazy.rs
+++ b/clippy_utils/src/eager_or_lazy.rs
@@ -9,7 +9,7 @@
 //!  - or-fun-call
 //!  - option-if-let-else
 
-use crate::consts::{constant, FullInt};
+use crate::consts::{ConstEvalCtxt, FullInt};
 use crate::ty::{all_predicates_of, is_copy};
 use crate::visitors::is_const_evaluatable;
 use rustc_hir::def::{DefKind, Res};
@@ -206,7 +206,7 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
                 },
 
                 // `-i32::MIN` panics with overflow checks
-                ExprKind::Unary(UnOp::Neg, right) if constant(self.cx, self.cx.typeck_results(), right).is_none() => {
+                ExprKind::Unary(UnOp::Neg, right) if ConstEvalCtxt::new(self.cx).eval(right).is_none() => {
                     self.eagerness |= NoChange;
                 },
 
@@ -232,7 +232,7 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
                 // Thus, we would realistically only delay the lint.
                 ExprKind::Binary(op, _, right)
                     if matches!(op.node, BinOpKind::Shl | BinOpKind::Shr)
-                        && constant(self.cx, self.cx.typeck_results(), right).is_none() =>
+                        && ConstEvalCtxt::new(self.cx).eval(right).is_none() =>
                 {
                     self.eagerness |= NoChange;
                 },
@@ -240,9 +240,9 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
                 ExprKind::Binary(op, left, right)
                     if matches!(op.node, BinOpKind::Div | BinOpKind::Rem)
                         && let right_ty = self.cx.typeck_results().expr_ty(right)
-                        && let left = constant(self.cx, self.cx.typeck_results(), left)
-                        && let right = constant(self.cx, self.cx.typeck_results(), right)
-                            .and_then(|c| c.int_value(self.cx, right_ty))
+                        && let ecx = ConstEvalCtxt::new(self.cx)
+                        && let left = ecx.eval(left)
+                        && let right = ecx.eval(right).and_then(|c| c.int_value(self.cx.tcx, right_ty))
                         && matches!(
                             (left, right),
                             // `1 / x`: x might be zero
@@ -261,8 +261,8 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
                 ExprKind::Binary(op, left, right)
                     if matches!(op.node, BinOpKind::Add | BinOpKind::Sub | BinOpKind::Mul)
                         && !self.cx.typeck_results().expr_ty(e).is_floating_point()
-                        && (constant(self.cx, self.cx.typeck_results(), left).is_none()
-                            || constant(self.cx, self.cx.typeck_results(), right).is_none()) =>
+                        && let ecx = ConstEvalCtxt::new(self.cx)
+                        && (ecx.eval(left).is_none() || ecx.eval(right).is_none()) =>
                 {
                     self.eagerness |= NoChange;
                 },
diff --git a/clippy_utils/src/higher.rs b/clippy_utils/src/higher.rs
index 277ba8427e054..8970b4d122984 100644
--- a/clippy_utils/src/higher.rs
+++ b/clippy_utils/src/higher.rs
@@ -2,7 +2,7 @@
 
 #![deny(clippy::missing_docs_in_private_items)]
 
-use crate::consts::{constant_simple, Constant};
+use crate::consts::{ConstEvalCtxt, Constant};
 use crate::ty::is_type_diagnostic_item;
 use crate::{is_expn_of, match_def_path, paths};
 
@@ -25,6 +25,8 @@ pub struct ForLoop<'tcx> {
     pub loop_id: HirId,
     /// entire `for` loop span
     pub span: Span,
+    /// label
+    pub label: Option<ast::Label>,
 }
 
 impl<'tcx> ForLoop<'tcx> {
@@ -33,7 +35,7 @@ impl<'tcx> ForLoop<'tcx> {
         if let ExprKind::DropTemps(e) = expr.kind
             && let ExprKind::Match(iterexpr, [arm], MatchSource::ForLoopDesugar) = e.kind
             && let ExprKind::Call(_, [arg]) = iterexpr.kind
-            && let ExprKind::Loop(block, ..) = arm.body.kind
+            && let ExprKind::Loop(block, label, ..) = arm.body.kind
             && let [stmt] = block.stmts
             && let hir::StmtKind::Expr(e) = stmt.kind
             && let ExprKind::Match(_, [_, some_arm], _) = e.kind
@@ -45,6 +47,7 @@ impl<'tcx> ForLoop<'tcx> {
                 body: some_arm.body,
                 loop_id: arm.body.hir_id,
                 span: expr.span.ctxt().outer_expn_data().call_site,
+                label,
             });
         }
         None
@@ -367,6 +370,7 @@ pub struct WhileLet<'hir> {
     pub let_expr: &'hir Expr<'hir>,
     /// `while let` loop body
     pub if_then: &'hir Expr<'hir>,
+    pub label: Option<ast::Label>,
     /// `while let PAT = EXPR`
     ///        ^^^^^^^^^^^^^^
     pub let_span: Span,
@@ -399,7 +403,7 @@ impl<'hir> WhileLet<'hir> {
                     }),
                 ..
             },
-            _,
+            label,
             LoopSource::While,
             _,
         ) = expr.kind
@@ -408,6 +412,7 @@ impl<'hir> WhileLet<'hir> {
                 let_pat,
                 let_expr,
                 if_then,
+                label,
                 let_span,
             });
         }
@@ -466,7 +471,7 @@ pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -
                     return Some(VecInitKind::Default);
                 } else if name.ident.name.as_str() == "with_capacity" {
                     let arg = args.first()?;
-                    return match constant_simple(cx, cx.typeck_results(), arg) {
+                    return match ConstEvalCtxt::new(cx).eval_simple(arg) {
                         Some(Constant::Int(num)) => Some(VecInitKind::WithConstCapacity(num)),
                         _ => Some(VecInitKind::WithExprCapacity(arg.hir_id)),
                     };
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index 28178a61a9323..f325e4eaf1544 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1,4 +1,4 @@
-use crate::consts::constant_simple;
+use crate::consts::ConstEvalCtxt;
 use crate::macros::macro_backtrace;
 use crate::source::{snippet_opt, walk_span_to_context, SpanRange, SpanRangeExt};
 use crate::tokenize_with_text;
@@ -255,8 +255,8 @@ impl HirEqInterExpr<'_, '_, '_> {
         if let Some((typeck_lhs, typeck_rhs)) = self.inner.maybe_typeck_results
             && typeck_lhs.expr_ty(left) == typeck_rhs.expr_ty(right)
             && let (Some(l), Some(r)) = (
-                constant_simple(self.inner.cx, typeck_lhs, left),
-                constant_simple(self.inner.cx, typeck_rhs, right),
+                ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.param_env, typeck_lhs).eval_simple(left),
+                ConstEvalCtxt::with_env(self.inner.cx.tcx, self.inner.cx.param_env, typeck_rhs).eval_simple(right),
             )
             && l == r
         {
@@ -714,9 +714,9 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
 
     #[expect(clippy::too_many_lines)]
     pub fn hash_expr(&mut self, e: &Expr<'_>) {
-        let simple_const = self
-            .maybe_typeck_results
-            .and_then(|typeck_results| constant_simple(self.cx, typeck_results, e));
+        let simple_const = self.maybe_typeck_results.and_then(|typeck_results| {
+            ConstEvalCtxt::with_env(self.cx.tcx, self.cx.param_env, typeck_results).eval_simple(e)
+        });
 
         // const hashing may result in the same hash as some unrelated node, so add a sort of
         // discriminant depending on which path we're choosing next
diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index 1d5f1a2a2bb13..af74e4b67c162 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -10,7 +10,6 @@
 #![feature(assert_matches)]
 #![feature(unwrap_infallible)]
 #![recursion_limit = "512"]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![allow(
     clippy::missing_errors_doc,
     clippy::missing_panics_doc,
@@ -126,7 +125,7 @@ use rustc_span::{sym, Span};
 use rustc_target::abi::Integer;
 use visitors::Visitable;
 
-use crate::consts::{constant, mir_to_const, Constant};
+use crate::consts::{mir_to_const, ConstEvalCtxt, Constant};
 use crate::higher::Range;
 use crate::ty::{adt_and_variant_of_res, can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type};
 use crate::visitors::for_each_expr_without_closures;
@@ -211,20 +210,24 @@ pub fn local_is_initialized(cx: &LateContext<'_>, local: HirId) -> bool {
     false
 }
 
-/// Returns `true` if the given `HirId` is inside a constant context.
+/// Checks if we are currently in a const context (e.g. `const fn`, `static`/`const` initializer).
 ///
-/// This is the same as `is_inside_always_const_context`, but also includes
-/// `const fn`.
+/// The current context is determined based on the current body which is set before calling a lint's
+/// entry point (any function on `LateLintPass`). If you need to check in a different context use
+/// `tcx.hir().is_inside_const_context(_)`.
 ///
-/// # Example
-///
-/// ```rust,ignore
-/// if in_constant(cx, expr.hir_id) {
-///     // Do something
-/// }
-/// ```
-pub fn in_constant(cx: &LateContext<'_>, id: HirId) -> bool {
-    cx.tcx.hir().is_inside_const_context(id)
+/// Do not call this unless the `LateContext` has an enclosing body. For release build this case
+/// will safely return `false`, but debug builds will ICE. Note that `check_expr`, `check_block`,
+/// `check_pat` and a few other entry points will always have an enclosing body. Some entry points
+/// like `check_path` or `check_ty` may or may not have one.
+pub fn is_in_const_context(cx: &LateContext<'_>) -> bool {
+    debug_assert!(cx.enclosing_body.is_some(), "`LateContext` has no enclosing body");
+    cx.enclosing_body.is_some_and(|id| {
+        cx.tcx
+            .hir()
+            .body_const_context(cx.tcx.hir().body_owner_def_id(id))
+            .is_some()
+    })
 }
 
 /// Returns `true` if the given `HirId` is inside an always constant context.
@@ -589,9 +592,8 @@ fn find_primitive_impls<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<It
         "u128" => SimplifiedType::Uint(UintTy::U128),
         "f32" => SimplifiedType::Float(FloatTy::F32),
         "f64" => SimplifiedType::Float(FloatTy::F64),
-        #[allow(trivial_casts)]
         _ => {
-            return Result::<_, rustc_errors::ErrorGuaranteed>::Ok(&[] as &[_])
+            return Result::<&[_], rustc_errors::ErrorGuaranteed>::Ok(&[])
                 .into_iter()
                 .flatten()
                 .copied();
@@ -1579,8 +1581,8 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
             if let rustc_ty::Adt(_, subst) = ty.kind()
                 && let bnd_ty = subst.type_at(0)
                 && let Some(min_val) = bnd_ty.numeric_min_val(cx.tcx)
-                && let Some(min_const) = mir_to_const(cx, Const::from_ty_const(min_val, bnd_ty, cx.tcx))
-                && let Some(start_const) = constant(cx, cx.typeck_results(), start)
+                && let Some(min_const) = mir_to_const(cx.tcx, Const::from_ty_const(min_val, bnd_ty, cx.tcx))
+                && let Some(start_const) = ConstEvalCtxt::new(cx).eval(start)
             {
                 start_const == min_const
             } else {
@@ -1592,8 +1594,8 @@ pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Opti
                 if let rustc_ty::Adt(_, subst) = ty.kind()
                     && let bnd_ty = subst.type_at(0)
                     && let Some(max_val) = bnd_ty.numeric_max_val(cx.tcx)
-                    && let Some(max_const) = mir_to_const(cx, Const::from_ty_const(max_val, bnd_ty, cx.tcx))
-                    && let Some(end_const) = constant(cx, cx.typeck_results(), end)
+                    && let Some(max_const) = mir_to_const(cx.tcx, Const::from_ty_const(max_val, bnd_ty, cx.tcx))
+                    && let Some(end_const) = ConstEvalCtxt::new(cx).eval(end)
                 {
                     end_const == max_const
                 } else {
@@ -1624,7 +1626,9 @@ pub fn is_integer_const(cx: &LateContext<'_>, e: &Expr<'_>, value: u128) -> bool
         return true;
     }
     let enclosing_body = cx.tcx.hir().enclosing_body_owner(e.hir_id);
-    if let Some(Constant::Int(v)) = constant(cx, cx.tcx.typeck(enclosing_body), e) {
+    if let Some(Constant::Int(v)) =
+        ConstEvalCtxt::with_env(cx.tcx, cx.tcx.param_env(enclosing_body), cx.tcx.typeck(enclosing_body)).eval(e)
+    {
         return value == v;
     }
     false
diff --git a/clippy_utils/src/paths.rs b/clippy_utils/src/paths.rs
index d5a3d8b9e5a2e..684c645c19964 100644
--- a/clippy_utils/src/paths.rs
+++ b/clippy_utils/src/paths.rs
@@ -16,7 +16,6 @@ pub const BINARYHEAP_ITER: [&str; 5] = ["alloc", "collections", "binary_heap", "
 pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
 pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
 pub const BTREESET_ITER: [&str; 6] = ["alloc", "collections", "btree", "set", "BTreeSet", "iter"];
-pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
 pub const CORE_ITER_CLONED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "cloned"];
 pub const CORE_ITER_COPIED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "copied"];
 pub const CORE_ITER_FILTER: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "filter"];
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 496c8f5b55373..96dd3c55d37ae 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -6,7 +6,8 @@ use rustc_ast::{LitKind, StrStyle};
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::Applicability;
 use rustc_hir::{BlockCheckMode, Expr, ExprKind, UnsafeSource};
-use rustc_lint::{LateContext, LintContext};
+use rustc_lint::{EarlyContext, LateContext};
+use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_span::source_map::{original_sp, SourceMap};
 use rustc_span::{
@@ -17,6 +18,30 @@ use std::borrow::Cow;
 use std::fmt;
 use std::ops::Range;
 
+pub trait HasSession {
+    fn sess(&self) -> &Session;
+}
+impl HasSession for Session {
+    fn sess(&self) -> &Session {
+        self
+    }
+}
+impl HasSession for TyCtxt<'_> {
+    fn sess(&self) -> &Session {
+        self.sess
+    }
+}
+impl HasSession for EarlyContext<'_> {
+    fn sess(&self) -> &Session {
+        ::rustc_lint::LintContext::sess(self)
+    }
+}
+impl HasSession for LateContext<'_> {
+    fn sess(&self) -> &Session {
+        self.tcx.sess()
+    }
+}
+
 /// Conversion of a value into the range portion of a `Span`.
 pub trait SpanRange: Sized {
     fn into_range(self) -> Range<BytePos>;
@@ -71,19 +96,19 @@ impl IntoSpan for Range<BytePos> {
 pub trait SpanRangeExt: SpanRange {
     /// Gets the source file, and range in the file, of the given span. Returns `None` if the span
     /// extends through multiple files, or is malformed.
-    fn get_source_text(self, cx: &impl LintContext) -> Option<SourceFileRange> {
+    fn get_source_text(self, cx: &impl HasSession) -> Option<SourceFileRange> {
         get_source_text(cx.sess().source_map(), self.into_range())
     }
 
     /// Calls the given function with the source text referenced and returns the value. Returns
     /// `None` if the source text cannot be retrieved.
-    fn with_source_text<T>(self, cx: &impl LintContext, f: impl for<'a> FnOnce(&'a str) -> T) -> Option<T> {
+    fn with_source_text<T>(self, cx: &impl HasSession, f: impl for<'a> FnOnce(&'a str) -> T) -> Option<T> {
         with_source_text(cx.sess().source_map(), self.into_range(), f)
     }
 
     /// Checks if the referenced source text satisfies the given predicate. Returns `false` if the
     /// source text cannot be retrieved.
-    fn check_source_text(self, cx: &impl LintContext, pred: impl for<'a> FnOnce(&'a str) -> bool) -> bool {
+    fn check_source_text(self, cx: &impl HasSession, pred: impl for<'a> FnOnce(&'a str) -> bool) -> bool {
         self.with_source_text(cx, pred).unwrap_or(false)
     }
 
@@ -91,7 +116,7 @@ pub trait SpanRangeExt: SpanRange {
     /// and returns the value. Returns `None` if the source text cannot be retrieved.
     fn with_source_text_and_range<T>(
         self,
-        cx: &impl LintContext,
+        cx: &impl HasSession,
         f: impl for<'a> FnOnce(&'a str, Range<usize>) -> T,
     ) -> Option<T> {
         with_source_text_and_range(cx.sess().source_map(), self.into_range(), f)
@@ -104,30 +129,30 @@ pub trait SpanRangeExt: SpanRange {
     /// The new range must reside within the same source file.
     fn map_range(
         self,
-        cx: &impl LintContext,
+        cx: &impl HasSession,
         f: impl for<'a> FnOnce(&'a str, Range<usize>) -> Option<Range<usize>>,
     ) -> Option<Range<BytePos>> {
         map_range(cx.sess().source_map(), self.into_range(), f)
     }
 
     /// Extends the range to include all preceding whitespace characters.
-    fn with_leading_whitespace(self, cx: &impl LintContext) -> Range<BytePos> {
+    fn with_leading_whitespace(self, cx: &impl HasSession) -> Range<BytePos> {
         with_leading_whitespace(cx.sess().source_map(), self.into_range())
     }
 
     /// Trims the leading whitespace from the range.
-    fn trim_start(self, cx: &impl LintContext) -> Range<BytePos> {
+    fn trim_start(self, cx: &impl HasSession) -> Range<BytePos> {
         trim_start(cx.sess().source_map(), self.into_range())
     }
 
     /// Writes the referenced source text to the given writer. Will return `Err` if the source text
     /// could not be retrieved.
-    fn write_source_text_to(self, cx: &impl LintContext, dst: &mut impl fmt::Write) -> fmt::Result {
+    fn write_source_text_to(self, cx: &impl HasSession, dst: &mut impl fmt::Write) -> fmt::Result {
         write_source_text_to(cx.sess().source_map(), self.into_range(), dst)
     }
 
     /// Extracts the referenced source text as an owned string.
-    fn source_text_to_string(self, cx: &impl LintContext) -> Option<String> {
+    fn source_text_to_string(self, cx: &impl HasSession) -> Option<String> {
         self.with_source_text(cx, ToOwned::to_owned)
     }
 }
@@ -227,15 +252,15 @@ impl SourceFileRange {
 }
 
 /// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
-pub fn expr_block<T: LintContext>(
-    cx: &T,
+pub fn expr_block(
+    sess: &impl HasSession,
     expr: &Expr<'_>,
     outer: SyntaxContext,
     default: &str,
     indent_relative_to: Option<Span>,
     app: &mut Applicability,
 ) -> String {
-    let (code, from_macro) = snippet_block_with_context(cx, expr.span, outer, default, indent_relative_to, app);
+    let (code, from_macro) = snippet_block_with_context(sess, expr.span, outer, default, indent_relative_to, app);
     if !from_macro
         && let ExprKind::Block(block, _) = expr.kind
         && block.rules != BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
@@ -260,13 +285,13 @@ pub fn expr_block<T: LintContext>(
 ///     let x = ();
 /// //  ^^^^^^^^^^
 /// ```
-pub fn first_line_of_span<T: LintContext>(cx: &T, span: Span) -> Span {
-    first_char_in_first_line(cx, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
+pub fn first_line_of_span(sess: &impl HasSession, span: Span) -> Span {
+    first_char_in_first_line(sess, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
 }
 
-fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePos> {
-    let line_span = line_span(cx, span);
-    snippet_opt(cx, line_span).and_then(|snip| {
+fn first_char_in_first_line(sess: &impl HasSession, span: Span) -> Option<BytePos> {
+    let line_span = line_span(sess, span);
+    snippet_opt(sess, line_span).and_then(|snip| {
         snip.find(|c: char| !c.is_whitespace())
             .map(|pos| line_span.lo() + BytePos::from_usize(pos))
     })
@@ -281,9 +306,9 @@ fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePo
 ///        let x = ();
 /// // ^^^^^^^^^^^^^^
 /// ```
-fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
+fn line_span(sess: &impl HasSession, span: Span) -> Span {
     let span = original_sp(span, DUMMY_SP);
-    let SourceFileAndLine { sf, line } = cx.sess().source_map().lookup_line(span.lo()).unwrap();
+    let SourceFileAndLine { sf, line } = sess.sess().source_map().lookup_line(span.lo()).unwrap();
     let line_start = sf.lines()[line];
     let line_start = sf.absolute_position(line_start);
     span.with_lo(line_start)
@@ -297,13 +322,13 @@ fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
 ///     let x = ();
 /// //          ^^ -- will return 4
 /// ```
-pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
-    snippet_opt(cx, line_span(cx, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
+pub fn indent_of(sess: &impl HasSession, span: Span) -> Option<usize> {
+    snippet_opt(sess, line_span(sess, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
 }
 
 /// Gets a snippet of the indentation of the line of a span
-pub fn snippet_indent<T: LintContext>(cx: &T, span: Span) -> Option<String> {
-    snippet_opt(cx, line_span(cx, span)).map(|mut s| {
+pub fn snippet_indent(sess: &impl HasSession, span: Span) -> Option<String> {
+    snippet_opt(sess, line_span(sess, span)).map(|mut s| {
         let len = s.len() - s.trim_start().len();
         s.truncate(len);
         s
@@ -315,8 +340,8 @@ pub fn snippet_indent<T: LintContext>(cx: &T, span: Span) -> Option<String> {
 // sources that the user has no control over.
 // For some reason these attributes don't have any expansion info on them, so
 // we have to check it this way until there is a better way.
-pub fn is_present_in_source<T: LintContext>(cx: &T, span: Span) -> bool {
-    if let Some(snippet) = snippet_opt(cx, span) {
+pub fn is_present_in_source(sess: &impl HasSession, span: Span) -> bool {
+    if let Some(snippet) = snippet_opt(sess, span) {
         if snippet.is_empty() {
             return false;
         }
@@ -407,8 +432,8 @@ fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>,
 /// snippet(cx, span1, "..") // -> "value"
 /// snippet(cx, span2, "..") // -> "Vec::new()"
 /// ```
-pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
-    snippet_opt(cx, span).map_or_else(|| Cow::Borrowed(default), From::from)
+pub fn snippet<'a>(sess: &impl HasSession, span: Span, default: &'a str) -> Cow<'a, str> {
+    snippet_opt(sess, span).map_or_else(|| Cow::Borrowed(default), From::from)
 }
 
 /// Same as [`snippet`], but it adapts the applicability level by following rules:
@@ -417,13 +442,13 @@ pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<
 /// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
 /// - If the default value is used and the applicability level is `MachineApplicable`, change it to
 ///   `HasPlaceholders`
-pub fn snippet_with_applicability<'a, T: LintContext>(
-    cx: &T,
+pub fn snippet_with_applicability<'a>(
+    sess: &impl HasSession,
     span: Span,
     default: &'a str,
     applicability: &mut Applicability,
 ) -> Cow<'a, str> {
-    snippet_with_applicability_sess(cx.sess(), span, default, applicability)
+    snippet_with_applicability_sess(sess.sess(), span, default, applicability)
 }
 
 fn snippet_with_applicability_sess<'a>(
@@ -435,7 +460,7 @@ fn snippet_with_applicability_sess<'a>(
     if *applicability != Applicability::Unspecified && span.from_expansion() {
         *applicability = Applicability::MaybeIncorrect;
     }
-    snippet_opt_sess(sess, span).map_or_else(
+    snippet_opt(sess, span).map_or_else(
         || {
             if *applicability == Applicability::MachineApplicable {
                 *applicability = Applicability::HasPlaceholders;
@@ -447,12 +472,8 @@ fn snippet_with_applicability_sess<'a>(
 }
 
 /// Converts a span to a code snippet. Returns `None` if not available.
-pub fn snippet_opt(cx: &impl LintContext, span: Span) -> Option<String> {
-    snippet_opt_sess(cx.sess(), span)
-}
-
-fn snippet_opt_sess(sess: &Session, span: Span) -> Option<String> {
-    sess.source_map().span_to_snippet(span).ok()
+pub fn snippet_opt(sess: &impl HasSession, span: Span) -> Option<String> {
+    sess.sess().source_map().span_to_snippet(span).ok()
 }
 
 /// Converts a span (from a block) to a code snippet if available, otherwise use default.
@@ -489,41 +510,41 @@ fn snippet_opt_sess(sess: &Session, span: Span) -> Option<String> {
 ///     } // aligned with `if`
 /// ```
 /// Note that the first line of the snippet always has 0 indentation.
-pub fn snippet_block<'a, T: LintContext>(
-    cx: &T,
+pub fn snippet_block<'a>(
+    sess: &impl HasSession,
     span: Span,
     default: &'a str,
     indent_relative_to: Option<Span>,
 ) -> Cow<'a, str> {
-    let snip = snippet(cx, span, default);
-    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+    let snip = snippet(sess, span, default);
+    let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
     reindent_multiline(snip, true, indent)
 }
 
 /// Same as `snippet_block`, but adapts the applicability level by the rules of
 /// `snippet_with_applicability`.
 pub fn snippet_block_with_applicability<'a>(
-    cx: &impl LintContext,
+    sess: &impl HasSession,
     span: Span,
     default: &'a str,
     indent_relative_to: Option<Span>,
     applicability: &mut Applicability,
 ) -> Cow<'a, str> {
-    let snip = snippet_with_applicability(cx, span, default, applicability);
-    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+    let snip = snippet_with_applicability(sess, span, default, applicability);
+    let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
     reindent_multiline(snip, true, indent)
 }
 
 pub fn snippet_block_with_context<'a>(
-    cx: &impl LintContext,
+    sess: &impl HasSession,
     span: Span,
     outer: SyntaxContext,
     default: &'a str,
     indent_relative_to: Option<Span>,
     app: &mut Applicability,
 ) -> (Cow<'a, str>, bool) {
-    let (snip, from_macro) = snippet_with_context(cx, span, outer, default, app);
-    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
+    let (snip, from_macro) = snippet_with_context(sess, span, outer, default, app);
+    let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
     (reindent_multiline(snip, true, indent), from_macro)
 }
 
@@ -537,13 +558,13 @@ pub fn snippet_block_with_context<'a>(
 ///
 /// This will also return whether or not the snippet is a macro call.
 pub fn snippet_with_context<'a>(
-    cx: &impl LintContext,
+    sess: &impl HasSession,
     span: Span,
     outer: SyntaxContext,
     default: &'a str,
     applicability: &mut Applicability,
 ) -> (Cow<'a, str>, bool) {
-    snippet_with_context_sess(cx.sess(), span, outer, default, applicability)
+    snippet_with_context_sess(sess.sess(), span, outer, default, applicability)
 }
 
 fn snippet_with_context_sess<'a>(
@@ -661,15 +682,15 @@ pub fn trim_span(sm: &SourceMap, span: Span) -> Span {
 /// writeln!(o, "")   ->   writeln!(o, "")
 ///             ^^                   ^^^^
 /// ```
-pub fn expand_past_previous_comma(cx: &LateContext<'_>, span: Span) -> Span {
-    let extended = cx.sess().source_map().span_extend_to_prev_char(span, ',', true);
+pub fn expand_past_previous_comma(sess: &impl HasSession, span: Span) -> Span {
+    let extended = sess.sess().source_map().span_extend_to_prev_char(span, ',', true);
     extended.with_lo(extended.lo() - BytePos(1))
 }
 
 /// Converts `expr` to a `char` literal if it's a `str` literal containing a single
 /// character (or a single byte with `ascii_only`)
 pub fn str_literal_to_char_literal(
-    cx: &LateContext<'_>,
+    sess: &impl HasSession,
     expr: &Expr<'_>,
     applicability: &mut Applicability,
     ascii_only: bool,
@@ -684,7 +705,7 @@ pub fn str_literal_to_char_literal(
         }
         && len == 1
     {
-        let snip = snippet_with_applicability(cx, expr.span, string, applicability);
+        let snip = snippet_with_applicability(sess, expr.span, string, applicability);
         let ch = if let StrStyle::Raw(nhash) = style {
             let nhash = nhash as usize;
             // for raw string: r##"a"##
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index 812fb647fdab6..bd48990aea95f 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -525,19 +525,6 @@ pub fn needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
 }
 
-/// Peels off all references on the type. Returns the underlying type and the number of references
-/// removed.
-pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
-        if let ty::Ref(_, ty, _) = ty.kind() {
-            peel(*ty, count + 1)
-        } else {
-            (ty, count)
-        }
-    }
-    peel(ty, 0)
-}
-
 /// Peels off all references on the type. Returns the underlying type, the number of references
 /// removed, and whether the pointer is ultimately mutable or not.
 pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 7066c9ad2b96b..2a5d3536ff6b7 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -1,6 +1,7 @@
 use crate::ty::needs_ordered_drop;
 use crate::{get_enclosing_block, path_to_local_id};
 use core::ops::ControlFlow;
+use rustc_ast::visit::{try_visit, VisitorResult};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::intravisit::{self, walk_block, walk_expr, Visitor};
@@ -50,16 +51,17 @@ impl Continue for Descend {
 /// A type which can be visited.
 pub trait Visitable<'tcx> {
     /// Calls the corresponding `visit_*` function on the visitor.
-    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V);
+    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) -> V::Result;
 }
 impl<'tcx, T> Visitable<'tcx> for &'tcx [T]
 where
     &'tcx T: Visitable<'tcx>,
 {
-    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) -> V::Result {
         for x in self {
-            x.visit(visitor);
+            try_visit!(x.visit(visitor));
         }
+        V::Result::output()
     }
 }
 impl<'tcx, A, B> Visitable<'tcx> for (A, B)
@@ -67,27 +69,28 @@ where
     A: Visitable<'tcx>,
     B: Visitable<'tcx>,
 {
-    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) -> V::Result {
         let (a, b) = self;
-        a.visit(visitor);
-        b.visit(visitor);
+        try_visit!(a.visit(visitor));
+        b.visit(visitor)
     }
 }
 impl<'tcx, T> Visitable<'tcx> for Option<T>
 where
     T: Visitable<'tcx>,
 {
-    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
+    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) -> V::Result {
         if let Some(x) = self {
-            x.visit(visitor);
+            try_visit!(x.visit(visitor));
         }
+        V::Result::output()
     }
 }
 macro_rules! visitable_ref {
     ($t:ident, $f:ident) => {
         impl<'tcx> Visitable<'tcx> for &'tcx $t<'tcx> {
-            fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
-                visitor.$f(self);
+            fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) -> V::Result {
+                visitor.$f(self)
             }
         }
     };
@@ -104,45 +107,37 @@ pub fn for_each_expr_without_closures<'tcx, B, C: Continue>(
     node: impl Visitable<'tcx>,
     f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>,
 ) -> Option<B> {
-    struct V<B, F> {
+    struct V<F> {
         f: F,
-        res: Option<B>,
     }
-    impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<B, F> {
-        type Result = ControlFlow<()>;
+    impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<F> {
+        type Result = ControlFlow<B>;
 
-        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) -> ControlFlow<()> {
-            if self.res.is_some() {
-                return ControlFlow::Break(());
-            }
+        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) -> Self::Result {
             match (self.f)(e) {
                 ControlFlow::Continue(c) if c.descend() => walk_expr(self, e),
-                ControlFlow::Break(b) => {
-                    self.res = Some(b);
-                    ControlFlow::Break(())
-                },
+                ControlFlow::Break(b) => ControlFlow::Break(b),
                 ControlFlow::Continue(_) => ControlFlow::Continue(()),
             }
         }
 
         // Avoid unnecessary `walk_*` calls.
-        fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) -> ControlFlow<()> {
+        fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) -> Self::Result {
             ControlFlow::Continue(())
         }
-        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) -> ControlFlow<()> {
+        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) -> Self::Result {
             ControlFlow::Continue(())
         }
-        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) -> ControlFlow<()> {
+        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) -> Self::Result {
             ControlFlow::Continue(())
         }
         // Avoid monomorphising all `visit_*` functions.
-        fn visit_nested_item(&mut self, _: ItemId) -> ControlFlow<()> {
+        fn visit_nested_item(&mut self, _: ItemId) -> Self::Result {
             ControlFlow::Continue(())
         }
     }
-    let mut v = V { f, res: None };
-    node.visit(&mut v);
-    v.res
+    let mut v = V { f };
+    node.visit(&mut v).break_value()
 }
 
 /// Calls the given function once for each expression contained. This will enter bodies, but not
@@ -152,44 +147,47 @@ pub fn for_each_expr<'tcx, B, C: Continue>(
     node: impl Visitable<'tcx>,
     f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>,
 ) -> Option<B> {
-    struct V<'tcx, B, F> {
+    struct V<'tcx, F> {
         tcx: TyCtxt<'tcx>,
         f: F,
-        res: Option<B>,
     }
-    impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<'tcx, B, F> {
+    impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<'tcx, F> {
         type NestedFilter = nested_filter::OnlyBodies;
+        type Result = ControlFlow<B>;
+
         fn nested_visit_map(&mut self) -> Self::Map {
             self.tcx.hir()
         }
 
-        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
-            if self.res.is_some() {
-                return;
-            }
+        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) -> Self::Result {
             match (self.f)(e) {
                 ControlFlow::Continue(c) if c.descend() => walk_expr(self, e),
-                ControlFlow::Break(b) => self.res = Some(b),
-                ControlFlow::Continue(_) => (),
+                ControlFlow::Break(b) => ControlFlow::Break(b),
+                ControlFlow::Continue(_) => ControlFlow::Continue(()),
             }
         }
 
         // Only walk closures
-        fn visit_anon_const(&mut self, _: &'tcx AnonConst) {}
+        fn visit_anon_const(&mut self, _: &'tcx AnonConst) -> Self::Result {
+            ControlFlow::Continue(())
+        }
         // Avoid unnecessary `walk_*` calls.
-        fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) {}
-        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) {}
-        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) {}
+        fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) -> Self::Result {
+            ControlFlow::Continue(())
+        }
+        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) -> Self::Result {
+            ControlFlow::Continue(())
+        }
+        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) -> Self::Result {
+            ControlFlow::Continue(())
+        }
         // Avoid monomorphising all `visit_*` functions.
-        fn visit_nested_item(&mut self, _: ItemId) {}
+        fn visit_nested_item(&mut self, _: ItemId) -> Self::Result {
+            ControlFlow::Continue(())
+        }
     }
-    let mut v = V {
-        tcx: cx.tcx,
-        f,
-        res: None,
-    };
-    node.visit(&mut v);
-    v.res
+    let mut v = V { tcx: cx.tcx, f };
+    node.visit(&mut v).break_value()
 }
 
 /// returns `true` if expr contains match expr desugared from try
diff --git a/declare_clippy_lint/Cargo.toml b/declare_clippy_lint/Cargo.toml
index 80106f683c2ae..31270241b0b2e 100644
--- a/declare_clippy_lint/Cargo.toml
+++ b/declare_clippy_lint/Cargo.toml
@@ -11,6 +11,3 @@ proc-macro = true
 itertools = "0.12"
 quote = "1.0.21"
 syn = "2.0"
-
-[features]
-deny-warnings = []
diff --git a/declare_clippy_lint/src/lib.rs b/declare_clippy_lint/src/lib.rs
index 25b2fc9395cd9..ca070f6c250bf 100644
--- a/declare_clippy_lint/src/lib.rs
+++ b/declare_clippy_lint/src/lib.rs
@@ -1,5 +1,4 @@
 #![feature(let_chains)]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 // warn on lints, that are included in `rust-lang/rust`s bootstrap
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
diff --git a/lintcheck/Cargo.toml b/lintcheck/Cargo.toml
index 350418eeeb871..b0e4e3e3e573b 100644
--- a/lintcheck/Cargo.toml
+++ b/lintcheck/Cargo.toml
@@ -25,6 +25,3 @@ tar = "0.4"
 toml = "0.7.3"
 ureq = { version = "2.2", features = ["json"] }
 walkdir = "2.3"
-
-[features]
-deny-warnings = []
diff --git a/lintcheck/src/config.rs b/lintcheck/src/config.rs
index 6bec1753fc7b8..bd4fcc5e337e9 100644
--- a/lintcheck/src/config.rs
+++ b/lintcheck/src/config.rs
@@ -33,13 +33,13 @@ pub(crate) struct LintcheckConfig {
     /// Runs cargo clippy --fix and checks if all suggestions apply
     #[clap(long, conflicts_with("max_jobs"))]
     pub fix: bool,
-    /// Apply a filter to only collect specified lints, this also overrides `allow` attributes
+    /// Apply a filter to only collect specified lints
     #[clap(long = "filter", value_name = "clippy_lint_name", use_value_delimiter = true)]
     pub lint_filter: Vec<String>,
-    /// Set all lints to the "warn" lint level, even resitriction ones. Usually,
-    /// it's better to use `--filter` instead
+    /// Check all Clippy lints, by default only `clippy::all` and `clippy::pedantic` are checked.
+    /// Usually, it's better to use `--filter` instead
     #[clap(long, conflicts_with("lint_filter"))]
-    pub warn_all: bool,
+    pub all_lints: bool,
     /// Set the output format of the log file
     #[clap(long, short, default_value = "text")]
     pub format: OutputFormat,
diff --git a/lintcheck/src/input.rs b/lintcheck/src/input.rs
index 3b263674aa87a..3383d50fa02c7 100644
--- a/lintcheck/src/input.rs
+++ b/lintcheck/src/input.rs
@@ -98,12 +98,12 @@ pub fn read_crates(toml_path: &Path) -> (Vec<CrateWithSource>, RecursiveOptions)
     let crate_list: SourceList =
         toml::from_str(&toml_content).unwrap_or_else(|e| panic!("Failed to parse {}: \n{e}", toml_path.display()));
     // parse the hashmap of the toml file into a list of crates
-    let tomlcrates: Vec<TomlCrate> = crate_list.crates.into_values().collect();
+    let toml_crates: Vec<TomlCrate> = crate_list.crates.into_values().collect();
 
     // flatten TomlCrates into CrateSources (one TomlCrates may represent several versions of a crate =>
-    // multiple Cratesources)
+    // multiple CrateSources)
     let mut crate_sources = Vec::new();
-    for tk in tomlcrates {
+    for tk in toml_crates {
         if let Some(ref path) = tk.path {
             crate_sources.push(CrateWithSource {
                 name: tk.name.clone(),
diff --git a/lintcheck/src/main.rs b/lintcheck/src/main.rs
index 0dd62ded293c8..acb6eaa5278aa 100644
--- a/lintcheck/src/main.rs
+++ b/lintcheck/src/main.rs
@@ -119,7 +119,8 @@ impl Crate {
         cmd.arg(if config.fix { "fix" } else { "check" })
             .arg("--quiet")
             .current_dir(&self.path)
-            .env("CLIPPY_ARGS", clippy_args.join("__CLIPPY_HACKERY__"));
+            .env("CLIPPY_ARGS", clippy_args.join("__CLIPPY_HACKERY__"))
+            .env("CLIPPY_DISABLE_DOCS_LINKS", "1");
 
         if let Some(server) = server {
             // `cargo clippy` is a wrapper around `cargo check` that mainly sets `RUSTC_WORKSPACE_WRAPPER` to
@@ -284,29 +285,24 @@ fn lintcheck(config: LintcheckConfig) {
     let (crates, recursive_options) = read_crates(&config.sources_toml_path);
 
     let counter = AtomicUsize::new(1);
-    let mut lint_level_args: Vec<String> = vec![];
+    let mut lint_level_args: Vec<String> = vec!["--cap-lints=allow".into()];
     if config.lint_filter.is_empty() {
-        lint_level_args.push("--cap-lints=warn".to_string());
-
-        // Set allow-by-default to warn
-        if config.warn_all {
-            [
+        let groups = if config.all_lints {
+            &[
+                "clippy::all",
                 "clippy::cargo",
                 "clippy::nursery",
                 "clippy::pedantic",
                 "clippy::restriction",
-            ]
+            ][..]
+        } else {
+            &["clippy::all", "clippy::pedantic"]
+        };
+        groups
             .iter()
-            .map(|group| format!("--warn={group}"))
+            .map(|group| format!("--force-warn={group}"))
             .collect_into(&mut lint_level_args);
-        } else {
-            ["clippy::cargo", "clippy::pedantic"]
-                .iter()
-                .map(|group| format!("--warn={group}"))
-                .collect_into(&mut lint_level_args);
-        }
     } else {
-        lint_level_args.push("--cap-lints=allow".to_string());
         config
             .lint_filter
             .iter()
diff --git a/rust-toolchain b/rust-toolchain
index 69fb11a4824af..5fbe4e544a9e4 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2024-07-25"
+channel = "nightly-2024-08-08"
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"
diff --git a/rustc_tools_util/Cargo.toml b/rustc_tools_util/Cargo.toml
index 877049ae7d0eb..37b592da132f4 100644
--- a/rustc_tools_util/Cargo.toml
+++ b/rustc_tools_util/Cargo.toml
@@ -10,6 +10,3 @@ categories = ["development-tools"]
 edition = "2018"
 
 [dependencies]
-
-[features]
-deny-warnings = []
diff --git a/rustc_tools_util/src/lib.rs b/rustc_tools_util/src/lib.rs
index 4c1d8c3733df6..2cc38130472f8 100644
--- a/rustc_tools_util/src/lib.rs
+++ b/rustc_tools_util/src/lib.rs
@@ -1,4 +1,4 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
+use std::str;
 
 /// This macro creates the version string during compilation from the
 /// current environment
@@ -101,49 +101,46 @@ impl std::fmt::Debug for VersionInfo {
 
 #[must_use]
 pub fn get_commit_hash() -> Option<String> {
-    std::process::Command::new("git")
-        .args(["rev-parse", "--short", "HEAD"])
+    let output = std::process::Command::new("git")
+        .args(["rev-parse", "HEAD"])
         .output()
-        .ok()
-        .and_then(|r| String::from_utf8(r.stdout).ok())
+        .ok()?;
+    let mut stdout = output.status.success().then_some(output.stdout)?;
+    stdout.truncate(10);
+    String::from_utf8(stdout).ok()
 }
 
 #[must_use]
 pub fn get_commit_date() -> Option<String> {
-    std::process::Command::new("git")
+    let output = std::process::Command::new("git")
         .args(["log", "-1", "--date=short", "--pretty=format:%cd"])
         .output()
-        .ok()
-        .and_then(|r| String::from_utf8(r.stdout).ok())
+        .ok()?;
+    let stdout = output.status.success().then_some(output.stdout)?;
+    String::from_utf8(stdout).ok()
 }
 
 #[must_use]
 pub fn get_channel() -> String {
-    match std::env::var("CFG_RELEASE_CHANNEL") {
-        Ok(channel) => channel,
-        Err(_) => {
-            // if that failed, try to ask rustc -V, do some parsing and find out
-            match std::process::Command::new("rustc")
-                .arg("-V")
-                .output()
-                .ok()
-                .and_then(|r| String::from_utf8(r.stdout).ok())
-            {
-                Some(rustc_output) => {
-                    if rustc_output.contains("beta") {
-                        String::from("beta")
-                    } else if rustc_output.contains("stable") {
-                        String::from("stable")
-                    } else {
-                        // default to nightly if we fail to parse
-                        String::from("nightly")
-                    }
-                },
-                // default to nightly
-                None => String::from("nightly"),
+    if let Ok(channel) = std::env::var("CFG_RELEASE_CHANNEL") {
+        return channel;
+    }
+
+    // if that failed, try to ask rustc -V, do some parsing and find out
+    if let Ok(output) = std::process::Command::new("rustc").arg("-V").output() {
+        if output.status.success() {
+            if let Ok(rustc_output) = str::from_utf8(&output.stdout) {
+                if rustc_output.contains("beta") {
+                    return String::from("beta");
+                } else if rustc_output.contains("stable") {
+                    return String::from("stable");
+                }
             }
-        },
+        }
     }
+
+    // default to nightly
+    String::from("nightly")
 }
 
 #[cfg(test)]
diff --git a/src/driver.rs b/src/driver.rs
index 3fafe2427a256..0ac3f35b4465a 100644
--- a/src/driver.rs
+++ b/src/driver.rs
@@ -2,7 +2,6 @@
 #![allow(rustc::untranslatable_diagnostic)]
 #![feature(rustc_private)]
 #![feature(let_chains)]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 // warn on lints, that are included in `rust-lang/rust`s bootstrap
 #![warn(rust_2018_idioms, unused_lifetimes)]
 // warn on rustc internal lints
@@ -151,7 +150,6 @@ impl rustc_driver::Callbacks for ClippyCallbacks {
             let conf = clippy_config::Conf::read(sess, &conf_path);
             clippy_lints::register_lints(lint_store, conf);
             clippy_lints::register_pre_expansion_lints(lint_store, conf);
-            clippy_lints::register_renamed(lint_store);
         }));
 
         // FIXME: #4825; This is required, because Clippy lints that are based on MIR have to be
diff --git a/src/main.rs b/src/main.rs
index 30beaae34d2fe..c9af2138a7233 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 // warn on lints, that are included in `rust-lang/rust`s bootstrap
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
diff --git a/tests/check-fmt.rs b/tests/check-fmt.rs
index e106583de4a2e..cd3fed896c2de 100644
--- a/tests/check-fmt.rs
+++ b/tests/check-fmt.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
 use std::path::PathBuf;
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index 4e5120406b0d8..c7080e5dcdc9e 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![warn(rust_2018_idioms, unused_lifetimes)]
 #![allow(unused_extern_crates)]
 
@@ -208,7 +207,8 @@ fn run_ui_toml() {
     ui_test::run_tests_generic(
         vec![config],
         ui_test::default_file_filter,
-        |config, path, _file_contents| {
+        |config, file_contents| {
+            let path = file_contents.span().file;
             config
                 .program
                 .envs
@@ -260,7 +260,7 @@ fn run_ui_cargo() {
             path.ends_with("Cargo.toml")
                 .then(|| ui_test::default_any_file_filter(path, config) && !ignored_32bit(path))
         },
-        |_config, _path, _file_contents| {},
+        |_config, _file_contents| {},
         status_emitter::Text::from(args.format),
     )
     .unwrap();
diff --git a/tests/dogfood.rs b/tests/dogfood.rs
index c8a761bf509ec..8d10d5e7161a6 100644
--- a/tests/dogfood.rs
+++ b/tests/dogfood.rs
@@ -3,7 +3,6 @@
 //!
 //! See [Eating your own dog food](https://en.wikipedia.org/wiki/Eating_your_own_dog_food) for context
 
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
 use itertools::Itertools;
diff --git a/tests/integration.rs b/tests/integration.rs
index 77b7bb6a7bf69..13cf36823c5e4 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -8,7 +8,6 @@
 //! Clippy doesn't produce an ICE. Lint warnings are ignored by this test.
 
 #![cfg(feature = "integration")]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
 use std::env;
diff --git a/tests/lint_message_convention.rs b/tests/lint_message_convention.rs
index 6ce7e44474d81..7ed1f485c1cfd 100644
--- a/tests/lint_message_convention.rs
+++ b/tests/lint_message_convention.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
 use std::ffi::OsStr;
diff --git a/tests/missing-test-files.rs b/tests/missing-test-files.rs
index 141c11ddb47f9..a8225d037e828 100644
--- a/tests/missing-test-files.rs
+++ b/tests/missing-test-files.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![warn(rust_2018_idioms, unused_lifetimes)]
 #![allow(clippy::assertions_on_constants)]
 #![feature(path_file_prefix)]
diff --git a/tests/ui-internal/default_deprecation_reason.rs b/tests/ui-internal/default_deprecation_reason.rs
deleted file mode 100644
index c8961d5e1f0bd..0000000000000
--- a/tests/ui-internal/default_deprecation_reason.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-#![deny(clippy::internal)]
-#![feature(rustc_private)]
-
-#[macro_use]
-extern crate clippy_lints;
-use clippy_lints::deprecated_lints::ClippyDeprecatedLint;
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// TODO
-    #[clippy::version = "1.63.0"]
-    pub COOL_LINT_DEFAULT,
-    "default deprecation note"
-}
-
-declare_deprecated_lint! {
-    /// ### What it does
-    /// Nothing. This lint has been deprecated.
-    ///
-    /// ### Deprecation reason
-    /// This lint has been replaced by `cooler_lint`
-    #[clippy::version = "1.63.0"]
-    pub COOL_LINT,
-    "this lint has been replaced by `cooler_lint`"
-}
-
-fn main() {}
diff --git a/tests/ui-internal/default_deprecation_reason.stderr b/tests/ui-internal/default_deprecation_reason.stderr
deleted file mode 100644
index 3b7c747c23f41..0000000000000
--- a/tests/ui-internal/default_deprecation_reason.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error: the lint `COOL_LINT_DEFAULT` has the default deprecation reason
-  --> tests/ui-internal/default_deprecation_reason.rs:8:1
-   |
-LL | / declare_deprecated_lint! {
-LL | |     /// ### What it does
-LL | |     /// Nothing. This lint has been deprecated.
-LL | |     ///
-...  |
-LL | |     "default deprecation note"
-LL | | }
-   | |_^
-   |
-note: the lint level is defined here
-  --> tests/ui-internal/default_deprecation_reason.rs:1:9
-   |
-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 1 previous error
-
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
index 4375f324acaa6..858aab528a91a 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.rs
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -1,15 +1,19 @@
 //@aux-build:../../ui/auxiliary/proc_macros.rs
 #![rustfmt::skip]
 #![feature(custom_inner_attributes)]
-#![allow(unused)]
-#![allow(clippy::let_and_return)]
-#![allow(clippy::redundant_closure_call)]
-#![allow(clippy::no_effect)]
-#![allow(clippy::unnecessary_operation)]
-#![allow(clippy::never_loop)]
-#![allow(clippy::needless_if)]
 #![warn(clippy::excessive_nesting)]
-#![allow(clippy::collapsible_if, clippy::blocks_in_conditions)]
+#![allow(
+    unused,
+    clippy::let_and_return,
+    clippy::redundant_closure_call,
+    clippy::no_effect,
+    clippy::unnecessary_operation,
+    clippy::never_loop,
+    clippy::needless_if,
+    clippy::collapsible_if,
+    clippy::blocks_in_conditions,
+    clippy::single_match,
+)]
 
 #[macro_use]
 extern crate proc_macros;
diff --git a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
index dafcd4420554b..ccdaecdd48170 100644
--- a/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
+++ b/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
@@ -1,5 +1,5 @@
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:21:25
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:25:25
    |
 LL |                 let w = { 3 };
    |                         ^^^^^
@@ -9,7 +9,7 @@ LL |                 let w = { 3 };
    = help: to override `-D warnings` add `#[allow(clippy::excessive_nesting)]`
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:67:17
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:71:17
    |
 LL | /                 impl C {
 LL | |                     pub fn c() {}
@@ -19,7 +19,7 @@ LL | |                 }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:81:25
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:85:25
    |
 LL |                 let x = { 1 }; // not a warning, but cc is
    |                         ^^^^^
@@ -27,7 +27,7 @@ LL |                 let x = { 1 }; // not a warning, but cc is
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:98:17
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:102:17
    |
 LL | /                 pub mod e {
 LL | |                     pub mod f {}
@@ -37,7 +37,7 @@ LL | |                 } // not here
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:111:18
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:115:18
    |
 LL |     a_but_not({{{{{{{{0}}}}}}}});
    |                  ^^^^^^^^^^^
@@ -45,7 +45,7 @@ LL |     a_but_not({{{{{{{{0}}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:112:12
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:116:12
    |
 LL |     a.a({{{{{{{{{0}}}}}}}}});
    |            ^^^^^^^^^^^^^
@@ -53,7 +53,7 @@ LL |     a.a({{{{{{{{{0}}}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:113:12
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:117:12
    |
 LL |     (0, {{{{{{{1}}}}}}});
    |            ^^^^^^^^^
@@ -61,7 +61,7 @@ LL |     (0, {{{{{{{1}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:118:25
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:122:25
    |
 LL |                   if true {
    |  _________________________^
@@ -74,7 +74,7 @@ LL | |                 }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:130:29
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:134:29
    |
 LL |                   let z = (|| {
    |  _____________________________^
@@ -86,7 +86,7 @@ LL | |                 })();
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:149:13
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:153:13
    |
 LL |     y += {{{{{5}}}}};
    |             ^^^^^
@@ -94,7 +94,7 @@ LL |     y += {{{{{5}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:150:20
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:154:20
    |
 LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    |                    ^^^^^^^^^^^^^
@@ -102,7 +102,7 @@ LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:151:12
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:155:12
    |
 LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    |            ^^^^^^^^^^^^^^^
@@ -110,7 +110,7 @@ LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:152:25
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:156:25
    |
 LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    |                         ^^^^^^^^^^^^^
@@ -118,7 +118,7 @@ LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:153:11
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:157:11
    |
 LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -126,7 +126,7 @@ LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:154:13
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:158:13
    |
 LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    |             ^^^^^^^^^^^^^^^
@@ -134,7 +134,7 @@ LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:156:17
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:160:17
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                 ^^^^
@@ -142,7 +142,7 @@ LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:156:28
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:160:28
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                            ^^^^^^^^^^
@@ -150,7 +150,7 @@ LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:158:28
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:162:28
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                            ^^^^^^^^^^^^^
@@ -158,7 +158,7 @@ LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:158:48
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:162:48
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                                                ^^^^^^^^
@@ -166,7 +166,7 @@ LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:160:14
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:14
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |              ^^^^^^^^^^^^^^
@@ -174,7 +174,7 @@ LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:160:35
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:35
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |                                   ^^^^^^^^^^^^
@@ -182,7 +182,7 @@ LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:162:23
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:166:23
    |
 LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -190,7 +190,7 @@ LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:8
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:168:8
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |        ^^^^
@@ -198,7 +198,7 @@ LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:20
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:168:20
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |                    ^^^^^^^
@@ -206,7 +206,7 @@ LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:165:8
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:169:8
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |        ^^^^
@@ -214,7 +214,7 @@ LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:165:21
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:169:21
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -222,7 +222,7 @@ LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:166:10
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:170:10
    |
 LL |     ..{{{{{{{5}}}}}}};
    |          ^^^^^^^^^
@@ -230,7 +230,7 @@ LL |     ..{{{{{{{5}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:167:11
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:171:11
    |
 LL |     ..={{{{{3}}}}};
    |           ^^^^^
@@ -238,7 +238,7 @@ LL |     ..={{{{{3}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:168:8
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:172:8
    |
 LL |     {{{{{1;}}}}}..;
    |        ^^^^^^
@@ -246,7 +246,7 @@ LL |     {{{{{1;}}}}}..;
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:170:20
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:174:20
    |
 LL |     loop { break {{{{1}}}} };
    |                    ^^^^^
@@ -254,7 +254,7 @@ LL |     loop { break {{{{1}}}} };
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:171:13
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:175:13
    |
 LL |     loop {{{{{{}}}}}}
    |             ^^^^^^
@@ -262,7 +262,7 @@ LL |     loop {{{{{{}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:173:14
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:177:14
    |
 LL |     match {{{{{{true}}}}}} {
    |              ^^^^^^^^^^
@@ -270,7 +270,7 @@ LL |     match {{{{{{true}}}}}} {
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:174:20
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:178:20
    |
 LL |         true => {{{{}}}},
    |                    ^^
@@ -278,7 +278,7 @@ LL |         true => {{{{}}}},
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:175:21
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:179:21
    |
 LL |         false => {{{{}}}},
    |                     ^^
@@ -286,7 +286,7 @@ LL |         false => {{{{}}}},
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:181:17
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:185:17
    |
 LL | /                 {
 LL | |                     println!("warning! :)");
@@ -296,7 +296,7 @@ LL | |                 }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:190:28
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:194:28
    |
 LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    |                            ^^^^^^^^^
@@ -304,7 +304,7 @@ LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:196:8
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:200:8
    |
 LL |     {{{{b().await}}}};
    |        ^^^^^^^^^^^
diff --git a/tests/ui-toml/unwrap_used/unwrap_used.stderr b/tests/ui-toml/unwrap_used/unwrap_used.stderr
index 41d5afd3efeca..320578bfabce0 100644
--- a/tests/ui-toml/unwrap_used/unwrap_used.stderr
+++ b/tests/ui-toml/unwrap_used/unwrap_used.stderr
@@ -1,11 +1,15 @@
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:38:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::get-unwrap` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::get_unwrap)]`
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &boxed_slice[1];
+   |                 ~~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:38:17
@@ -18,11 +22,16 @@ LL |         let _ = boxed_slice.get(1).unwrap();
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_used)]`
 
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:39:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_slice[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &some_slice[0];
+   |                 ~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:39:17
@@ -33,11 +42,16 @@ LL |         let _ = some_slice.get(0).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a Vec
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:40:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vec[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &some_vec[0];
+   |                 ~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:40:17
@@ -48,11 +62,16 @@ LL |         let _ = some_vec.get(0).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a VecDeque
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:41:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vecdeque[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &some_vecdeque[0];
+   |                 ~~~~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:41:17
@@ -63,11 +82,16 @@ LL |         let _ = some_vecdeque.get(0).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a HashMap
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:42:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_hashmap[&1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &some_hashmap[&1];
+   |                 ~~~~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:42:17
@@ -78,11 +102,16 @@ LL |         let _ = some_hashmap.get(&1).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a BTreeMap
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:43:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_btreemap[&1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &some_btreemap[&1];
+   |                 ~~~~~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:43:17
@@ -93,11 +122,16 @@ LL |         let _ = some_btreemap.get(&1).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:47:21
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[1]`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _: u8 = boxed_slice[1];
+   |                     ~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:47:22
@@ -108,11 +142,16 @@ LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a slice
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:52:9
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         boxed_slice[0] = 1;
+   |         ~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:52:10
@@ -123,11 +162,16 @@ LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a slice
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:53:9
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_slice[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         some_slice[0] = 1;
+   |         ~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:53:10
@@ -138,11 +182,16 @@ LL |         *some_slice.get_mut(0).unwrap() = 1;
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a Vec
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:54:9
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         some_vec[0] = 1;
+   |         ~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:54:10
@@ -153,11 +202,16 @@ LL |         *some_vec.get_mut(0).unwrap() = 1;
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a VecDeque
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:55:9
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vecdeque[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         some_vecdeque[0] = 1;
+   |         ~~~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:55:10
@@ -168,11 +222,16 @@ LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a Vec
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:67:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = some_vec[0..1].to_vec();
+   |                 ~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:67:17
@@ -183,11 +242,16 @@ LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a Vec
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:68:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = some_vec[0..1].to_vec();
+   |                 ~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:68:17
@@ -198,17 +262,27 @@ LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:75:13
    |
 LL |     let _ = boxed_slice.get(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |     let _ = &boxed_slice[1];
+   |             ~~~~~~~~~~~~~~~
 
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui-toml/unwrap_used/unwrap_used.rs:93:17
    |
 LL |         let _ = Box::new([0]).get(1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&Box::new([0])[1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &Box::new([0])[1];
+   |                 ~~~~~~~~~~~~~~~~~
 
 error: aborting due to 28 previous errors
 
diff --git a/tests/ui/assigning_clones.fixed b/tests/ui/assigning_clones.fixed
index 60f6a385fc506..b376d55a40250 100644
--- a/tests/ui/assigning_clones.fixed
+++ b/tests/ui/assigning_clones.fixed
@@ -3,6 +3,7 @@
 #![allow(clippy::ptr_arg)] // https://github.com/rust-lang/rust-clippy/issues/10612
 #![allow(clippy::needless_late_init)]
 #![allow(clippy::box_collection)]
+#![allow(clippy::boxed_local)]
 #![warn(clippy::assigning_clones)]
 
 use std::borrow::ToOwned;
@@ -182,6 +183,31 @@ impl Clone for AvoidRecursiveCloneFrom {
     }
 }
 
+// Deref handling
+fn clone_into_deref_method(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
+    (*a).clone_from(&b);
+}
+
+fn clone_into_deref_with_clone_method(mut a: DerefWrapperWithClone<HasCloneFrom>, b: HasCloneFrom) {
+    (*a).clone_from(&b);
+}
+
+fn clone_into_box_method(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
+    (*a).clone_from(&b);
+}
+
+fn clone_into_self_deref_method(a: &mut DerefWrapperWithClone<HasCloneFrom>, b: DerefWrapperWithClone<HasCloneFrom>) {
+    a.clone_from(&b);
+}
+
+fn clone_into_deref_function(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
+    Clone::clone_from(&mut *a, &b);
+}
+
+fn clone_into_box_function(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
+    Clone::clone_from(&mut *a, &b);
+}
+
 // ToOwned
 fn owned_method_mut_ref(mut_string: &mut String, ref_str: &str) {
     ref_str.clone_into(mut_string);
@@ -328,3 +354,45 @@ mod borrowck_conflicts {
         path = path.components().as_path().to_owned();
     }
 }
+
+struct DerefWrapper<T>(T);
+
+impl<T> Deref for DerefWrapper<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for DerefWrapper<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+struct DerefWrapperWithClone<T>(T);
+
+impl<T> Deref for DerefWrapperWithClone<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for DerefWrapperWithClone<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T: Clone> Clone for DerefWrapperWithClone<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        *self = Self(source.0.clone());
+    }
+}
diff --git a/tests/ui/assigning_clones.rs b/tests/ui/assigning_clones.rs
index 6eb85be511a89..11a5d4459c350 100644
--- a/tests/ui/assigning_clones.rs
+++ b/tests/ui/assigning_clones.rs
@@ -3,6 +3,7 @@
 #![allow(clippy::ptr_arg)] // https://github.com/rust-lang/rust-clippy/issues/10612
 #![allow(clippy::needless_late_init)]
 #![allow(clippy::box_collection)]
+#![allow(clippy::boxed_local)]
 #![warn(clippy::assigning_clones)]
 
 use std::borrow::ToOwned;
@@ -182,6 +183,31 @@ impl Clone for AvoidRecursiveCloneFrom {
     }
 }
 
+// Deref handling
+fn clone_into_deref_method(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
+    *a = b.clone();
+}
+
+fn clone_into_deref_with_clone_method(mut a: DerefWrapperWithClone<HasCloneFrom>, b: HasCloneFrom) {
+    *a = b.clone();
+}
+
+fn clone_into_box_method(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
+    *a = b.clone();
+}
+
+fn clone_into_self_deref_method(a: &mut DerefWrapperWithClone<HasCloneFrom>, b: DerefWrapperWithClone<HasCloneFrom>) {
+    *a = b.clone();
+}
+
+fn clone_into_deref_function(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
+    *a = Clone::clone(&b);
+}
+
+fn clone_into_box_function(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
+    *a = Clone::clone(&b);
+}
+
 // ToOwned
 fn owned_method_mut_ref(mut_string: &mut String, ref_str: &str) {
     *mut_string = ref_str.to_owned();
@@ -328,3 +354,45 @@ mod borrowck_conflicts {
         path = path.components().as_path().to_owned();
     }
 }
+
+struct DerefWrapper<T>(T);
+
+impl<T> Deref for DerefWrapper<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for DerefWrapper<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+struct DerefWrapperWithClone<T>(T);
+
+impl<T> Deref for DerefWrapperWithClone<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for DerefWrapperWithClone<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T: Clone> Clone for DerefWrapperWithClone<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+
+    fn clone_from(&mut self, source: &Self) {
+        *self = Self(source.0.clone());
+    }
+}
diff --git a/tests/ui/assigning_clones.stderr b/tests/ui/assigning_clones.stderr
index a68516376abb5..19724a6d4ec2f 100644
--- a/tests/ui/assigning_clones.stderr
+++ b/tests/ui/assigning_clones.stderr
@@ -1,5 +1,5 @@
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:24:5
+  --> tests/ui/assigning_clones.rs:25:5
    |
 LL |     *mut_thing = value_thing.clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(&value_thing)`
@@ -8,142 +8,178 @@ LL |     *mut_thing = value_thing.clone();
    = help: to override `-D warnings` add `#[allow(clippy::assigning_clones)]`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:28:5
+  --> tests/ui/assigning_clones.rs:29:5
    |
 LL |     *mut_thing = ref_thing.clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:32:5
+  --> tests/ui/assigning_clones.rs:33:5
    |
 LL |     mut_thing = ref_thing.clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:36:5
+  --> tests/ui/assigning_clones.rs:37:5
    |
 LL |     *mut_thing = Clone::clone(ref_thing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:40:5
+  --> tests/ui/assigning_clones.rs:41:5
    |
 LL |     mut_thing = Clone::clone(ref_thing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut mut_thing, ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:44:5
+  --> tests/ui/assigning_clones.rs:45:5
    |
 LL |     *mut_thing = Clone::clone(ref_thing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:48:5
+  --> tests/ui/assigning_clones.rs:49:5
    |
 LL |     *mut_thing = HasCloneFrom::clone(ref_thing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:52:5
+  --> tests/ui/assigning_clones.rs:53:5
    |
 LL |     *mut_thing = <HasCloneFrom as Clone>::clone(ref_thing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:57:5
+  --> tests/ui/assigning_clones.rs:58:5
    |
 LL |     *(mut_thing + &mut HasCloneFrom) = ref_thing.clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `(mut_thing + &mut HasCloneFrom).clone_from(ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:62:5
+  --> tests/ui/assigning_clones.rs:63:5
    |
 LL |     *mut_thing = (ref_thing + ref_thing).clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(ref_thing + ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:67:5
+  --> tests/ui/assigning_clones.rs:68:5
    |
 LL |     s = format!("{} {}", "hello", "world").clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `s.clone_from(&format!("{} {}", "hello", "world"))`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:72:5
+  --> tests/ui/assigning_clones.rs:73:5
    |
 LL |     s = Clone::clone(&format!("{} {}", "hello", "world"));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut s, &format!("{} {}", "hello", "world"))`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:78:9
+  --> tests/ui/assigning_clones.rs:79:9
    |
 LL |         a = b.clone();
    |         ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:149:5
+  --> tests/ui/assigning_clones.rs:150:5
    |
 LL |     a = b.clone();
    |     ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:156:5
+  --> tests/ui/assigning_clones.rs:157:5
    |
 LL |     a = b.clone();
    |     ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:157:5
+  --> tests/ui/assigning_clones.rs:158:5
    |
 LL |     a = c.to_owned();
    |     ^^^^^^^^^^^^^^^^ help: use `clone_into()`: `c.clone_into(&mut a)`
 
+error: assigning the result of `Clone::clone()` may be inefficient
+  --> tests/ui/assigning_clones.rs:188:5
+   |
+LL |     *a = b.clone();
+   |     ^^^^^^^^^^^^^^ help: use `clone_from()`: `(*a).clone_from(&b)`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+  --> tests/ui/assigning_clones.rs:192:5
+   |
+LL |     *a = b.clone();
+   |     ^^^^^^^^^^^^^^ help: use `clone_from()`: `(*a).clone_from(&b)`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+  --> tests/ui/assigning_clones.rs:196:5
+   |
+LL |     *a = b.clone();
+   |     ^^^^^^^^^^^^^^ help: use `clone_from()`: `(*a).clone_from(&b)`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+  --> tests/ui/assigning_clones.rs:200:5
+   |
+LL |     *a = b.clone();
+   |     ^^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+  --> tests/ui/assigning_clones.rs:204:5
+   |
+LL |     *a = Clone::clone(&b);
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut *a, &b)`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+  --> tests/ui/assigning_clones.rs:208:5
+   |
+LL |     *a = Clone::clone(&b);
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut *a, &b)`
+
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:187:5
+  --> tests/ui/assigning_clones.rs:213:5
    |
 LL |     *mut_string = ref_str.to_owned();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(mut_string)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:191:5
+  --> tests/ui/assigning_clones.rs:217:5
    |
 LL |     mut_string = ref_str.to_owned();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut mut_string)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:212:5
+  --> tests/ui/assigning_clones.rs:238:5
    |
 LL |     **mut_box_string = ref_str.to_owned();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut (*mut_box_string))`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:216:5
+  --> tests/ui/assigning_clones.rs:242:5
    |
 LL |     **mut_box_string = ref_str.to_owned();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut (*mut_box_string))`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:220:5
+  --> tests/ui/assigning_clones.rs:246:5
    |
 LL |     *mut_thing = ToOwned::to_owned(ref_str);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(ref_str, mut_thing)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:224:5
+  --> tests/ui/assigning_clones.rs:250:5
    |
 LL |     mut_thing = ToOwned::to_owned(ref_str);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(ref_str, &mut mut_thing)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:229:5
+  --> tests/ui/assigning_clones.rs:255:5
    |
 LL |     s = format!("{} {}", "hello", "world").to_owned();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `format!("{} {}", "hello", "world").clone_into(&mut s)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:234:5
+  --> tests/ui/assigning_clones.rs:260:5
    |
 LL |     s = ToOwned::to_owned(&format!("{} {}", "hello", "world"));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(&format!("{} {}", "hello", "world"), &mut s)`
 
-error: aborting due to 24 previous errors
+error: aborting due to 30 previous errors
 
diff --git a/tests/ui/bind_instead_of_map_multipart.stderr b/tests/ui/bind_instead_of_map_multipart.stderr
index b15857c325ae5..2adaecc96d6a9 100644
--- a/tests/ui/bind_instead_of_map_multipart.stderr
+++ b/tests/ui/bind_instead_of_map_multipart.stderr
@@ -9,7 +9,7 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::bind_instead_of_map)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: try
+help: use `map` instead
    |
 LL |     let _ = Some("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
    |                        ~~~                       ~          ~~~~~~~
@@ -20,7 +20,7 @@ error: using `Result.and_then(|x| Ok(y))`, which is more succinctly expressed as
 LL |     let _ = Ok::<_, ()>("42").and_then(|s| if s.len() < 42 { Ok(0) } else { Ok(s.len()) });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: try
+help: use `map` instead
    |
 LL |     let _ = Ok::<_, ()>("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
    |                               ~~~                       ~          ~~~~~~~
@@ -31,7 +31,7 @@ error: using `Result.or_else(|x| Err(y))`, which is more succinctly expressed as
 LL |     let _ = Err::<(), _>("42").or_else(|s| if s.len() < 42 { Err(s.len() + 20) } else { Err(s.len()) });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: try
+help: use `map_err` instead
    |
 LL |     let _ = Err::<(), _>("42").map_err(|s| if s.len() < 42 { s.len() + 20 } else { s.len() });
    |                                ~~~~~~~                       ~~~~~~~~~~~~          ~~~~~~~
@@ -48,7 +48,7 @@ LL | |         }
 LL | |     });
    | |______^
    |
-help: try
+help: use `map` instead
    |
 LL ~     Some("42").map(|s| {
 LL |         if {
@@ -82,7 +82,7 @@ error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed
 LL |     let _ = Some("").and_then(|s| if s.len() == 20 { Some(m!()) } else { Some(Some(20)) });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: try
+help: use `map` instead
    |
 LL |     let _ = Some("").map(|s| if s.len() == 20 { m!() } else { Some(20) });
    |                      ~~~                        ~~~~          ~~~~~~~~
diff --git a/tests/ui/crashes/ice-3717.stderr b/tests/ui/crashes/ice-3717.stderr
index 01627ff5b94b9..4b4618ee1bbd0 100644
--- a/tests/ui/crashes/ice-3717.stderr
+++ b/tests/ui/crashes/ice-3717.stderr
@@ -9,14 +9,13 @@ note: the lint level is defined here
    |
 LL | #![deny(clippy::implicit_hasher)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^
-help: consider adding a type parameter
+help: add a type parameter for `BuildHasher`
    |
-LL | pub fn ice_3717<S: ::std::hash::BuildHasher + Default>(_: &HashSet<usize, S>) {
-   |                +++++++++++++++++++++++++++++++++++++++     ~~~~~~~~~~~~~~~~~
-help: ...and use generic constructor
+LL ~ pub fn ice_3717<S: ::std::hash::BuildHasher + Default>(_: &HashSet<usize, S>) {
+LL |
+LL |     let _ = [0u8; 0];
+LL ~     let _: HashSet<usize> = HashSet::default();
    |
-LL |     let _: HashSet<usize> = HashSet::default();
-   |                             ~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/crashes/ice-6254.rs b/tests/ui/crashes/ice-6254.rs
index 8af60890390e7..aaca32ab2d93e 100644
--- a/tests/ui/crashes/ice-6254.rs
+++ b/tests/ui/crashes/ice-6254.rs
@@ -2,7 +2,8 @@
 // panicked at 'assertion failed: rows.iter().all(|r| r.len() == v.len())',
 // compiler/rustc_mir_build/src/thir/pattern/_match.rs:2030:5
 
-#[allow(clippy::derive_partial_eq_without_eq)]
+#![allow(clippy::derive_partial_eq_without_eq, clippy::single_match)]
+
 #[derive(PartialEq)]
 struct Foo(i32);
 const FOO_REF_REF: &&Foo = &&Foo(42);
diff --git a/tests/ui/create_dir.stderr b/tests/ui/create_dir.stderr
index 9c6e640ca784c..ab51705bb55a5 100644
--- a/tests/ui/create_dir.stderr
+++ b/tests/ui/create_dir.stderr
@@ -2,16 +2,25 @@ error: calling `std::fs::create_dir` where there may be a better way
   --> tests/ui/create_dir.rs:10:5
    |
 LL |     std::fs::create_dir("foo");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `create_dir_all("foo")`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::create-dir` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::create_dir)]`
+help: consider calling `std::fs::create_dir_all` instead
+   |
+LL |     create_dir_all("foo");
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: calling `std::fs::create_dir` where there may be a better way
   --> tests/ui/create_dir.rs:11:5
    |
 LL |     std::fs::create_dir("bar").unwrap();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `std::fs::create_dir_all` instead: `create_dir_all("bar")`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider calling `std::fs::create_dir_all` instead
+   |
+LL |     create_dir_all("bar").unwrap();
+   |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/dbg_macro/dbg_macro.stderr b/tests/ui/dbg_macro/dbg_macro.stderr
index 7d3c3f7c918e8..b3d74b9ff6173 100644
--- a/tests/ui/dbg_macro/dbg_macro.stderr
+++ b/tests/ui/dbg_macro/dbg_macro.stderr
@@ -81,7 +81,7 @@ error: the `dbg!` macro is intended as a debugging tool
   --> tests/ui/dbg_macro/dbg_macro.rs:48:5
    |
 LL |     dbg!();
-   |     ^^^^^^^
+   |     ^^^^^^
    |
 help: remove the invocation before committing it to a version control system
    |
@@ -136,7 +136,7 @@ error: the `dbg!` macro is intended as a debugging tool
   --> tests/ui/dbg_macro/dbg_macro.rs:43:13
    |
 LL |             dbg!();
-   |             ^^^^^^^
+   |             ^^^^^^
 ...
 LL |     expand_to_dbg!();
    |     ---------------- in this macro invocation
diff --git a/tests/ui/dbg_macro/dbg_macro_unfixable.stderr b/tests/ui/dbg_macro/dbg_macro_unfixable.stderr
index 16e51f4742e34..b8e91906b9317 100644
--- a/tests/ui/dbg_macro/dbg_macro_unfixable.stderr
+++ b/tests/ui/dbg_macro/dbg_macro_unfixable.stderr
@@ -2,7 +2,7 @@ error: the `dbg!` macro is intended as a debugging tool
   --> tests/ui/dbg_macro/auxiliary/submodule.rs:2:5
    |
 LL |     dbg!();
-   |     ^^^^^^^
+   |     ^^^^^^
    |
    = note: `-D clippy::dbg-macro` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::dbg_macro)]`
diff --git a/tests/ui/deprecated.rs b/tests/ui/deprecated.rs
index d3c34fb371674..5617db90a470a 100644
--- a/tests/ui/deprecated.rs
+++ b/tests/ui/deprecated.rs
@@ -2,23 +2,18 @@
 // Use that command to update this file and do not edit by hand.
 // Manual edits will be overwritten.
 
-#![warn(clippy::should_assert_eq)]
-#![warn(clippy::extend_from_slice)]
-#![warn(clippy::range_step_by_zero)]
-#![warn(clippy::unstable_as_slice)]
-#![warn(clippy::unstable_as_mut_slice)]
-#![warn(clippy::misaligned_transmute)]
-#![warn(clippy::assign_ops)]
-#![warn(clippy::if_let_redundant_pattern_matching)]
-#![warn(clippy::unsafe_vector_initialization)]
-#![warn(clippy::unused_collect)]
-#![warn(clippy::replace_consts)]
-#![warn(clippy::regex_macro)]
-#![warn(clippy::find_map)]
-#![warn(clippy::filter_map)]
-#![warn(clippy::pub_enum_variant_names)]
-#![warn(clippy::wrong_pub_self_convention)]
-#![warn(clippy::maybe_misused_cfg)]
-#![warn(clippy::mismatched_target_os)]
+#![warn(clippy::should_assert_eq)] //~ ERROR: lint `clippy::should_assert_eq`
+#![warn(clippy::extend_from_slice)] //~ ERROR: lint `clippy::extend_from_slice`
+#![warn(clippy::range_step_by_zero)] //~ ERROR: lint `clippy::range_step_by_zero`
+#![warn(clippy::unstable_as_slice)] //~ ERROR: lint `clippy::unstable_as_slice`
+#![warn(clippy::unstable_as_mut_slice)] //~ ERROR: lint `clippy::unstable_as_mut_slice`
+#![warn(clippy::misaligned_transmute)] //~ ERROR: lint `clippy::misaligned_transmute`
+#![warn(clippy::assign_ops)] //~ ERROR: lint `clippy::assign_ops`
+#![warn(clippy::unsafe_vector_initialization)] //~ ERROR: lint `clippy::unsafe_vector_initialization`
+#![warn(clippy::unused_collect)] //~ ERROR: lint `clippy::unused_collect`
+#![warn(clippy::replace_consts)] //~ ERROR: lint `clippy::replace_consts`
+#![warn(clippy::regex_macro)] //~ ERROR: lint `clippy::regex_macro`
+#![warn(clippy::pub_enum_variant_names)] //~ ERROR: lint `clippy::pub_enum_variant_names`
+#![warn(clippy::wrong_pub_self_convention)] //~ ERROR: lint `clippy::wrong_pub_self_convention`
 
 fn main() {}
diff --git a/tests/ui/deprecated.stderr b/tests/ui/deprecated.stderr
index 49b90c70c06ef..b3e1646c8045b 100644
--- a/tests/ui/deprecated.stderr
+++ b/tests/ui/deprecated.stderr
@@ -1,4 +1,4 @@
-error: lint `clippy::should_assert_eq` has been removed: `assert!()` will be more flexible with RFC 2011
+error: lint `clippy::should_assert_eq` has been removed: `assert!(a == b)` can now print the values the same way `assert_eq!(a, b) can
   --> tests/ui/deprecated.rs:5:9
    |
 LL | #![warn(clippy::should_assert_eq)]
@@ -7,107 +7,77 @@ LL | #![warn(clippy::should_assert_eq)]
    = note: `-D renamed-and-removed-lints` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(renamed_and_removed_lints)]`
 
-error: lint `clippy::extend_from_slice` has been removed: `.extend_from_slice(_)` is a faster way to extend a Vec by a slice
+error: lint `clippy::extend_from_slice` has been removed: `Vec::extend_from_slice` is no longer faster than `Vec::extend` due to specialization
   --> tests/ui/deprecated.rs:6:9
    |
 LL | #![warn(clippy::extend_from_slice)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::range_step_by_zero` has been removed: `iterator.step_by(0)` panics nowadays
+error: lint `clippy::range_step_by_zero` has been removed: `Iterator::step_by(0)` now panics and is no longer an infinite iterator
   --> tests/ui/deprecated.rs:7:9
    |
 LL | #![warn(clippy::range_step_by_zero)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
+error: lint `clippy::unstable_as_slice` has been removed: `Vec::as_slice` is now stable
   --> tests/ui/deprecated.rs:8:9
    |
 LL | #![warn(clippy::unstable_as_slice)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` has been stabilized in 1.7
+error: lint `clippy::unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` is now stable
   --> tests/ui/deprecated.rs:9:9
    |
 LL | #![warn(clippy::unstable_as_mut_slice)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::misaligned_transmute` has been removed: this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr
+error: lint `clippy::misaligned_transmute` has been removed: split into `clippy::cast_ptr_alignment` and `clippy::transmute_ptr_to_ptr`
   --> tests/ui/deprecated.rs:10:9
    |
 LL | #![warn(clippy::misaligned_transmute)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::assign_ops` has been removed: using compound assignment operators (e.g., `+=`) is harmless
+error: lint `clippy::assign_ops` has been removed: compound operators are harmless and linting on them is not in scope for clippy
   --> tests/ui/deprecated.rs:11:9
    |
 LL | #![warn(clippy::assign_ops)]
    |         ^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::if_let_redundant_pattern_matching` has been removed: this lint has been changed to redundant_pattern_matching
+error: lint `clippy::unsafe_vector_initialization` has been removed: the suggested alternative could be substantially slower
   --> tests/ui/deprecated.rs:12:9
    |
-LL | #![warn(clippy::if_let_redundant_pattern_matching)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: lint `clippy::unsafe_vector_initialization` has been removed: the replacement suggested by this lint had substantially different behavior
-  --> tests/ui/deprecated.rs:13:9
-   |
 LL | #![warn(clippy::unsafe_vector_initialization)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::unused_collect` has been removed: `collect` has been marked as #[must_use] in rustc and that covers all cases of this lint
-  --> tests/ui/deprecated.rs:14:9
+error: lint `clippy::unused_collect` has been removed: `Iterator::collect` is now marked as `#[must_use]`
+  --> tests/ui/deprecated.rs:13:9
    |
 LL | #![warn(clippy::unused_collect)]
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::replace_consts` has been removed: associated-constants `MIN`/`MAX` of integers are preferred to `{min,max}_value()` and module constants
-  --> tests/ui/deprecated.rs:15:9
+error: lint `clippy::replace_consts` has been removed: `min_value` and `max_value` are now deprecated
+  --> tests/ui/deprecated.rs:14:9
    |
 LL | #![warn(clippy::replace_consts)]
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::regex_macro` has been removed: the regex! macro has been removed from the regex crate in 2018
-  --> tests/ui/deprecated.rs:16:9
+error: lint `clippy::regex_macro` has been removed: the `regex!` macro was removed from the regex crate in 2018
+  --> tests/ui/deprecated.rs:15:9
    |
 LL | #![warn(clippy::regex_macro)]
    |         ^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::find_map` has been removed: this lint has been replaced by `manual_find_map`, a more specific lint
-  --> tests/ui/deprecated.rs:17:9
-   |
-LL | #![warn(clippy::find_map)]
-   |         ^^^^^^^^^^^^^^^^
-
-error: lint `clippy::filter_map` has been removed: this lint has been replaced by `manual_filter_map`, a more specific lint
-  --> tests/ui/deprecated.rs:18:9
-   |
-LL | #![warn(clippy::filter_map)]
-   |         ^^^^^^^^^^^^^^^^^^
-
-error: lint `clippy::pub_enum_variant_names` has been removed: set the `avoid-breaking-exported-api` config option to `false` to enable the `enum_variant_names` lint for public items
-  --> tests/ui/deprecated.rs:19:9
+error: lint `clippy::pub_enum_variant_names` has been removed: `clippy::enum_variant_names` now covers this case via the `avoid-breaking-exported-api` config
+  --> tests/ui/deprecated.rs:16:9
    |
 LL | #![warn(clippy::pub_enum_variant_names)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::wrong_pub_self_convention` has been removed: set the `avoid-breaking-exported-api` config option to `false` to enable the `wrong_self_convention` lint for public items
-  --> tests/ui/deprecated.rs:20:9
+error: lint `clippy::wrong_pub_self_convention` has been removed: `clippy::wrong_self_convention` now covers this case via the `avoid-breaking-exported-api` config
+  --> tests/ui/deprecated.rs:17:9
    |
 LL | #![warn(clippy::wrong_pub_self_convention)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: lint `clippy::maybe_misused_cfg` has been removed: this lint has been replaced by `unexpected_cfgs`
-  --> tests/ui/deprecated.rs:21:9
-   |
-LL | #![warn(clippy::maybe_misused_cfg)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: lint `clippy::mismatched_target_os` has been removed: this lint has been replaced by `unexpected_cfgs`
-  --> tests/ui/deprecated.rs:22:9
-   |
-LL | #![warn(clippy::mismatched_target_os)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 18 previous errors
+error: aborting due to 13 previous errors
 
diff --git a/tests/ui/deprecated_old.rs b/tests/ui/deprecated_old.rs
deleted file mode 100644
index 356ad5f060b6c..0000000000000
--- a/tests/ui/deprecated_old.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#[warn(unstable_as_slice)]
-//~^ ERROR: lint `unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized
-//~| NOTE: `-D renamed-and-removed-lints` implied by `-D warnings`
-#[warn(unstable_as_mut_slice)]
-//~^ ERROR: lint `unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` has been st
-#[warn(misaligned_transmute)]
-//~^ ERROR: lint `misaligned_transmute` has been removed: this lint has been split into ca
-
-fn main() {}
diff --git a/tests/ui/deprecated_old.stderr b/tests/ui/deprecated_old.stderr
deleted file mode 100644
index 685bca64df59a..0000000000000
--- a/tests/ui/deprecated_old.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-error: lint `unstable_as_slice` has been removed: `Vec::as_slice` has been stabilized in 1.7
-  --> tests/ui/deprecated_old.rs:1:8
-   |
-LL | #[warn(unstable_as_slice)]
-   |        ^^^^^^^^^^^^^^^^^
-   |
-   = note: `-D renamed-and-removed-lints` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(renamed_and_removed_lints)]`
-
-error: lint `unstable_as_mut_slice` has been removed: `Vec::as_mut_slice` has been stabilized in 1.7
-  --> tests/ui/deprecated_old.rs:4:8
-   |
-LL | #[warn(unstable_as_mut_slice)]
-   |        ^^^^^^^^^^^^^^^^^^^^^
-
-error: lint `misaligned_transmute` has been removed: this lint has been split into cast_ptr_alignment and transmute_ptr_to_ptr
-  --> tests/ui/deprecated_old.rs:6:8
-   |
-LL | #[warn(misaligned_transmute)]
-   |        ^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 3 previous errors
-
diff --git a/tests/ui/deref_by_slicing.fixed b/tests/ui/deref_by_slicing.fixed
index a3c2e84566681..87b33b1f881d8 100644
--- a/tests/ui/deref_by_slicing.fixed
+++ b/tests/ui/deref_by_slicing.fixed
@@ -25,4 +25,8 @@ fn main() {
 
     let bytes: &[u8] = &[];
     let _ = (&*bytes).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
+
+    // issue 12751
+    let a = &mut [1, 2, 3][..];
+    let _ = &*a;
 }
diff --git a/tests/ui/deref_by_slicing.rs b/tests/ui/deref_by_slicing.rs
index 5b4a73712ee6e..8d8882a1781e8 100644
--- a/tests/ui/deref_by_slicing.rs
+++ b/tests/ui/deref_by_slicing.rs
@@ -25,4 +25,8 @@ fn main() {
 
     let bytes: &[u8] = &[];
     let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
+
+    // issue 12751
+    let a = &mut [1, 2, 3][..];
+    let _ = &a[..];
 }
diff --git a/tests/ui/deref_by_slicing.stderr b/tests/ui/deref_by_slicing.stderr
index 17b00610899d6..ceb9ab6db73dc 100644
--- a/tests/ui/deref_by_slicing.stderr
+++ b/tests/ui/deref_by_slicing.stderr
@@ -55,5 +55,11 @@ error: slicing when dereferencing would work
 LL |     let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
    |             ^^^^^^^^^^^^ help: reborrow the original value instead: `(&*bytes)`
 
-error: aborting due to 9 previous errors
+error: slicing when dereferencing would work
+  --> tests/ui/deref_by_slicing.rs:31:13
+   |
+LL |     let _ = &a[..];
+   |             ^^^^^^ help: reborrow the original value instead: `&*a`
+
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/doc/footnote_issue_13183.rs b/tests/ui/doc/footnote_issue_13183.rs
new file mode 100644
index 0000000000000..a18b4c3ac539b
--- /dev/null
+++ b/tests/ui/doc/footnote_issue_13183.rs
@@ -0,0 +1,10 @@
+// This is a regression test for <https://github.com/rust-lang/rust-clippy/issues/13183>.
+// It should not warn on missing backticks on footnote references.
+
+#![warn(clippy::doc_markdown)]
+// Should not warn!
+//! Here's a footnote[^example_footnote_identifier]
+//!
+//! [^example_footnote_identifier]: This is merely an example.
+
+fn main() {}
diff --git a/tests/ui/empty_drop.stderr b/tests/ui/empty_drop.stderr
index 4223ddaf3fba5..d4d020fec30cf 100644
--- a/tests/ui/empty_drop.stderr
+++ b/tests/ui/empty_drop.stderr
@@ -4,10 +4,11 @@ error: empty drop implementation
 LL | / impl Drop for Foo {
 LL | |     fn drop(&mut self) {}
 LL | | }
-   | |_^ help: try removing this impl
+   | |_^
    |
    = note: `-D clippy::empty-drop` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::empty_drop)]`
+   = help: try removing this impl
 
 error: empty drop implementation
   --> tests/ui/empty_drop.rs:23:1
@@ -17,7 +18,9 @@ LL | |     fn drop(&mut self) {
 LL | |         {}
 LL | |     }
 LL | | }
-   | |_^ help: try removing this impl
+   | |_^
+   |
+   = help: try removing this impl
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/eta.fixed b/tests/ui/eta.fixed
index 7126f2799455f..ca422ee29c104 100644
--- a/tests/ui/eta.fixed
+++ b/tests/ui/eta.fixed
@@ -2,6 +2,7 @@
 #![allow(unused)]
 #![allow(
     clippy::needless_borrow,
+    clippy::needless_option_as_deref,
     clippy::needless_pass_by_value,
     clippy::no_effect,
     clippy::option_map_unit_fn,
@@ -482,3 +483,19 @@ mod issue_12853 {
         x();
     }
 }
+
+mod issue_13073 {
+    fn get_default() -> Option<&'static str> {
+        Some("foo")
+    }
+
+    pub fn foo() {
+        // shouldn't lint
+        let bind: Option<String> = None;
+        let _field = bind.as_deref().or_else(|| get_default()).unwrap();
+        let bind: Option<&'static str> = None;
+        let _field = bind.as_deref().or_else(|| get_default()).unwrap();
+        // should lint
+        let _field = bind.or_else(get_default).unwrap();
+    }
+}
diff --git a/tests/ui/eta.rs b/tests/ui/eta.rs
index 0787abf5f3e37..c0db91c03ef45 100644
--- a/tests/ui/eta.rs
+++ b/tests/ui/eta.rs
@@ -2,6 +2,7 @@
 #![allow(unused)]
 #![allow(
     clippy::needless_borrow,
+    clippy::needless_option_as_deref,
     clippy::needless_pass_by_value,
     clippy::no_effect,
     clippy::option_map_unit_fn,
@@ -482,3 +483,19 @@ mod issue_12853 {
         x();
     }
 }
+
+mod issue_13073 {
+    fn get_default() -> Option<&'static str> {
+        Some("foo")
+    }
+
+    pub fn foo() {
+        // shouldn't lint
+        let bind: Option<String> = None;
+        let _field = bind.as_deref().or_else(|| get_default()).unwrap();
+        let bind: Option<&'static str> = None;
+        let _field = bind.as_deref().or_else(|| get_default()).unwrap();
+        // should lint
+        let _field = bind.or_else(|| get_default()).unwrap();
+    }
+}
diff --git a/tests/ui/eta.stderr b/tests/ui/eta.stderr
index c757601042f16..5540261fc5744 100644
--- a/tests/ui/eta.stderr
+++ b/tests/ui/eta.stderr
@@ -1,5 +1,5 @@
 error: redundant closure
-  --> tests/ui/eta.rs:29:27
+  --> tests/ui/eta.rs:30:27
    |
 LL |     let a = Some(1u8).map(|a| foo(a));
    |                           ^^^^^^^^^^ help: replace the closure with the function itself: `foo`
@@ -8,31 +8,31 @@ LL |     let a = Some(1u8).map(|a| foo(a));
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure)]`
 
 error: redundant closure
-  --> tests/ui/eta.rs:33:40
+  --> tests/ui/eta.rs:34:40
    |
 LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
    |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
 
 error: redundant closure
-  --> tests/ui/eta.rs:34:35
+  --> tests/ui/eta.rs:35:35
    |
 LL |     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
    |                                   ^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo2`
 
 error: redundant closure
-  --> tests/ui/eta.rs:35:26
+  --> tests/ui/eta.rs:36:26
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                          ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
 
 error: redundant closure
-  --> tests/ui/eta.rs:42:27
+  --> tests/ui/eta.rs:43:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> tests/ui/eta.rs:94:51
+  --> tests/ui/eta.rs:95:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -41,166 +41,172 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure_for_method_calls)]`
 
 error: redundant closure
-  --> tests/ui/eta.rs:95:51
+  --> tests/ui/eta.rs:96:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> tests/ui/eta.rs:97:42
+  --> tests/ui/eta.rs:98:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> tests/ui/eta.rs:101:29
+  --> tests/ui/eta.rs:102:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> tests/ui/eta.rs:102:27
+  --> tests/ui/eta.rs:103:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> tests/ui/eta.rs:104:65
+  --> tests/ui/eta.rs:105:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> tests/ui/eta.rs:167:22
+  --> tests/ui/eta.rs:168:22
    |
 LL |     requires_fn_once(|| x());
    |                      ^^^^^^ help: replace the closure with the function itself: `x`
 
 error: redundant closure
-  --> tests/ui/eta.rs:174:27
+  --> tests/ui/eta.rs:175:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> tests/ui/eta.rs:179:27
+  --> tests/ui/eta.rs:180:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: redundant closure
-  --> tests/ui/eta.rs:211:28
+  --> tests/ui/eta.rs:212:28
    |
 LL |     x.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> tests/ui/eta.rs:212:28
+  --> tests/ui/eta.rs:213:28
    |
 LL |     y.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> tests/ui/eta.rs:213:28
+  --> tests/ui/eta.rs:214:28
    |
 LL |     z.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
 
 error: redundant closure
-  --> tests/ui/eta.rs:220:21
+  --> tests/ui/eta.rs:221:21
    |
 LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
 error: redundant closure
-  --> tests/ui/eta.rs:224:21
+  --> tests/ui/eta.rs:225:21
    |
 LL |         Some(1).map(|n| in_loop(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
 
 error: redundant closure
-  --> tests/ui/eta.rs:317:18
+  --> tests/ui/eta.rs:318:18
    |
 LL |     takes_fn_mut(|| f());
    |                  ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:320:19
+  --> tests/ui/eta.rs:321:19
    |
 LL |     takes_fn_once(|| f());
    |                   ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:324:26
+  --> tests/ui/eta.rs:325:26
    |
 LL |     move || takes_fn_mut(|| f_used_once())
    |                          ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut f_used_once`
 
 error: redundant closure
-  --> tests/ui/eta.rs:336:19
+  --> tests/ui/eta.rs:337:19
    |
 LL |     array_opt.map(|a| a.as_slice());
    |                   ^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8; 3]>::as_slice`
 
 error: redundant closure
-  --> tests/ui/eta.rs:339:19
+  --> tests/ui/eta.rs:340:19
    |
 LL |     slice_opt.map(|s| s.len());
    |                   ^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8]>::len`
 
 error: redundant closure
-  --> tests/ui/eta.rs:342:17
+  --> tests/ui/eta.rs:343:17
    |
 LL |     ptr_opt.map(|p| p.is_null());
    |                 ^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<*const usize>::is_null`
 
 error: redundant closure
-  --> tests/ui/eta.rs:346:17
+  --> tests/ui/eta.rs:347:17
    |
 LL |     dyn_opt.map(|d| d.method_on_dyn());
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
 
 error: redundant closure
-  --> tests/ui/eta.rs:406:19
+  --> tests/ui/eta.rs:407:19
    |
 LL |     let _ = f(&0, |x, y| f2(x, y));
    |                   ^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `f2`
 
 error: redundant closure
-  --> tests/ui/eta.rs:434:22
+  --> tests/ui/eta.rs:435:22
    |
 LL |             test.map(|t| t.method())
    |                      ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `Test::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:438:22
+  --> tests/ui/eta.rs:439:22
    |
 LL |             test.map(|t| t.method())
    |                      ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `super::Outer::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:451:18
+  --> tests/ui/eta.rs:452:18
    |
 LL |         test.map(|t| t.method())
    |                  ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `test_mod::Test::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:458:30
+  --> tests/ui/eta.rs:459:30
    |
 LL |                     test.map(|t| t.method())
    |                              ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `crate::issue_10854::d::Test::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:477:38
+  --> tests/ui/eta.rs:478:38
    |
 LL |         let x = Box::new(|| None.map(|x| f(x)));
    |                                      ^^^^^^^^ help: replace the closure with the function itself: `&f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:481:38
+  --> tests/ui/eta.rs:482:38
    |
 LL |         let x = Box::new(|| None.map(|x| f(x)));
    |                                      ^^^^^^^^ help: replace the closure with the function itself: `f`
 
-error: aborting due to 33 previous errors
+error: redundant closure
+  --> tests/ui/eta.rs:499:35
+   |
+LL |         let _field = bind.or_else(|| get_default()).unwrap();
+   |                                   ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `get_default`
+
+error: aborting due to 34 previous errors
 
diff --git a/tests/ui/excessive_precision.stderr b/tests/ui/excessive_precision.stderr
index 6d8e166a649d8..81e4fb6765d0b 100644
--- a/tests/ui/excessive_precision.stderr
+++ b/tests/ui/excessive_precision.stderr
@@ -2,100 +2,179 @@ error: float has excessive precision
   --> tests/ui/excessive_precision.rs:20:26
    |
 LL |     const BAD32_1: f32 = 0.123_456_789_f32;
-   |                          ^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_79_f32`
+   |                          ^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::excessive-precision` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::excessive_precision)]`
+help: consider changing the type or truncating it to
+   |
+LL |     const BAD32_1: f32 = 0.123_456_79_f32;
+   |                          ~~~~~~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:21:26
    |
 LL |     const BAD32_2: f32 = 0.123_456_789;
-   |                          ^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_79`
+   |                          ^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     const BAD32_2: f32 = 0.123_456_79;
+   |                          ~~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:22:26
    |
 LL |     const BAD32_3: f32 = 0.100_000_000_000_1;
-   |                          ^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.1`
+   |                          ^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     const BAD32_3: f32 = 0.1;
+   |                          ~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:23:29
    |
 LL |     const BAD32_EDGE: f32 = 1.000_000_9;
-   |                             ^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.000_001`
+   |                             ^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     const BAD32_EDGE: f32 = 1.000_001;
+   |                             ~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:27:26
    |
 LL |     const BAD64_3: f64 = 0.100_000_000_000_000_000_1;
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.1`
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     const BAD64_3: f64 = 0.1;
+   |                          ~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:30:22
    |
 LL |     println!("{:?}", 8.888_888_888_888_888_888_888);
-   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `8.888_888_888_888_89`
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     println!("{:?}", 8.888_888_888_888_89);
+   |                      ~~~~~~~~~~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:41:22
    |
 LL |     let bad32: f32 = 1.123_456_789;
-   |                      ^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8`
+   |                      ^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     let bad32: f32 = 1.123_456_8;
+   |                      ~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:42:26
    |
 LL |     let bad32_suf: f32 = 1.123_456_789_f32;
-   |                          ^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8_f32`
+   |                          ^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     let bad32_suf: f32 = 1.123_456_8_f32;
+   |                          ~~~~~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:43:21
    |
 LL |     let bad32_inf = 1.123_456_789_f32;
-   |                     ^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8_f32`
+   |                     ^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     let bad32_inf = 1.123_456_8_f32;
+   |                     ~~~~~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:53:36
    |
 LL |     let bad_vec32: Vec<f32> = vec![0.123_456_789];
-   |                                    ^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_79`
+   |                                    ^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     let bad_vec32: Vec<f32> = vec![0.123_456_79];
+   |                                    ~~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:54:36
    |
 LL |     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_789];
-   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0.123_456_789_123_456_78`
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_78];
+   |                                    ~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:58:24
    |
 LL |     let bad_e32: f32 = 1.123_456_788_888e-10;
-   |                        ^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8e-10`
+   |                        ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     let bad_e32: f32 = 1.123_456_8e-10;
+   |                        ~~~~~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:61:27
    |
 LL |     let bad_bige32: f32 = 1.123_456_788_888E-10;
-   |                           ^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `1.123_456_8E-10`
+   |                           ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     let bad_bige32: f32 = 1.123_456_8E-10;
+   |                           ~~~~~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:70:13
    |
 LL |     let _ = 2.225_073_858_507_201_1e-308_f64;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `2.225_073_858_507_201e-308_f64`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     let _ = 2.225_073_858_507_201e-308_f64;
+   |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:73:13
    |
 LL |     let _ = 1.000_000_000_000_001e-324_f64;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `0_f64`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     let _ = 0_f64;
+   |             ~~~~~
 
 error: float has excessive precision
   --> tests/ui/excessive_precision.rs:83:20
    |
 LL |     const _: f64 = 3.0000000000000000e+00;
-   |                    ^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or truncating it to: `3.0`
+   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or truncating it to
+   |
+LL |     const _: f64 = 3.0;
+   |                    ~~~
 
 error: aborting due to 16 previous errors
 
diff --git a/tests/ui/explicit_counter_loop.rs b/tests/ui/explicit_counter_loop.rs
index c25e79a36171f..28b477b69215b 100644
--- a/tests/ui/explicit_counter_loop.rs
+++ b/tests/ui/explicit_counter_loop.rs
@@ -278,3 +278,16 @@ mod issue_10058 {
         }
     }
 }
+
+mod issue_13123 {
+    pub fn test() {
+        let mut vec = vec![1, 2, 3, 4];
+        let mut _index = 0;
+        'label: for v in vec {
+            _index += 1;
+            if v == 1 {
+                break 'label;
+            }
+        }
+    }
+}
diff --git a/tests/ui/explicit_counter_loop.stderr b/tests/ui/explicit_counter_loop.stderr
index e28f8783f9c36..1b2d1f8570a3e 100644
--- a/tests/ui/explicit_counter_loop.stderr
+++ b/tests/ui/explicit_counter_loop.stderr
@@ -57,5 +57,11 @@ LL |         for _item in slice {
    |
    = note: `idx_u32` is of type `u32`, making it ineligible for `Iterator::enumerate`
 
-error: aborting due to 9 previous errors
+error: the variable `_index` is used as a loop counter
+  --> tests/ui/explicit_counter_loop.rs:286:9
+   |
+LL |         'label: for v in vec {
+   |         ^^^^^^^^^^^^^^^^^^^^ help: consider using: `'label: for (_index, v) in vec.into_iter().enumerate()`
+
+error: aborting due to 10 previous errors
 
diff --git a/tests/ui/fn_to_numeric_cast_any.stderr b/tests/ui/fn_to_numeric_cast_any.stderr
index e5bb8d1326975..a05b7138bc99b 100644
--- a/tests/ui/fn_to_numeric_cast_any.stderr
+++ b/tests/ui/fn_to_numeric_cast_any.stderr
@@ -2,106 +2,190 @@ error: casting function pointer `foo` to `i8`
   --> tests/ui/fn_to_numeric_cast_any.rs:23:13
    |
 LL |     let _ = foo as i8;
-   |             ^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i8`
+   |             ^^^^^^^^^
    |
    = note: `-D clippy::fn-to-numeric-cast-any` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::fn_to_numeric_cast_any)]`
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as i8;
+   |             ~~~~~~~~~~~
 
 error: casting function pointer `foo` to `i16`
   --> tests/ui/fn_to_numeric_cast_any.rs:26:13
    |
 LL |     let _ = foo as i16;
-   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i16`
+   |             ^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as i16;
+   |             ~~~~~~~~~~~~
 
 error: casting function pointer `foo` to `i32`
   --> tests/ui/fn_to_numeric_cast_any.rs:28:13
    |
 LL |     let _ = foo as i32;
-   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i32`
+   |             ^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as i32;
+   |             ~~~~~~~~~~~~
 
 error: casting function pointer `foo` to `i64`
   --> tests/ui/fn_to_numeric_cast_any.rs:30:13
    |
 LL |     let _ = foo as i64;
-   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i64`
+   |             ^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as i64;
+   |             ~~~~~~~~~~~~
 
 error: casting function pointer `foo` to `i128`
   --> tests/ui/fn_to_numeric_cast_any.rs:32:13
    |
 LL |     let _ = foo as i128;
-   |             ^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as i128`
+   |             ^^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as i128;
+   |             ~~~~~~~~~~~~~
 
 error: casting function pointer `foo` to `isize`
   --> tests/ui/fn_to_numeric_cast_any.rs:34:13
    |
 LL |     let _ = foo as isize;
-   |             ^^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as isize`
+   |             ^^^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as isize;
+   |             ~~~~~~~~~~~~~~
 
 error: casting function pointer `foo` to `u8`
   --> tests/ui/fn_to_numeric_cast_any.rs:37:13
    |
 LL |     let _ = foo as u8;
-   |             ^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u8`
+   |             ^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as u8;
+   |             ~~~~~~~~~~~
 
 error: casting function pointer `foo` to `u16`
   --> tests/ui/fn_to_numeric_cast_any.rs:39:13
    |
 LL |     let _ = foo as u16;
-   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u16`
+   |             ^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as u16;
+   |             ~~~~~~~~~~~~
 
 error: casting function pointer `foo` to `u32`
   --> tests/ui/fn_to_numeric_cast_any.rs:41:13
    |
 LL |     let _ = foo as u32;
-   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u32`
+   |             ^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as u32;
+   |             ~~~~~~~~~~~~
 
 error: casting function pointer `foo` to `u64`
   --> tests/ui/fn_to_numeric_cast_any.rs:43:13
    |
 LL |     let _ = foo as u64;
-   |             ^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u64`
+   |             ^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as u64;
+   |             ~~~~~~~~~~~~
 
 error: casting function pointer `foo` to `u128`
   --> tests/ui/fn_to_numeric_cast_any.rs:45:13
    |
 LL |     let _ = foo as u128;
-   |             ^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as u128`
+   |             ^^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as u128;
+   |             ~~~~~~~~~~~~~
 
 error: casting function pointer `foo` to `usize`
   --> tests/ui/fn_to_numeric_cast_any.rs:47:13
    |
 LL |     let _ = foo as usize;
-   |             ^^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as usize`
+   |             ^^^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as usize;
+   |             ~~~~~~~~~~~~~~
 
 error: casting function pointer `Struct::static_method` to `usize`
   --> tests/ui/fn_to_numeric_cast_any.rs:52:13
    |
 LL |     let _ = Struct::static_method as usize;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `Struct::static_method() as usize`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = Struct::static_method() as usize;
+   |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting function pointer `f` to `usize`
   --> tests/ui/fn_to_numeric_cast_any.rs:57:5
    |
 LL |     f as usize
-   |     ^^^^^^^^^^ help: did you mean to invoke the function?: `f() as usize`
+   |     ^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     f() as usize
+   |
 
 error: casting function pointer `T::static_method` to `usize`
   --> tests/ui/fn_to_numeric_cast_any.rs:62:5
    |
 LL |     T::static_method as usize
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `T::static_method() as usize`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     T::static_method() as usize
+   |
 
 error: casting function pointer `(clos as fn(u32) -> u32)` to `usize`
   --> tests/ui/fn_to_numeric_cast_any.rs:69:13
    |
 LL |     let _ = (clos as fn(u32) -> u32) as usize;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `(clos as fn(u32) -> u32)() as usize`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = (clos as fn(u32) -> u32)() as usize;
+   |             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: casting function pointer `foo` to `*const ()`
   --> tests/ui/fn_to_numeric_cast_any.rs:74:13
    |
 LL |     let _ = foo as *const ();
-   |             ^^^^^^^^^^^^^^^^ help: did you mean to invoke the function?: `foo() as *const ()`
+   |             ^^^^^^^^^^^^^^^^
+   |
+help: did you mean to invoke the function?
+   |
+LL |     let _ = foo() as *const ();
+   |             ~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 17 previous errors
 
diff --git a/tests/ui/for_kv_map.fixed b/tests/ui/for_kv_map.fixed
index a2112d7b73005..1733b29128fe5 100644
--- a/tests/ui/for_kv_map.fixed
+++ b/tests/ui/for_kv_map.fixed
@@ -40,6 +40,16 @@ fn main() {
         let _k = k;
     }
 
+    let m: HashMap<u64, u64> = HashMap::new();
+    let rm = &m;
+    'label: for k in rm.keys() {
+        //~^ ERROR: you seem to want to iterate on a map's keys
+        let _k = k;
+        if *k == 0u64 {
+            break 'label;
+        }
+    }
+
     // The following should not produce warnings.
 
     let m: HashMap<u64, u64> = HashMap::new();
diff --git a/tests/ui/for_kv_map.rs b/tests/ui/for_kv_map.rs
index 1b7959b8f92d6..de465a7c8e6e3 100644
--- a/tests/ui/for_kv_map.rs
+++ b/tests/ui/for_kv_map.rs
@@ -40,6 +40,16 @@ fn main() {
         let _k = k;
     }
 
+    let m: HashMap<u64, u64> = HashMap::new();
+    let rm = &m;
+    'label: for (k, _value) in rm {
+        //~^ ERROR: you seem to want to iterate on a map's keys
+        let _k = k;
+        if *k == 0u64 {
+            break 'label;
+        }
+    }
+
     // The following should not produce warnings.
 
     let m: HashMap<u64, u64> = HashMap::new();
diff --git a/tests/ui/for_kv_map.stderr b/tests/ui/for_kv_map.stderr
index f4ce473d095bf..adcc3ab8fdb90 100644
--- a/tests/ui/for_kv_map.stderr
+++ b/tests/ui/for_kv_map.stderr
@@ -55,5 +55,16 @@ help: use the corresponding method
 LL |     for k in rm.keys() {
    |         ~    ~~~~~~~~~
 
-error: aborting due to 5 previous errors
+error: you seem to want to iterate on a map's keys
+  --> tests/ui/for_kv_map.rs:45:32
+   |
+LL |     'label: for (k, _value) in rm {
+   |                                ^^
+   |
+help: use the corresponding method
+   |
+LL |     'label: for k in rm.keys() {
+   |                 ~    ~~~~~~~~~
+
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui/get_unwrap.stderr b/tests/ui/get_unwrap.stderr
index a08b6657dcc7c..0f8b279da1e7a 100644
--- a/tests/ui/get_unwrap.stderr
+++ b/tests/ui/get_unwrap.stderr
@@ -1,14 +1,18 @@
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui/get_unwrap.rs:37:17
    |
 LL |         let _ = boxed_slice.get(1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&boxed_slice[1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> tests/ui/get_unwrap.rs:9:9
    |
 LL | #![deny(clippy::get_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &boxed_slice[1];
+   |                 ~~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:37:17
@@ -21,11 +25,16 @@ LL |         let _ = boxed_slice.get(1).unwrap();
    = note: `-D clippy::unwrap-used` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_used)]`
 
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui/get_unwrap.rs:38:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_slice[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &some_slice[0];
+   |                 ~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:38:17
@@ -36,11 +45,16 @@ LL |         let _ = some_slice.get(0).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a Vec
   --> tests/ui/get_unwrap.rs:39:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vec[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &some_vec[0];
+   |                 ~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:39:17
@@ -51,11 +65,16 @@ LL |         let _ = some_vec.get(0).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a VecDeque
   --> tests/ui/get_unwrap.rs:40:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_vecdeque[0]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &some_vecdeque[0];
+   |                 ~~~~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:40:17
@@ -66,11 +85,16 @@ LL |         let _ = some_vecdeque.get(0).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a HashMap. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a HashMap
   --> tests/ui/get_unwrap.rs:41:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_hashmap[&1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &some_hashmap[&1];
+   |                 ~~~~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:41:17
@@ -81,11 +105,16 @@ LL |         let _ = some_hashmap.get(&1).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a BTreeMap. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a BTreeMap
   --> tests/ui/get_unwrap.rs:42:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&some_btreemap[&1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = &some_btreemap[&1];
+   |                 ~~~~~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:42:17
@@ -96,11 +125,16 @@ LL |         let _ = some_btreemap.get(&1).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui/get_unwrap.rs:46:21
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[1]`
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _: u8 = boxed_slice[1];
+   |                     ~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:46:22
@@ -111,11 +145,16 @@ LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a slice
   --> tests/ui/get_unwrap.rs:51:9
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         boxed_slice[0] = 1;
+   |         ~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:51:10
@@ -126,11 +165,16 @@ LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a slice
   --> tests/ui/get_unwrap.rs:52:9
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_slice[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         some_slice[0] = 1;
+   |         ~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:52:10
@@ -141,11 +185,16 @@ LL |         *some_slice.get_mut(0).unwrap() = 1;
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a Vec
   --> tests/ui/get_unwrap.rs:53:9
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         some_vec[0] = 1;
+   |         ~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:53:10
@@ -156,11 +205,16 @@ LL |         *some_vec.get_mut(0).unwrap() = 1;
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get_mut().unwrap()` on a VecDeque. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a VecDeque
   --> tests/ui/get_unwrap.rs:54:9
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vecdeque[0]`
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         some_vecdeque[0] = 1;
+   |         ~~~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:54:10
@@ -171,11 +225,16 @@ LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a Vec
   --> tests/ui/get_unwrap.rs:66:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = some_vec[0..1].to_vec();
+   |                 ~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:66:17
@@ -186,11 +245,16 @@ LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get_mut().unwrap()` on a Vec. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a Vec
   --> tests/ui/get_unwrap.rs:67:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `some_vec[0..1]`
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _ = some_vec[0..1].to_vec();
+   |                 ~~~~~~~~~~~~~~
 
 error: used `unwrap()` on an `Option` value
   --> tests/ui/get_unwrap.rs:67:17
@@ -201,29 +265,49 @@ LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    = note: if this value is `None`, it will panic
    = help: consider using `expect()` to provide a better panic message
 
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui/get_unwrap.rs:77:24
    |
 LL |         let _x: &i32 = f.get(1 + 2).unwrap();
-   |                        ^^^^^^^^^^^^^^^^^^^^^ help: try: `&f[1 + 2]`
+   |                        ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _x: &i32 = &f[1 + 2];
+   |                        ~~~~~~~~~
 
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui/get_unwrap.rs:80:18
    |
 LL |         let _x = f.get(1 + 2).unwrap().to_string();
-   |                  ^^^^^^^^^^^^^^^^^^^^^ help: try: `f[1 + 2]`
+   |                  ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _x = f[1 + 2].to_string();
+   |                  ~~~~~~~~
 
-error: called `.get().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get().unwrap()` on a slice
   --> tests/ui/get_unwrap.rs:83:18
    |
 LL |         let _x = f.get(1 + 2).unwrap().abs();
-   |                  ^^^^^^^^^^^^^^^^^^^^^ help: try: `f[1 + 2]`
+   |                  ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |         let _x = f[1 + 2].abs();
+   |                  ~~~~~~~~
 
-error: called `.get_mut().unwrap()` on a slice. Using `[]` is more clear and more concise
+error: called `.get_mut().unwrap()` on a slice
   --> tests/ui/get_unwrap.rs:100:33
    |
 LL |                         let b = rest.get_mut(linidx(j, k) - linidx(i, k) - 1).unwrap();
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut rest[linidx(j, k) - linidx(i, k) - 1]`
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: using `[]` is clearer and more concise
+   |
+LL |                         let b = &mut rest[linidx(j, k) - linidx(i, k) - 1];
+   |                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 30 previous errors
 
diff --git a/tests/ui/if_let_mutex.rs b/tests/ui/if_let_mutex.rs
index cb6915e0ebaaa..bb0eadfca1c7a 100644
--- a/tests/ui/if_let_mutex.rs
+++ b/tests/ui/if_let_mutex.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::if_let_mutex)]
+#![allow(clippy::redundant_pattern_matching)]
 
 use std::ops::Deref;
 use std::sync::Mutex;
@@ -50,4 +51,12 @@ fn mutex_ref(mutex: &Mutex<i32>) {
     };
 }
 
+fn multiple_mutexes(m1: &Mutex<()>, m2: &Mutex<()>) {
+    if let Ok(_) = m1.lock() {
+        m2.lock();
+    } else {
+        m1.lock();
+    }
+}
+
 fn main() {}
diff --git a/tests/ui/if_let_mutex.stderr b/tests/ui/if_let_mutex.stderr
index 6e0115c23af68..45df4ac4d6795 100644
--- a/tests/ui/if_let_mutex.stderr
+++ b/tests/ui/if_let_mutex.stderr
@@ -1,5 +1,5 @@
 error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
-  --> tests/ui/if_let_mutex.rs:10:5
+  --> tests/ui/if_let_mutex.rs:11:5
    |
 LL |       if let Err(locked) = m.lock() {
    |       ^                    - this Mutex will remain locked for the entire `if let`-block...
@@ -19,7 +19,7 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::if_let_mutex)]`
 
 error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
-  --> tests/ui/if_let_mutex.rs:23:5
+  --> tests/ui/if_let_mutex.rs:24:5
    |
 LL |       if let Some(locked) = m.lock().unwrap().deref() {
    |       ^                     - this Mutex will remain locked for the entire `if let`-block...
@@ -37,7 +37,7 @@ LL | |     };
    = help: move the lock call outside of the `if let ...` expression
 
 error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
-  --> tests/ui/if_let_mutex.rs:45:5
+  --> tests/ui/if_let_mutex.rs:46:5
    |
 LL |       if let Ok(i) = mutex.lock() {
    |       ^              ----- this Mutex will remain locked for the entire `if let`-block...
@@ -53,5 +53,21 @@ LL | |     };
    |
    = help: move the lock call outside of the `if let ...` expression
 
-error: aborting due to 3 previous errors
+error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
+  --> tests/ui/if_let_mutex.rs:55:5
+   |
+LL |       if let Ok(_) = m1.lock() {
+   |       ^              -- this Mutex will remain locked for the entire `if let`-block...
+   |  _____|
+   | |
+LL | |         m2.lock();
+LL | |     } else {
+LL | |         m1.lock();
+   | |         -- ... and is tried to lock again here, which will always deadlock.
+LL | |     }
+   | |_____^
+   |
+   = help: move the lock call outside of the `if let ...` expression
+
+error: aborting due to 4 previous errors
 
diff --git a/tests/ui/if_then_some_else_none.fixed b/tests/ui/if_then_some_else_none.fixed
new file mode 100644
index 0000000000000..ad13372a68b7e
--- /dev/null
+++ b/tests/ui/if_then_some_else_none.fixed
@@ -0,0 +1,119 @@
+#![warn(clippy::if_then_some_else_none)]
+#![allow(clippy::redundant_pattern_matching, clippy::unnecessary_lazy_evaluations)]
+
+fn main() {
+    // Should issue an error.
+    let _ = foo().then(||  { println!("true!"); "foo" });
+
+    // Should issue an error when macros are used.
+    let _ = matches!(true, true).then(||  { println!("true!"); matches!(true, false) });
+
+    // Should issue an error. Binary expression `o < 32` should be parenthesized.
+    let x = Some(5);
+    let _ = x.and_then(|o| (o < 32).then_some(o));
+    //~^ ERROR: this could be simplified with `bool::then_some`
+
+    // Should issue an error. Unary expression `!x` should be parenthesized.
+    let x = true;
+    let _ = (!x).then_some(0);
+    //~^ ERROR: this could be simplified with `bool::then_some`
+
+    // Should not issue an error since the `else` block has a statement besides `None`.
+    let _ = if foo() {
+        println!("true!");
+        Some("foo")
+    } else {
+        eprintln!("false...");
+        None
+    };
+
+    // Should not issue an error since there are more than 2 blocks in the if-else chain.
+    let _ = if foo() {
+        println!("foo true!");
+        Some("foo")
+    } else if bar() {
+        println!("bar true!");
+        Some("bar")
+    } else {
+        None
+    };
+
+    let _ = if foo() {
+        println!("foo true!");
+        Some("foo")
+    } else {
+        bar().then(|| {
+            println!("bar true!");
+            "bar"
+        })
+    };
+
+    // Should not issue an error since the `then` block has `None`, not `Some`.
+    let _ = if foo() { None } else { Some("foo is false") };
+
+    // Should not issue an error since the `else` block doesn't use `None` directly.
+    let _ = if foo() { Some("foo is true") } else { into_none() };
+
+    // Should not issue an error since the `then` block doesn't use `Some` directly.
+    let _ = if foo() { into_some("foo") } else { None };
+}
+
+#[clippy::msrv = "1.49"]
+fn _msrv_1_49() {
+    // `bool::then` was stabilized in 1.50. Do not lint this
+    let _ = if foo() {
+        println!("true!");
+        Some(149)
+    } else {
+        None
+    };
+}
+
+#[clippy::msrv = "1.50"]
+fn _msrv_1_50() {
+    let _ = foo().then(||  { println!("true!"); 150 });
+}
+
+fn foo() -> bool {
+    unimplemented!()
+}
+
+fn bar() -> bool {
+    unimplemented!()
+}
+
+fn into_some<T>(v: T) -> Option<T> {
+    Some(v)
+}
+
+fn into_none<T>() -> Option<T> {
+    None
+}
+
+// Should not warn
+fn f(b: bool, v: Option<()>) -> Option<()> {
+    if b {
+        v?; // This is a potential early return, is not equivalent with `bool::then`
+
+        Some(())
+    } else {
+        None
+    }
+}
+
+fn issue11394(b: bool, v: Result<(), ()>) -> Result<(), ()> {
+    let x = if b {
+        #[allow(clippy::let_unit_value)]
+        let _ = v?;
+        Some(())
+    } else {
+        None
+    };
+
+    Ok(())
+}
+
+const fn issue12103(x: u32) -> Option<u32> {
+    // Should not issue an error in `const` context
+    if x > 42 { Some(150) } else { None }
+}
diff --git a/tests/ui/if_then_some_else_none.rs b/tests/ui/if_then_some_else_none.rs
index ccde154bd56ca..73edbb7da2a87 100644
--- a/tests/ui/if_then_some_else_none.rs
+++ b/tests/ui/if_then_some_else_none.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::if_then_some_else_none)]
-#![allow(clippy::redundant_pattern_matching)]
+#![allow(clippy::redundant_pattern_matching, clippy::unnecessary_lazy_evaluations)]
 
 fn main() {
     // Should issue an error.
diff --git a/tests/ui/if_then_some_else_none.stderr b/tests/ui/if_then_some_else_none.stderr
index e0a95aebdc134..aed01e026cbe7 100644
--- a/tests/ui/if_then_some_else_none.stderr
+++ b/tests/ui/if_then_some_else_none.stderr
@@ -9,9 +9,8 @@ LL | |         Some("foo")
 LL | |     } else {
 LL | |         None
 LL | |     };
-   | |_____^
+   | |_____^ help: try: `foo().then(||  { println!("true!"); "foo" })`
    |
-   = help: consider using `bool::then` like: `foo().then(|| { /* snippet */ "foo" })`
    = note: `-D clippy::if-then-some-else-none` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::if_then_some_else_none)]`
 
@@ -26,25 +25,19 @@ LL | |         Some(matches!(true, false))
 LL | |     } else {
 LL | |         None
 LL | |     };
-   | |_____^
-   |
-   = help: consider using `bool::then` like: `matches!(true, true).then(|| { /* snippet */ matches!(true, false) })`
+   | |_____^ help: try: `matches!(true, true).then(||  { println!("true!"); matches!(true, false) })`
 
 error: this could be simplified with `bool::then_some`
   --> tests/ui/if_then_some_else_none.rs:25:28
    |
 LL |     let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
-   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using `bool::then_some` like: `(o < 32).then_some(o)`
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(o < 32).then_some(o)`
 
 error: this could be simplified with `bool::then_some`
   --> tests/ui/if_then_some_else_none.rs:30:13
    |
 LL |     let _ = if !x { Some(0) } else { None };
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = help: consider using `bool::then_some` like: `(!x).then_some(0)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(!x).then_some(0)`
 
 error: this could be simplified with `bool::then`
   --> tests/ui/if_then_some_else_none.rs:86:13
@@ -57,9 +50,7 @@ LL | |         Some(150)
 LL | |     } else {
 LL | |         None
 LL | |     };
-   | |_____^
-   |
-   = help: consider using `bool::then` like: `foo().then(|| { /* snippet */ 150 })`
+   | |_____^ help: try: `foo().then(||  { println!("true!"); 150 })`
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/implicit_hasher.fixed b/tests/ui/implicit_hasher.fixed
new file mode 100644
index 0000000000000..2d6dc0274cf2a
--- /dev/null
+++ b/tests/ui/implicit_hasher.fixed
@@ -0,0 +1,102 @@
+//@aux-build:proc_macros.rs
+#![deny(clippy::implicit_hasher)]
+
+#[macro_use]
+extern crate proc_macros;
+
+use std::cmp::Eq;
+use std::collections::{HashMap, HashSet};
+use std::hash::{BuildHasher, Hash};
+
+pub trait Foo<T>: Sized {
+    fn make() -> (Self, Self);
+}
+
+impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashMap<K, V, S> {
+    fn make() -> (Self, Self) {
+        // OK, don't suggest to modify these
+        let _: HashMap<i32, i32> = HashMap::new();
+        let _: HashSet<i32> = HashSet::new();
+
+        (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
+    }
+}
+impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for (HashMap<K, V, S>,) {
+    fn make() -> (Self, Self) {
+        ((HashMap::default(),), (HashMap::with_capacity_and_hasher(10, Default::default()),))
+    }
+}
+impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashMap<String, String, S> {
+    fn make() -> (Self, Self) {
+        (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
+    }
+}
+
+impl<K: Hash + Eq, V, S: BuildHasher + Default> Foo<i32> for HashMap<K, V, S> {
+    fn make() -> (Self, Self) {
+        (HashMap::default(), HashMap::with_capacity_and_hasher(10, S::default()))
+    }
+}
+impl<S: BuildHasher + Default> Foo<i64> for HashMap<String, String, S> {
+    fn make() -> (Self, Self) {
+        (HashMap::default(), HashMap::with_capacity_and_hasher(10, S::default()))
+    }
+}
+
+impl<T: Hash + Eq, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashSet<T, S> {
+    fn make() -> (Self, Self) {
+        (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
+    }
+}
+impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashSet<String, S> {
+    fn make() -> (Self, Self) {
+        (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
+    }
+}
+
+impl<T: Hash + Eq, S: BuildHasher + Default> Foo<i32> for HashSet<T, S> {
+    fn make() -> (Self, Self) {
+        (HashSet::default(), HashSet::with_capacity_and_hasher(10, S::default()))
+    }
+}
+impl<S: BuildHasher + Default> Foo<i64> for HashSet<String, S> {
+    fn make() -> (Self, Self) {
+        (HashSet::default(), HashSet::with_capacity_and_hasher(10, S::default()))
+    }
+}
+
+pub fn map<S: ::std::hash::BuildHasher>(map: &mut HashMap<i32, i32, S>) {}
+
+pub fn set<S: ::std::hash::BuildHasher>(set: &mut HashSet<i32, S>) {}
+
+#[inline_macros]
+pub mod gen {
+    use super::*;
+    inline! {
+        impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<u8> for HashMap<K, V, S> {
+            fn make() -> (Self, Self) {
+                (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
+            }
+        }
+
+        pub fn bar(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32>) {}
+    }
+}
+
+// When the macro is in a different file, the suggestion spans can't be combined properly
+// and should not cause an ICE
+// See #2707
+#[macro_use]
+#[path = "auxiliary/test_macro.rs"]
+pub mod test_macro;
+__implicit_hasher_test_macro!(impl<K, V> for HashMap<K, V> where V: test_macro::A);
+
+// #4260
+external! {
+    pub fn f(input: &HashMap<u32, u32>) {}
+}
+
+// #7712
+pub async fn election_vote<S: ::std::hash::BuildHasher>(_data: HashMap<i32, i32, S>) {}
+
+fn main() {}
diff --git a/tests/ui/implicit_hasher.rs b/tests/ui/implicit_hasher.rs
index f7cd541741b11..0a334357bd1b8 100644
--- a/tests/ui/implicit_hasher.rs
+++ b/tests/ui/implicit_hasher.rs
@@ -1,11 +1,8 @@
 //@aux-build:proc_macros.rs
-//@no-rustfix
 #![deny(clippy::implicit_hasher)]
-#![allow(unused)]
 
 #[macro_use]
 extern crate proc_macros;
-use proc_macros::external;
 
 use std::cmp::Eq;
 use std::collections::{HashMap, HashSet};
@@ -68,9 +65,11 @@ impl<S: BuildHasher + Default> Foo<i64> for HashSet<String, S> {
     }
 }
 
-pub fn foo(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32>) {}
+pub fn map(map: &mut HashMap<i32, i32>) {}
 
-#[proc_macros::inline_macros]
+pub fn set(set: &mut HashSet<i32>) {}
+
+#[inline_macros]
 pub mod gen {
     use super::*;
     inline! {
diff --git a/tests/ui/implicit_hasher.stderr b/tests/ui/implicit_hasher.stderr
index a3df8edf389be..48c6ebc209cf3 100644
--- a/tests/ui/implicit_hasher.stderr
+++ b/tests/ui/implicit_hasher.stderr
@@ -1,40 +1,121 @@
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
-  --> tests/ui/implicit_hasher.rs:14:1
+error: impl for `HashMap` should be generalized over different hashers
+  --> tests/ui/implicit_hasher.rs:15:35
+   |
+LL | impl<K: Hash + Eq, V> Foo<i8> for HashMap<K, V> {
+   |                                   ^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> tests/ui/implicit_hasher.rs:2:9
+   |
+LL | #![deny(clippy::implicit_hasher)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+help: add a type parameter for `BuildHasher`
+   |
+LL ~ impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashMap<K, V, S> {
+LL |     fn make() -> (Self, Self) {
+...
+LL |
+LL ~         (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
+   |
+
+error: impl for `HashMap` should be generalized over different hashers
+  --> tests/ui/implicit_hasher.rs:24:36
+   |
+LL | impl<K: Hash + Eq, V> Foo<i8> for (HashMap<K, V>,) {
+   |                                    ^^^^^^^^^^^^^
+   |
+help: add a type parameter for `BuildHasher`
+   |
+LL ~ impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for (HashMap<K, V, S>,) {
+LL |     fn make() -> (Self, Self) {
+LL ~         ((HashMap::default(),), (HashMap::with_capacity_and_hasher(10, Default::default()),))
+   |
+
+error: impl for `HashMap` should be generalized over different hashers
+  --> tests/ui/implicit_hasher.rs:29:19
+   |
+LL | impl Foo<i16> for HashMap<String, String> {
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: add a type parameter for `BuildHasher`
+   |
+LL ~ impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashMap<String, String, S> {
+LL |     fn make() -> (Self, Self) {
+LL ~         (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
+   |
+
+error: impl for `HashSet` should be generalized over different hashers
+  --> tests/ui/implicit_hasher.rs:46:32
+   |
+LL | impl<T: Hash + Eq> Foo<i8> for HashSet<T> {
+   |                                ^^^^^^^^^^
+   |
+help: add a type parameter for `BuildHasher`
+   |
+LL ~ impl<T: Hash + Eq, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashSet<T, S> {
+LL |     fn make() -> (Self, Self) {
+LL ~         (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
    |
-LL | pub trait Foo<T>: Sized {
-   | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
-  --> tests/ui/implicit_hasher.rs:71:1
+error: impl for `HashSet` should be generalized over different hashers
+  --> tests/ui/implicit_hasher.rs:51:19
+   |
+LL | impl Foo<i16> for HashSet<String> {
+   |                   ^^^^^^^^^^^^^^^
+   |
+help: add a type parameter for `BuildHasher`
+   |
+LL ~ impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashSet<String, S> {
+LL |     fn make() -> (Self, Self) {
+LL ~         (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
    |
-LL | pub fn foo(_map: &mut HashMap<i32, i32>, _set: &mut HashSet<i32>) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
-  --> tests/ui/implicit_hasher.rs:74:1
+error: parameter of type `HashMap` should be generalized over different hashers
+  --> tests/ui/implicit_hasher.rs:68:22
+   |
+LL | pub fn map(map: &mut HashMap<i32, i32>) {}
+   |                      ^^^^^^^^^^^^^^^^^
    |
-LL | pub mod gen {
-   | ^^^^^^^^^^^
+help: add a type parameter for `BuildHasher`
+   |
+LL | pub fn map<S: ::std::hash::BuildHasher>(map: &mut HashMap<i32, i32, S>) {}
+   |           +++++++++++++++++++++++++++++           ~~~~~~~~~~~~~~~~~~~~
 
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
-  --> tests/ui/implicit_hasher.rs:92:1
+error: parameter of type `HashSet` should be generalized over different hashers
+  --> tests/ui/implicit_hasher.rs:70:22
+   |
+LL | pub fn set(set: &mut HashSet<i32>) {}
+   |                      ^^^^^^^^^^^^
    |
-LL | pub mod test_macro;
-   | ^^^^^^^^^^^^^^^^^^^
+help: add a type parameter for `BuildHasher`
+   |
+LL | pub fn set<S: ::std::hash::BuildHasher>(set: &mut HashSet<i32, S>) {}
+   |           +++++++++++++++++++++++++++++           ~~~~~~~~~~~~~~~
 
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
-  --> tests/ui/implicit_hasher.rs:96:1
+error: impl for `HashMap` should be generalized over different hashers
+  --> tests/ui/implicit_hasher.rs:76:43
+   |
+LL |         impl<K: Hash + Eq, V> Foo<u8> for HashMap<K, V> {
+   |                                           ^^^^^^^^^^^^^
    |
-LL | external! {
-   | ^^^^^^^^^
+   = note: this error originates in the macro `__inline_mac_mod_gen` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: add a type parameter for `BuildHasher`
+   |
+LL ~         impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<u8> for HashMap<K, V, S> {
+LL |             fn make() -> (Self, Self) {
+LL ~                 (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
    |
-   = note: this error originates in the macro `external` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]`
-  --> tests/ui/implicit_hasher.rs:101:1
+error: parameter of type `HashMap` should be generalized over different hashers
+  --> tests/ui/implicit_hasher.rs:100:35
    |
 LL | pub async fn election_vote(_data: HashMap<i32, i32>) {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                   ^^^^^^^^^^^^^^^^^
+   |
+help: add a type parameter for `BuildHasher`
+   |
+LL | pub async fn election_vote<S: ::std::hash::BuildHasher>(_data: HashMap<i32, i32, S>) {}
+   |                           +++++++++++++++++++++++++++++        ~~~~~~~~~~~~~~~~~~~~
 
-error: aborting due to 6 previous errors
+error: aborting due to 9 previous errors
 
diff --git a/tests/ui/implicit_return.stderr b/tests/ui/implicit_return.stderr
index f06d4e983c57a..3b06f26f5a05f 100644
--- a/tests/ui/implicit_return.stderr
+++ b/tests/ui/implicit_return.stderr
@@ -2,88 +2,157 @@ error: missing `return` statement
   --> tests/ui/implicit_return.rs:15:5
    |
 LL |     true
-   |     ^^^^ help: add `return` as shown: `return true`
+   |     ^^^^
    |
    = note: `-D clippy::implicit-return` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::implicit_return)]`
+help: add `return` as shown
+   |
+LL |     return true
+   |
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:19:15
    |
 LL |     if true { true } else { false }
-   |               ^^^^ help: add `return` as shown: `return true`
+   |               ^^^^
+   |
+help: add `return` as shown
+   |
+LL |     if true { return true } else { false }
+   |               ~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:19:29
    |
 LL |     if true { true } else { false }
-   |                             ^^^^^ help: add `return` as shown: `return false`
+   |                             ^^^^^
+   |
+help: add `return` as shown
+   |
+LL |     if true { true } else { return false }
+   |                             ~~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:25:17
    |
 LL |         true => false,
-   |                 ^^^^^ help: add `return` as shown: `return false`
+   |                 ^^^^^
+   |
+help: add `return` as shown
+   |
+LL |         true => return false,
+   |                 ~~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:26:20
    |
 LL |         false => { true },
-   |                    ^^^^ help: add `return` as shown: `return true`
+   |                    ^^^^
+   |
+help: add `return` as shown
+   |
+LL |         false => { return true },
+   |                    ~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:39:9
    |
 LL |         break true;
-   |         ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
+   |         ^^^^^^^^^^
+   |
+help: change `break` to `return` as shown
+   |
+LL |         return true;
+   |         ~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:46:13
    |
 LL |             break true;
-   |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
+   |             ^^^^^^^^^^
+   |
+help: change `break` to `return` as shown
+   |
+LL |             return true;
+   |             ~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:54:13
    |
 LL |             break true;
-   |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
+   |             ^^^^^^^^^^
+   |
+help: change `break` to `return` as shown
+   |
+LL |             return true;
+   |             ~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:72:18
    |
 LL |     let _ = || { true };
-   |                  ^^^^ help: add `return` as shown: `return true`
+   |                  ^^^^
+   |
+help: add `return` as shown
+   |
+LL |     let _ = || { return true };
+   |                  ~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:73:16
    |
 LL |     let _ = || true;
-   |                ^^^^ help: add `return` as shown: `return true`
+   |                ^^^^
+   |
+help: add `return` as shown
+   |
+LL |     let _ = || return true;
+   |                ~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:81:5
    |
 LL |     format!("test {}", "test")
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add `return` as shown: `return format!("test {}", "test")`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: add `return` as shown
+   |
+LL |     return format!("test {}", "test")
+   |
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:90:5
    |
 LL |     m!(true, false)
-   |     ^^^^^^^^^^^^^^^ help: add `return` as shown: `return m!(true, false)`
+   |     ^^^^^^^^^^^^^^^
+   |
+help: add `return` as shown
+   |
+LL |     return m!(true, false)
+   |
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:96:13
    |
 LL |             break true;
-   |             ^^^^^^^^^^ help: change `break` to `return` as shown: `return true`
+   |             ^^^^^^^^^^
+   |
+help: change `break` to `return` as shown
+   |
+LL |             return true;
+   |             ~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:101:17
    |
 LL |                 break 'outer false;
-   |                 ^^^^^^^^^^^^^^^^^^ help: change `break` to `return` as shown: `return false`
+   |                 ^^^^^^^^^^^^^^^^^^
+   |
+help: change `break` to `return` as shown
+   |
+LL |                 return false;
+   |                 ~~~~~~~~~~~~
 
 error: missing `return` statement
   --> tests/ui/implicit_return.rs:116:5
@@ -104,7 +173,12 @@ error: missing `return` statement
   --> tests/ui/implicit_return.rs:130:5
    |
 LL |     true
-   |     ^^^^ help: add `return` as shown: `return true`
+   |     ^^^^
+   |
+help: add `return` as shown
+   |
+LL |     return true
+   |
 
 error: aborting due to 16 previous errors
 
diff --git a/tests/ui/lossy_float_literal.stderr b/tests/ui/lossy_float_literal.stderr
index b5a07418734c9..3026854e317ae 100644
--- a/tests/ui/lossy_float_literal.stderr
+++ b/tests/ui/lossy_float_literal.stderr
@@ -2,70 +2,124 @@ error: literal cannot be represented as the underlying type without loss of prec
   --> tests/ui/lossy_float_literal.rs:14:18
    |
 LL |     let _: f32 = 16_777_217.0;
-   |                  ^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_216.0`
+   |                  ^^^^^^^^^^^^
    |
    = note: `-D clippy::lossy-float-literal` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::lossy_float_literal)]`
+help: consider changing the type or replacing it with
+   |
+LL |     let _: f32 = 16_777_216.0;
+   |                  ~~~~~~~~~~~~
 
 error: literal cannot be represented as the underlying type without loss of precision
   --> tests/ui/lossy_float_literal.rs:15:18
    |
 LL |     let _: f32 = 16_777_219.0;
-   |                  ^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
+   |                  ^^^^^^^^^^^^
+   |
+help: consider changing the type or replacing it with
+   |
+LL |     let _: f32 = 16_777_220.0;
+   |                  ~~~~~~~~~~~~
 
 error: literal cannot be represented as the underlying type without loss of precision
   --> tests/ui/lossy_float_literal.rs:16:18
    |
 LL |     let _: f32 = 16_777_219.;
-   |                  ^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
+   |                  ^^^^^^^^^^^
+   |
+help: consider changing the type or replacing it with
+   |
+LL |     let _: f32 = 16_777_220.0;
+   |                  ~~~~~~~~~~~~
 
 error: literal cannot be represented as the underlying type without loss of precision
   --> tests/ui/lossy_float_literal.rs:17:18
    |
 LL |     let _: f32 = 16_777_219.000;
-   |                  ^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
+   |                  ^^^^^^^^^^^^^^
+   |
+help: consider changing the type or replacing it with
+   |
+LL |     let _: f32 = 16_777_220.0;
+   |                  ~~~~~~~~~~~~
 
 error: literal cannot be represented as the underlying type without loss of precision
   --> tests/ui/lossy_float_literal.rs:18:13
    |
 LL |     let _ = 16_777_219f32;
-   |             ^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220_f32`
+   |             ^^^^^^^^^^^^^
+   |
+help: consider changing the type or replacing it with
+   |
+LL |     let _ = 16_777_220_f32;
+   |             ~~~~~~~~~~~~~~
 
 error: literal cannot be represented as the underlying type without loss of precision
   --> tests/ui/lossy_float_literal.rs:19:19
    |
 LL |     let _: f32 = -16_777_219.0;
-   |                   ^^^^^^^^^^^^ help: consider changing the type or replacing it with: `16_777_220.0`
+   |                   ^^^^^^^^^^^^
+   |
+help: consider changing the type or replacing it with
+   |
+LL |     let _: f32 = -16_777_220.0;
+   |                   ~~~~~~~~~~~~
 
 error: literal cannot be represented as the underlying type without loss of precision
   --> tests/ui/lossy_float_literal.rs:21:18
    |
 LL |     let _: f64 = 9_007_199_254_740_993.0;
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or replacing it with
+   |
+LL |     let _: f64 = 9_007_199_254_740_992.0;
+   |                  ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: literal cannot be represented as the underlying type without loss of precision
   --> tests/ui/lossy_float_literal.rs:22:18
    |
 LL |     let _: f64 = 9_007_199_254_740_993.;
-   |                  ^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
+   |                  ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or replacing it with
+   |
+LL |     let _: f64 = 9_007_199_254_740_992.0;
+   |                  ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: literal cannot be represented as the underlying type without loss of precision
   --> tests/ui/lossy_float_literal.rs:23:18
    |
 LL |     let _: f64 = 9_007_199_254_740_993.00;
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or replacing it with
+   |
+LL |     let _: f64 = 9_007_199_254_740_992.0;
+   |                  ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: literal cannot be represented as the underlying type without loss of precision
   --> tests/ui/lossy_float_literal.rs:24:13
    |
 LL |     let _ = 9_007_199_254_740_993f64;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992_f64`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or replacing it with
+   |
+LL |     let _ = 9_007_199_254_740_992_f64;
+   |             ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: literal cannot be represented as the underlying type without loss of precision
   --> tests/ui/lossy_float_literal.rs:25:19
    |
 LL |     let _: f64 = -9_007_199_254_740_993.0;
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing the type or replacing it with: `9_007_199_254_740_992.0`
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider changing the type or replacing it with
+   |
+LL |     let _: f64 = -9_007_199_254_740_992.0;
+   |                   ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 11 previous errors
 
diff --git a/tests/ui/missing_trait_methods.rs b/tests/ui/missing_trait_methods.rs
index 1b09b717ff70a..55b904bde59af 100644
--- a/tests/ui/missing_trait_methods.rs
+++ b/tests/ui/missing_trait_methods.rs
@@ -49,4 +49,12 @@ impl B for Complete {
     }
 }
 
+trait MissingMultiple {
+    fn one() {}
+    fn two() {}
+    fn three() {}
+}
+
+impl MissingMultiple for Partial {}
+
 fn main() {}
diff --git a/tests/ui/missing_trait_methods.stderr b/tests/ui/missing_trait_methods.stderr
index f5d5d4418b287..9c4968b022d7e 100644
--- a/tests/ui/missing_trait_methods.stderr
+++ b/tests/ui/missing_trait_methods.stderr
@@ -24,5 +24,41 @@ help: implement the method
 LL |     fn b<'a, T: AsRef<[u8]>>(a: &'a T) -> &'a [u8] {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 2 previous errors
+error: missing trait method provided by default: `one`
+  --> tests/ui/missing_trait_methods.rs:58:1
+   |
+LL | impl MissingMultiple for Partial {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: implement the method
+  --> tests/ui/missing_trait_methods.rs:53:5
+   |
+LL |     fn one() {}
+   |     ^^^^^^^^
+
+error: missing trait method provided by default: `two`
+  --> tests/ui/missing_trait_methods.rs:58:1
+   |
+LL | impl MissingMultiple for Partial {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: implement the method
+  --> tests/ui/missing_trait_methods.rs:54:5
+   |
+LL |     fn two() {}
+   |     ^^^^^^^^
+
+error: missing trait method provided by default: `three`
+  --> tests/ui/missing_trait_methods.rs:58:1
+   |
+LL | impl MissingMultiple for Partial {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: implement the method
+  --> tests/ui/missing_trait_methods.rs:55:5
+   |
+LL |     fn three() {}
+   |     ^^^^^^^^^^
+
+error: aborting due to 5 previous errors
 
diff --git a/tests/ui/needless_borrows_for_generic_args.fixed b/tests/ui/needless_borrows_for_generic_args.fixed
index 5478372cbe00f..c1dc8b5e8d09c 100644
--- a/tests/ui/needless_borrows_for_generic_args.fixed
+++ b/tests/ui/needless_borrows_for_generic_args.fixed
@@ -333,4 +333,12 @@ fn main() {
         f(&y); // Don't lint
         f("".to_owned()); // Lint
     }
+    {
+        fn takes_writer<T: std::io::Write>(_: T) {}
+
+        fn issue_12856(mut buffer: &mut Vec<u8>) {
+            takes_writer(&mut buffer); // Don't lint, would make buffer unavailable later
+            buffer.extend(b"\n");
+        }
+    }
 }
diff --git a/tests/ui/needless_borrows_for_generic_args.rs b/tests/ui/needless_borrows_for_generic_args.rs
index 2643815d939b5..c7f66824d5818 100644
--- a/tests/ui/needless_borrows_for_generic_args.rs
+++ b/tests/ui/needless_borrows_for_generic_args.rs
@@ -333,4 +333,12 @@ fn main() {
         f(&y); // Don't lint
         f(&"".to_owned()); // Lint
     }
+    {
+        fn takes_writer<T: std::io::Write>(_: T) {}
+
+        fn issue_12856(mut buffer: &mut Vec<u8>) {
+            takes_writer(&mut buffer); // Don't lint, would make buffer unavailable later
+            buffer.extend(b"\n");
+        }
+    }
 }
diff --git a/tests/ui/needless_pub_self.stderr b/tests/ui/needless_pub_self.stderr
index 0bff2e4b8b71b..1fdd841656594 100644
--- a/tests/ui/needless_pub_self.stderr
+++ b/tests/ui/needless_pub_self.stderr
@@ -2,22 +2,27 @@ error: unnecessary `pub(self)`
   --> tests/ui/needless_pub_self.rs:13:1
    |
 LL | pub(self) fn a() {}
-   | ^^^^^^^^^ help: remove it
+   | ^^^^^^^^^
    |
    = note: `-D clippy::needless-pub-self` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::needless_pub_self)]`
+   = help: remove it
 
 error: unnecessary `pub(in self)`
   --> tests/ui/needless_pub_self.rs:14:1
    |
 LL | pub(in self) fn b() {}
-   | ^^^^^^^^^^^^ help: remove it
+   | ^^^^^^^^^^^^
+   |
+   = help: remove it
 
 error: unnecessary `pub(self)`
   --> tests/ui/needless_pub_self.rs:20:5
    |
 LL |     pub(self) fn f() {}
-   |     ^^^^^^^^^ help: remove it
+   |     ^^^^^^^^^
+   |
+   = help: remove it
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/nonminimal_bool.rs b/tests/ui/nonminimal_bool.rs
index d117e8bf9c7a1..52b0155a762ea 100644
--- a/tests/ui/nonminimal_bool.rs
+++ b/tests/ui/nonminimal_bool.rs
@@ -177,3 +177,9 @@ fn issue_12371(x: usize) -> bool {
     // Should not warn!
     !x != 0
 }
+
+// Not linted because it is slow to do so
+// https://github.com/rust-lang/rust-clippy/issues/13206
+fn many_ops(a: bool, b: bool, c: bool, d: bool, e: bool, f: bool) -> bool {
+    (a && c && f) || (!a && b && !d) || (!b && !c && !e) || (d && e && !f)
+}
diff --git a/tests/ui/patterns.fixed b/tests/ui/patterns.fixed
index 332cba9715575..feaec33ac15a1 100644
--- a/tests/ui/patterns.fixed
+++ b/tests/ui/patterns.fixed
@@ -1,7 +1,7 @@
 //@aux-build:proc_macros.rs
 #![warn(clippy::all)]
 #![allow(unused)]
-#![allow(clippy::uninlined_format_args)]
+#![allow(clippy::uninlined_format_args, clippy::single_match)]
 
 #[macro_use]
 extern crate proc_macros;
diff --git a/tests/ui/patterns.rs b/tests/ui/patterns.rs
index 45d907688e379..53812c7deec3e 100644
--- a/tests/ui/patterns.rs
+++ b/tests/ui/patterns.rs
@@ -1,7 +1,7 @@
 //@aux-build:proc_macros.rs
 #![warn(clippy::all)]
 #![allow(unused)]
-#![allow(clippy::uninlined_format_args)]
+#![allow(clippy::uninlined_format_args, clippy::single_match)]
 
 #[macro_use]
 extern crate proc_macros;
diff --git a/tests/ui/rename.fixed b/tests/ui/rename.fixed
index d70c9f8d06c07..b810fd8224f63 100644
--- a/tests/ui/rename.fixed
+++ b/tests/ui/rename.fixed
@@ -13,7 +13,10 @@
 #![allow(clippy::disallowed_methods)]
 #![allow(clippy::disallowed_types)]
 #![allow(clippy::mixed_read_write_in_expression)]
+#![allow(clippy::manual_find_map)]
+#![allow(clippy::manual_filter_map)]
 #![allow(clippy::useless_conversion)]
+#![allow(clippy::redundant_pattern_matching)]
 #![allow(clippy::match_result_ok)]
 #![allow(clippy::non_canonical_clone_impl)]
 #![allow(clippy::non_canonical_partial_ord_impl)]
@@ -47,6 +50,7 @@
 #![allow(invalid_value)]
 #![allow(invalid_from_utf8_unchecked)]
 #![allow(let_underscore_drop)]
+#![allow(unexpected_cfgs)]
 #![allow(enum_intrinsics_non_enums)]
 #![allow(non_fmt_panics)]
 #![allow(named_arguments_used_positionally)]
@@ -55,65 +59,72 @@
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
 #![allow(ambiguous_wide_pointer_comparisons)]
-#![warn(clippy::almost_complete_range)]
-#![warn(clippy::disallowed_names)]
-#![warn(clippy::blocks_in_conditions)]
-#![warn(clippy::blocks_in_conditions)]
-#![warn(clippy::blocks_in_conditions)]
-#![warn(clippy::box_collection)]
-#![warn(clippy::redundant_static_lifetimes)]
-#![warn(clippy::cognitive_complexity)]
-#![warn(clippy::derived_hash_with_manual_eq)]
-#![warn(clippy::disallowed_methods)]
-#![warn(clippy::disallowed_types)]
-#![warn(clippy::mixed_read_write_in_expression)]
-#![warn(clippy::useless_conversion)]
-#![warn(clippy::match_result_ok)]
-#![warn(clippy::non_canonical_clone_impl)]
-#![warn(clippy::non_canonical_partial_ord_impl)]
-#![warn(clippy::arithmetic_side_effects)]
-#![warn(clippy::overly_complex_bool_expr)]
-#![warn(clippy::new_without_default)]
-#![warn(clippy::bind_instead_of_map)]
-#![warn(clippy::expect_used)]
-#![warn(clippy::map_unwrap_or)]
-#![warn(clippy::map_unwrap_or)]
-#![warn(clippy::unwrap_used)]
-#![warn(clippy::panicking_overflow_checks)]
-#![warn(clippy::needless_borrow)]
-#![warn(clippy::expect_used)]
-#![warn(clippy::map_unwrap_or)]
-#![warn(clippy::unwrap_used)]
-#![warn(clippy::single_char_add_str)]
-#![warn(clippy::module_name_repetitions)]
-#![warn(clippy::missing_const_for_thread_local)]
-#![warn(clippy::recursive_format_impl)]
-#![warn(clippy::unwrap_or_default)]
-#![warn(clippy::invisible_characters)]
-#![warn(invalid_reference_casting)]
-#![warn(suspicious_double_ref_op)]
-#![warn(invalid_nan_comparisons)]
-#![warn(drop_bounds)]
-#![warn(dropping_copy_types)]
-#![warn(dropping_references)]
-#![warn(useless_ptr_null_checks)]
-#![warn(for_loops_over_fallibles)]
-#![warn(for_loops_over_fallibles)]
-#![warn(for_loops_over_fallibles)]
-#![warn(forgetting_copy_types)]
-#![warn(forgetting_references)]
-#![warn(array_into_iter)]
-#![warn(invalid_atomic_ordering)]
-#![warn(invalid_value)]
-#![warn(invalid_from_utf8_unchecked)]
-#![warn(let_underscore_drop)]
-#![warn(enum_intrinsics_non_enums)]
-#![warn(non_fmt_panics)]
-#![warn(named_arguments_used_positionally)]
-#![warn(temporary_cstring_as_ptr)]
-#![warn(undropped_manually_drops)]
-#![warn(unknown_lints)]
-#![warn(unused_labels)]
-#![warn(ambiguous_wide_pointer_comparisons)]
+#![allow(clippy::reversed_empty_ranges)]
+#![warn(clippy::almost_complete_range)] //~ ERROR: lint `clippy::almost_complete_letter_range`
+#![warn(clippy::disallowed_names)] //~ ERROR: lint `clippy::blacklisted_name`
+#![warn(clippy::blocks_in_conditions)] //~ ERROR: lint `clippy::block_in_if_condition_expr`
+#![warn(clippy::blocks_in_conditions)] //~ ERROR: lint `clippy::block_in_if_condition_stmt`
+#![warn(clippy::blocks_in_conditions)] //~ ERROR: lint `clippy::blocks_in_if_conditions`
+#![warn(clippy::box_collection)] //~ ERROR: lint `clippy::box_vec`
+#![warn(clippy::redundant_static_lifetimes)] //~ ERROR: lint `clippy::const_static_lifetime`
+#![warn(clippy::cognitive_complexity)] //~ ERROR: lint `clippy::cyclomatic_complexity`
+#![warn(clippy::derived_hash_with_manual_eq)] //~ ERROR: lint `clippy::derive_hash_xor_eq`
+#![warn(clippy::disallowed_methods)] //~ ERROR: lint `clippy::disallowed_method`
+#![warn(clippy::disallowed_types)] //~ ERROR: lint `clippy::disallowed_type`
+#![warn(clippy::mixed_read_write_in_expression)] //~ ERROR: lint `clippy::eval_order_dependence`
+#![warn(clippy::manual_find_map)] //~ ERROR: lint `clippy::find_map`
+#![warn(clippy::manual_filter_map)] //~ ERROR: lint `clippy::filter_map`
+#![warn(clippy::useless_conversion)] //~ ERROR: lint `clippy::identity_conversion`
+#![warn(clippy::redundant_pattern_matching)] //~ ERROR: lint `clippy::if_let_redundant_pattern_matching`
+#![warn(clippy::match_result_ok)] //~ ERROR: lint `clippy::if_let_some_result`
+#![warn(clippy::non_canonical_clone_impl)] //~ ERROR: lint `clippy::incorrect_clone_impl_on_copy_type`
+#![warn(clippy::non_canonical_partial_ord_impl)] //~ ERROR: lint `clippy::incorrect_partial_ord_impl_on_ord_type`
+#![warn(clippy::arithmetic_side_effects)] //~ ERROR: lint `clippy::integer_arithmetic`
+#![warn(clippy::overly_complex_bool_expr)] //~ ERROR: lint `clippy::logic_bug`
+#![warn(clippy::new_without_default)] //~ ERROR: lint `clippy::new_without_default_derive`
+#![warn(clippy::bind_instead_of_map)] //~ ERROR: lint `clippy::option_and_then_some`
+#![warn(clippy::expect_used)] //~ ERROR: lint `clippy::option_expect_used`
+#![warn(clippy::map_unwrap_or)] //~ ERROR: lint `clippy::option_map_unwrap_or`
+#![warn(clippy::map_unwrap_or)] //~ ERROR: lint `clippy::option_map_unwrap_or_else`
+#![warn(clippy::unwrap_used)] //~ ERROR: lint `clippy::option_unwrap_used`
+#![warn(clippy::panicking_overflow_checks)] //~ ERROR: lint `clippy::overflow_check_conditional`
+#![warn(clippy::needless_borrow)] //~ ERROR: lint `clippy::ref_in_deref`
+#![warn(clippy::expect_used)] //~ ERROR: lint `clippy::result_expect_used`
+#![warn(clippy::map_unwrap_or)] //~ ERROR: lint `clippy::result_map_unwrap_or_else`
+#![warn(clippy::unwrap_used)] //~ ERROR: lint `clippy::result_unwrap_used`
+#![warn(clippy::single_char_add_str)] //~ ERROR: lint `clippy::single_char_push_str`
+#![warn(clippy::module_name_repetitions)] //~ ERROR: lint `clippy::stutter`
+#![warn(clippy::missing_const_for_thread_local)] //~ ERROR: lint `clippy::thread_local_initializer_can_be_made_const`
+#![warn(clippy::recursive_format_impl)] //~ ERROR: lint `clippy::to_string_in_display`
+#![warn(clippy::unwrap_or_default)] //~ ERROR: lint `clippy::unwrap_or_else_default`
+#![warn(clippy::invisible_characters)] //~ ERROR: lint `clippy::zero_width_space`
+#![warn(invalid_reference_casting)] //~ ERROR: lint `clippy::cast_ref_to_mut`
+#![warn(suspicious_double_ref_op)] //~ ERROR: lint `clippy::clone_double_ref`
+#![warn(invalid_nan_comparisons)] //~ ERROR: lint `clippy::cmp_nan`
+#![warn(drop_bounds)] //~ ERROR: lint `clippy::drop_bounds`
+#![warn(dropping_copy_types)] //~ ERROR: lint `clippy::drop_copy`
+#![warn(dropping_references)] //~ ERROR: lint `clippy::drop_ref`
+#![warn(useless_ptr_null_checks)] //~ ERROR: lint `clippy::fn_null_check`
+#![warn(for_loops_over_fallibles)] //~ ERROR: lint `clippy::for_loop_over_option`
+#![warn(for_loops_over_fallibles)] //~ ERROR: lint `clippy::for_loop_over_result`
+#![warn(for_loops_over_fallibles)] //~ ERROR: lint `clippy::for_loops_over_fallibles`
+#![warn(forgetting_copy_types)] //~ ERROR: lint `clippy::forget_copy`
+#![warn(forgetting_references)] //~ ERROR: lint `clippy::forget_ref`
+#![warn(array_into_iter)] //~ ERROR: lint `clippy::into_iter_on_array`
+#![warn(invalid_atomic_ordering)] //~ ERROR: lint `clippy::invalid_atomic_ordering`
+#![warn(invalid_value)] //~ ERROR: lint `clippy::invalid_ref`
+#![warn(invalid_from_utf8_unchecked)] //~ ERROR: lint `clippy::invalid_utf8_in_unchecked`
+#![warn(let_underscore_drop)] //~ ERROR: lint `clippy::let_underscore_drop`
+#![warn(unexpected_cfgs)] //~ ERROR: lint `clippy::maybe_misused_cfg`
+#![warn(enum_intrinsics_non_enums)] //~ ERROR: lint `clippy::mem_discriminant_non_enum`
+#![warn(unexpected_cfgs)] //~ ERROR: lint `clippy::mismatched_target_os`
+#![warn(non_fmt_panics)] //~ ERROR: lint `clippy::panic_params`
+#![warn(named_arguments_used_positionally)] //~ ERROR: lint `clippy::positional_named_format_parameters`
+#![warn(temporary_cstring_as_ptr)] //~ ERROR: lint `clippy::temporary_cstring_as_ptr`
+#![warn(undropped_manually_drops)] //~ ERROR: lint `clippy::undropped_manually_drops`
+#![warn(unknown_lints)] //~ ERROR: lint `clippy::unknown_clippy_lints`
+#![warn(unused_labels)] //~ ERROR: lint `clippy::unused_label`
+#![warn(ambiguous_wide_pointer_comparisons)] //~ ERROR: lint `clippy::vtable_address_comparisons`
+#![warn(clippy::reversed_empty_ranges)] //~ ERROR: lint `clippy::reverse_range_loop`
 
 fn main() {}
diff --git a/tests/ui/rename.rs b/tests/ui/rename.rs
index 8d0ac3c8f9555..e03df1658ee36 100644
--- a/tests/ui/rename.rs
+++ b/tests/ui/rename.rs
@@ -13,7 +13,10 @@
 #![allow(clippy::disallowed_methods)]
 #![allow(clippy::disallowed_types)]
 #![allow(clippy::mixed_read_write_in_expression)]
+#![allow(clippy::manual_find_map)]
+#![allow(clippy::manual_filter_map)]
 #![allow(clippy::useless_conversion)]
+#![allow(clippy::redundant_pattern_matching)]
 #![allow(clippy::match_result_ok)]
 #![allow(clippy::non_canonical_clone_impl)]
 #![allow(clippy::non_canonical_partial_ord_impl)]
@@ -47,6 +50,7 @@
 #![allow(invalid_value)]
 #![allow(invalid_from_utf8_unchecked)]
 #![allow(let_underscore_drop)]
+#![allow(unexpected_cfgs)]
 #![allow(enum_intrinsics_non_enums)]
 #![allow(non_fmt_panics)]
 #![allow(named_arguments_used_positionally)]
@@ -55,65 +59,72 @@
 #![allow(unknown_lints)]
 #![allow(unused_labels)]
 #![allow(ambiguous_wide_pointer_comparisons)]
-#![warn(clippy::almost_complete_letter_range)]
-#![warn(clippy::blacklisted_name)]
-#![warn(clippy::block_in_if_condition_expr)]
-#![warn(clippy::block_in_if_condition_stmt)]
-#![warn(clippy::blocks_in_if_conditions)]
-#![warn(clippy::box_vec)]
-#![warn(clippy::const_static_lifetime)]
-#![warn(clippy::cyclomatic_complexity)]
-#![warn(clippy::derive_hash_xor_eq)]
-#![warn(clippy::disallowed_method)]
-#![warn(clippy::disallowed_type)]
-#![warn(clippy::eval_order_dependence)]
-#![warn(clippy::identity_conversion)]
-#![warn(clippy::if_let_some_result)]
-#![warn(clippy::incorrect_clone_impl_on_copy_type)]
-#![warn(clippy::incorrect_partial_ord_impl_on_ord_type)]
-#![warn(clippy::integer_arithmetic)]
-#![warn(clippy::logic_bug)]
-#![warn(clippy::new_without_default_derive)]
-#![warn(clippy::option_and_then_some)]
-#![warn(clippy::option_expect_used)]
-#![warn(clippy::option_map_unwrap_or)]
-#![warn(clippy::option_map_unwrap_or_else)]
-#![warn(clippy::option_unwrap_used)]
-#![warn(clippy::overflow_check_conditional)]
-#![warn(clippy::ref_in_deref)]
-#![warn(clippy::result_expect_used)]
-#![warn(clippy::result_map_unwrap_or_else)]
-#![warn(clippy::result_unwrap_used)]
-#![warn(clippy::single_char_push_str)]
-#![warn(clippy::stutter)]
-#![warn(clippy::thread_local_initializer_can_be_made_const)]
-#![warn(clippy::to_string_in_display)]
-#![warn(clippy::unwrap_or_else_default)]
-#![warn(clippy::zero_width_space)]
-#![warn(clippy::cast_ref_to_mut)]
-#![warn(clippy::clone_double_ref)]
-#![warn(clippy::cmp_nan)]
-#![warn(clippy::drop_bounds)]
-#![warn(clippy::drop_copy)]
-#![warn(clippy::drop_ref)]
-#![warn(clippy::fn_null_check)]
-#![warn(clippy::for_loop_over_option)]
-#![warn(clippy::for_loop_over_result)]
-#![warn(clippy::for_loops_over_fallibles)]
-#![warn(clippy::forget_copy)]
-#![warn(clippy::forget_ref)]
-#![warn(clippy::into_iter_on_array)]
-#![warn(clippy::invalid_atomic_ordering)]
-#![warn(clippy::invalid_ref)]
-#![warn(clippy::invalid_utf8_in_unchecked)]
-#![warn(clippy::let_underscore_drop)]
-#![warn(clippy::mem_discriminant_non_enum)]
-#![warn(clippy::panic_params)]
-#![warn(clippy::positional_named_format_parameters)]
-#![warn(clippy::temporary_cstring_as_ptr)]
-#![warn(clippy::undropped_manually_drops)]
-#![warn(clippy::unknown_clippy_lints)]
-#![warn(clippy::unused_label)]
-#![warn(clippy::vtable_address_comparisons)]
+#![allow(clippy::reversed_empty_ranges)]
+#![warn(clippy::almost_complete_letter_range)] //~ ERROR: lint `clippy::almost_complete_letter_range`
+#![warn(clippy::blacklisted_name)] //~ ERROR: lint `clippy::blacklisted_name`
+#![warn(clippy::block_in_if_condition_expr)] //~ ERROR: lint `clippy::block_in_if_condition_expr`
+#![warn(clippy::block_in_if_condition_stmt)] //~ ERROR: lint `clippy::block_in_if_condition_stmt`
+#![warn(clippy::blocks_in_if_conditions)] //~ ERROR: lint `clippy::blocks_in_if_conditions`
+#![warn(clippy::box_vec)] //~ ERROR: lint `clippy::box_vec`
+#![warn(clippy::const_static_lifetime)] //~ ERROR: lint `clippy::const_static_lifetime`
+#![warn(clippy::cyclomatic_complexity)] //~ ERROR: lint `clippy::cyclomatic_complexity`
+#![warn(clippy::derive_hash_xor_eq)] //~ ERROR: lint `clippy::derive_hash_xor_eq`
+#![warn(clippy::disallowed_method)] //~ ERROR: lint `clippy::disallowed_method`
+#![warn(clippy::disallowed_type)] //~ ERROR: lint `clippy::disallowed_type`
+#![warn(clippy::eval_order_dependence)] //~ ERROR: lint `clippy::eval_order_dependence`
+#![warn(clippy::find_map)] //~ ERROR: lint `clippy::find_map`
+#![warn(clippy::filter_map)] //~ ERROR: lint `clippy::filter_map`
+#![warn(clippy::identity_conversion)] //~ ERROR: lint `clippy::identity_conversion`
+#![warn(clippy::if_let_redundant_pattern_matching)] //~ ERROR: lint `clippy::if_let_redundant_pattern_matching`
+#![warn(clippy::if_let_some_result)] //~ ERROR: lint `clippy::if_let_some_result`
+#![warn(clippy::incorrect_clone_impl_on_copy_type)] //~ ERROR: lint `clippy::incorrect_clone_impl_on_copy_type`
+#![warn(clippy::incorrect_partial_ord_impl_on_ord_type)] //~ ERROR: lint `clippy::incorrect_partial_ord_impl_on_ord_type`
+#![warn(clippy::integer_arithmetic)] //~ ERROR: lint `clippy::integer_arithmetic`
+#![warn(clippy::logic_bug)] //~ ERROR: lint `clippy::logic_bug`
+#![warn(clippy::new_without_default_derive)] //~ ERROR: lint `clippy::new_without_default_derive`
+#![warn(clippy::option_and_then_some)] //~ ERROR: lint `clippy::option_and_then_some`
+#![warn(clippy::option_expect_used)] //~ ERROR: lint `clippy::option_expect_used`
+#![warn(clippy::option_map_unwrap_or)] //~ ERROR: lint `clippy::option_map_unwrap_or`
+#![warn(clippy::option_map_unwrap_or_else)] //~ ERROR: lint `clippy::option_map_unwrap_or_else`
+#![warn(clippy::option_unwrap_used)] //~ ERROR: lint `clippy::option_unwrap_used`
+#![warn(clippy::overflow_check_conditional)] //~ ERROR: lint `clippy::overflow_check_conditional`
+#![warn(clippy::ref_in_deref)] //~ ERROR: lint `clippy::ref_in_deref`
+#![warn(clippy::result_expect_used)] //~ ERROR: lint `clippy::result_expect_used`
+#![warn(clippy::result_map_unwrap_or_else)] //~ ERROR: lint `clippy::result_map_unwrap_or_else`
+#![warn(clippy::result_unwrap_used)] //~ ERROR: lint `clippy::result_unwrap_used`
+#![warn(clippy::single_char_push_str)] //~ ERROR: lint `clippy::single_char_push_str`
+#![warn(clippy::stutter)] //~ ERROR: lint `clippy::stutter`
+#![warn(clippy::thread_local_initializer_can_be_made_const)] //~ ERROR: lint `clippy::thread_local_initializer_can_be_made_const`
+#![warn(clippy::to_string_in_display)] //~ ERROR: lint `clippy::to_string_in_display`
+#![warn(clippy::unwrap_or_else_default)] //~ ERROR: lint `clippy::unwrap_or_else_default`
+#![warn(clippy::zero_width_space)] //~ ERROR: lint `clippy::zero_width_space`
+#![warn(clippy::cast_ref_to_mut)] //~ ERROR: lint `clippy::cast_ref_to_mut`
+#![warn(clippy::clone_double_ref)] //~ ERROR: lint `clippy::clone_double_ref`
+#![warn(clippy::cmp_nan)] //~ ERROR: lint `clippy::cmp_nan`
+#![warn(clippy::drop_bounds)] //~ ERROR: lint `clippy::drop_bounds`
+#![warn(clippy::drop_copy)] //~ ERROR: lint `clippy::drop_copy`
+#![warn(clippy::drop_ref)] //~ ERROR: lint `clippy::drop_ref`
+#![warn(clippy::fn_null_check)] //~ ERROR: lint `clippy::fn_null_check`
+#![warn(clippy::for_loop_over_option)] //~ ERROR: lint `clippy::for_loop_over_option`
+#![warn(clippy::for_loop_over_result)] //~ ERROR: lint `clippy::for_loop_over_result`
+#![warn(clippy::for_loops_over_fallibles)] //~ ERROR: lint `clippy::for_loops_over_fallibles`
+#![warn(clippy::forget_copy)] //~ ERROR: lint `clippy::forget_copy`
+#![warn(clippy::forget_ref)] //~ ERROR: lint `clippy::forget_ref`
+#![warn(clippy::into_iter_on_array)] //~ ERROR: lint `clippy::into_iter_on_array`
+#![warn(clippy::invalid_atomic_ordering)] //~ ERROR: lint `clippy::invalid_atomic_ordering`
+#![warn(clippy::invalid_ref)] //~ ERROR: lint `clippy::invalid_ref`
+#![warn(clippy::invalid_utf8_in_unchecked)] //~ ERROR: lint `clippy::invalid_utf8_in_unchecked`
+#![warn(clippy::let_underscore_drop)] //~ ERROR: lint `clippy::let_underscore_drop`
+#![warn(clippy::maybe_misused_cfg)] //~ ERROR: lint `clippy::maybe_misused_cfg`
+#![warn(clippy::mem_discriminant_non_enum)] //~ ERROR: lint `clippy::mem_discriminant_non_enum`
+#![warn(clippy::mismatched_target_os)] //~ ERROR: lint `clippy::mismatched_target_os`
+#![warn(clippy::panic_params)] //~ ERROR: lint `clippy::panic_params`
+#![warn(clippy::positional_named_format_parameters)] //~ ERROR: lint `clippy::positional_named_format_parameters`
+#![warn(clippy::temporary_cstring_as_ptr)] //~ ERROR: lint `clippy::temporary_cstring_as_ptr`
+#![warn(clippy::undropped_manually_drops)] //~ ERROR: lint `clippy::undropped_manually_drops`
+#![warn(clippy::unknown_clippy_lints)] //~ ERROR: lint `clippy::unknown_clippy_lints`
+#![warn(clippy::unused_label)] //~ ERROR: lint `clippy::unused_label`
+#![warn(clippy::vtable_address_comparisons)] //~ ERROR: lint `clippy::vtable_address_comparisons`
+#![warn(clippy::reverse_range_loop)] //~ ERROR: lint `clippy::reverse_range_loop`
 
 fn main() {}
diff --git a/tests/ui/rename.stderr b/tests/ui/rename.stderr
index d6637324a030b..46d9f0fac59f9 100644
--- a/tests/ui/rename.stderr
+++ b/tests/ui/rename.stderr
@@ -1,5 +1,5 @@
 error: lint `clippy::almost_complete_letter_range` has been renamed to `clippy::almost_complete_range`
-  --> tests/ui/rename.rs:58:9
+  --> tests/ui/rename.rs:63:9
    |
 LL | #![warn(clippy::almost_complete_letter_range)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::almost_complete_range`
@@ -8,358 +8,394 @@ LL | #![warn(clippy::almost_complete_letter_range)]
    = help: to override `-D warnings` add `#[allow(renamed_and_removed_lints)]`
 
 error: lint `clippy::blacklisted_name` has been renamed to `clippy::disallowed_names`
-  --> tests/ui/rename.rs:59:9
+  --> tests/ui/rename.rs:64:9
    |
 LL | #![warn(clippy::blacklisted_name)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_names`
 
 error: lint `clippy::block_in_if_condition_expr` has been renamed to `clippy::blocks_in_conditions`
-  --> tests/ui/rename.rs:60:9
+  --> tests/ui/rename.rs:65:9
    |
 LL | #![warn(clippy::block_in_if_condition_expr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_conditions`
 
 error: lint `clippy::block_in_if_condition_stmt` has been renamed to `clippy::blocks_in_conditions`
-  --> tests/ui/rename.rs:61:9
+  --> tests/ui/rename.rs:66:9
    |
 LL | #![warn(clippy::block_in_if_condition_stmt)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_conditions`
 
 error: lint `clippy::blocks_in_if_conditions` has been renamed to `clippy::blocks_in_conditions`
-  --> tests/ui/rename.rs:62:9
+  --> tests/ui/rename.rs:67:9
    |
 LL | #![warn(clippy::blocks_in_if_conditions)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::blocks_in_conditions`
 
 error: lint `clippy::box_vec` has been renamed to `clippy::box_collection`
-  --> tests/ui/rename.rs:63:9
+  --> tests/ui/rename.rs:68:9
    |
 LL | #![warn(clippy::box_vec)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::box_collection`
 
 error: lint `clippy::const_static_lifetime` has been renamed to `clippy::redundant_static_lifetimes`
-  --> tests/ui/rename.rs:64:9
+  --> tests/ui/rename.rs:69:9
    |
 LL | #![warn(clippy::const_static_lifetime)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_static_lifetimes`
 
 error: lint `clippy::cyclomatic_complexity` has been renamed to `clippy::cognitive_complexity`
-  --> tests/ui/rename.rs:65:9
+  --> tests/ui/rename.rs:70:9
    |
 LL | #![warn(clippy::cyclomatic_complexity)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::cognitive_complexity`
 
 error: lint `clippy::derive_hash_xor_eq` has been renamed to `clippy::derived_hash_with_manual_eq`
-  --> tests/ui/rename.rs:66:9
+  --> tests/ui/rename.rs:71:9
    |
 LL | #![warn(clippy::derive_hash_xor_eq)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::derived_hash_with_manual_eq`
 
 error: lint `clippy::disallowed_method` has been renamed to `clippy::disallowed_methods`
-  --> tests/ui/rename.rs:67:9
+  --> tests/ui/rename.rs:72:9
    |
 LL | #![warn(clippy::disallowed_method)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_methods`
 
 error: lint `clippy::disallowed_type` has been renamed to `clippy::disallowed_types`
-  --> tests/ui/rename.rs:68:9
+  --> tests/ui/rename.rs:73:9
    |
 LL | #![warn(clippy::disallowed_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::disallowed_types`
 
 error: lint `clippy::eval_order_dependence` has been renamed to `clippy::mixed_read_write_in_expression`
-  --> tests/ui/rename.rs:69:9
+  --> tests/ui/rename.rs:74:9
    |
 LL | #![warn(clippy::eval_order_dependence)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::mixed_read_write_in_expression`
 
+error: lint `clippy::find_map` has been renamed to `clippy::manual_find_map`
+  --> tests/ui/rename.rs:75:9
+   |
+LL | #![warn(clippy::find_map)]
+   |         ^^^^^^^^^^^^^^^^ help: use the new name: `clippy::manual_find_map`
+
+error: lint `clippy::filter_map` has been renamed to `clippy::manual_filter_map`
+  --> tests/ui/rename.rs:76:9
+   |
+LL | #![warn(clippy::filter_map)]
+   |         ^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::manual_filter_map`
+
 error: lint `clippy::identity_conversion` has been renamed to `clippy::useless_conversion`
-  --> tests/ui/rename.rs:70:9
+  --> tests/ui/rename.rs:77:9
    |
 LL | #![warn(clippy::identity_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::useless_conversion`
 
+error: lint `clippy::if_let_redundant_pattern_matching` has been renamed to `clippy::redundant_pattern_matching`
+  --> tests/ui/rename.rs:78:9
+   |
+LL | #![warn(clippy::if_let_redundant_pattern_matching)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::redundant_pattern_matching`
+
 error: lint `clippy::if_let_some_result` has been renamed to `clippy::match_result_ok`
-  --> tests/ui/rename.rs:71:9
+  --> tests/ui/rename.rs:79:9
    |
 LL | #![warn(clippy::if_let_some_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::match_result_ok`
 
 error: lint `clippy::incorrect_clone_impl_on_copy_type` has been renamed to `clippy::non_canonical_clone_impl`
-  --> tests/ui/rename.rs:72:9
+  --> tests/ui/rename.rs:80:9
    |
 LL | #![warn(clippy::incorrect_clone_impl_on_copy_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::non_canonical_clone_impl`
 
 error: lint `clippy::incorrect_partial_ord_impl_on_ord_type` has been renamed to `clippy::non_canonical_partial_ord_impl`
-  --> tests/ui/rename.rs:73:9
+  --> tests/ui/rename.rs:81:9
    |
 LL | #![warn(clippy::incorrect_partial_ord_impl_on_ord_type)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::non_canonical_partial_ord_impl`
 
 error: lint `clippy::integer_arithmetic` has been renamed to `clippy::arithmetic_side_effects`
-  --> tests/ui/rename.rs:74:9
+  --> tests/ui/rename.rs:82:9
    |
 LL | #![warn(clippy::integer_arithmetic)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::arithmetic_side_effects`
 
 error: lint `clippy::logic_bug` has been renamed to `clippy::overly_complex_bool_expr`
-  --> tests/ui/rename.rs:75:9
+  --> tests/ui/rename.rs:83:9
    |
 LL | #![warn(clippy::logic_bug)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::overly_complex_bool_expr`
 
 error: lint `clippy::new_without_default_derive` has been renamed to `clippy::new_without_default`
-  --> tests/ui/rename.rs:76:9
+  --> tests/ui/rename.rs:84:9
    |
 LL | #![warn(clippy::new_without_default_derive)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::new_without_default`
 
 error: lint `clippy::option_and_then_some` has been renamed to `clippy::bind_instead_of_map`
-  --> tests/ui/rename.rs:77:9
+  --> tests/ui/rename.rs:85:9
    |
 LL | #![warn(clippy::option_and_then_some)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::bind_instead_of_map`
 
 error: lint `clippy::option_expect_used` has been renamed to `clippy::expect_used`
-  --> tests/ui/rename.rs:78:9
+  --> tests/ui/rename.rs:86:9
    |
 LL | #![warn(clippy::option_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::option_map_unwrap_or` has been renamed to `clippy::map_unwrap_or`
-  --> tests/ui/rename.rs:79:9
+  --> tests/ui/rename.rs:87:9
    |
 LL | #![warn(clippy::option_map_unwrap_or)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> tests/ui/rename.rs:80:9
+  --> tests/ui/rename.rs:88:9
    |
 LL | #![warn(clippy::option_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::option_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> tests/ui/rename.rs:81:9
+  --> tests/ui/rename.rs:89:9
    |
 LL | #![warn(clippy::option_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::overflow_check_conditional` has been renamed to `clippy::panicking_overflow_checks`
-  --> tests/ui/rename.rs:82:9
+  --> tests/ui/rename.rs:90:9
    |
 LL | #![warn(clippy::overflow_check_conditional)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::panicking_overflow_checks`
 
 error: lint `clippy::ref_in_deref` has been renamed to `clippy::needless_borrow`
-  --> tests/ui/rename.rs:83:9
+  --> tests/ui/rename.rs:91:9
    |
 LL | #![warn(clippy::ref_in_deref)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::needless_borrow`
 
 error: lint `clippy::result_expect_used` has been renamed to `clippy::expect_used`
-  --> tests/ui/rename.rs:84:9
+  --> tests/ui/rename.rs:92:9
    |
 LL | #![warn(clippy::result_expect_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::expect_used`
 
 error: lint `clippy::result_map_unwrap_or_else` has been renamed to `clippy::map_unwrap_or`
-  --> tests/ui/rename.rs:85:9
+  --> tests/ui/rename.rs:93:9
    |
 LL | #![warn(clippy::result_map_unwrap_or_else)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::map_unwrap_or`
 
 error: lint `clippy::result_unwrap_used` has been renamed to `clippy::unwrap_used`
-  --> tests/ui/rename.rs:86:9
+  --> tests/ui/rename.rs:94:9
    |
 LL | #![warn(clippy::result_unwrap_used)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_used`
 
 error: lint `clippy::single_char_push_str` has been renamed to `clippy::single_char_add_str`
-  --> tests/ui/rename.rs:87:9
+  --> tests/ui/rename.rs:95:9
    |
 LL | #![warn(clippy::single_char_push_str)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::single_char_add_str`
 
 error: lint `clippy::stutter` has been renamed to `clippy::module_name_repetitions`
-  --> tests/ui/rename.rs:88:9
+  --> tests/ui/rename.rs:96:9
    |
 LL | #![warn(clippy::stutter)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `clippy::module_name_repetitions`
 
 error: lint `clippy::thread_local_initializer_can_be_made_const` has been renamed to `clippy::missing_const_for_thread_local`
-  --> tests/ui/rename.rs:89:9
+  --> tests/ui/rename.rs:97:9
    |
 LL | #![warn(clippy::thread_local_initializer_can_be_made_const)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::missing_const_for_thread_local`
 
 error: lint `clippy::to_string_in_display` has been renamed to `clippy::recursive_format_impl`
-  --> tests/ui/rename.rs:90:9
+  --> tests/ui/rename.rs:98:9
    |
 LL | #![warn(clippy::to_string_in_display)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::recursive_format_impl`
 
 error: lint `clippy::unwrap_or_else_default` has been renamed to `clippy::unwrap_or_default`
-  --> tests/ui/rename.rs:91:9
+  --> tests/ui/rename.rs:99:9
    |
 LL | #![warn(clippy::unwrap_or_else_default)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::unwrap_or_default`
 
 error: lint `clippy::zero_width_space` has been renamed to `clippy::invisible_characters`
-  --> tests/ui/rename.rs:92:9
+  --> tests/ui/rename.rs:100:9
    |
 LL | #![warn(clippy::zero_width_space)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::invisible_characters`
 
 error: lint `clippy::cast_ref_to_mut` has been renamed to `invalid_reference_casting`
-  --> tests/ui/rename.rs:93:9
+  --> tests/ui/rename.rs:101:9
    |
 LL | #![warn(clippy::cast_ref_to_mut)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_reference_casting`
 
 error: lint `clippy::clone_double_ref` has been renamed to `suspicious_double_ref_op`
-  --> tests/ui/rename.rs:94:9
+  --> tests/ui/rename.rs:102:9
    |
 LL | #![warn(clippy::clone_double_ref)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `suspicious_double_ref_op`
 
 error: lint `clippy::cmp_nan` has been renamed to `invalid_nan_comparisons`
-  --> tests/ui/rename.rs:95:9
+  --> tests/ui/rename.rs:103:9
    |
 LL | #![warn(clippy::cmp_nan)]
    |         ^^^^^^^^^^^^^^^ help: use the new name: `invalid_nan_comparisons`
 
 error: lint `clippy::drop_bounds` has been renamed to `drop_bounds`
-  --> tests/ui/rename.rs:96:9
+  --> tests/ui/rename.rs:104:9
    |
 LL | #![warn(clippy::drop_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `drop_bounds`
 
 error: lint `clippy::drop_copy` has been renamed to `dropping_copy_types`
-  --> tests/ui/rename.rs:97:9
+  --> tests/ui/rename.rs:105:9
    |
 LL | #![warn(clippy::drop_copy)]
    |         ^^^^^^^^^^^^^^^^^ help: use the new name: `dropping_copy_types`
 
 error: lint `clippy::drop_ref` has been renamed to `dropping_references`
-  --> tests/ui/rename.rs:98:9
+  --> tests/ui/rename.rs:106:9
    |
 LL | #![warn(clippy::drop_ref)]
    |         ^^^^^^^^^^^^^^^^ help: use the new name: `dropping_references`
 
 error: lint `clippy::fn_null_check` has been renamed to `useless_ptr_null_checks`
-  --> tests/ui/rename.rs:99:9
+  --> tests/ui/rename.rs:107:9
    |
 LL | #![warn(clippy::fn_null_check)]
    |         ^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `useless_ptr_null_checks`
 
 error: lint `clippy::for_loop_over_option` has been renamed to `for_loops_over_fallibles`
-  --> tests/ui/rename.rs:100:9
+  --> tests/ui/rename.rs:108:9
    |
 LL | #![warn(clippy::for_loop_over_option)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loop_over_result` has been renamed to `for_loops_over_fallibles`
-  --> tests/ui/rename.rs:101:9
+  --> tests/ui/rename.rs:109:9
    |
 LL | #![warn(clippy::for_loop_over_result)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::for_loops_over_fallibles` has been renamed to `for_loops_over_fallibles`
-  --> tests/ui/rename.rs:102:9
+  --> tests/ui/rename.rs:110:9
    |
 LL | #![warn(clippy::for_loops_over_fallibles)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `for_loops_over_fallibles`
 
 error: lint `clippy::forget_copy` has been renamed to `forgetting_copy_types`
-  --> tests/ui/rename.rs:103:9
+  --> tests/ui/rename.rs:111:9
    |
 LL | #![warn(clippy::forget_copy)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_copy_types`
 
 error: lint `clippy::forget_ref` has been renamed to `forgetting_references`
-  --> tests/ui/rename.rs:104:9
+  --> tests/ui/rename.rs:112:9
    |
 LL | #![warn(clippy::forget_ref)]
    |         ^^^^^^^^^^^^^^^^^^ help: use the new name: `forgetting_references`
 
 error: lint `clippy::into_iter_on_array` has been renamed to `array_into_iter`
-  --> tests/ui/rename.rs:105:9
+  --> tests/ui/rename.rs:113:9
    |
 LL | #![warn(clippy::into_iter_on_array)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `array_into_iter`
 
 error: lint `clippy::invalid_atomic_ordering` has been renamed to `invalid_atomic_ordering`
-  --> tests/ui/rename.rs:106:9
+  --> tests/ui/rename.rs:114:9
    |
 LL | #![warn(clippy::invalid_atomic_ordering)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_atomic_ordering`
 
 error: lint `clippy::invalid_ref` has been renamed to `invalid_value`
-  --> tests/ui/rename.rs:107:9
+  --> tests/ui/rename.rs:115:9
    |
 LL | #![warn(clippy::invalid_ref)]
    |         ^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_value`
 
 error: lint `clippy::invalid_utf8_in_unchecked` has been renamed to `invalid_from_utf8_unchecked`
-  --> tests/ui/rename.rs:108:9
+  --> tests/ui/rename.rs:116:9
    |
 LL | #![warn(clippy::invalid_utf8_in_unchecked)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `invalid_from_utf8_unchecked`
 
 error: lint `clippy::let_underscore_drop` has been renamed to `let_underscore_drop`
-  --> tests/ui/rename.rs:109:9
+  --> tests/ui/rename.rs:117:9
    |
 LL | #![warn(clippy::let_underscore_drop)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `let_underscore_drop`
 
+error: lint `clippy::maybe_misused_cfg` has been renamed to `unexpected_cfgs`
+  --> tests/ui/rename.rs:118:9
+   |
+LL | #![warn(clippy::maybe_misused_cfg)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unexpected_cfgs`
+
 error: lint `clippy::mem_discriminant_non_enum` has been renamed to `enum_intrinsics_non_enums`
-  --> tests/ui/rename.rs:110:9
+  --> tests/ui/rename.rs:119:9
    |
 LL | #![warn(clippy::mem_discriminant_non_enum)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `enum_intrinsics_non_enums`
 
+error: lint `clippy::mismatched_target_os` has been renamed to `unexpected_cfgs`
+  --> tests/ui/rename.rs:120:9
+   |
+LL | #![warn(clippy::mismatched_target_os)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unexpected_cfgs`
+
 error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
-  --> tests/ui/rename.rs:111:9
+  --> tests/ui/rename.rs:121:9
    |
 LL | #![warn(clippy::panic_params)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
 
 error: lint `clippy::positional_named_format_parameters` has been renamed to `named_arguments_used_positionally`
-  --> tests/ui/rename.rs:112:9
+  --> tests/ui/rename.rs:122:9
    |
 LL | #![warn(clippy::positional_named_format_parameters)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `named_arguments_used_positionally`
 
 error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cstring_as_ptr`
-  --> tests/ui/rename.rs:113:9
+  --> tests/ui/rename.rs:123:9
    |
 LL | #![warn(clippy::temporary_cstring_as_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
 
 error: lint `clippy::undropped_manually_drops` has been renamed to `undropped_manually_drops`
-  --> tests/ui/rename.rs:114:9
+  --> tests/ui/rename.rs:124:9
    |
 LL | #![warn(clippy::undropped_manually_drops)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `undropped_manually_drops`
 
 error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
-  --> tests/ui/rename.rs:115:9
+  --> tests/ui/rename.rs:125:9
    |
 LL | #![warn(clippy::unknown_clippy_lints)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unknown_lints`
 
 error: lint `clippy::unused_label` has been renamed to `unused_labels`
-  --> tests/ui/rename.rs:116:9
+  --> tests/ui/rename.rs:126:9
    |
 LL | #![warn(clippy::unused_label)]
    |         ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `unused_labels`
 
 error: lint `clippy::vtable_address_comparisons` has been renamed to `ambiguous_wide_pointer_comparisons`
-  --> tests/ui/rename.rs:117:9
+  --> tests/ui/rename.rs:127:9
    |
 LL | #![warn(clippy::vtable_address_comparisons)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `ambiguous_wide_pointer_comparisons`
 
-error: aborting due to 60 previous errors
+error: lint `clippy::reverse_range_loop` has been renamed to `clippy::reversed_empty_ranges`
+  --> tests/ui/rename.rs:128:9
+   |
+LL | #![warn(clippy::reverse_range_loop)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `clippy::reversed_empty_ranges`
+
+error: aborting due to 66 previous errors
 
diff --git a/tests/ui/set_contains_or_insert.rs b/tests/ui/set_contains_or_insert.rs
index 8465007402ab0..d3a3e1c878b3a 100644
--- a/tests/ui/set_contains_or_insert.rs
+++ b/tests/ui/set_contains_or_insert.rs
@@ -3,17 +3,78 @@
 #![allow(clippy::needless_borrow)]
 #![warn(clippy::set_contains_or_insert)]
 
-use std::collections::HashSet;
+use std::collections::{BTreeSet, HashSet};
 
-fn main() {
-    should_warn_cases();
+fn should_warn_hashset() {
+    let mut set = HashSet::new();
+    let value = 5;
+
+    if !set.contains(&value) {
+        set.insert(value);
+        println!("Just a comment");
+    }
+
+    if set.contains(&value) {
+        set.insert(value);
+        println!("Just a comment");
+    }
+
+    if !set.contains(&value) {
+        set.insert(value);
+    }
 
-    should_not_warn_cases();
+    if !!set.contains(&value) {
+        set.insert(value);
+        println!("Just a comment");
+    }
+
+    if (&set).contains(&value) {
+        set.insert(value);
+    }
+
+    let borrow_value = &6;
+    if !set.contains(borrow_value) {
+        set.insert(*borrow_value);
+    }
+
+    let borrow_set = &mut set;
+    if !borrow_set.contains(&value) {
+        borrow_set.insert(value);
+    }
 }
 
-fn should_warn_cases() {
+fn should_not_warn_hashset() {
     let mut set = HashSet::new();
     let value = 5;
+    let another_value = 6;
+
+    if !set.contains(&value) {
+        set.insert(another_value);
+    }
+
+    if !set.contains(&value) {
+        println!("Just a comment");
+    }
+
+    if simply_true() {
+        set.insert(value);
+    }
+
+    if !set.contains(&value) {
+        set.replace(value); //it is not insert
+        println!("Just a comment");
+    }
+
+    if set.contains(&value) {
+        println!("value is already in set");
+    } else {
+        set.insert(value);
+    }
+}
+
+fn should_warn_btreeset() {
+    let mut set = BTreeSet::new();
+    let value = 5;
 
     if !set.contains(&value) {
         set.insert(value);
@@ -49,8 +110,8 @@ fn should_warn_cases() {
     }
 }
 
-fn should_not_warn_cases() {
-    let mut set = HashSet::new();
+fn should_not_warn_btreeset() {
+    let mut set = BTreeSet::new();
     let value = 5;
     let another_value = 6;
 
@@ -81,3 +142,11 @@ fn should_not_warn_cases() {
 fn simply_true() -> bool {
     true
 }
+
+// This is placed last in order to be able to add new tests without changing line numbers
+fn main() {
+    should_warn_hashset();
+    should_warn_btreeset();
+    should_not_warn_hashset();
+    should_not_warn_btreeset();
+}
diff --git a/tests/ui/set_contains_or_insert.stderr b/tests/ui/set_contains_or_insert.stderr
index 507e20964fc20..14ad630054482 100644
--- a/tests/ui/set_contains_or_insert.stderr
+++ b/tests/ui/set_contains_or_insert.stderr
@@ -1,5 +1,5 @@
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:18:13
+  --> tests/ui/set_contains_or_insert.rs:12:13
    |
 LL |     if !set.contains(&value) {
    |             ^^^^^^^^^^^^^^^^
@@ -10,7 +10,7 @@ LL |         set.insert(value);
    = help: to override `-D warnings` add `#[allow(clippy::set_contains_or_insert)]`
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:23:12
+  --> tests/ui/set_contains_or_insert.rs:17:12
    |
 LL |     if set.contains(&value) {
    |            ^^^^^^^^^^^^^^^^
@@ -18,7 +18,7 @@ LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:28:13
+  --> tests/ui/set_contains_or_insert.rs:22:13
    |
 LL |     if !set.contains(&value) {
    |             ^^^^^^^^^^^^^^^^
@@ -26,7 +26,7 @@ LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:32:14
+  --> tests/ui/set_contains_or_insert.rs:26:14
    |
 LL |     if !!set.contains(&value) {
    |              ^^^^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:37:15
+  --> tests/ui/set_contains_or_insert.rs:31:15
    |
 LL |     if (&set).contains(&value) {
    |               ^^^^^^^^^^^^^^^^
@@ -42,7 +42,7 @@ LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:42:13
+  --> tests/ui/set_contains_or_insert.rs:36:13
    |
 LL |     if !set.contains(borrow_value) {
    |             ^^^^^^^^^^^^^^^^^^^^^^
@@ -50,12 +50,68 @@ LL |         set.insert(*borrow_value);
    |             ^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:47:20
+  --> tests/ui/set_contains_or_insert.rs:41:20
    |
 LL |     if !borrow_set.contains(&value) {
    |                    ^^^^^^^^^^^^^^^^
 LL |         borrow_set.insert(value);
    |                    ^^^^^^^^^^^^^
 
-error: aborting due to 7 previous errors
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+  --> tests/ui/set_contains_or_insert.rs:79:13
+   |
+LL |     if !set.contains(&value) {
+   |             ^^^^^^^^^^^^^^^^
+LL |         set.insert(value);
+   |             ^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+  --> tests/ui/set_contains_or_insert.rs:84:12
+   |
+LL |     if set.contains(&value) {
+   |            ^^^^^^^^^^^^^^^^
+LL |         set.insert(value);
+   |             ^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+  --> tests/ui/set_contains_or_insert.rs:89:13
+   |
+LL |     if !set.contains(&value) {
+   |             ^^^^^^^^^^^^^^^^
+LL |         set.insert(value);
+   |             ^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+  --> tests/ui/set_contains_or_insert.rs:93:14
+   |
+LL |     if !!set.contains(&value) {
+   |              ^^^^^^^^^^^^^^^^
+LL |         set.insert(value);
+   |             ^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+  --> tests/ui/set_contains_or_insert.rs:98:15
+   |
+LL |     if (&set).contains(&value) {
+   |               ^^^^^^^^^^^^^^^^
+LL |         set.insert(value);
+   |             ^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+  --> tests/ui/set_contains_or_insert.rs:103:13
+   |
+LL |     if !set.contains(borrow_value) {
+   |             ^^^^^^^^^^^^^^^^^^^^^^
+LL |         set.insert(*borrow_value);
+   |             ^^^^^^^^^^^^^^^^^^^^^
+
+error: usage of `BTreeSet::insert` after `BTreeSet::contains`
+  --> tests/ui/set_contains_or_insert.rs:108:20
+   |
+LL |     if !borrow_set.contains(&value) {
+   |                    ^^^^^^^^^^^^^^^^
+LL |         borrow_set.insert(value);
+   |                    ^^^^^^^^^^^^^
+
+error: aborting due to 14 previous errors
 
diff --git a/tests/ui/single_match.fixed b/tests/ui/single_match.fixed
index acd70416d8bf0..5249c4408899a 100644
--- a/tests/ui/single_match.fixed
+++ b/tests/ui/single_match.fixed
@@ -253,3 +253,46 @@ mod issue8634 {
         }
     }
 }
+
+fn issue11365() {
+    enum Foo {
+        A,
+        B,
+        C,
+    }
+    use Foo::{A, B, C};
+
+    match Some(A) {
+        Some(A | B | C) => println!(),
+        None => {},
+    }
+
+    match Some(A) {
+        Some(A | B) => println!(),
+        Some { 0: C } | None => {},
+    }
+
+    match [A, A] {
+        [A, _] => println!(),
+        [_, A | B | C] => {},
+    }
+
+    match Ok::<_, u32>(Some(A)) {
+        Ok(Some(A)) => println!(),
+        Err(_) | Ok(None | Some(B | C)) => {},
+    }
+
+    if let Ok(Some(A)) = Ok::<_, u32>(Some(A)) { println!() }
+
+    match &Some(A) {
+        Some(A | B | C) => println!(),
+        None => {},
+    }
+
+    match &Some(A) {
+        &Some(A | B | C) => println!(),
+        None => {},
+    }
+
+    if let Some(A | B) = &Some(A) { println!() }
+}
diff --git a/tests/ui/single_match.rs b/tests/ui/single_match.rs
index bde7819981089..882098a56e780 100644
--- a/tests/ui/single_match.rs
+++ b/tests/ui/single_match.rs
@@ -311,3 +311,52 @@ mod issue8634 {
         }
     }
 }
+
+fn issue11365() {
+    enum Foo {
+        A,
+        B,
+        C,
+    }
+    use Foo::{A, B, C};
+
+    match Some(A) {
+        Some(A | B | C) => println!(),
+        None => {},
+    }
+
+    match Some(A) {
+        Some(A | B) => println!(),
+        Some { 0: C } | None => {},
+    }
+
+    match [A, A] {
+        [A, _] => println!(),
+        [_, A | B | C] => {},
+    }
+
+    match Ok::<_, u32>(Some(A)) {
+        Ok(Some(A)) => println!(),
+        Err(_) | Ok(None | Some(B | C)) => {},
+    }
+
+    match Ok::<_, u32>(Some(A)) {
+        Ok(Some(A)) => println!(),
+        Err(_) | Ok(None | Some(_)) => {},
+    }
+
+    match &Some(A) {
+        Some(A | B | C) => println!(),
+        None => {},
+    }
+
+    match &Some(A) {
+        &Some(A | B | C) => println!(),
+        None => {},
+    }
+
+    match &Some(A) {
+        Some(A | B) => println!(),
+        None | Some(_) => {},
+    }
+}
diff --git a/tests/ui/single_match.stderr b/tests/ui/single_match.stderr
index a249c120ee4a4..ceb2a193bf7b1 100644
--- a/tests/ui/single_match.stderr
+++ b/tests/ui/single_match.stderr
@@ -198,5 +198,23 @@ LL +         }
 LL +     }
    |
 
-error: aborting due to 18 previous errors
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> tests/ui/single_match.rs:343:5
+   |
+LL | /     match Ok::<_, u32>(Some(A)) {
+LL | |         Ok(Some(A)) => println!(),
+LL | |         Err(_) | Ok(None | Some(_)) => {},
+LL | |     }
+   | |_____^ help: try: `if let Ok(Some(A)) = Ok::<_, u32>(Some(A)) { println!() }`
+
+error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
+  --> tests/ui/single_match.rs:358:5
+   |
+LL | /     match &Some(A) {
+LL | |         Some(A | B) => println!(),
+LL | |         None | Some(_) => {},
+LL | |     }
+   | |_____^ help: try: `if let Some(A | B) = &Some(A) { println!() }`
+
+error: aborting due to 20 previous errors
 
diff --git a/tests/ui/std_instead_of_core.fixed b/tests/ui/std_instead_of_core.fixed
index 6ede7bfcd9f66..227b98c683e97 100644
--- a/tests/ui/std_instead_of_core.fixed
+++ b/tests/ui/std_instead_of_core.fixed
@@ -75,8 +75,17 @@ mod std_in_proc_macro_derive {
     struct B {}
 }
 
-fn main() {
-    std_instead_of_core();
-    std_instead_of_alloc();
-    alloc_instead_of_core();
+// Some intrinsics are usable on stable but live in an unstable module, but should still suggest
+// replacing std -> core
+fn intrinsic(a: *mut u8, b: *mut u8) {
+    unsafe {
+        core::intrinsics::copy(a, b, 1);
+        //~^ std_instead_of_core
+    }
 }
+
+#[clippy::msrv = "1.76"]
+fn msrv_1_76(_: std::net::IpAddr) {}
+
+#[clippy::msrv = "1.77"]
+fn msrv_1_77(_: core::net::IpAddr) {}
diff --git a/tests/ui/std_instead_of_core.rs b/tests/ui/std_instead_of_core.rs
index e22b4f61f3ecc..01bb78dd3bf1d 100644
--- a/tests/ui/std_instead_of_core.rs
+++ b/tests/ui/std_instead_of_core.rs
@@ -75,8 +75,17 @@ mod std_in_proc_macro_derive {
     struct B {}
 }
 
-fn main() {
-    std_instead_of_core();
-    std_instead_of_alloc();
-    alloc_instead_of_core();
+// Some intrinsics are usable on stable but live in an unstable module, but should still suggest
+// replacing std -> core
+fn intrinsic(a: *mut u8, b: *mut u8) {
+    unsafe {
+        std::intrinsics::copy(a, b, 1);
+        //~^ std_instead_of_core
+    }
 }
+
+#[clippy::msrv = "1.76"]
+fn msrv_1_76(_: std::net::IpAddr) {}
+
+#[clippy::msrv = "1.77"]
+fn msrv_1_77(_: std::net::IpAddr) {}
diff --git a/tests/ui/std_instead_of_core.stderr b/tests/ui/std_instead_of_core.stderr
index 22cb9db7050b8..45d60d235ceb3 100644
--- a/tests/ui/std_instead_of_core.stderr
+++ b/tests/ui/std_instead_of_core.stderr
@@ -85,5 +85,17 @@ LL |     use alloc::slice::from_ref;
    = note: `-D clippy::alloc-instead-of-core` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::alloc_instead_of_core)]`
 
-error: aborting due to 13 previous errors
+error: used import from `std` instead of `core`
+  --> tests/ui/std_instead_of_core.rs:82:9
+   |
+LL |         std::intrinsics::copy(a, b, 1);
+   |         ^^^ help: consider importing the item from `core`: `core`
+
+error: used import from `std` instead of `core`
+  --> tests/ui/std_instead_of_core.rs:91:17
+   |
+LL | fn msrv_1_77(_: std::net::IpAddr) {}
+   |                 ^^^ help: consider importing the item from `core`: `core`
+
+error: aborting due to 15 previous errors
 
diff --git a/tests/ui/suspicious_xor_used_as_pow.stderr b/tests/ui/suspicious_xor_used_as_pow.stderr
index 4faf0237c17ad..43b03676b1db5 100644
--- a/tests/ui/suspicious_xor_used_as_pow.stderr
+++ b/tests/ui/suspicious_xor_used_as_pow.stderr
@@ -2,51 +2,84 @@ error: `^` is not the exponentiation operator
   --> tests/ui/suspicious_xor_used_as_pow.rs:19:13
    |
 LL |     let _ = 2 ^ 5;
-   |             ^^^^^ help: did you mean to write: `2.pow(5)`
+   |             ^^^^^
    |
    = note: `-D clippy::suspicious-xor-used-as-pow` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_xor_used_as_pow)]`
+help: did you mean to write
+   |
+LL |     let _ = 2.pow(5);
+   |             ~~~~~~~~
 
 error: `^` is not the exponentiation operator
   --> tests/ui/suspicious_xor_used_as_pow.rs:22:13
    |
 LL |     let _ = 2i32 ^ 9i32;
-   |             ^^^^^^^^^^^ help: did you mean to write: `2i32.pow(9i32)`
+   |             ^^^^^^^^^^^
+   |
+help: did you mean to write
+   |
+LL |     let _ = 2i32.pow(9i32);
+   |             ~~~~~~~~~~~~~~
 
 error: `^` is not the exponentiation operator
   --> tests/ui/suspicious_xor_used_as_pow.rs:24:13
    |
 LL |     let _ = 2i32 ^ 2i32;
-   |             ^^^^^^^^^^^ help: did you mean to write: `2i32.pow(2i32)`
+   |             ^^^^^^^^^^^
+   |
+help: did you mean to write
+   |
+LL |     let _ = 2i32.pow(2i32);
+   |             ~~~~~~~~~~~~~~
 
 error: `^` is not the exponentiation operator
   --> tests/ui/suspicious_xor_used_as_pow.rs:26:13
    |
 LL |     let _ = 50i32 ^ 3i32;
-   |             ^^^^^^^^^^^^ help: did you mean to write: `50i32.pow(3i32)`
+   |             ^^^^^^^^^^^^
+   |
+help: did you mean to write
+   |
+LL |     let _ = 50i32.pow(3i32);
+   |             ~~~~~~~~~~~~~~~
 
 error: `^` is not the exponentiation operator
   --> tests/ui/suspicious_xor_used_as_pow.rs:28:13
    |
 LL |     let _ = 5i32 ^ 8i32;
-   |             ^^^^^^^^^^^ help: did you mean to write: `5i32.pow(8i32)`
+   |             ^^^^^^^^^^^
+   |
+help: did you mean to write
+   |
+LL |     let _ = 5i32.pow(8i32);
+   |             ~~~~~~~~~~~~~~
 
 error: `^` is not the exponentiation operator
   --> tests/ui/suspicious_xor_used_as_pow.rs:30:13
    |
 LL |     let _ = 2i32 ^ 32i32;
-   |             ^^^^^^^^^^^^ help: did you mean to write: `2i32.pow(32i32)`
+   |             ^^^^^^^^^^^^
+   |
+help: did you mean to write
+   |
+LL |     let _ = 2i32.pow(32i32);
+   |             ~~~~~~~~~~~~~~~
 
 error: `^` is not the exponentiation operator
   --> tests/ui/suspicious_xor_used_as_pow.rs:13:9
    |
 LL |         1 ^ 2 // should warn even if inside macro
-   |         ^^^^^ help: did you mean to write: `1.pow(2)`
+   |         ^^^^^
 ...
 LL |     macro_test_inside!();
    |     -------------------- in this macro invocation
    |
    = note: this error originates in the macro `macro_test_inside` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: did you mean to write
+   |
+LL |         1.pow(2) // should warn even if inside macro
+   |         ~~~~~~~~
 
 error: aborting due to 7 previous errors
 
diff --git a/tests/ui/try_err.fixed b/tests/ui/try_err.fixed
index aae4f8ac47f82..f149bfb77740c 100644
--- a/tests/ui/try_err.fixed
+++ b/tests/ui/try_err.fixed
@@ -1,5 +1,5 @@
 //@aux-build:proc_macros.rs
-
+#![feature(try_blocks)]
 #![deny(clippy::try_err)]
 #![allow(
     clippy::unnecessary_wraps,
@@ -152,3 +152,11 @@ pub fn try_return(x: bool) -> Result<i32, i32> {
     }
     Ok(0)
 }
+
+// Test that the lint is suppressed in try block.
+pub fn try_block() -> Result<(), i32> {
+    let _: Result<_, i32> = try {
+        Err(1)?;
+    };
+    Ok(())
+}
diff --git a/tests/ui/try_err.rs b/tests/ui/try_err.rs
index 927eccf2d54c5..841ec6b5d5c77 100644
--- a/tests/ui/try_err.rs
+++ b/tests/ui/try_err.rs
@@ -1,5 +1,5 @@
 //@aux-build:proc_macros.rs
-
+#![feature(try_blocks)]
 #![deny(clippy::try_err)]
 #![allow(
     clippy::unnecessary_wraps,
@@ -152,3 +152,11 @@ pub fn try_return(x: bool) -> Result<i32, i32> {
     }
     Ok(0)
 }
+
+// Test that the lint is suppressed in try block.
+pub fn try_block() -> Result<(), i32> {
+    let _: Result<_, i32> = try {
+        Err(1)?;
+    };
+    Ok(())
+}
diff --git a/tests/ui/uninit_vec.rs b/tests/ui/uninit_vec.rs
index 58729a97d57bb..0cc77a8775d57 100644
--- a/tests/ui/uninit_vec.rs
+++ b/tests/ui/uninit_vec.rs
@@ -1,7 +1,7 @@
 #![warn(clippy::uninit_vec)]
 
-use std::mem::MaybeUninit;
 use std::cell::UnsafeCell;
+use std::mem::MaybeUninit;
 
 #[derive(Default)]
 struct MyVec {
diff --git a/tests/ui/unneeded_field_pattern.rs b/tests/ui/unneeded_field_pattern.rs
index 0dc21f4ce945d..1d42f81711bd6 100644
--- a/tests/ui/unneeded_field_pattern.rs
+++ b/tests/ui/unneeded_field_pattern.rs
@@ -1,6 +1,6 @@
 //@aux-build:proc_macros.rs
 #![warn(clippy::unneeded_field_pattern)]
-#![allow(dead_code, unused)]
+#![allow(dead_code, unused, clippy::single_match)]
 
 #[macro_use]
 extern crate proc_macros;
diff --git a/tests/ui/unused_result_ok.fixed b/tests/ui/unused_result_ok.fixed
new file mode 100644
index 0000000000000..e78fde5c9e3cc
--- /dev/null
+++ b/tests/ui/unused_result_ok.fixed
@@ -0,0 +1,40 @@
+//@aux-build:proc_macros.rs
+#![warn(clippy::unused_result_ok)]
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn bad_style(x: &str) {
+    let _ = x.parse::<u32>();
+}
+
+fn good_style(x: &str) -> Option<u32> {
+    x.parse::<u32>().ok()
+}
+
+#[rustfmt::skip]
+fn strange_parse(x: &str) {
+    let _ = x   .   parse::<i32>();
+}
+
+macro_rules! v {
+    () => {
+        Ok::<(), ()>(())
+    };
+}
+
+macro_rules! w {
+    () => {
+        let _ = Ok::<(), ()>(());
+    };
+}
+
+fn main() {
+    let _ = v!();
+    w!();
+
+    external! {
+        Ok::<(),()>(()).ok();
+    };
+}
diff --git a/tests/ui/unused_result_ok.rs b/tests/ui/unused_result_ok.rs
new file mode 100644
index 0000000000000..117d64c4cec60
--- /dev/null
+++ b/tests/ui/unused_result_ok.rs
@@ -0,0 +1,40 @@
+//@aux-build:proc_macros.rs
+#![warn(clippy::unused_result_ok)]
+#![allow(dead_code)]
+
+#[macro_use]
+extern crate proc_macros;
+
+fn bad_style(x: &str) {
+    x.parse::<u32>().ok();
+}
+
+fn good_style(x: &str) -> Option<u32> {
+    x.parse::<u32>().ok()
+}
+
+#[rustfmt::skip]
+fn strange_parse(x: &str) {
+    x   .   parse::<i32>()   .   ok   ();
+}
+
+macro_rules! v {
+    () => {
+        Ok::<(), ()>(())
+    };
+}
+
+macro_rules! w {
+    () => {
+        Ok::<(), ()>(()).ok();
+    };
+}
+
+fn main() {
+    v!().ok();
+    w!();
+
+    external! {
+        Ok::<(),()>(()).ok();
+    };
+}
diff --git a/tests/ui/unused_result_ok.stderr b/tests/ui/unused_result_ok.stderr
new file mode 100644
index 0000000000000..241e0c71261e3
--- /dev/null
+++ b/tests/ui/unused_result_ok.stderr
@@ -0,0 +1,52 @@
+error: ignoring a result with `.ok()` is misleading
+  --> tests/ui/unused_result_ok.rs:9:5
+   |
+LL |     x.parse::<u32>().ok();
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::unused-result-ok` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unused_result_ok)]`
+help: consider using `let _ =` and removing the call to `.ok()` instead
+   |
+LL |     let _ = x.parse::<u32>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: ignoring a result with `.ok()` is misleading
+  --> tests/ui/unused_result_ok.rs:18:5
+   |
+LL |     x   .   parse::<i32>()   .   ok   ();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `let _ =` and removing the call to `.ok()` instead
+   |
+LL |     let _ = x   .   parse::<i32>();
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: ignoring a result with `.ok()` is misleading
+  --> tests/ui/unused_result_ok.rs:34:5
+   |
+LL |     v!().ok();
+   |     ^^^^^^^^^
+   |
+help: consider using `let _ =` and removing the call to `.ok()` instead
+   |
+LL |     let _ = v!();
+   |     ~~~~~~~~~~~~
+
+error: ignoring a result with `.ok()` is misleading
+  --> tests/ui/unused_result_ok.rs:29:9
+   |
+LL |         Ok::<(), ()>(()).ok();
+   |         ^^^^^^^^^^^^^^^^^^^^^
+...
+LL |     w!();
+   |     ---- in this macro invocation
+   |
+   = note: this error originates in the macro `w` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider using `let _ =` and removing the call to `.ok()` instead
+   |
+LL |         let _ = Ok::<(), ()>(());
+   |         ~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/unwrap_expect_used.rs b/tests/ui/unwrap_expect_used.rs
index 96368a0705361..a56bd0a8d0790 100644
--- a/tests/ui/unwrap_expect_used.rs
+++ b/tests/ui/unwrap_expect_used.rs
@@ -31,7 +31,7 @@ fn main() {
 
     // Don't trigger on unwrap_err on an option
     Some(3).unwrap_err();
-    Some(3).expect_err("Hellow none!");
+    Some(3).expect_err("Hello none!");
 
     // Issue #11245: The `Err` variant can never be constructed so do not lint this.
     let x: Result<(), !> = Ok(());
diff --git a/tests/ui/while_let_on_iterator.fixed b/tests/ui/while_let_on_iterator.fixed
index 59b5c858d0460..b8087c6e000f5 100644
--- a/tests/ui/while_let_on_iterator.fixed
+++ b/tests/ui/while_let_on_iterator.fixed
@@ -456,6 +456,15 @@ fn fn_once_closure() {
     });
 }
 
+fn issue13123() {
+    let mut it = 0..20;
+    'label: for n in it {
+        if n % 25 == 0 {
+            break 'label;
+        }
+    }
+}
+
 fn main() {
     let mut it = 0..20;
     for _ in it {
diff --git a/tests/ui/while_let_on_iterator.rs b/tests/ui/while_let_on_iterator.rs
index 559513d56946d..8e02f59b51265 100644
--- a/tests/ui/while_let_on_iterator.rs
+++ b/tests/ui/while_let_on_iterator.rs
@@ -456,6 +456,15 @@ fn fn_once_closure() {
     });
 }
 
+fn issue13123() {
+    let mut it = 0..20;
+    'label: while let Some(n) = it.next() {
+        if n % 25 == 0 {
+            break 'label;
+        }
+    }
+}
+
 fn main() {
     let mut it = 0..20;
     while let Some(..) = it.next() {
diff --git a/tests/ui/while_let_on_iterator.stderr b/tests/ui/while_let_on_iterator.stderr
index 8ff1f23644b16..d96b26acf345d 100644
--- a/tests/ui/while_let_on_iterator.stderr
+++ b/tests/ui/while_let_on_iterator.stderr
@@ -160,8 +160,14 @@ LL |         while let Some(x) = it.next() {
 error: this loop could be written as a `for` loop
   --> tests/ui/while_let_on_iterator.rs:461:5
    |
+LL |     'label: while let Some(n) = it.next() {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'label: for n in it`
+
+error: this loop could be written as a `for` loop
+  --> tests/ui/while_let_on_iterator.rs:470:5
+   |
 LL |     while let Some(..) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
 
-error: aborting due to 27 previous errors
+error: aborting due to 28 previous errors
 
diff --git a/tests/versioncheck.rs b/tests/versioncheck.rs
index eba5405e67ed2..6832833393766 100644
--- a/tests/versioncheck.rs
+++ b/tests/versioncheck.rs
@@ -1,4 +1,3 @@
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
 #![warn(rust_2018_idioms, unused_lifetimes)]
 #![allow(clippy::single_match_else)]
 
diff --git a/tests/workspace_test/path_dep/Cargo.toml b/tests/workspace_test/path_dep/Cargo.toml
index 85a91cd2decd5..98b4fb7aa5042 100644
--- a/tests/workspace_test/path_dep/Cargo.toml
+++ b/tests/workspace_test/path_dep/Cargo.toml
@@ -1,3 +1,6 @@
 [package]
 name = "path_dep"
 version = "0.1.0"
+
+[features]
+primary_package_test = []
diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index 0c0f28e4fbd3d..300c9de178f2b 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -541,7 +541,7 @@ <h1>Clippy Lints</h1>
                     <div class="col-12 col-md-5 search-control">
                         <div class="input-group">
                             <label class="input-group-addon" id="filter-label" for="search-input">Filter:</label>
-                            <input type="text" class="form-control filter-input" placeholder="Keywords or search string" id="search-input"
+                            <input type="text" class="form-control filter-input" placeholder="Keywords or search string (`S` or `/` to focus)" id="search-input"
                                 ng-model="search" ng-blur="updatePath()" ng-keyup="$event.keyCode == 13 && updatePath()"
                                 ng-model-options="{debounce: 50}" />
                             <span class="input-group-btn">
@@ -605,7 +605,7 @@ <h2 class="panel-title">
                             <a href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+{{lint.id}}">Related Issues</a>
                         </div>
                         <!-- Jump to source -->
-                        <div class="lint-additional-info-item">
+                        <div class="lint-additional-info-item" ng-if="lint.id_span">
                             <a href="https://github.com/rust-lang/rust-clippy/blob/{{docVersion}}/clippy_lints/{{lint.id_span.path}}#L{{lint.id_span.line}}">View Source</a>
                         </div>
                     </div>
diff --git a/util/gh-pages/script.js b/util/gh-pages/script.js
index 661f80a6d3468..ed1e090e1b540 100644
--- a/util/gh-pages/script.js
+++ b/util/gh-pages/script.js
@@ -1,5 +1,5 @@
 (function () {
-    var md = window.markdownit({
+    const md = window.markdownit({
         html: true,
         linkify: true,
         typographer: true,
@@ -17,7 +17,7 @@
     });
 
     function scrollToLint(lintId) {
-        var target = document.getElementById(lintId);
+        const target = document.getElementById(lintId);
         if (!target) {
             return;
         }
@@ -25,21 +25,17 @@
     }
 
     function scrollToLintByURL($scope, $location) {
-        var removeListener = $scope.$on('ngRepeatFinished', function (ngRepeatFinishedEvent) {
+        const removeListener = $scope.$on('ngRepeatFinished', function (ngRepeatFinishedEvent) {
             scrollToLint($location.path().substring(1));
             removeListener();
         });
     }
 
     function selectGroup($scope, selectedGroup) {
-        var groups = $scope.groups;
-        for (var group in groups) {
+        const groups = $scope.groups;
+        for (const group in groups) {
             if (groups.hasOwnProperty(group)) {
-                if (group === selectedGroup) {
-                    groups[group] = true;
-                } else {
-                    groups[group] = false;
-                }
+                groups[group] = group === selectedGroup;
             }
         }
     }
@@ -108,7 +104,7 @@
         })
         .controller("lintList", function ($scope, $http, $location, $timeout) {
             // Level filter
-            var LEVEL_FILTERS_DEFAULT = {allow: true, warn: true, deny: true, none: true};
+            const LEVEL_FILTERS_DEFAULT = {allow: true, warn: true, deny: true, none: true};
             $scope.levels = { ...LEVEL_FILTERS_DEFAULT };
             $scope.byLevels = function (lint) {
                 return $scope.levels[lint.level];
@@ -367,7 +363,7 @@
             }
 
             $scope.clearVersionFilters = function () {
-                for (let filter in $scope.versionFilters) {
+                for (const filter in $scope.versionFilters) {
                     $scope.versionFilters[filter] = { enabled: false, minorVersion: null };
                 }
             }
@@ -378,7 +374,7 @@
 
             $scope.updateVersionFilters = function() {
                 for (const filter in $scope.versionFilters) {
-                    let minorVersion = $scope.versionFilters[filter].minorVersion;
+                    const minorVersion = $scope.versionFilters[filter].minorVersion;
 
                     // 1.29.0 and greater
                     if (minorVersion && minorVersion > 28) {
@@ -391,14 +387,14 @@
             }
 
             $scope.byVersion = function(lint) {
-                let filters = $scope.versionFilters;
+                const filters = $scope.versionFilters;
                 for (const filter in filters) {
                     if (filters[filter].enabled) {
-                        let minorVersion = filters[filter].minorVersion;
+                        const minorVersion = filters[filter].minorVersion;
 
                         // Strip the "pre " prefix for pre 1.29.0 lints
-                        let lintVersion = lint.version.startsWith("pre ") ? lint.version.substring(4, lint.version.length) : lint.version;
-                        let lintMinorVersion = lintVersion.substring(2, 4);
+                        const lintVersion = lint.version.startsWith("pre ") ? lint.version.substring(4, lint.version.length) : lint.version;
+                        const lintMinorVersion = lintVersion.substring(2, 4);
 
                         switch (filter) {
                             // "=" gets the highest priority, since all filters are inclusive
@@ -441,8 +437,8 @@
 
                 // Search the description
                 // The use of `for`-loops instead of `foreach` enables us to return early
-                let terms = searchStr.split(" ");
-                let docsLowerCase = lint.docs.toLowerCase();
+                const terms = searchStr.split(" ");
+                const docsLowerCase = lint.docs.toLowerCase();
                 for (index = 0; index < terms.length; index++) {
                     // This is more likely and will therefore be checked first
                     if (docsLowerCase.indexOf(terms[index]) !== -1) {
@@ -479,7 +475,7 @@
                 const clipboard = document.getElementById("clipboard-" + lint.id);
                 if (clipboard) {
                     let resetClipboardTimeout = null;
-                    let resetClipboardIcon = clipboard.innerHTML;
+                    const resetClipboardIcon = clipboard.innerHTML;
 
                     function resetClipboard() {
                         resetClipboardTimeout = null;
@@ -511,7 +507,7 @@
                     $scope.data = data;
                     $scope.loading = false;
 
-                    var selectedGroup = getQueryVariable("sel");
+                    const selectedGroup = getQueryVariable("sel");
                     if (selectedGroup) {
                         selectGroup($scope, selectedGroup.toLowerCase());
                     }
@@ -519,7 +515,7 @@
                     scrollToLintByURL($scope, $location);
 
                     setTimeout(function () {
-                        var el = document.getElementById('filter-input');
+                        const el = document.getElementById('filter-input');
                         if (el) { el.focus() }
                     }, 0);
                 })
@@ -531,10 +527,10 @@
 })();
 
 function getQueryVariable(variable) {
-    var query = window.location.search.substring(1);
-    var vars = query.split('&');
-    for (var i = 0; i < vars.length; i++) {
-        var pair = vars[i].split('=');
+    const query = window.location.search.substring(1);
+    const vars = query.split('&');
+    for (const entry of vars) {
+        const pair = entry.split('=');
         if (decodeURIComponent(pair[0]) == variable) {
             return decodeURIComponent(pair[1]);
         }
@@ -579,6 +575,32 @@ function setTheme(theme, store) {
     }
 }
 
+function handleShortcut(ev) {
+    if (ev.ctrlKey || ev.altKey || ev.metaKey) {
+        return;
+    }
+
+    if (document.activeElement.tagName === "INPUT") {
+        if (ev.key === "Escape") {
+            document.activeElement.blur();
+        }
+    } else {
+        switch (ev.key) {
+            case "s":
+            case "S":
+            case "/":
+                ev.preventDefault(); // To prevent the key to be put into the input.
+                document.getElementById("search-input").focus();
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+document.addEventListener("keypress", handleShortcut);
+document.addEventListener("keydown", handleShortcut);
+
 // loading the theme after the initial load
 const prefersDark = window.matchMedia("(prefers-color-scheme: dark)");
 const theme = localStorage.getItem('clippy-lint-list-theme');

From f6767f7a68f42101e6820171c033565e0f3a807a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 31 Jul 2024 22:39:40 +0000
Subject: [PATCH 073/685] Detect `*` operator on `!Sized` expression

```
error[E0277]: the size for values of type `str` cannot be known at compilation time
  --> $DIR/unsized-str-in-return-expr-arg-and-local.rs:15:9
   |
LL |     let x = *"";
   |         ^ doesn't have a size known at compile-time
   |
   = help: the trait `Sized` is not implemented for `str`
   = note: all local variables must have a statically known size
   = help: unsized locals are gated as an unstable feature
help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
   |
LL -     let x = *"";
LL +     let x = "";
   |
```
---
 compiler/rustc_hir_typeck/src/expr.rs         |  6 +-
 compiler/rustc_middle/src/traits/mod.rs       |  2 +-
 .../src/error_reporting/traits/suggestions.rs | 49 ++++++++++--
 tests/ui/dst/dst-rvalue.stderr                | 10 +++
 tests/ui/issues/issue-17651.stderr            |  5 ++
 tests/ui/sized/unsized-binding.stderr         |  5 ++
 ...nsized-str-in-return-expr-arg-and-local.rs | 30 ++++++++
 ...ed-str-in-return-expr-arg-and-local.stderr | 74 +++++++++++++++++++
 .../suggestions/issue-84973-blacklist.stderr  |  5 ++
 tests/ui/unsized/unsized6.stderr              | 10 +++
 10 files changed, 187 insertions(+), 9 deletions(-)
 create mode 100644 tests/ui/sized/unsized-str-in-return-expr-arg-and-local.rs
 create mode 100644 tests/ui/sized/unsized-str-in-return-expr-arg-and-local.stderr

diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index e54f9486f6a89..f13321a56bf7d 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -841,6 +841,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let ret_ty = ret_coercion.borrow().expected_ty();
         let return_expr_ty = self.check_expr_with_hint(return_expr, ret_ty);
         let mut span = return_expr.span;
+        let mut hir_id = return_expr.hir_id;
         // Use the span of the trailing expression for our cause,
         // not the span of the entire function
         if !explicit_return
@@ -848,6 +849,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             && let Some(last_expr) = body.expr
         {
             span = last_expr.span;
+            hir_id = last_expr.hir_id;
         }
         ret_coercion.borrow_mut().coerce(
             self,
@@ -864,6 +866,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             self.select_obligations_where_possible(|errors| {
                 self.point_at_return_for_opaque_ty_error(
                     errors,
+                    hir_id,
                     span,
                     return_expr_ty,
                     return_expr.span,
@@ -921,6 +924,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn point_at_return_for_opaque_ty_error(
         &self,
         errors: &mut Vec<traits::FulfillmentError<'tcx>>,
+        hir_id: HirId,
         span: Span,
         return_expr_ty: Ty<'tcx>,
         return_span: Span,
@@ -935,7 +939,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let new_cause = ObligationCause::new(
                     cause.span,
                     cause.body_id,
-                    ObligationCauseCode::OpaqueReturnType(Some((return_expr_ty, span))),
+                    ObligationCauseCode::OpaqueReturnType(Some((return_expr_ty, hir_id))),
                 );
                 *cause = new_cause;
             }
diff --git a/compiler/rustc_middle/src/traits/mod.rs b/compiler/rustc_middle/src/traits/mod.rs
index d54e2ca0a74f7..a3277fb96d229 100644
--- a/compiler/rustc_middle/src/traits/mod.rs
+++ b/compiler/rustc_middle/src/traits/mod.rs
@@ -353,7 +353,7 @@ pub enum ObligationCauseCode<'tcx> {
     ReturnValue(HirId),
 
     /// Opaque return type of this function
-    OpaqueReturnType(Option<(Ty<'tcx>, Span)>),
+    OpaqueReturnType(Option<(Ty<'tcx>, HirId)>),
 
     /// Block implicit return
     BlockTailExpression(HirId, hir::MatchSource),
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index 0d15ef55e24e7..b1aa455ce8860 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -2725,6 +2725,20 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
 
         let tcx = self.tcx;
         let predicate = predicate.upcast(tcx);
+        let suggest_remove_deref = |err: &mut Diag<'_, G>, expr: &hir::Expr<'_>| {
+            if let Some(pred) = predicate.as_trait_clause()
+                && tcx.is_lang_item(pred.def_id(), LangItem::Sized)
+                && let hir::ExprKind::Unary(hir::UnOp::Deref, inner) = expr.kind
+            {
+                err.span_suggestion_verbose(
+                    expr.span.until(inner.span),
+                    "references are always `Sized`, even if they point to unsized data; consider \
+                     not dereferencing the expression",
+                    String::new(),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        };
         match *cause_code {
             ObligationCauseCode::ExprAssignable
             | ObligationCauseCode::MatchExpressionArm { .. }
@@ -2771,6 +2785,19 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             | ObligationCauseCode::WhereClauseInExpr(item_def_id, span, ..)
                 if !span.is_dummy() =>
             {
+                if let ObligationCauseCode::WhereClauseInExpr(_, _, hir_id, pos) = &cause_code {
+                    if let Node::Expr(expr) = tcx.parent_hir_node(*hir_id)
+                        && let hir::ExprKind::Call(_, args) = expr.kind
+                        && let Some(expr) = args.get(*pos)
+                    {
+                        suggest_remove_deref(err, &expr);
+                    } else if let Node::Expr(expr) = self.tcx.hir_node(*hir_id)
+                        && let hir::ExprKind::MethodCall(_, _, args, _) = expr.kind
+                        && let Some(expr) = args.get(*pos)
+                    {
+                        suggest_remove_deref(err, &expr);
+                    }
+                }
                 let item_name = tcx.def_path_str(item_def_id);
                 let short_item_name = with_forced_trimmed_paths!(tcx.def_path_str(item_def_id));
                 let mut multispan = MultiSpan::from(span);
@@ -2968,6 +2995,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     ));
                     err.downgrade_to_delayed_bug();
                 }
+                let mut local = true;
                 match tcx.parent_hir_node(hir_id) {
                     Node::LetStmt(hir::LetStmt { ty: Some(ty), .. }) => {
                         err.span_suggestion_verbose(
@@ -2976,7 +3004,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                             "&",
                             Applicability::MachineApplicable,
                         );
-                        err.note("all local variables must have a statically known size");
                     }
                     Node::LetStmt(hir::LetStmt {
                         init: Some(hir::Expr { kind: hir::ExprKind::Index(..), span, .. }),
@@ -2991,7 +3018,11 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                             "&",
                             Applicability::MachineApplicable,
                         );
-                        err.note("all local variables must have a statically known size");
+                    }
+                    Node::LetStmt(hir::LetStmt { init: Some(expr), .. }) => {
+                        // When encountering an assignment of an unsized trait, like `let x = *"";`,
+                        // we check if the RHS is a deref operation, to suggest removing it.
+                        suggest_remove_deref(err, &expr);
                     }
                     Node::Param(param) => {
                         err.span_suggestion_verbose(
@@ -3001,10 +3032,12 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                             "&",
                             Applicability::MachineApplicable,
                         );
+                        local = false;
                     }
-                    _ => {
-                        err.note("all local variables must have a statically known size");
-                    }
+                    _ => {}
+                }
+                if local {
+                    err.note("all local variables must have a statically known size");
                 }
                 if !tcx.features().unsized_locals {
                     err.help("unsized locals are gated as an unstable feature");
@@ -3527,14 +3560,16 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 );
             }
             ObligationCauseCode::OpaqueReturnType(expr_info) => {
-                if let Some((expr_ty, expr_span)) = expr_info {
+                if let Some((expr_ty, hir_id)) = expr_info {
                     let expr_ty = self.tcx.short_ty_string(expr_ty, &mut long_ty_file);
+                    let expr = self.infcx.tcx.hir().expect_expr(hir_id);
                     err.span_label(
-                        expr_span,
+                        expr.span,
                         with_forced_trimmed_paths!(format!(
                             "return type was inferred to be `{expr_ty}` here",
                         )),
                     );
+                    suggest_remove_deref(err, &expr);
                 }
             }
         }
diff --git a/tests/ui/dst/dst-rvalue.stderr b/tests/ui/dst/dst-rvalue.stderr
index 8d0a82b707dda..d8c529617f75f 100644
--- a/tests/ui/dst/dst-rvalue.stderr
+++ b/tests/ui/dst/dst-rvalue.stderr
@@ -9,6 +9,11 @@ LL |     let _x: Box<str> = Box::new(*"hello world");
    = help: the trait `Sized` is not implemented for `str`
 note: required by a bound in `Box::<T>::new`
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     let _x: Box<str> = Box::new(*"hello world");
+LL +     let _x: Box<str> = Box::new("hello world");
+   |
 
 error[E0277]: the size for values of type `[isize]` cannot be known at compilation time
   --> $DIR/dst-rvalue.rs:8:37
@@ -21,6 +26,11 @@ LL |     let _x: Box<[isize]> = Box::new(*array);
    = help: the trait `Sized` is not implemented for `[isize]`
 note: required by a bound in `Box::<T>::new`
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     let _x: Box<[isize]> = Box::new(*array);
+LL +     let _x: Box<[isize]> = Box::new(array);
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/issues/issue-17651.stderr b/tests/ui/issues/issue-17651.stderr
index 0c95a3c0c40d8..9519507320d82 100644
--- a/tests/ui/issues/issue-17651.stderr
+++ b/tests/ui/issues/issue-17651.stderr
@@ -9,6 +9,11 @@ LL |     (|| Box::new(*(&[0][..])))();
    = help: the trait `Sized` is not implemented for `[{integer}]`
 note: required by a bound in `Box::<T>::new`
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     (|| Box::new(*(&[0][..])))();
+LL +     (|| Box::new((&[0][..])))();
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/sized/unsized-binding.stderr b/tests/ui/sized/unsized-binding.stderr
index 7c3276032c2b4..8de236cd0b6e0 100644
--- a/tests/ui/sized/unsized-binding.stderr
+++ b/tests/ui/sized/unsized-binding.stderr
@@ -7,6 +7,11 @@ LL |     let x = *"";
    = help: the trait `Sized` is not implemented for `str`
    = note: all local variables must have a statically known size
    = help: unsized locals are gated as an unstable feature
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     let x = *"";
+LL +     let x = "";
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/sized/unsized-str-in-return-expr-arg-and-local.rs b/tests/ui/sized/unsized-str-in-return-expr-arg-and-local.rs
new file mode 100644
index 0000000000000..35abbb80d99e5
--- /dev/null
+++ b/tests/ui/sized/unsized-str-in-return-expr-arg-and-local.rs
@@ -0,0 +1,30 @@
+fn foo() -> impl Sized {
+//~^ ERROR the size for values of type `str` cannot be known at compilation time
+//~| HELP the trait `Sized` is not implemented for `str`
+    *"" //~ HELP consider not dereferencing the expression
+}
+fn bar(_: impl Sized) {}
+struct S;
+
+impl S {
+    fn baz(&self, _: impl Sized) {}
+}
+
+fn main() {
+    let _ = foo();
+    let x = *"";
+    //~^ ERROR the size for values of type `str` cannot be known at compilation time
+    //~| HELP consider not dereferencing the expression
+    //~| HELP the trait `Sized` is not implemented for `str`
+    //~| HELP unsized locals are gated as an unstable feature
+    bar(x);
+    S.baz(x);
+    bar(*"");
+    //~^ ERROR the size for values of type `str` cannot be known at compilation time
+    //~| HELP consider not dereferencing the expression
+    //~| HELP the trait `Sized` is not implemented for `str`
+    S.baz(*"");
+    //~^ ERROR the size for values of type `str` cannot be known at compilation time
+    //~| HELP consider not dereferencing the expression
+    //~| HELP the trait `Sized` is not implemented for `str`
+}
diff --git a/tests/ui/sized/unsized-str-in-return-expr-arg-and-local.stderr b/tests/ui/sized/unsized-str-in-return-expr-arg-and-local.stderr
new file mode 100644
index 0000000000000..9b7258aff1261
--- /dev/null
+++ b/tests/ui/sized/unsized-str-in-return-expr-arg-and-local.stderr
@@ -0,0 +1,74 @@
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+  --> $DIR/unsized-str-in-return-expr-arg-and-local.rs:1:13
+   |
+LL | fn foo() -> impl Sized {
+   |             ^^^^^^^^^^ doesn't have a size known at compile-time
+...
+LL |     *""
+   |     --- return type was inferred to be `str` here
+   |
+   = help: the trait `Sized` is not implemented for `str`
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     *""
+LL +     ""
+   |
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+  --> $DIR/unsized-str-in-return-expr-arg-and-local.rs:15:9
+   |
+LL |     let x = *"";
+   |         ^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `str`
+   = note: all local variables must have a statically known size
+   = help: unsized locals are gated as an unstable feature
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     let x = *"";
+LL +     let x = "";
+   |
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+  --> $DIR/unsized-str-in-return-expr-arg-and-local.rs:22:9
+   |
+LL |     bar(*"");
+   |     --- ^^^ doesn't have a size known at compile-time
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = help: the trait `Sized` is not implemented for `str`
+note: required by a bound in `bar`
+  --> $DIR/unsized-str-in-return-expr-arg-and-local.rs:6:16
+   |
+LL | fn bar(_: impl Sized) {}
+   |                ^^^^^ required by this bound in `bar`
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     bar(*"");
+LL +     bar("");
+   |
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+  --> $DIR/unsized-str-in-return-expr-arg-and-local.rs:26:11
+   |
+LL |     S.baz(*"");
+   |       --- ^^^ doesn't have a size known at compile-time
+   |       |
+   |       required by a bound introduced by this call
+   |
+   = help: the trait `Sized` is not implemented for `str`
+note: required by a bound in `S::baz`
+  --> $DIR/unsized-str-in-return-expr-arg-and-local.rs:10:27
+   |
+LL |     fn baz(&self, _: impl Sized) {}
+   |                           ^^^^^ required by this bound in `S::baz`
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     S.baz(*"");
+LL +     S.baz("");
+   |
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/suggestions/issue-84973-blacklist.stderr b/tests/ui/suggestions/issue-84973-blacklist.stderr
index 4fd063e46926a..c1ef1cd428e4a 100644
--- a/tests/ui/suggestions/issue-84973-blacklist.stderr
+++ b/tests/ui/suggestions/issue-84973-blacklist.stderr
@@ -66,6 +66,11 @@ note: required by a bound in `f_sized`
    |
 LL | fn f_sized<T: Sized>(t: T) {}
    |               ^^^^^ required by this bound in `f_sized`
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     f_sized(*ref_cl);
+LL +     f_sized(ref_cl);
+   |
 
 error[E0277]: `Rc<{integer}>` cannot be sent between threads safely
   --> $DIR/issue-84973-blacklist.rs:27:12
diff --git a/tests/ui/unsized/unsized6.stderr b/tests/ui/unsized/unsized6.stderr
index 56e7f60f9ff08..d406120efc532 100644
--- a/tests/ui/unsized/unsized6.stderr
+++ b/tests/ui/unsized/unsized6.stderr
@@ -123,6 +123,11 @@ help: consider removing the `?Sized` bound to make the type parameter `Sized`
 LL - fn f3<X: ?Sized>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
 LL + fn f3<X>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
    |
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     let y = *x2;
+LL +     let y = x2;
+   |
 
 error[E0277]: the size for values of type `X` cannot be known at compilation time
   --> $DIR/unsized6.rs:26:10
@@ -177,6 +182,11 @@ help: consider removing the `?Sized` bound to make the type parameter `Sized`
 LL - fn f4<X: ?Sized + T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
 LL + fn f4<X: T>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
    |
+help: references are always `Sized`, even if they point to unsized data; consider not dereferencing the expression
+   |
+LL -     let y = *x2;
+LL +     let y = x2;
+   |
 
 error[E0277]: the size for values of type `X` cannot be known at compilation time
   --> $DIR/unsized6.rs:34:10

From 1350a65736d66ff771010442258c1cbf499b1842 Mon Sep 17 00:00:00 2001
From: Veera <sveera.2001@gmail.com>
Date: Thu, 8 Aug 2024 15:21:15 -0400
Subject: [PATCH 074/685] Remove a Redundant Conditional Check

The existing code check for `where_bounds.is_empty()` twice when
it can be combined into one. Moreover, the refactored code reads
better and feels straightforward.
---
 compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index d865357b82900..2fb1bcf2dbfff 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -959,11 +959,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                      \n    where\n        T: {qself_str},\n{}",
                     where_bounds.join(",\n"),
                 ));
-            }
-            let reported = err.emit();
-            if !where_bounds.is_empty() {
+                let reported = err.emit();
                 return Err(reported);
             }
+            err.emit();
         }
 
         Ok(bound)

From 9948b423a0e602e514e63ead9dfebdfa9acb0f03 Mon Sep 17 00:00:00 2001
From: Alexey Semenyuk <alexsemenyuk88@gmail.com>
Date: Fri, 9 Aug 2024 01:35:28 +0500
Subject: [PATCH 075/685] Fix confusing message in double_must_use lint

---
 clippy_lints/src/functions/must_use.rs |  4 ++--
 tests/ui/double_must_use.rs            |  8 ++++----
 tests/ui/double_must_use.stderr        | 16 ++++++++--------
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index b179d7b52492c..97be38c4a7dd6 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -129,9 +129,9 @@ fn check_needless_must_use(
             cx,
             DOUBLE_MUST_USE,
             fn_header_span,
-            "this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`",
+            "this function has a `#[must_use]` attribute with no message, but returns a type already marked as `#[must_use]`",
             None,
-            "either add some descriptive text or remove the attribute",
+            "either add some descriptive message or remove the attribute",
         );
     }
 }
diff --git a/tests/ui/double_must_use.rs b/tests/ui/double_must_use.rs
index 615de3e24743c..4460aeb075bf6 100644
--- a/tests/ui/double_must_use.rs
+++ b/tests/ui/double_must_use.rs
@@ -3,19 +3,19 @@
 
 #[must_use]
 pub fn must_use_result() -> Result<(), ()> {
-    //~^ ERROR: this function has an empty `#[must_use]` attribute, but returns a type already
+    //~^ ERROR: this function has a `#[must_use]` attribute with no message, but returns a type already
     unimplemented!();
 }
 
 #[must_use]
 pub fn must_use_tuple() -> (Result<(), ()>, u8) {
-    //~^ ERROR: this function has an empty `#[must_use]` attribute, but returns a type already
+    //~^ ERROR: this function has a `#[must_use]` attribute with no message, but returns a type already
     unimplemented!();
 }
 
 #[must_use]
 pub fn must_use_array() -> [Result<(), ()>; 1] {
-    //~^ ERROR: this function has an empty `#[must_use]` attribute, but returns a type already
+    //~^ ERROR: this function has a `#[must_use]` attribute with no message, but returns a type already
     unimplemented!();
 }
 
@@ -32,7 +32,7 @@ async fn async_must_use() -> usize {
 
 #[must_use]
 async fn async_must_use_result() -> Result<(), ()> {
-    //~^ ERROR: this function has an empty `#[must_use]` attribute, but returns a type already
+    //~^ ERROR: this function has a `#[must_use]` attribute with no message, but returns a type already
     Ok(())
 }
 
diff --git a/tests/ui/double_must_use.stderr b/tests/ui/double_must_use.stderr
index 0f2154ecbcfab..b26d1e48a8b86 100644
--- a/tests/ui/double_must_use.stderr
+++ b/tests/ui/double_must_use.stderr
@@ -1,36 +1,36 @@
-error: this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`
+error: this function has a `#[must_use]` attribute with no message, but returns a type already marked as `#[must_use]`
   --> tests/ui/double_must_use.rs:5:1
    |
 LL | pub fn must_use_result() -> Result<(), ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: either add some descriptive text or remove the attribute
+   = help: either add some descriptive message or remove the attribute
    = note: `-D clippy::double-must-use` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::double_must_use)]`
 
-error: this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`
+error: this function has a `#[must_use]` attribute with no message, but returns a type already marked as `#[must_use]`
   --> tests/ui/double_must_use.rs:11:1
    |
 LL | pub fn must_use_tuple() -> (Result<(), ()>, u8) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: either add some descriptive text or remove the attribute
+   = help: either add some descriptive message or remove the attribute
 
-error: this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`
+error: this function has a `#[must_use]` attribute with no message, but returns a type already marked as `#[must_use]`
   --> tests/ui/double_must_use.rs:17:1
    |
 LL | pub fn must_use_array() -> [Result<(), ()>; 1] {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: either add some descriptive text or remove the attribute
+   = help: either add some descriptive message or remove the attribute
 
-error: this function has an empty `#[must_use]` attribute, but returns a type already marked as `#[must_use]`
+error: this function has a `#[must_use]` attribute with no message, but returns a type already marked as `#[must_use]`
   --> tests/ui/double_must_use.rs:34:1
    |
 LL | async fn async_must_use_result() -> Result<(), ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = help: either add some descriptive text or remove the attribute
+   = help: either add some descriptive message or remove the attribute
 
 error: aborting due to 4 previous errors
 

From 21f91750ab98a8ea7bab6386061a254ad0dfd1f4 Mon Sep 17 00:00:00 2001
From: Zachary S <zasample18+github@gmail.com>
Date: Thu, 8 Aug 2024 10:25:22 -0500
Subject: [PATCH 076/685] Don't panic on `miri_print_borrow_state()` under
 `-Zmiri-disable-stacked-borrows`.

---
 src/tools/miri/src/borrow_tracker/mod.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/src/borrow_tracker/mod.rs b/src/tools/miri/src/borrow_tracker/mod.rs
index d537a7fbc1798..ac4f6979a087b 100644
--- a/src/tools/miri/src/borrow_tracker/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/mod.rs
@@ -346,7 +346,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
     fn print_borrow_state(&mut self, alloc_id: AllocId, show_unnamed: bool) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
-        let method = this.machine.borrow_tracker.as_ref().unwrap().borrow().borrow_tracker_method;
+        let Some(borrow_tracker) = &this.machine.borrow_tracker else {
+            eprintln!("attempted to print borrow state, but no borrow state is being tracked");
+            return Ok(());
+        };
+        let method = borrow_tracker.borrow().borrow_tracker_method;
         match method {
             BorrowTrackerMethod::StackedBorrows => this.print_stacks(alloc_id),
             BorrowTrackerMethod::TreeBorrows => this.print_tree(alloc_id, show_unnamed),

From 6552a82166aa20c48103e846c0d2387159fe6d12 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Fri, 9 Aug 2024 12:16:47 +0800
Subject: [PATCH 077/685] throw_unsup_format for alignment greater than 2^29
 and refactor non-power-of-two alignment check

---
 src/tools/miri/src/shims/foreign_items.rs       | 17 ++++++++++++++---
 .../fail/alloc/unsupported_big_alignment.rs     | 14 ++++++++++++++
 .../fail/alloc/unsupported_big_alignment.stderr | 14 ++++++++++++++
 .../unsupported_non_power_two_alignment.rs      | 11 +++++++++++
 .../unsupported_non_power_two_alignment.stderr  | 15 +++++++++++++++
 5 files changed, 68 insertions(+), 3 deletions(-)
 create mode 100644 src/tools/miri/tests/fail/alloc/unsupported_big_alignment.rs
 create mode 100644 src/tools/miri/tests/fail/alloc/unsupported_big_alignment.stderr
 create mode 100644 src/tools/miri/tests/fail/alloc/unsupported_non_power_two_alignment.rs
 create mode 100644 src/tools/miri/tests/fail/alloc/unsupported_non_power_two_alignment.stderr

diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index 7f6f63ff5e79b..6ceec56e2f503 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -8,7 +8,7 @@ use rustc_middle::mir;
 use rustc_middle::ty;
 use rustc_span::Symbol;
 use rustc_target::{
-    abi::{Align, Size},
+    abi::{Align, AlignFromBytesError, Size},
     spec::abi::Abi,
 };
 
@@ -199,9 +199,20 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
         if i128::from(size) > this.tcx.data_layout.pointer_size.signed_int_max() {
             throw_ub_format!("creating an allocation larger than half the address space");
         }
-        if !align.is_power_of_two() {
-            throw_ub_format!("creating allocation with non-power-of-two alignment {}", align);
+        if let Err(e) = Align::from_bytes(align) {
+            match e {
+                AlignFromBytesError::TooLarge(_) => {
+                    throw_unsup_format!(
+                        "creating allocation with alignment {align} exceeding rustc's maximum \
+                         supported value"
+                    );
+                }
+                AlignFromBytesError::NotPowerOfTwo(_) => {
+                    throw_ub_format!("creating allocation with non-power-of-two alignment {align}");
+                }
+            }
         }
+
         Ok(())
     }
 
diff --git a/src/tools/miri/tests/fail/alloc/unsupported_big_alignment.rs b/src/tools/miri/tests/fail/alloc/unsupported_big_alignment.rs
new file mode 100644
index 0000000000000..08d84c461bfaa
--- /dev/null
+++ b/src/tools/miri/tests/fail/alloc/unsupported_big_alignment.rs
@@ -0,0 +1,14 @@
+// Previously, attempting to allocate with an alignment greater than 2^29 would cause miri to ICE
+// because rustc does not support alignments that large.
+// https://github.com/rust-lang/miri/issues/3687
+
+extern "Rust" {
+    fn __rust_alloc(size: usize, align: usize) -> *mut u8;
+}
+
+fn main() {
+    unsafe {
+        __rust_alloc(1, 1 << 30);
+        //~^ERROR: exceeding rustc's maximum supported value
+    }
+}
diff --git a/src/tools/miri/tests/fail/alloc/unsupported_big_alignment.stderr b/src/tools/miri/tests/fail/alloc/unsupported_big_alignment.stderr
new file mode 100644
index 0000000000000..4c783b866c877
--- /dev/null
+++ b/src/tools/miri/tests/fail/alloc/unsupported_big_alignment.stderr
@@ -0,0 +1,14 @@
+error: unsupported operation: creating allocation with alignment ALIGN exceeding rustc's maximum supported value
+  --> $DIR/unsupported_big_alignment.rs:LL:CC
+   |
+LL |         __rust_alloc(1, 1 << 30);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ creating allocation with alignment ALIGN exceeding rustc's maximum supported value
+   |
+   = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
+   = note: BACKTRACE:
+   = note: inside `main` at $DIR/unsupported_big_alignment.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/fail/alloc/unsupported_non_power_two_alignment.rs b/src/tools/miri/tests/fail/alloc/unsupported_non_power_two_alignment.rs
new file mode 100644
index 0000000000000..a4ab8094bf4e1
--- /dev/null
+++ b/src/tools/miri/tests/fail/alloc/unsupported_non_power_two_alignment.rs
@@ -0,0 +1,11 @@
+// Test non-power-of-two alignment.
+extern "Rust" {
+    fn __rust_alloc(size: usize, align: usize) -> *mut u8;
+}
+
+fn main() {
+    unsafe {
+        __rust_alloc(1, 3);
+        //~^ERROR: creating allocation with non-power-of-two alignment
+    }
+}
diff --git a/src/tools/miri/tests/fail/alloc/unsupported_non_power_two_alignment.stderr b/src/tools/miri/tests/fail/alloc/unsupported_non_power_two_alignment.stderr
new file mode 100644
index 0000000000000..69a6c375f47f0
--- /dev/null
+++ b/src/tools/miri/tests/fail/alloc/unsupported_non_power_two_alignment.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: creating allocation with non-power-of-two alignment ALIGN
+  --> $DIR/unsupported_non_power_two_alignment.rs:LL:CC
+   |
+LL |         __rust_alloc(1, 3);
+   |         ^^^^^^^^^^^^^^^^^^ creating allocation with non-power-of-two alignment ALIGN
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: BACKTRACE:
+   = note: inside `main` at $DIR/unsupported_non_power_two_alignment.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+

From 3fc5469a8d340bd6872e8067ea449af90b79e142 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 9 Aug 2024 14:03:16 +1000
Subject: [PATCH 078/685] Remove `Binder::split`.

It's unused.
---
 compiler/rustc_type_ir/src/binder.rs | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
index c1f6fb36324ed..84ff5cebba1ec 100644
--- a/compiler/rustc_type_ir/src/binder.rs
+++ b/compiler/rustc_type_ir/src/binder.rs
@@ -247,21 +247,6 @@ impl<I: Interner, T> Binder<I, T> {
         // `self.value` is equivalent to `self.skip_binder()`
         if self.value.has_escaping_bound_vars() { None } else { Some(self.skip_binder()) }
     }
-
-    /// Splits the contents into two things that share the same binder
-    /// level as the original, returning two distinct binders.
-    ///
-    /// `f` should consider bound regions at depth 1 to be free, and
-    /// anything it produces with bound regions at depth 1 will be
-    /// bound in the resulting return values.
-    pub fn split<U, V, F>(self, f: F) -> (Binder<I, U>, Binder<I, V>)
-    where
-        F: FnOnce(T) -> (U, V),
-    {
-        let Binder { value, bound_vars } = self;
-        let (u, v) = f(value);
-        (Binder { value: u, bound_vars }, Binder { value: v, bound_vars })
-    }
 }
 
 impl<I: Interner, T> Binder<I, Option<T>> {

From 8640998869b28adab4b8faeaee169744804d3e68 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 9 Aug 2024 10:01:59 +1000
Subject: [PATCH 079/685] Split `split_inputs_and_output` in two.

I think it's a little clearer and nicer that way.
---
 compiler/rustc_middle/src/ty/sty.rs    |  9 ++++++---
 compiler/rustc_type_ir/src/inherent.rs |  4 +++-
 compiler/rustc_type_ir/src/ty_kind.rs  | 11 ++++-------
 3 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 8c97de1c59b26..fe2ea2e5da56c 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -1955,9 +1955,12 @@ impl<'tcx> Ty<'tcx> {
 }
 
 impl<'tcx> rustc_type_ir::inherent::Tys<TyCtxt<'tcx>> for &'tcx ty::List<Ty<'tcx>> {
-    fn split_inputs_and_output(self) -> (&'tcx [Ty<'tcx>], Ty<'tcx>) {
-        let (output, inputs) = self.split_last().unwrap();
-        (inputs, *output)
+    fn inputs(self) -> &'tcx [Ty<'tcx>] {
+        self.split_last().unwrap().1
+    }
+
+    fn output(self) -> Ty<'tcx> {
+        *self.split_last().unwrap().0
     }
 }
 
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index 263ba676427c5..6ca2fed038065 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -203,7 +203,9 @@ pub trait Ty<I: Interner<Ty = Self>>:
 pub trait Tys<I: Interner<Tys = Self>>:
     Copy + Debug + Hash + Eq + SliceLike<Item = I::Ty> + TypeFoldable<I> + Default
 {
-    fn split_inputs_and_output(self) -> (I::FnInputTys, I::Ty);
+    fn inputs(self) -> I::FnInputTys;
+
+    fn output(self) -> I::Ty;
 }
 
 pub trait Abi<I: Interner<Abi = Self>>: Copy + Debug + Hash + Eq + Relate<I> {
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 7e48f1b20a868..828f90212c48e 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -868,16 +868,12 @@ pub struct FnSig<I: Interner> {
 }
 
 impl<I: Interner> FnSig<I> {
-    pub fn split_inputs_and_output(self) -> (I::FnInputTys, I::Ty) {
-        self.inputs_and_output.split_inputs_and_output()
-    }
-
     pub fn inputs(self) -> I::FnInputTys {
-        self.split_inputs_and_output().0
+        self.inputs_and_output.inputs()
     }
 
     pub fn output(self) -> I::Ty {
-        self.split_inputs_and_output().1
+        self.inputs_and_output.output()
     }
 
     pub fn is_fn_trait_compatible(self) -> bool {
@@ -935,7 +931,7 @@ impl<I: Interner> fmt::Debug for FnSig<I> {
         }
 
         write!(f, "fn(")?;
-        let (inputs, output) = sig.split_inputs_and_output();
+        let inputs = sig.inputs();
         for (i, ty) in inputs.iter().enumerate() {
             if i > 0 {
                 write!(f, ", ")?;
@@ -951,6 +947,7 @@ impl<I: Interner> fmt::Debug for FnSig<I> {
         }
         write!(f, ")")?;
 
+        let output = sig.output();
         match output.kind() {
             Tuple(list) if list.is_empty() => Ok(()),
             _ => write!(f, " -> {:?}", sig.output()),

From c4717cc9d15d30e08f03f51845c950175979bcc4 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 8 Aug 2024 17:18:20 +1000
Subject: [PATCH 080/685] Shrink `TyKind::FnPtr`.

By splitting the `FnSig` within `TyKind::FnPtr` into `FnSigTys` and
`FnHeader`, which can be packed more efficiently. This reduces the size
of the hot `TyKind` type from 32 bytes to 24 bytes on 64-bit platforms.
This reduces peak memory usage by a few percent on some benchmarks. It
also reduces cache misses and page faults similarly, though this doesn't
translate to clear cycles or wall-time improvements on CI.
---
 .../src/diagnostics/conflict_errors.rs        |  2 +-
 compiler/rustc_borrowck/src/lib.rs            |  4 +-
 compiler/rustc_borrowck/src/type_check/mod.rs |  4 +-
 .../rustc_codegen_cranelift/src/common.rs     |  2 +-
 .../src/value_and_place.rs                    |  2 +-
 compiler/rustc_codegen_gcc/src/type_of.rs     |  5 +-
 .../src/debuginfo/metadata.rs                 |  2 +-
 .../src/debuginfo/type_names.rs               |  2 +-
 compiler/rustc_codegen_ssa/src/mir/block.rs   |  2 +-
 .../src/check_consts/check.rs                 |  4 +-
 .../src/const_eval/valtrees.rs                |  4 +-
 .../rustc_const_eval/src/interpret/cast.rs    |  4 +-
 .../src/interpret/intrinsics.rs               |  2 +-
 .../rustc_const_eval/src/interpret/stack.rs   |  2 +-
 .../rustc_const_eval/src/interpret/step.rs    |  2 +-
 .../src/interpret/validity.rs                 |  2 +-
 .../rustc_const_eval/src/util/type_name.rs    |  2 +-
 .../src/check/intrinsicck.rs                  |  2 +-
 .../rustc_hir_analysis/src/check/wfcheck.rs   |  2 +-
 .../src/coherence/inherent_impls.rs           |  2 +-
 .../src/variance/constraints.rs               |  4 +-
 compiler/rustc_hir_typeck/src/callee.rs       |  4 +-
 compiler/rustc_hir_typeck/src/closure.rs      |  4 +-
 compiler/rustc_hir_typeck/src/coercion.rs     | 17 ++---
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    |  2 +-
 .../src/fn_ctxt/suggestions.rs                |  2 +-
 .../rustc_hir_typeck/src/method/suggest.rs    |  2 +-
 .../src/infer/canonical/canonicalizer.rs      |  2 +-
 compiler/rustc_lint/src/types.rs              |  9 ++-
 compiler/rustc_middle/src/ty/context.rs       |  2 +-
 compiler/rustc_middle/src/ty/error.rs         |  4 +-
 compiler/rustc_middle/src/ty/flags.rs         |  6 +-
 compiler/rustc_middle/src/ty/layout.rs        |  5 +-
 compiler/rustc_middle/src/ty/mod.rs           |  2 +-
 compiler/rustc_middle/src/ty/print/mod.rs     |  2 +-
 compiler/rustc_middle/src/ty/print/pretty.rs  |  6 +-
 .../rustc_middle/src/ty/structural_impls.rs   |  4 +-
 compiler/rustc_middle/src/ty/sty.rs           | 19 ++---
 compiler/rustc_middle/src/ty/util.rs          | 12 +--
 compiler/rustc_middle/src/ty/walk.rs          |  9 ++-
 .../src/move_paths/builder.rs                 |  4 +-
 .../src/abort_unwinding_calls.rs              |  2 +-
 .../src/ffi_unwind_calls.rs                   |  2 +-
 compiler/rustc_mir_transform/src/shim.rs      |  2 +-
 .../src/canonicalizer.rs                      |  2 +-
 .../rustc_next_trait_solver/src/coherence.rs  |  2 +-
 .../src/solve/assembly/mod.rs                 |  4 +-
 .../src/solve/assembly/structural_traits.rs   |  9 ++-
 .../src/solve/trait_goals.rs                  |  2 +-
 compiler/rustc_passes/src/abi_test.rs         | 17 +++--
 compiler/rustc_pattern_analysis/src/rustc.rs  |  2 +-
 .../src/cfi/typeid/itanium_cxx_abi/encode.rs  |  9 ++-
 .../rustc_smir/src/rustc_internal/internal.rs |  5 +-
 .../rustc_smir/src/rustc_smir/convert/ty.rs   |  4 +-
 compiler/rustc_symbol_mangling/src/v0.rs      |  3 +-
 .../src/error_reporting/infer/mod.rs          | 12 +--
 .../error_reporting/infer/note_and_explain.rs |  6 +-
 .../src/error_reporting/infer/suggest.rs      | 13 ++--
 .../traits/fulfillment_errors.rs              | 12 +--
 .../src/error_reporting/traits/suggestions.rs | 20 ++---
 .../src/traits/project.rs                     |  2 +-
 .../src/traits/query/dropck_outlives.rs       |  4 +-
 .../src/traits/select/candidate_assembly.rs   | 16 ++--
 .../src/traits/select/confirmation.rs         |  2 +-
 .../src/traits/select/mod.rs                  |  6 +-
 .../rustc_trait_selection/src/traits/wf.rs    |  2 +-
 compiler/rustc_ty_utils/src/instance.rs       |  2 +-
 compiler/rustc_ty_utils/src/layout.rs         |  2 +-
 compiler/rustc_type_ir/src/binder.rs          |  1 +
 compiler/rustc_type_ir/src/fast_reject.rs     | 21 +++---
 compiler/rustc_type_ir/src/inherent.rs        |  6 +-
 compiler/rustc_type_ir/src/outlives.rs        |  2 +-
 compiler/rustc_type_ir/src/relate.rs          |  4 +-
 compiler/rustc_type_ir/src/ty_kind.rs         | 73 ++++++++++++++++++-
 compiler/rustc_type_ir/src/ty_kind/closure.rs | 24 +++---
 src/librustdoc/clean/mod.rs                   |  2 +-
 .../passes/collect_intra_doc_links.rs         |  2 +-
 .../src/casts/fn_to_numeric_cast.rs           |  2 +-
 .../src/casts/fn_to_numeric_cast_any.rs       |  2 +-
 .../fn_to_numeric_cast_with_truncation.rs     |  2 +-
 .../src/default_numeric_fallback.rs           |  2 +-
 .../clippy/clippy_lints/src/dereference.rs    |  2 +-
 .../clippy/clippy_lints/src/eta_reduction.rs  |  2 +-
 .../clippy_lints/src/methods/map_flatten.rs   |  2 +-
 .../src/mixed_read_write_in_expression.rs     |  2 +-
 .../src/multiple_unsafe_ops_per_block.rs      |  2 +-
 .../clippy/clippy_lints/src/mut_reference.rs  |  2 +-
 src/tools/clippy/clippy_utils/src/ty.rs       |  4 +-
 src/tools/clippy/clippy_utils/src/visitors.rs |  2 +-
 89 files changed, 298 insertions(+), 201 deletions(-)

diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 7a925705806fc..bb5b73931ce11 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -3989,7 +3989,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
             } else {
                 let ty = self.infcx.tcx.type_of(self.mir_def_id()).instantiate_identity();
                 match ty.kind() {
-                    ty::FnDef(_, _) | ty::FnPtr(_) => self.annotate_fn_sig(
+                    ty::FnDef(_, _) | ty::FnPtr(..) => self.annotate_fn_sig(
                         self.mir_def_id(),
                         self.infcx.tcx.fn_sig(self.mir_def_id()).instantiate_identity(),
                     ),
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 9c2a0036befa8..30dd45d847c9b 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -1644,7 +1644,7 @@ impl<'mir, 'tcx> MirBorrowckCtxt<'_, 'mir, '_, 'tcx> {
                     | ty::Pat(_, _)
                     | ty::Slice(_)
                     | ty::FnDef(_, _)
-                    | ty::FnPtr(_)
+                    | ty::FnPtr(..)
                     | ty::Dynamic(_, _, _)
                     | ty::Closure(_, _)
                     | ty::CoroutineClosure(_, _)
@@ -1689,7 +1689,7 @@ impl<'mir, 'tcx> MirBorrowckCtxt<'_, 'mir, '_, 'tcx> {
                     | ty::RawPtr(_, _)
                     | ty::Ref(_, _, _)
                     | ty::FnDef(_, _)
-                    | ty::FnPtr(_)
+                    | ty::FnPtr(..)
                     | ty::Dynamic(_, _, _)
                     | ty::CoroutineWitness(..)
                     | ty::Never
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index b13773ffe1460..f9af133f0e57e 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1364,7 +1364,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 debug!("func_ty.kind: {:?}", func_ty.kind());
 
                 let sig = match func_ty.kind() {
-                    ty::FnDef(..) | ty::FnPtr(_) => func_ty.fn_sig(tcx),
+                    ty::FnDef(..) | ty::FnPtr(..) => func_ty.fn_sig(tcx),
                     _ => {
                         span_mirbug!(self, term, "call to non-function {:?}", func_ty);
                         return;
@@ -2420,7 +2420,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 let ty_left = left.ty(body, tcx);
                 match ty_left.kind() {
                     // Types with regions are comparable if they have a common super-type.
-                    ty::RawPtr(_, _) | ty::FnPtr(_) => {
+                    ty::RawPtr(_, _) | ty::FnPtr(..) => {
                         let ty_right = right.ty(body, tcx);
                         let common_ty = self.infcx.next_ty_var(body.source_info(location).span);
                         self.sub_types(
diff --git a/compiler/rustc_codegen_cranelift/src/common.rs b/compiler/rustc_codegen_cranelift/src/common.rs
index 0931713993691..cbede8bc5790e 100644
--- a/compiler/rustc_codegen_cranelift/src/common.rs
+++ b/compiler/rustc_codegen_cranelift/src/common.rs
@@ -69,7 +69,7 @@ fn clif_type_from_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<types::Typ
             FloatTy::F64 => types::F64,
             FloatTy::F128 => unimplemented!("f16_f128"),
         },
-        ty::FnPtr(_) => pointer_ty(tcx),
+        ty::FnPtr(..) => pointer_ty(tcx),
         ty::RawPtr(pointee_ty, _) | ty::Ref(_, pointee_ty, _) => {
             if has_ptr_meta(tcx, *pointee_ty) {
                 return None;
diff --git a/compiler/rustc_codegen_cranelift/src/value_and_place.rs b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
index 1aa28daeafc7e..c2aa1f206488b 100644
--- a/compiler/rustc_codegen_cranelift/src/value_and_place.rs
+++ b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
@@ -872,7 +872,7 @@ pub(crate) fn assert_assignable<'tcx>(
         (ty::Ref(_, a, _), ty::RawPtr(b, _)) | (ty::RawPtr(a, _), ty::Ref(_, b, _)) => {
             assert_assignable(fx, *a, *b, limit - 1);
         }
-        (ty::FnPtr(_), ty::FnPtr(_)) => {
+        (ty::FnPtr(..), ty::FnPtr(..)) => {
             let from_sig = fx.tcx.normalize_erasing_late_bound_regions(
                 ParamEnv::reveal_all(),
                 from_ty.fn_sig(fx.tcx),
diff --git a/compiler/rustc_codegen_gcc/src/type_of.rs b/compiler/rustc_codegen_gcc/src/type_of.rs
index d85ed4f12ffab..b7b1be5369c42 100644
--- a/compiler/rustc_codegen_gcc/src/type_of.rs
+++ b/compiler/rustc_codegen_gcc/src/type_of.rs
@@ -213,9 +213,8 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
                 // NOTE: we cannot remove this match like in the LLVM codegen because the call
                 // to fn_ptr_backend_type handle the on-stack attribute.
                 // TODO(antoyo): find a less hackish way to hande the on-stack attribute.
-                ty::FnPtr(sig) => {
-                    cx.fn_ptr_backend_type(cx.fn_abi_of_fn_ptr(sig, ty::List::empty()))
-                }
+                ty::FnPtr(sig_tys, hdr) => cx
+                    .fn_ptr_backend_type(cx.fn_abi_of_fn_ptr(sig_tys.with(hdr), ty::List::empty())),
                 _ => self.scalar_gcc_type_at(cx, scalar, Size::ZERO),
             };
             cx.scalar_types.borrow_mut().insert(self.ty, ty);
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index ad63858861261..87bea22d8ddaf 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -456,7 +456,7 @@ pub fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll D
         {
             build_pointer_or_reference_di_node(cx, t, t.boxed_ty(), unique_type_id)
         }
-        ty::FnDef(..) | ty::FnPtr(_) => build_subroutine_type_di_node(cx, unique_type_id),
+        ty::FnDef(..) | ty::FnPtr(..) => build_subroutine_type_di_node(cx, unique_type_id),
         ty::Closure(..) => build_closure_env_di_node(cx, unique_type_id),
         ty::CoroutineClosure(..) => build_closure_env_di_node(cx, unique_type_id),
         ty::Coroutine(..) => enums::build_coroutine_di_node(cx, unique_type_id),
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
index 2755803892751..359043a6d78ec 100644
--- a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
+++ b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@@ -331,7 +331,7 @@ fn push_debuginfo_type_name<'tcx>(
                 output.push(')');
             }
         }
-        ty::FnDef(..) | ty::FnPtr(_) => {
+        ty::FnDef(..) | ty::FnPtr(..) => {
             // We've encountered a weird 'recursive type'
             // Currently, the only way to generate such a type
             // is by using 'impl trait':
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index bc3076528da24..5f5ddd6f4f74d 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -846,7 +846,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 ),
                 None,
             ),
-            ty::FnPtr(_) => (None, Some(callee.immediate())),
+            ty::FnPtr(..) => (None, Some(callee.immediate())),
             _ => bug!("{} is not callable", callee.layout.ty),
         };
 
diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index 3ded81b90ffc1..69850a35c612b 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -170,7 +170,7 @@ struct LocalReturnTyVisitor<'ck, 'mir, 'tcx> {
 impl<'ck, 'mir, 'tcx> TypeVisitor<TyCtxt<'tcx>> for LocalReturnTyVisitor<'ck, 'mir, 'tcx> {
     fn visit_ty(&mut self, t: Ty<'tcx>) {
         match t.kind() {
-            ty::FnPtr(_) => {}
+            ty::FnPtr(..) => {}
             ty::Ref(_, _, hir::Mutability::Mut) => {
                 self.checker.check_op(ops::mut_ref::MutRef(self.kind));
                 t.super_visit_with(self)
@@ -725,7 +725,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                 let (mut callee, mut fn_args) = match *fn_ty.kind() {
                     ty::FnDef(def_id, fn_args) => (def_id, fn_args),
 
-                    ty::FnPtr(_) => {
+                    ty::FnPtr(..) => {
                         self.check_op(ops::FnCallIndirect);
                         return;
                     }
diff --git a/compiler/rustc_const_eval/src/const_eval/valtrees.rs b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
index 8227c04594883..53693f9a6a60e 100644
--- a/compiler/rustc_const_eval/src/const_eval/valtrees.rs
+++ b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
@@ -132,7 +132,7 @@ fn const_to_valtree_inner<'tcx>(
 
         // Technically we could allow function pointers (represented as `ty::Instance`), but this is not guaranteed to
         // agree with runtime equality tests.
-        ty::FnPtr(_) => Err(ValTreeCreationError::NonSupportedType(ty)),
+        ty::FnPtr(..) => Err(ValTreeCreationError::NonSupportedType(ty)),
 
         ty::Ref(_, _, _)  => {
             let derefd_place = ecx.deref_pointer(place)?;
@@ -353,7 +353,7 @@ pub fn valtree_to_const_value<'tcx>(
         | ty::CoroutineClosure(..)
         | ty::Coroutine(..)
         | ty::CoroutineWitness(..)
-        | ty::FnPtr(_)
+        | ty::FnPtr(..)
         | ty::Str
         | ty::Slice(_)
         | ty::Dynamic(..) => bug!("no ValTree should have been created for type {:?}", ty.kind()),
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
index b2f07de0ac4e2..6a6e7250f334f 100644
--- a/compiler/rustc_const_eval/src/interpret/cast.rs
+++ b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -97,7 +97,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             CastKind::PointerCoercion(PointerCoercion::UnsafeFnPointer) => {
                 let src = self.read_immediate(src)?;
                 match cast_ty.kind() {
-                    ty::FnPtr(_) => {
+                    ty::FnPtr(..) => {
                         // No change to value
                         self.write_immediate(*src, dest)?;
                     }
@@ -230,7 +230,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         src: &ImmTy<'tcx, M::Provenance>,
         cast_to: TyAndLayout<'tcx>,
     ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
-        assert_matches!(src.layout.ty.kind(), ty::RawPtr(_, _) | ty::FnPtr(_));
+        assert_matches!(src.layout.ty.kind(), ty::RawPtr(_, _) | ty::FnPtr(..));
         assert!(cast_to.ty.is_integral());
 
         let scalar = src.to_scalar();
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index 9210ec4e16fd0..d6d528ef36164 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -79,7 +79,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
             | ty::RawPtr(_, _)
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Dynamic(_, _, _)
             | ty::Closure(_, _)
             | ty::CoroutineClosure(_, _)
diff --git a/compiler/rustc_const_eval/src/interpret/stack.rs b/compiler/rustc_const_eval/src/interpret/stack.rs
index 50dbced6a2a6a..0f6bf5c03364c 100644
--- a/compiler/rustc_const_eval/src/interpret/stack.rs
+++ b/compiler/rustc_const_eval/src/interpret/stack.rs
@@ -483,7 +483,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 | ty::Bool
                 | ty::Float(_)
                 | ty::FnDef(..)
-                | ty::FnPtr(_)
+                | ty::FnPtr(..)
                 | ty::RawPtr(..)
                 | ty::Char
                 | ty::Ref(..)
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index 2527eca344620..aaee6f6d247f8 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -424,7 +424,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             self.tcx.mk_type_list_from_iter(extra_args.iter().map(|arg| arg.layout().ty));
 
         let (callee, fn_abi, with_caller_location) = match *func.layout.ty.kind() {
-            ty::FnPtr(_sig) => {
+            ty::FnPtr(..) => {
                 let fn_ptr = self.read_pointer(&func)?;
                 let fn_val = self.get_ptr_fn(fn_ptr)?;
                 (fn_val, self.fn_abi_of_fn_ptr(fn_sig_binder, extra_args)?, false)
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 460f5448634b5..47e86e0702b0a 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -616,7 +616,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
                 self.check_safe_pointer(value, PointerKind::Ref(*mutbl))?;
                 Ok(true)
             }
-            ty::FnPtr(_sig) => {
+            ty::FnPtr(..) => {
                 let value = self.read_scalar(value, ExpectedKind::FnPtr)?;
 
                 // If we check references recursively, also check that this points to a function.
diff --git a/compiler/rustc_const_eval/src/util/type_name.rs b/compiler/rustc_const_eval/src/util/type_name.rs
index 3aa3b3b74e053..36c7bed5c1194 100644
--- a/compiler/rustc_const_eval/src/util/type_name.rs
+++ b/compiler/rustc_const_eval/src/util/type_name.rs
@@ -35,7 +35,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
             | ty::Slice(_)
             | ty::RawPtr(_, _)
             | ty::Ref(_, _, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Never
             | ty::Tuple(_)
             | ty::Dynamic(_, _, _) => self.pretty_print_type(ty),
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsicck.rs b/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
index 847a1e6470679..ff008536b4b8e 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
@@ -66,7 +66,7 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
             ty::Float(FloatTy::F32) => Some(InlineAsmType::F32),
             ty::Float(FloatTy::F64) => Some(InlineAsmType::F64),
             ty::Float(FloatTy::F128) => Some(InlineAsmType::F128),
-            ty::FnPtr(_) => Some(asm_ty_isize),
+            ty::FnPtr(..) => Some(asm_ty_isize),
             ty::RawPtr(ty, _) if self.is_thin_ptr_ty(ty) => Some(asm_ty_isize),
             ty::Adt(adt, args) if adt.repr().simd() => {
                 let fields = &adt.non_enum_variant().fields;
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index c878095ba0d70..196bb4548a72d 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -951,7 +951,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
             } else {
                 let mut diag = match ty.kind() {
                     ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Error(_) => return Ok(()),
-                    ty::FnPtr(_) => tcx.dcx().struct_span_err(
+                    ty::FnPtr(..) => tcx.dcx().struct_span_err(
                         hir_ty.span,
                         "using function pointers as const generic parameters is forbidden",
                     ),
diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
index e2d3ff558cf7d..89acb778d6c29 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
@@ -172,7 +172,7 @@ impl<'tcx> InherentCollect<'tcx> {
             | ty::RawPtr(_, _)
             | ty::Ref(..)
             | ty::Never
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Tuple(..) => self.check_primitive_impl(id, self_ty),
             ty::Alias(ty::Projection | ty::Inherent | ty::Opaque, _) | ty::Param(_) => {
                 Err(self.tcx.dcx().emit_err(errors::InherentNominal { span: item_span }))
diff --git a/compiler/rustc_hir_analysis/src/variance/constraints.rs b/compiler/rustc_hir_analysis/src/variance/constraints.rs
index 92baa41e07f90..ce9e73bf24503 100644
--- a/compiler/rustc_hir_analysis/src/variance/constraints.rs
+++ b/compiler/rustc_hir_analysis/src/variance/constraints.rs
@@ -317,8 +317,8 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
                 self.add_constraint(current, data.index, variance);
             }
 
-            ty::FnPtr(sig) => {
-                self.add_constraints_from_sig(current, sig, variance);
+            ty::FnPtr(sig_tys, hdr) => {
+                self.add_constraints_from_sig(current, sig_tys.with(hdr), variance);
             }
 
             ty::Error(_) => {
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index 07f64ead6f636..44cb08e44eb81 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -137,7 +137,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // If the callee is a bare function or a closure, then we're all set.
         match *adjusted_ty.kind() {
-            ty::FnDef(..) | ty::FnPtr(_) => {
+            ty::FnDef(..) | ty::FnPtr(..) => {
                 let adjustments = self.adjust_steps(autoderef);
                 self.apply_adjustments(callee_expr, adjustments);
                 return Some(CallStep::Builtin(adjusted_ty));
@@ -467,7 +467,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 (fn_sig, Some(def_id))
             }
             // FIXME(effects): these arms should error because we can't enforce them
-            ty::FnPtr(sig) => (sig, None),
+            ty::FnPtr(sig_tys, hdr) => (sig_tys.with(hdr), None),
             _ => {
                 for arg in arg_exprs {
                     self.check_expr(arg);
diff --git a/compiler/rustc_hir_typeck/src/closure.rs b/compiler/rustc_hir_typeck/src/closure.rs
index a7953acc95c80..589a9c5a71914 100644
--- a/compiler/rustc_hir_typeck/src/closure.rs
+++ b/compiler/rustc_hir_typeck/src/closure.rs
@@ -336,9 +336,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     .into_iter()
                     .map(|obl| (obl.predicate, obl.cause.span)),
             ),
-            ty::FnPtr(sig) => match closure_kind {
+            ty::FnPtr(sig_tys, hdr) => match closure_kind {
                 hir::ClosureKind::Closure => {
-                    let expected_sig = ExpectedSig { cause_span: None, sig };
+                    let expected_sig = ExpectedSig { cause_span: None, sig: sig_tys.with(hdr) };
                     (Some(expected_sig), Some(ty::ClosureKind::Fn))
                 }
                 hir::ClosureKind::Coroutine(_) | hir::ClosureKind::CoroutineClosure(_) => {
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index fcd3798eb48e6..0c83d50ad121c 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -225,10 +225,10 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 // items to drop the unsafe qualifier.
                 self.coerce_from_fn_item(a, b)
             }
-            ty::FnPtr(a_f) => {
+            ty::FnPtr(a_sig_tys, a_hdr) => {
                 // We permit coercion of fn pointers to drop the
                 // unsafe qualifier.
-                self.coerce_from_fn_pointer(a, a_f, b)
+                self.coerce_from_fn_pointer(a, a_sig_tys.with(a_hdr), b)
             }
             ty::Closure(closure_def_id_a, args_a) => {
                 // Non-capturing closures are coercible to
@@ -788,9 +788,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         self.commit_if_ok(|snapshot| {
             let outer_universe = self.infcx.universe();
 
-            let result = if let ty::FnPtr(fn_ty_b) = b.kind()
-                && let (hir::Safety::Safe, hir::Safety::Unsafe) =
-                    (fn_ty_a.safety(), fn_ty_b.safety())
+            let result = if let ty::FnPtr(_, hdr_b) = b.kind()
+                && let (hir::Safety::Safe, hir::Safety::Unsafe) = (fn_ty_a.safety(), hdr_b.safety)
             {
                 let unsafe_a = self.tcx.safe_to_unsafe_fn_ty(fn_ty_a);
                 self.unify_and(unsafe_a, b, to_unsafe)
@@ -842,7 +841,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         debug!("coerce_from_fn_item(a={:?}, b={:?})", a, b);
 
         match b.kind() {
-            ty::FnPtr(b_sig) => {
+            ty::FnPtr(_, b_hdr) => {
                 let a_sig = a.fn_sig(self.tcx);
                 if let ty::FnDef(def_id, _) = *a.kind() {
                     // Intrinsics are not coercible to function pointers
@@ -852,7 +851,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
 
                     // Safe `#[target_feature]` functions are not assignable to safe fn pointers (RFC 2396).
 
-                    if b_sig.safety() == hir::Safety::Safe
+                    if b_hdr.safety == hir::Safety::Safe
                         && !self.tcx.codegen_fn_attrs(def_id).target_features.is_empty()
                     {
                         return Err(TypeError::TargetFeatureCast(def_id));
@@ -910,7 +909,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             //
             // All we care here is if any variable is being captured and not the exact paths,
             // so we check `upvars_mentioned` for root variables being captured.
-            ty::FnPtr(fn_ty)
+            ty::FnPtr(_, hdr)
                 if self
                     .tcx
                     .upvars_mentioned(closure_def_id_a.expect_local())
@@ -923,7 +922,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 // or
                 //     `unsafe fn(arg0,arg1,...) -> _`
                 let closure_sig = args_a.as_closure().sig();
-                let safety = fn_ty.safety();
+                let safety = hdr.safety;
                 let pointer_ty =
                     Ty::new_fn_ptr(self.tcx, self.tcx.signature_unclosure(closure_sig, safety));
                 debug!("coerce_closure_to_fn(a={:?}, b={:?}, pty={:?})", a, b, pointer_ty);
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index cef003e0a43de..0c727d285a871 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -1527,7 +1527,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     ty::Int(_) | ty::Uint(_) => Some(ty),
                     ty::Char => Some(tcx.types.u8),
                     ty::RawPtr(..) => Some(tcx.types.usize),
-                    ty::FnDef(..) | ty::FnPtr(_) => Some(tcx.types.usize),
+                    ty::FnDef(..) | ty::FnPtr(..) => Some(tcx.types.usize),
                     _ => None,
                 });
                 opt_ty.unwrap_or_else(|| self.next_int_var())
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index 6b4edcd95d993..703273968c5bb 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -604,7 +604,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expected: Ty<'tcx>,
         found: Ty<'tcx>,
     ) -> bool {
-        if let (ty::FnPtr(_), ty::Closure(def_id, _)) = (expected.kind(), found.kind()) {
+        if let (ty::FnPtr(..), ty::Closure(def_id, _)) = (expected.kind(), found.kind()) {
             if let Some(upvars) = self.tcx.upvars_mentioned(*def_id) {
                 // Report upto four upvars being captured to reduce the amount error messages
                 // reported back to the user.
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 94133357a3eb5..b8af839094f0d 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -50,7 +50,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // Not all of these (e.g., unsafe fns) implement `FnOnce`,
             // so we look for these beforehand.
             // FIXME(async_closures): These don't impl `FnOnce` by default.
-            ty::Closure(..) | ty::FnDef(..) | ty::FnPtr(_) => true,
+            ty::Closure(..) | ty::FnDef(..) | ty::FnPtr(..) => true,
             // If it's not a simple function, look for things which implement `FnOnce`.
             _ => {
                 let Some(fn_once) = tcx.lang_items().fn_once_trait() else {
diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
index 3bcb92d8029a2..db5139172b022 100644
--- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
+++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs
@@ -438,7 +438,7 @@ impl<'cx, 'tcx> TypeFolder<TyCtxt<'tcx>> for Canonicalizer<'cx, 'tcx> {
             | ty::RawPtr(..)
             | ty::Ref(..)
             | ty::FnDef(..)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Dynamic(..)
             | ty::Never
             | ty::Tuple(..)
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index 5b17c0d718a44..77fa40fea3956 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -1025,7 +1025,7 @@ fn ty_is_known_nonnull<'tcx>(
     let ty = tcx.try_normalize_erasing_regions(param_env, ty).unwrap_or(ty);
 
     match ty.kind() {
-        ty::FnPtr(_) => true,
+        ty::FnPtr(..) => true,
         ty::Ref(..) => true,
         ty::Adt(def, _) if def.is_box() && matches!(mode, CItemKind::Definition) => true,
         ty::Adt(def, args) if def.repr().transparent() && !def.is_union() => {
@@ -1476,7 +1476,8 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
 
             ty::Array(inner_ty, _) => self.check_type_for_ffi(cache, inner_ty),
 
-            ty::FnPtr(sig) => {
+            ty::FnPtr(sig_tys, hdr) => {
+                let sig = sig_tys.with(hdr);
                 if self.is_internal_abi(sig.abi()) {
                     return FfiUnsafe {
                         ty,
@@ -1712,8 +1713,8 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> {
             type Result = ControlFlow<Ty<'tcx>>;
 
             fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
-                if let ty::FnPtr(sig) = ty.kind()
-                    && !self.visitor.is_internal_abi(sig.abi())
+                if let ty::FnPtr(_, hdr) = ty.kind()
+                    && !self.visitor.is_internal_abi(hdr.abi)
                 {
                     self.tys.push(ty);
                 }
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 8f8fd09c9e4d9..53380bfd7218a 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -427,7 +427,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
             | ty::RawPtr(_, _)
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Dynamic(_, _, _)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs
index 2f9bdb16bb0ab..d974a86a3036f 100644
--- a/compiler/rustc_middle/src/ty/error.rs
+++ b/compiler/rustc_middle/src/ty/error.rs
@@ -130,7 +130,7 @@ impl<'tcx> Ty<'tcx> {
                 DefKind::Ctor(CtorOf::Variant, _) => "enum constructor".into(),
                 _ => "fn item".into(),
             },
-            ty::FnPtr(_) => "fn pointer".into(),
+            ty::FnPtr(..) => "fn pointer".into(),
             ty::Dynamic(inner, ..) if let Some(principal) = inner.principal() => {
                 format!("`dyn {}`", tcx.def_path_str(principal.def_id())).into()
             }
@@ -194,7 +194,7 @@ impl<'tcx> Ty<'tcx> {
                 DefKind::Ctor(CtorOf::Variant, _) => "enum constructor".into(),
                 _ => "fn item".into(),
             },
-            ty::FnPtr(_) => "fn pointer".into(),
+            ty::FnPtr(..) => "fn pointer".into(),
             ty::Dynamic(..) => "trait object".into(),
             ty::Closure(..) | ty::CoroutineClosure(..) => "closure".into(),
             ty::Coroutine(def_id, ..) => {
diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
index c3430b5840692..1e38e30628aa9 100644
--- a/compiler/rustc_middle/src/ty/flags.rs
+++ b/compiler/rustc_middle/src/ty/flags.rs
@@ -250,9 +250,9 @@ impl FlagComputation {
                 self.add_args(args);
             }
 
-            &ty::FnPtr(fn_sig) => self.bound_computation(fn_sig, |computation, fn_sig| {
-                computation.add_tys(fn_sig.inputs());
-                computation.add_ty(fn_sig.output());
+            &ty::FnPtr(sig_tys, _) => self.bound_computation(sig_tys, |computation, sig_tys| {
+                computation.add_tys(sig_tys.inputs());
+                computation.add_ty(sig_tys.output());
             }),
         }
     }
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index d7d27975f60a9..55511d0833ce0 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -801,7 +801,7 @@ where
                 | ty::Int(_)
                 | ty::Uint(_)
                 | ty::Float(_)
-                | ty::FnPtr(_)
+                | ty::FnPtr(..)
                 | ty::Never
                 | ty::FnDef(..)
                 | ty::CoroutineWitness(..)
@@ -986,7 +986,8 @@ where
                     safe: None,
                 })
             }
-            ty::FnPtr(fn_sig) if offset.bytes() == 0 => {
+            ty::FnPtr(sig_tys, hdr) if offset.bytes() == 0 => {
+                let fn_sig = sig_tys.with(hdr);
                 tcx.layout_of(param_env.and(Ty::new_fn_ptr(tcx, fn_sig))).ok().map(|layout| {
                     PointeeInfo { size: layout.size, align: layout.align.abi, safe: None }
                 })
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 9736428e6f7c7..2e6b961834143 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -2149,6 +2149,6 @@ mod size_asserts {
     use super::*;
     // tidy-alphabetical-start
     static_assert_size!(PredicateKind<'_>, 32);
-    static_assert_size!(WithCachedTypeInfo<TyKind<'_>>, 56);
+    static_assert_size!(WithCachedTypeInfo<TyKind<'_>>, 48);
     // tidy-alphabetical-end
 }
diff --git a/compiler/rustc_middle/src/ty/print/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs
index 6cce79dfdc1cf..cc7467467603a 100644
--- a/compiler/rustc_middle/src/ty/print/mod.rs
+++ b/compiler/rustc_middle/src/ty/print/mod.rs
@@ -290,7 +290,7 @@ fn characteristic_def_id_of_type_cached<'a>(
         | ty::Int(_)
         | ty::Uint(_)
         | ty::Str
-        | ty::FnPtr(_)
+        | ty::FnPtr(..)
         | ty::Alias(..)
         | ty::Placeholder(..)
         | ty::Param(_)
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 29d72183dd3ff..2dd0caf4f87ec 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -696,7 +696,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                     p!(print(sig), " {{", print_value_path(def_id, args), "}}");
                 }
             }
-            ty::FnPtr(ref bare_fn) => p!(print(bare_fn)),
+            ty::FnPtr(ref sig_tys, hdr) => p!(print(sig_tys.with(hdr))),
             ty::Infer(infer_ty) => {
                 if self.should_print_verbose() {
                     p!(write("{:?}", ty.kind()));
@@ -1678,7 +1678,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                     }
                 }
             }
-            ty::FnPtr(_) => {
+            ty::FnPtr(..) => {
                 // FIXME: We should probably have a helper method to share code with the "Byte strings"
                 // printing above (which also has to handle pointers to all sorts of things).
                 if let Some(GlobalAlloc::Function { instance, .. }) =
@@ -1741,7 +1741,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                 p!(write("{:?}", char::try_from(int).unwrap()))
             }
             // Pointer types
-            ty::Ref(..) | ty::RawPtr(_, _) | ty::FnPtr(_) => {
+            ty::Ref(..) | ty::RawPtr(_, _) | ty::FnPtr(..) => {
                 let data = int.to_bits(self.tcx().data_layout.pointer_size);
                 self.typed_value(
                     |this| {
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 8fb44a5f0b1b1..80b33c2cda929 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -374,7 +374,7 @@ impl<'tcx> TypeSuperFoldable<TyCtxt<'tcx>> for Ty<'tcx> {
             ),
             ty::Tuple(ts) => ty::Tuple(ts.try_fold_with(folder)?),
             ty::FnDef(def_id, args) => ty::FnDef(def_id, args.try_fold_with(folder)?),
-            ty::FnPtr(f) => ty::FnPtr(f.try_fold_with(folder)?),
+            ty::FnPtr(sig_tys, hdr) => ty::FnPtr(sig_tys.try_fold_with(folder)?, hdr),
             ty::Ref(r, ty, mutbl) => {
                 ty::Ref(r.try_fold_with(folder)?, ty.try_fold_with(folder)?, mutbl)
             }
@@ -424,7 +424,7 @@ impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for Ty<'tcx> {
             }
             ty::Tuple(ts) => ts.visit_with(visitor),
             ty::FnDef(_, args) => args.visit_with(visitor),
-            ty::FnPtr(ref f) => f.visit_with(visitor),
+            ty::FnPtr(ref sig_tys, _) => sig_tys.visit_with(visitor),
             ty::Ref(r, ty, _) => {
                 try_visit!(r.visit_with(visitor));
                 ty.visit_with(visitor)
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index fe2ea2e5da56c..609d929e4a1fc 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -658,7 +658,8 @@ impl<'tcx> Ty<'tcx> {
 
     #[inline]
     pub fn new_fn_ptr(tcx: TyCtxt<'tcx>, fty: PolyFnSig<'tcx>) -> Ty<'tcx> {
-        Ty::new(tcx, FnPtr(fty))
+        let (sig_tys, hdr) = fty.split();
+        Ty::new(tcx, FnPtr(sig_tys, hdr))
     }
 
     #[inline]
@@ -1182,7 +1183,7 @@ impl<'tcx> Ty<'tcx> {
                 | Float(_)
                 | Uint(_)
                 | FnDef(..)
-                | FnPtr(_)
+                | FnPtr(..)
                 | RawPtr(_, _)
                 | Infer(IntVar(_) | FloatVar(_))
         )
@@ -1333,7 +1334,7 @@ impl<'tcx> Ty<'tcx> {
     pub fn fn_sig(self, tcx: TyCtxt<'tcx>) -> PolyFnSig<'tcx> {
         match self.kind() {
             FnDef(def_id, args) => tcx.fn_sig(*def_id).instantiate(tcx, args),
-            FnPtr(f) => *f,
+            FnPtr(sig_tys, hdr) => sig_tys.with(*hdr),
             Error(_) => {
                 // ignore errors (#54954)
                 Binder::dummy(ty::FnSig {
@@ -1352,12 +1353,12 @@ impl<'tcx> Ty<'tcx> {
 
     #[inline]
     pub fn is_fn(self) -> bool {
-        matches!(self.kind(), FnDef(..) | FnPtr(_))
+        matches!(self.kind(), FnDef(..) | FnPtr(..))
     }
 
     #[inline]
     pub fn is_fn_ptr(self) -> bool {
-        matches!(self.kind(), FnPtr(_))
+        matches!(self.kind(), FnPtr(..))
     }
 
     #[inline]
@@ -1599,7 +1600,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Bool
             | ty::Float(_)
             | ty::FnDef(..)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::RawPtr(..)
             | ty::Char
             | ty::Ref(..)
@@ -1791,7 +1792,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Bool
             | ty::Float(_)
             | ty::FnDef(..)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::RawPtr(..)
             | ty::Char
             | ty::Ref(..)
@@ -1941,7 +1942,7 @@ impl<'tcx> Ty<'tcx> {
             | RawPtr(_, _)
             | Ref(_, _, _)
             | FnDef(_, _)
-            | FnPtr(_)
+            | FnPtr(..)
             | Dynamic(_, _, _)
             | Closure(_, _)
             | CoroutineClosure(_, _)
@@ -1972,6 +1973,6 @@ mod size_asserts {
     use super::*;
     // tidy-alphabetical-start
     static_assert_size!(ty::RegionKind<'_>, 24);
-    static_assert_size!(ty::TyKind<'_>, 32);
+    static_assert_size!(ty::TyKind<'_>, 24);
     // tidy-alphabetical-end
 }
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 3cf8531bb62d5..0343c762313de 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -1282,7 +1282,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::RawPtr(_, _)
             | ty::FnDef(..)
             | ty::Error(_)
-            | ty::FnPtr(_) => true,
+            | ty::FnPtr(..) => true,
             ty::Tuple(fields) => fields.iter().all(Self::is_trivially_freeze),
             ty::Pat(ty, _) | ty::Slice(ty) | ty::Array(ty, _) => ty.is_trivially_freeze(),
             ty::Adt(..)
@@ -1322,7 +1322,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::RawPtr(_, _)
             | ty::FnDef(..)
             | ty::Error(_)
-            | ty::FnPtr(_) => true,
+            | ty::FnPtr(..) => true,
             ty::Tuple(fields) => fields.iter().all(Self::is_trivially_unpin),
             ty::Pat(ty, _) | ty::Slice(ty) | ty::Array(ty, _) => ty.is_trivially_unpin(),
             ty::Adt(..)
@@ -1361,7 +1361,7 @@ impl<'tcx> Ty<'tcx> {
             | ty::Ref(..)
             | ty::RawPtr(..)
             | ty::FnDef(..)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Infer(ty::FreshIntTy(_))
             | ty::Infer(ty::FreshFloatTy(_)) => AsyncDropGlueMorphology::Noop,
 
@@ -1544,7 +1544,7 @@ impl<'tcx> Ty<'tcx> {
             ty::Pat(..) | ty::Ref(..) | ty::Array(..) | ty::Slice(_) | ty::Tuple(..) => true,
 
             // Raw pointers use bitwise comparison.
-            ty::RawPtr(_, _) | ty::FnPtr(_) => true,
+            ty::RawPtr(_, _) | ty::FnPtr(..) => true,
 
             // Floating point numbers are not `Eq`.
             ty::Float(_) => false,
@@ -1675,7 +1675,7 @@ pub fn needs_drop_components_with_async<'tcx>(
         | ty::Float(_)
         | ty::Never
         | ty::FnDef(..)
-        | ty::FnPtr(_)
+        | ty::FnPtr(..)
         | ty::Char
         | ty::RawPtr(_, _)
         | ty::Ref(..)
@@ -1742,7 +1742,7 @@ pub fn is_trivially_const_drop(ty: Ty<'_>) -> bool {
         | ty::RawPtr(_, _)
         | ty::Ref(..)
         | ty::FnDef(..)
-        | ty::FnPtr(_)
+        | ty::FnPtr(..)
         | ty::Never
         | ty::Foreign(_) => true,
 
diff --git a/compiler/rustc_middle/src/ty/walk.rs b/compiler/rustc_middle/src/ty/walk.rs
index 2dd7a96f19268..0a328352e2e97 100644
--- a/compiler/rustc_middle/src/ty/walk.rs
+++ b/compiler/rustc_middle/src/ty/walk.rs
@@ -189,9 +189,12 @@ fn push_inner<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent: GenericArg<'tcx>)
                 stack.extend(args.iter().rev());
             }
             ty::Tuple(ts) => stack.extend(ts.iter().rev().map(GenericArg::from)),
-            ty::FnPtr(sig) => {
-                stack.push(sig.skip_binder().output().into());
-                stack.extend(sig.skip_binder().inputs().iter().copied().rev().map(|ty| ty.into()));
+            ty::FnPtr(sig_tys, hdr) => {
+                let fn_sig = sig_tys.with(hdr);
+                stack.push(fn_sig.skip_binder().output().into());
+                stack.extend(
+                    fn_sig.skip_binder().inputs().iter().copied().rev().map(|ty| ty.into()),
+                );
             }
         },
         GenericArgKind::Lifetime(_) => {}
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index c26a72e454382..86091379f5a92 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -158,7 +158,7 @@ impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> {
                     | ty::Pat(_, _)
                     | ty::Slice(_)
                     | ty::FnDef(_, _)
-                    | ty::FnPtr(_)
+                    | ty::FnPtr(..)
                     | ty::Dynamic(_, _, _)
                     | ty::Closure(..)
                     | ty::CoroutineClosure(..)
@@ -201,7 +201,7 @@ impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> {
                     | ty::RawPtr(_, _)
                     | ty::Ref(_, _, _)
                     | ty::FnDef(_, _)
-                    | ty::FnPtr(_)
+                    | ty::FnPtr(..)
                     | ty::Dynamic(_, _, _)
                     | ty::CoroutineWitness(..)
                     | ty::Never
diff --git a/compiler/rustc_mir_transform/src/abort_unwinding_calls.rs b/compiler/rustc_mir_transform/src/abort_unwinding_calls.rs
index f52a4524d784b..edb6bc4fbea2f 100644
--- a/compiler/rustc_mir_transform/src/abort_unwinding_calls.rs
+++ b/compiler/rustc_mir_transform/src/abort_unwinding_calls.rs
@@ -64,7 +64,7 @@ impl<'tcx> MirPass<'tcx> for AbortUnwindingCalls {
                     let ty = func.ty(body, tcx);
                     let sig = ty.fn_sig(tcx);
                     let fn_def_id = match ty.kind() {
-                        ty::FnPtr(_) => None,
+                        ty::FnPtr(..) => None,
                         &ty::FnDef(def_id, _) => Some(def_id),
                         _ => span_bug!(span, "invalid callee of type {:?}", ty),
                     };
diff --git a/compiler/rustc_mir_transform/src/ffi_unwind_calls.rs b/compiler/rustc_mir_transform/src/ffi_unwind_calls.rs
index 4132e604f20e0..9a2cc057232f3 100644
--- a/compiler/rustc_mir_transform/src/ffi_unwind_calls.rs
+++ b/compiler/rustc_mir_transform/src/ffi_unwind_calls.rs
@@ -57,7 +57,7 @@ fn has_ffi_unwind_calls(tcx: TyCtxt<'_>, local_def_id: LocalDefId) -> bool {
         };
 
         let fn_def_id = match ty.kind() {
-            ty::FnPtr(_) => None,
+            ty::FnPtr(..) => None,
             &ty::FnDef(def_id, _) => {
                 // Rust calls cannot themselves create foreign unwinds (even if they use a non-Rust ABI).
                 // So the leak of the foreign unwind into Rust can only be elsewhere, not here.
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
index f41f3ef656c51..49d55166ec5bc 100644
--- a/compiler/rustc_mir_transform/src/shim.rs
+++ b/compiler/rustc_mir_transform/src/shim.rs
@@ -437,7 +437,7 @@ fn build_clone_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, self_ty: Ty<'tcx>) -
     let src = tcx.mk_place_deref(Place::from(Local::new(1 + 0)));
 
     match self_ty.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => builder.copy_shim(),
+        ty::FnDef(..) | ty::FnPtr(..) => builder.copy_shim(),
         ty::Closure(_, args) => builder.tuple_like_shim(dest, src, args.as_closure().upvar_tys()),
         ty::CoroutineClosure(_, args) => {
             builder.tuple_like_shim(dest, src, args.as_coroutine_closure().upvar_tys())
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index 82488088e30e6..394518daa4250 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -360,7 +360,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
             | ty::Ref(_, _, _)
             | ty::Pat(_, _)
             | ty::FnDef(_, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Dynamic(_, _, _)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
diff --git a/compiler/rustc_next_trait_solver/src/coherence.rs b/compiler/rustc_next_trait_solver/src/coherence.rs
index f22ea41c51222..2461ef0c0df57 100644
--- a/compiler/rustc_next_trait_solver/src/coherence.rs
+++ b/compiler/rustc_next_trait_solver/src/coherence.rs
@@ -334,7 +334,7 @@ where
             | ty::Str
             | ty::FnDef(..)
             | ty::Pat(..)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Array(..)
             | ty::Slice(..)
             | ty::RawPtr(..)
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
index 84921e87fb3f4..bb05eb4c25697 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -533,7 +533,7 @@ where
             | ty::RawPtr(_, _)
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Dynamic(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
@@ -620,7 +620,7 @@ where
             | ty::RawPtr(_, _)
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Alias(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index 00837f7cdd87d..f32531821ec47 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -31,7 +31,7 @@ where
         | ty::Bool
         | ty::Float(_)
         | ty::FnDef(..)
-        | ty::FnPtr(_)
+        | ty::FnPtr(..)
         | ty::Error(_)
         | ty::Never
         | ty::Char => Ok(vec![]),
@@ -117,7 +117,7 @@ where
         | ty::Bool
         | ty::Float(_)
         | ty::FnDef(..)
-        | ty::FnPtr(_)
+        | ty::FnPtr(..)
         | ty::RawPtr(..)
         | ty::Char
         | ty::Ref(..)
@@ -178,7 +178,7 @@ where
 {
     match ty.kind() {
         // impl Copy/Clone for FnDef, FnPtr
-        ty::FnDef(..) | ty::FnPtr(_) | ty::Error(_) => Ok(vec![]),
+        ty::FnDef(..) | ty::FnPtr(..) | ty::Error(_) => Ok(vec![]),
 
         // Implementations are provided in core
         ty::Uint(_)
@@ -269,7 +269,8 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_callable<I: Intern
             }
         }
         // keep this in sync with assemble_fn_pointer_candidates until the old solver is removed.
-        ty::FnPtr(sig) => {
+        ty::FnPtr(sig_tys, hdr) => {
+            let sig = sig_tys.with(hdr);
             if sig.is_fn_trait_compatible() {
                 Ok(Some(
                     sig.map_bound(|sig| (Ty::new_tup(cx, sig.inputs().as_slice()), sig.output())),
diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
index b1dba712f797a..1314b7eb6ffc6 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -1145,7 +1145,7 @@ where
             | ty::RawPtr(_, _)
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
             | ty::Coroutine(_, _)
diff --git a/compiler/rustc_passes/src/abi_test.rs b/compiler/rustc_passes/src/abi_test.rs
index 839b96fb3de84..d0cc123c41a8a 100644
--- a/compiler/rustc_passes/src/abi_test.rs
+++ b/compiler/rustc_passes/src/abi_test.rs
@@ -127,14 +127,17 @@ fn dump_abi_of_fn_type(tcx: TyCtxt<'_>, item_def_id: LocalDefId, attr: &Attribut
     for meta_item in meta_items {
         match meta_item.name_or_empty() {
             sym::debug => {
-                let ty::FnPtr(sig) = ty.kind() else {
+                let ty::FnPtr(sig_tys, hdr) = ty.kind() else {
                     span_bug!(
                         meta_item.span(),
                         "`#[rustc_abi(debug)]` on a type alias requires function pointer type"
                     );
                 };
                 let abi = unwrap_fn_abi(
-                    tcx.fn_abi_of_fn_ptr(param_env.and((*sig, /* extra_args */ ty::List::empty()))),
+                    tcx.fn_abi_of_fn_ptr(
+                        param_env
+                            .and((sig_tys.with(*hdr), /* extra_args */ ty::List::empty())),
+                    ),
                     tcx,
                     item_def_id,
                 );
@@ -155,7 +158,7 @@ fn dump_abi_of_fn_type(tcx: TyCtxt<'_>, item_def_id: LocalDefId, attr: &Attribut
                         "`#[rustc_abi(assert_eq)]` on a type alias requires pair type"
                     );
                 };
-                let ty::FnPtr(sig1) = field1.kind() else {
+                let ty::FnPtr(sig_tys1, hdr1) = field1.kind() else {
                     span_bug!(
                         meta_item.span(),
                         "`#[rustc_abi(assert_eq)]` on a type alias requires pair of function pointer types"
@@ -163,12 +166,13 @@ fn dump_abi_of_fn_type(tcx: TyCtxt<'_>, item_def_id: LocalDefId, attr: &Attribut
                 };
                 let abi1 = unwrap_fn_abi(
                     tcx.fn_abi_of_fn_ptr(
-                        param_env.and((*sig1, /* extra_args */ ty::List::empty())),
+                        param_env
+                            .and((sig_tys1.with(*hdr1), /* extra_args */ ty::List::empty())),
                     ),
                     tcx,
                     item_def_id,
                 );
-                let ty::FnPtr(sig2) = field2.kind() else {
+                let ty::FnPtr(sig_tys2, hdr2) = field2.kind() else {
                     span_bug!(
                         meta_item.span(),
                         "`#[rustc_abi(assert_eq)]` on a type alias requires pair of function pointer types"
@@ -176,7 +180,8 @@ fn dump_abi_of_fn_type(tcx: TyCtxt<'_>, item_def_id: LocalDefId, attr: &Attribut
                 };
                 let abi2 = unwrap_fn_abi(
                     tcx.fn_abi_of_fn_ptr(
-                        param_env.and((*sig2, /* extra_args */ ty::List::empty())),
+                        param_env
+                            .and((sig_tys2.with(*hdr2), /* extra_args */ ty::List::empty())),
                     ),
                     tcx,
                     item_def_id,
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 6290aeb252312..cc978b1208317 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -414,7 +414,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
             | ty::Foreign(_)
             | ty::RawPtr(_, _)
             | ty::FnDef(_, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Pat(_, _)
             | ty::Dynamic(_, _, _)
             | ty::Closure(..)
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
index 61de338eab1c0..a4e4f50e8f2d4 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
@@ -607,10 +607,15 @@ pub fn encode_ty<'tcx>(
             typeid.push_str(&s);
         }
 
-        ty::FnPtr(fn_sig) => {
+        ty::FnPtr(sig_tys, hdr) => {
             // PF<return-type><parameter-type1..parameter-typeN>E
             let mut s = String::from("P");
-            s.push_str(&encode_fnsig(tcx, &fn_sig.skip_binder(), dict, TypeIdOptions::empty()));
+            s.push_str(&encode_fnsig(
+                tcx,
+                &sig_tys.with(*hdr).skip_binder(),
+                dict,
+                TypeIdOptions::empty(),
+            ));
             compress(dict, DictKey::Ty(ty, TyQ::None), &mut s);
             typeid.push_str(&s);
         }
diff --git a/compiler/rustc_smir/src/rustc_internal/internal.rs b/compiler/rustc_smir/src/rustc_internal/internal.rs
index a4577461094bb..f52cb010a872f 100644
--- a/compiler/rustc_smir/src/rustc_internal/internal.rs
+++ b/compiler/rustc_smir/src/rustc_internal/internal.rs
@@ -131,7 +131,10 @@ impl RustcInternal for RigidTy {
             RigidTy::FnDef(def, args) => {
                 rustc_ty::TyKind::FnDef(def.0.internal(tables, tcx), args.internal(tables, tcx))
             }
-            RigidTy::FnPtr(sig) => rustc_ty::TyKind::FnPtr(sig.internal(tables, tcx)),
+            RigidTy::FnPtr(sig) => {
+                let (sig_tys, hdr) = sig.internal(tables, tcx).split();
+                rustc_ty::TyKind::FnPtr(sig_tys, hdr)
+            }
             RigidTy::Closure(def, args) => {
                 rustc_ty::TyKind::Closure(def.0.internal(tables, tcx), args.internal(tables, tcx))
             }
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
index ef2eb7d52eaef..332fe22d86955 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -352,7 +352,9 @@ impl<'tcx> Stable<'tcx> for ty::TyKind<'tcx> {
             ty::FnDef(def_id, generic_args) => {
                 TyKind::RigidTy(RigidTy::FnDef(tables.fn_def(*def_id), generic_args.stable(tables)))
             }
-            ty::FnPtr(poly_fn_sig) => TyKind::RigidTy(RigidTy::FnPtr(poly_fn_sig.stable(tables))),
+            ty::FnPtr(sig_tys, hdr) => {
+                TyKind::RigidTy(RigidTy::FnPtr(sig_tys.with(*hdr).stable(tables)))
+            }
             ty::Dynamic(existential_predicates, region, dyn_kind) => {
                 TyKind::RigidTy(RigidTy::Dynamic(
                     existential_predicates
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index c2451c08d1158..3a606f244e37a 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -427,7 +427,8 @@ impl<'tcx> Printer<'tcx> for SymbolMangler<'tcx> {
                 self.print_def_path(def_id, &[])?;
             }
 
-            ty::FnPtr(sig) => {
+            ty::FnPtr(sig_tys, hdr) => {
+                let sig = sig_tys.with(hdr);
                 self.push("F");
                 self.in_binder(&sig, |cx, sig| {
                     if sig.safety == hir::Safety::Unsafe {
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
index 8ccb2a8483ae3..5193333be8e90 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -1087,9 +1087,9 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 values
             }
 
-            (ty::FnDef(did1, args1), ty::FnPtr(sig2)) => {
+            (ty::FnDef(did1, args1), ty::FnPtr(sig_tys2, hdr2)) => {
                 let sig1 = self.tcx.fn_sig(*did1).instantiate(self.tcx, args1);
-                let mut values = self.cmp_fn_sig(&sig1, sig2);
+                let mut values = self.cmp_fn_sig(&sig1, &sig_tys2.with(*hdr2));
                 values.0.push_highlighted(format!(
                     " {{{}}}",
                     self.tcx.def_path_str_with_args(*did1, args1)
@@ -1097,16 +1097,18 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 values
             }
 
-            (ty::FnPtr(sig1), ty::FnDef(did2, args2)) => {
+            (ty::FnPtr(sig_tys1, hdr1), ty::FnDef(did2, args2)) => {
                 let sig2 = self.tcx.fn_sig(*did2).instantiate(self.tcx, args2);
-                let mut values = self.cmp_fn_sig(sig1, &sig2);
+                let mut values = self.cmp_fn_sig(&sig_tys1.with(*hdr1), &sig2);
                 values
                     .1
                     .push_normal(format!(" {{{}}}", self.tcx.def_path_str_with_args(*did2, args2)));
                 values
             }
 
-            (ty::FnPtr(sig1), ty::FnPtr(sig2)) => self.cmp_fn_sig(sig1, sig2),
+            (ty::FnPtr(sig_tys1, hdr1), ty::FnPtr(sig_tys2, hdr2)) => {
+                self.cmp_fn_sig(&sig_tys1.with(*hdr1), &sig_tys2.with(*hdr2))
+            }
 
             _ => {
                 let mut strs = (DiagStyledString::new(), DiagStyledString::new());
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
index 864510bb65047..e77c738acce1a 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
@@ -441,9 +441,9 @@ impl<T> Trait<T> for X {
                             }
                         }
                     }
-                    (ty::FnPtr(sig), ty::FnDef(def_id, _))
-                    | (ty::FnDef(def_id, _), ty::FnPtr(sig)) => {
-                        if tcx.fn_sig(def_id).skip_binder().safety() < sig.safety() {
+                    (ty::FnPtr(_, hdr), ty::FnDef(def_id, _))
+                    | (ty::FnDef(def_id, _), ty::FnPtr(_, hdr)) => {
+                        if tcx.fn_sig(def_id).skip_binder().safety() < hdr.safety {
                             diag.note(
                                 "unsafe functions cannot be coerced into safe function pointers",
                             );
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs
index ee159aa0b77a6..35f68a56d2ddc 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs
@@ -383,8 +383,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
             return;
         }
         match (&expected_inner.kind(), &found_inner.kind()) {
-            (ty::FnPtr(sig), ty::FnDef(did, args)) => {
-                let expected_sig = &(self.normalize_fn_sig)(*sig);
+            (ty::FnPtr(sig_tys, hdr), ty::FnDef(did, args)) => {
+                let sig = sig_tys.with(*hdr);
+                let expected_sig = &(self.normalize_fn_sig)(sig);
                 let found_sig =
                     &(self.normalize_fn_sig)(self.tcx.fn_sig(*did).instantiate(self.tcx, args));
 
@@ -402,11 +403,11 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                     (false, true) => FunctionPointerSuggestion::RemoveRef { span, fn_name },
                     (true, true) => {
                         diag.subdiagnostic(FnItemsAreDistinct);
-                        FunctionPointerSuggestion::CastRef { span, fn_name, sig: *sig }
+                        FunctionPointerSuggestion::CastRef { span, fn_name, sig }
                     }
                     (false, false) => {
                         diag.subdiagnostic(FnItemsAreDistinct);
-                        FunctionPointerSuggestion::Cast { span, fn_name, sig: *sig }
+                        FunctionPointerSuggestion::Cast { span, fn_name, sig }
                     }
                 };
                 diag.subdiagnostic(sugg);
@@ -449,10 +450,10 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
 
                 diag.subdiagnostic(sug);
             }
-            (ty::FnDef(did, args), ty::FnPtr(sig)) => {
+            (ty::FnDef(did, args), ty::FnPtr(sig_tys, hdr)) => {
                 let expected_sig =
                     &(self.normalize_fn_sig)(self.tcx.fn_sig(*did).instantiate(self.tcx, args));
-                let found_sig = &(self.normalize_fn_sig)(*sig);
+                let found_sig = &(self.normalize_fn_sig)(sig_tys.with(*hdr));
 
                 if !self.same_type_modulo_infer(*found_sig, *expected_sig) {
                     return;
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 1cee82f04ea0e..a5f9a22ad2be3 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -375,7 +375,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         let impl_candidates = self.find_similar_impl_candidates(leaf_trait_predicate);
                         suggested = if let &[cand] = &impl_candidates[..] {
                             let cand = cand.trait_ref;
-                            if let (ty::FnPtr(_), ty::FnDef(..)) =
+                            if let (ty::FnPtr(..), ty::FnDef(..)) =
                                 (cand.self_ty().kind(), main_trait_ref.self_ty().skip_binder().kind())
                             {
                                 err.span_suggestion(
@@ -793,8 +793,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             // is unimplemented is because async closures don't implement `Fn`/`FnMut`
             // if they have captures.
             if let Some(by_ref_captures) = by_ref_captures
-                && let ty::FnPtr(sig) = by_ref_captures.kind()
-                && !sig.skip_binder().output().is_unit()
+                && let ty::FnPtr(sig_tys, _) = by_ref_captures.kind()
+                && !sig_tys.skip_binder().output().is_unit()
             {
                 let mut err = self.dcx().create_err(AsyncClosureNotFn {
                     span: self.tcx.def_span(closure_def_id),
@@ -1061,7 +1061,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     "`{ty}` is forbidden as the type of a const generic parameter",
                 )
             }
-            ty::FnPtr(_) => {
+            ty::FnPtr(..) => {
                 struct_span_code_err!(
                     self.dcx(),
                     span,
@@ -1844,10 +1844,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             if let &[cand] = &candidates[..] {
                 let (desc, mention_castable) =
                     match (cand.self_ty().kind(), trait_ref.self_ty().skip_binder().kind()) {
-                        (ty::FnPtr(_), ty::FnDef(..)) => {
+                        (ty::FnPtr(..), ty::FnDef(..)) => {
                             (" implemented for fn pointer `", ", cast using `as`")
                         }
-                        (ty::FnPtr(_), _) => (" implemented for fn pointer `", ""),
+                        (ty::FnPtr(..), _) => (" implemented for fn pointer `", ""),
                         _ => (" implemented for `", ""),
                     };
                 err.highlighted_help(vec![
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index 0d15ef55e24e7..39c5dbebbf7a1 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -1077,10 +1077,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let Some((def_id_or_name, output, inputs)) =
             (self.autoderef_steps)(found).into_iter().find_map(|(found, _)| {
                 match *found.kind() {
-                    ty::FnPtr(fn_sig) => Some((
+                    ty::FnPtr(sig_tys, _) => Some((
                         DefIdOrName::Name("function pointer"),
-                        fn_sig.output(),
-                        fn_sig.inputs(),
+                        sig_tys.output(),
+                        sig_tys.inputs(),
                     )),
                     ty::FnDef(def_id, _) => {
                         let fn_sig = found.fn_sig(self.tcx);
@@ -1977,20 +1977,22 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let ObligationCauseCode::FunctionArg { arg_hir_id, .. } = cause else {
             return;
         };
-        let ty::FnPtr(expected) = expected.kind() else {
+        let ty::FnPtr(sig_tys, hdr) = expected.kind() else {
             return;
         };
-        let ty::FnPtr(found) = found.kind() else {
+        let expected = sig_tys.with(*hdr);
+        let ty::FnPtr(sig_tys, hdr) = found.kind() else {
             return;
         };
+        let found = sig_tys.with(*hdr);
         let Node::Expr(arg) = self.tcx.hir_node(*arg_hir_id) else {
             return;
         };
         let hir::ExprKind::Path(path) = arg.kind else {
             return;
         };
-        let expected_inputs = self.tcx.instantiate_bound_regions_with_erased(*expected).inputs();
-        let found_inputs = self.tcx.instantiate_bound_regions_with_erased(*found).inputs();
+        let expected_inputs = self.tcx.instantiate_bound_regions_with_erased(expected).inputs();
+        let found_inputs = self.tcx.instantiate_bound_regions_with_erased(found).inputs();
         let both_tys = expected_inputs.iter().copied().zip(found_inputs.iter().copied());
 
         let arg_expr = |infcx: &InferCtxt<'tcx>, name, expected: Ty<'tcx>, found: Ty<'tcx>| {
@@ -4790,13 +4792,13 @@ fn hint_missing_borrow<'tcx>(
     }
 
     let found_args = match found.kind() {
-        ty::FnPtr(f) => infcx.enter_forall(*f, |f| f.inputs().iter()),
+        ty::FnPtr(sig_tys, _) => infcx.enter_forall(*sig_tys, |sig_tys| sig_tys.inputs().iter()),
         kind => {
             span_bug!(span, "found was converted to a FnPtr above but is now {:?}", kind)
         }
     };
     let expected_args = match expected.kind() {
-        ty::FnPtr(f) => infcx.enter_forall(*f, |f| f.inputs().iter()),
+        ty::FnPtr(sig_tys, _) => infcx.enter_forall(*sig_tys, |sig_tys| sig_tys.inputs().iter()),
         kind => {
             span_bug!(span, "expected was converted to a FnPtr above but is now {:?}", kind)
         }
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
index 4b62a5c59b2f0..d74fafa4817ca 100644
--- a/compiler/rustc_trait_selection/src/traits/project.rs
+++ b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -1636,7 +1636,7 @@ fn confirm_fn_pointer_candidate<'cx, 'tcx>(
             .generics_of(def_id)
             .host_effect_index
             .map_or(tcx.consts.true_, |idx| args.const_at(idx)),
-        ty::FnPtr(_) => tcx.consts.true_,
+        ty::FnPtr(..) => tcx.consts.true_,
         _ => unreachable!("only expected FnPtr or FnDef in `confirm_fn_pointer_candidate`"),
     };
 
diff --git a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
index d3a1ed52d2e62..7d30e6524490c 100644
--- a/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/dropck_outlives.rs
@@ -33,7 +33,7 @@ pub fn trivial_dropck_outlives<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool {
         | ty::Float(_)
         | ty::Never
         | ty::FnDef(..)
-        | ty::FnPtr(_)
+        | ty::FnPtr(..)
         | ty::Char
         | ty::CoroutineWitness(..)
         | ty::RawPtr(_, _)
@@ -224,7 +224,7 @@ pub fn dtorck_constraint_for_ty_inner<'tcx>(
         | ty::RawPtr(..)
         | ty::Ref(..)
         | ty::FnDef(..)
-        | ty::FnPtr(_)
+        | ty::FnPtr(..)
         | ty::CoroutineWitness(..) => {
             // these types never have a destructor
         }
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index 9de62031311b7..cb8deeaedb66f 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -468,8 +468,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 candidates.vec.push(AsyncClosureCandidate);
             }
             // Provide an impl, but only for suitable `fn` pointers.
-            ty::FnPtr(sig) => {
-                if sig.is_fn_trait_compatible() {
+            ty::FnPtr(sig_tys, hdr) => {
+                if sig_tys.with(hdr).is_fn_trait_compatible() {
                     candidates.vec.push(AsyncClosureCandidate);
                 }
             }
@@ -535,8 +535,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 candidates.ambiguous = true; // Could wind up being a fn() type.
             }
             // Provide an impl, but only for suitable `fn` pointers.
-            ty::FnPtr(sig) => {
-                if sig.is_fn_trait_compatible() {
+            ty::FnPtr(sig_tys, hdr) => {
+                if sig_tys.with(hdr).is_fn_trait_compatible() {
                     candidates
                         .vec
                         .push(FnPointerCandidate { fn_host_effect: self.tcx().consts.true_ });
@@ -819,7 +819,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::RawPtr(_, _)
                 | ty::Ref(..)
                 | ty::FnDef(..)
-                | ty::FnPtr(_)
+                | ty::FnPtr(..)
                 | ty::Closure(..)
                 | ty::CoroutineClosure(..)
                 | ty::Coroutine(..)
@@ -1207,7 +1207,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::RawPtr(_, _)
             | ty::Ref(..)
             | ty::FnDef(..)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Never
             | ty::Foreign(_)
             | ty::Array(..)
@@ -1290,7 +1290,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
             | ty::Pat(_, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Dynamic(_, _, _)
             | ty::Closure(..)
             | ty::CoroutineClosure(..)
@@ -1339,7 +1339,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         let self_ty = self.infcx.resolve_vars_if_possible(obligation.self_ty());
 
         match self_ty.skip_binder().kind() {
-            ty::FnPtr(_) => candidates.vec.push(BuiltinCandidate { has_nested: false }),
+            ty::FnPtr(..) => candidates.vec.push(BuiltinCandidate { has_nested: false }),
             ty::Bool
             | ty::Char
             | ty::Int(_)
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index ddd8b970cc813..0d7ceca430174 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -1398,7 +1398,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 | ty::RawPtr(_, _)
                 | ty::Ref(..)
                 | ty::FnDef(..)
-                | ty::FnPtr(_)
+                | ty::FnPtr(..)
                 | ty::Never
                 | ty::Foreign(_) => {}
 
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 1d9a90f0300ab..cfc0fa4e3a84f 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2114,7 +2114,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Bool
             | ty::Float(_)
             | ty::FnDef(..)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::RawPtr(..)
             | ty::Char
             | ty::Ref(..)
@@ -2171,7 +2171,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
         use self::BuiltinImplConditions::{Ambiguous, None, Where};
 
         match *self_ty.kind() {
-            ty::FnDef(..) | ty::FnPtr(_) | ty::Error(_) => Where(ty::Binder::dummy(Vec::new())),
+            ty::FnDef(..) | ty::FnPtr(..) | ty::Error(_) => Where(ty::Binder::dummy(Vec::new())),
 
             ty::Uint(_)
             | ty::Int(_)
@@ -2333,7 +2333,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             | ty::Bool
             | ty::Float(_)
             | ty::FnDef(..)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Error(_)
             | ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
             | ty::Never
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index 7e5fe7e3c942b..a3982c3d987ef 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -812,7 +812,7 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                 return upvars.visit_with(self);
             }
 
-            ty::FnPtr(_) => {
+            ty::FnPtr(..) => {
                 // Let the visitor iterate into the argument/return
                 // types appearing in the fn signature.
             }
diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs
index 43e491387091e..c7ed6e6110fab 100644
--- a/compiler/rustc_ty_utils/src/instance.rs
+++ b/compiler/rustc_ty_utils/src/instance.rs
@@ -248,7 +248,7 @@ fn resolve_associated_item<'tcx>(
                 if name == sym::clone {
                     let self_ty = trait_ref.self_ty();
                     match self_ty.kind() {
-                        ty::FnDef(..) | ty::FnPtr(_) => (),
+                        ty::FnDef(..) | ty::FnPtr(..) => (),
                         ty::Coroutine(..)
                         | ty::CoroutineWitness(..)
                         | ty::Closure(..)
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index 3ef10f4e43c4b..53b198a2da9aa 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -184,7 +184,7 @@ fn layout_of_uncached<'tcx>(
         ty::Int(ity) => scalar(Int(Integer::from_int_ty(dl, ity), true)),
         ty::Uint(ity) => scalar(Int(Integer::from_uint_ty(dl, ity), false)),
         ty::Float(fty) => scalar(Float(Float::from_float_ty(fty))),
-        ty::FnPtr(_) => {
+        ty::FnPtr(..) => {
             let mut ptr = scalar_unit(Pointer(dl.instruction_address_space));
             ptr.valid_range_mut().start = 1;
             tcx.mk_layout(LayoutS::scalar(cx, ptr))
diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
index 84ff5cebba1ec..652201f11e385 100644
--- a/compiler/rustc_type_ir/src/binder.rs
+++ b/compiler/rustc_type_ir/src/binder.rs
@@ -86,6 +86,7 @@ macro_rules! impl_binder_encode_decode {
 #[cfg(feature = "nightly")]
 impl_binder_encode_decode! {
     ty::FnSig<I>,
+    ty::FnSigTys<I>,
     ty::TraitPredicate<I>,
     ty::ExistentialPredicate<I>,
     ty::TraitRef<I>,
diff --git a/compiler/rustc_type_ir/src/fast_reject.rs b/compiler/rustc_type_ir/src/fast_reject.rs
index 456accd1a1b78..718e13ffe943f 100644
--- a/compiler/rustc_type_ir/src/fast_reject.rs
+++ b/compiler/rustc_type_ir/src/fast_reject.rs
@@ -135,7 +135,9 @@ pub fn simplify_type<I: Interner>(
         ty::CoroutineWitness(def_id, _) => Some(SimplifiedType::CoroutineWitness(def_id)),
         ty::Never => Some(SimplifiedType::Never),
         ty::Tuple(tys) => Some(SimplifiedType::Tuple(tys.len())),
-        ty::FnPtr(f) => Some(SimplifiedType::Function(f.skip_binder().inputs().len())),
+        ty::FnPtr(sig_tys, _hdr) => {
+            Some(SimplifiedType::Function(sig_tys.skip_binder().inputs().len()))
+        }
         ty::Placeholder(..) => Some(SimplifiedType::Placeholder),
         ty::Param(_) => match treat_params {
             TreatParams::ForLookup => Some(SimplifiedType::Placeholder),
@@ -307,17 +309,14 @@ impl<I: Interner> DeepRejectCtxt<I> {
                     obl_preds.principal_def_id() == impl_preds.principal_def_id()
                 )
             }
-            ty::FnPtr(obl_sig) => match k {
-                ty::FnPtr(impl_sig) => {
-                    let ty::FnSig { inputs_and_output, c_variadic, safety, abi } =
-                        obl_sig.skip_binder();
-                    let impl_sig = impl_sig.skip_binder();
+            ty::FnPtr(obl_sig_tys, obl_hdr) => match k {
+                ty::FnPtr(impl_sig_tys, impl_hdr) => {
+                    let obl_sig_tys = obl_sig_tys.skip_binder().0;
+                    let impl_sig_tys = impl_sig_tys.skip_binder().0;
 
-                    abi == impl_sig.abi
-                        && c_variadic == impl_sig.c_variadic
-                        && safety == impl_sig.safety
-                        && inputs_and_output.len() == impl_sig.inputs_and_output.len()
-                        && iter::zip(inputs_and_output.iter(), impl_sig.inputs_and_output.iter())
+                    obl_hdr == impl_hdr
+                        && obl_sig_tys.len() == impl_sig_tys.len()
+                        && iter::zip(obl_sig_tys.iter(), impl_sig_tys.iter())
                             .all(|(obl, imp)| self.types_may_unify(obl, imp))
                 }
                 _ => false,
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index 6ca2fed038065..958360faede57 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -133,12 +133,12 @@ pub trait Ty<I: Interner<Ty = Self>>:
     }
 
     fn is_fn_ptr(self) -> bool {
-        matches!(self.kind(), ty::FnPtr(_))
+        matches!(self.kind(), ty::FnPtr(..))
     }
 
     fn fn_sig(self, interner: I) -> ty::Binder<I, ty::FnSig<I>> {
         match self.kind() {
-            ty::FnPtr(sig) => sig,
+            ty::FnPtr(sig_tys, hdr) => sig_tys.with(hdr),
             ty::FnDef(def_id, args) => interner.fn_sig(def_id).instantiate(interner, args),
             ty::Error(_) => {
                 // ignore errors (#54954)
@@ -181,7 +181,7 @@ pub trait Ty<I: Interner<Ty = Self>>:
             | ty::RawPtr(_, _)
             | ty::Ref(_, _, _)
             | ty::FnDef(_, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Dynamic(_, _, _)
             | ty::Closure(_, _)
             | ty::CoroutineClosure(_, _)
diff --git a/compiler/rustc_type_ir/src/outlives.rs b/compiler/rustc_type_ir/src/outlives.rs
index 2f26a43918383..bfcea6a81d313 100644
--- a/compiler/rustc_type_ir/src/outlives.rs
+++ b/compiler/rustc_type_ir/src/outlives.rs
@@ -186,7 +186,7 @@ impl<I: Interner> TypeVisitor<I> for OutlivesCollector<'_, I> {
             | ty::Slice(_)
             | ty::RawPtr(_, _)
             | ty::Ref(_, _, _)
-            | ty::FnPtr(_)
+            | ty::FnPtr(..)
             | ty::Dynamic(_, _, _)
             | ty::Tuple(_) => {
                 ty.super_visit_with(self);
diff --git a/compiler/rustc_type_ir/src/relate.rs b/compiler/rustc_type_ir/src/relate.rs
index 9fd3534d1fa6b..578436b622a87 100644
--- a/compiler/rustc_type_ir/src/relate.rs
+++ b/compiler/rustc_type_ir/src/relate.rs
@@ -524,8 +524,8 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
             Ok(Ty::new_fn_def(cx, a_def_id, args))
         }
 
-        (ty::FnPtr(a_fty), ty::FnPtr(b_fty)) => {
-            let fty = relation.relate(a_fty, b_fty)?;
+        (ty::FnPtr(a_sig_tys, a_hdr), ty::FnPtr(b_sig_tys, b_hdr)) => {
+            let fty = relation.relate(a_sig_tys.with(a_hdr), b_sig_tys.with(b_hdr))?;
             Ok(Ty::new_fn_ptr(cx, fty))
         }
 
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 828f90212c48e..8640a6019800a 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -143,7 +143,12 @@ pub enum TyKind<I: Interner> {
     /// fn foo() -> i32 { 1 }
     /// let bar: fn() -> i32 = foo;
     /// ```
-    FnPtr(ty::Binder<I, FnSig<I>>),
+    ///
+    /// These two fields are equivalent to a `ty::Binder<I, FnSig<I>>`. But by
+    /// splitting that into two pieces, we get a more compact data layout that
+    /// reduces the size of `TyKind` by 8 bytes. It is a very hot type, so it's
+    /// worth the mild inconvenience.
+    FnPtr(ty::Binder<I, FnSigTys<I>>, FnHeader<I>),
 
     /// A trait object. Written as `dyn for<'b> Trait<'b, Assoc = u32> + Send + 'a`.
     Dynamic(I::BoundExistentialPredicates, I::Region, DynKind),
@@ -288,7 +293,7 @@ impl<I: Interner> fmt::Debug for TyKind<I> {
             RawPtr(ty, mutbl) => write!(f, "*{} {:?}", mutbl.ptr_str(), ty),
             Ref(r, t, m) => write!(f, "&{:?} {}{:?}", r, m.prefix_str(), t),
             FnDef(d, s) => f.debug_tuple("FnDef").field(d).field(&s).finish(),
-            FnPtr(s) => write!(f, "{s:?}"),
+            FnPtr(sig_tys, hdr) => write!(f, "{:?}", sig_tys.with(*hdr)),
             Dynamic(p, r, repr) => match repr {
                 DynKind::Dyn => write!(f, "dyn {p:?} + {r:?}"),
                 DynKind::DynStar => write!(f, "dyn* {p:?} + {r:?}"),
@@ -918,6 +923,13 @@ impl<I: Interner> ty::Binder<I, FnSig<I>> {
     pub fn is_fn_trait_compatible(&self) -> bool {
         self.skip_binder().is_fn_trait_compatible()
     }
+
+    // Used to split a single value into the two fields in `TyKind::FnPtr`.
+    pub fn split(self) -> (ty::Binder<I, FnSigTys<I>>, FnHeader<I>) {
+        let hdr =
+            FnHeader { c_variadic: self.c_variadic(), safety: self.safety(), abi: self.abi() };
+        (self.map_bound(|sig| FnSigTys(sig.inputs_and_output)), hdr)
+    }
 }
 
 impl<I: Interner> fmt::Debug for FnSig<I> {
@@ -954,3 +966,60 @@ impl<I: Interner> fmt::Debug for FnSig<I> {
         }
     }
 }
+
+// This is just a `FnSig` without the `FnHeader` fields.
+#[derive_where(Clone, Copy, Debug, PartialEq, Eq, Hash; I: Interner)]
+#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
+#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
+pub struct FnSigTys<I: Interner>(pub I::Tys);
+
+impl<I: Interner> FnSigTys<I> {
+    pub fn inputs(self) -> I::FnInputTys {
+        self.0.inputs()
+    }
+
+    pub fn output(self) -> I::Ty {
+        self.0.output()
+    }
+}
+
+impl<I: Interner> ty::Binder<I, FnSigTys<I>> {
+    // Used to combine the two fields in `TyKind::FnPtr` into a single value.
+    pub fn with(self, hdr: FnHeader<I>) -> ty::Binder<I, FnSig<I>> {
+        self.map_bound(|sig_tys| FnSig {
+            inputs_and_output: sig_tys.0,
+            c_variadic: hdr.c_variadic,
+            safety: hdr.safety,
+            abi: hdr.abi,
+        })
+    }
+
+    #[inline]
+    pub fn inputs(self) -> ty::Binder<I, I::FnInputTys> {
+        self.map_bound(|sig_tys| sig_tys.inputs())
+    }
+
+    #[inline]
+    #[track_caller]
+    pub fn input(self, index: usize) -> ty::Binder<I, I::Ty> {
+        self.map_bound(|sig_tys| sig_tys.inputs().get(index).unwrap())
+    }
+
+    pub fn inputs_and_output(self) -> ty::Binder<I, I::Tys> {
+        self.map_bound(|sig_tys| sig_tys.0)
+    }
+
+    #[inline]
+    pub fn output(self) -> ty::Binder<I, I::Ty> {
+        self.map_bound(|sig_tys| sig_tys.output())
+    }
+}
+
+#[derive_where(Clone, Copy, Debug, PartialEq, Eq, Hash; I: Interner)]
+#[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
+#[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
+pub struct FnHeader<I: Interner> {
+    pub c_variadic: bool,
+    pub safety: I::Safety,
+    pub abi: I::Abi,
+}
diff --git a/compiler/rustc_type_ir/src/ty_kind/closure.rs b/compiler/rustc_type_ir/src/ty_kind/closure.rs
index 81717ce4a2266..9d907baeeb302 100644
--- a/compiler/rustc_type_ir/src/ty_kind/closure.rs
+++ b/compiler/rustc_type_ir/src/ty_kind/closure.rs
@@ -197,7 +197,7 @@ impl<I: Interner> ClosureArgs<I> {
     /// Extracts the signature from the closure.
     pub fn sig(self) -> ty::Binder<I, ty::FnSig<I>> {
         match self.sig_as_fn_ptr_ty().kind() {
-            ty::FnPtr(sig) => sig,
+            ty::FnPtr(sig_tys, hdr) => sig_tys.with(hdr),
             ty => panic!("closure_sig_as_fn_ptr_ty is not a fn-ptr: {ty:?}"),
         }
     }
@@ -292,21 +292,23 @@ impl<I: Interner> CoroutineClosureArgs<I> {
 
     pub fn coroutine_closure_sig(self) -> ty::Binder<I, CoroutineClosureSignature<I>> {
         let interior = self.coroutine_witness_ty();
-        let ty::FnPtr(sig) = self.signature_parts_ty().kind() else { panic!() };
-        sig.map_bound(|sig| {
-            let [resume_ty, tupled_inputs_ty] = *sig.inputs().as_slice() else {
+        let ty::FnPtr(sig_tys, hdr) = self.signature_parts_ty().kind() else { panic!() };
+        sig_tys.map_bound(|sig_tys| {
+            let [resume_ty, tupled_inputs_ty] = *sig_tys.inputs().as_slice() else {
                 panic!();
             };
-            let [yield_ty, return_ty] = *sig.output().tuple_fields().as_slice() else { panic!() };
+            let [yield_ty, return_ty] = *sig_tys.output().tuple_fields().as_slice() else {
+                panic!()
+            };
             CoroutineClosureSignature {
                 interior,
                 tupled_inputs_ty,
                 resume_ty,
                 yield_ty,
                 return_ty,
-                c_variadic: sig.c_variadic,
-                safety: sig.safety,
-                abi: sig.abi,
+                c_variadic: hdr.c_variadic,
+                safety: hdr.safety,
+                abi: hdr.abi,
             }
         })
     }
@@ -321,7 +323,7 @@ impl<I: Interner> CoroutineClosureArgs<I> {
 
     pub fn has_self_borrows(&self) -> bool {
         match self.coroutine_captures_by_ref_ty().kind() {
-            ty::FnPtr(sig) => sig
+            ty::FnPtr(sig_tys, _) => sig_tys
                 .skip_binder()
                 .visit_with(&mut HasRegionsBoundAt { binder: ty::INNERMOST })
                 .is_break(),
@@ -460,11 +462,11 @@ impl<I: Interner> CoroutineClosureSignature<I> {
     ) -> I::Ty {
         match kind {
             ty::ClosureKind::Fn | ty::ClosureKind::FnMut => {
-                let ty::FnPtr(sig) = coroutine_captures_by_ref_ty.kind() else {
+                let ty::FnPtr(sig_tys, _) = coroutine_captures_by_ref_ty.kind() else {
                     panic!();
                 };
                 let coroutine_captures_by_ref_ty =
-                    sig.output().skip_binder().fold_with(&mut FoldEscapingRegions {
+                    sig_tys.output().skip_binder().fold_with(&mut FoldEscapingRegions {
                         interner: cx,
                         region: env_region,
                         debruijn: ty::INNERMOST,
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index cffadc7c10a91..53757349a9b2c 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2069,7 +2069,7 @@ pub(crate) fn clean_middle_ty<'tcx>(
                 Some(ContainerTy::Ref(r)),
             )),
         },
-        ty::FnDef(..) | ty::FnPtr(_) => {
+        ty::FnDef(..) | ty::FnPtr(..) => {
             // FIXME: should we merge the outer and inner binders somehow?
             let sig = bound_ty.skip_binder().fn_sig(cx.tcx);
             let decl = clean_poly_fn_sig(cx, None, sig);
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 9c7eee4040bdf..5b96529fed70d 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -495,7 +495,7 @@ impl<'a, 'tcx> LinkCollector<'a, 'tcx> {
             ty::RawPtr(_, _) => Res::Primitive(RawPointer),
             ty::Ref(..) => Res::Primitive(Reference),
             ty::FnDef(..) => panic!("type alias to a function definition"),
-            ty::FnPtr(_) => Res::Primitive(Fn),
+            ty::FnPtr(..) => Res::Primitive(Fn),
             ty::Never => Res::Primitive(Never),
             ty::Adt(ty::AdtDef(Interned(&ty::AdtDefData { did, .. }, _)), _) | ty::Foreign(did) => {
                 Res::from_def_id(self.cx.tcx, did)
diff --git a/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast.rs b/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast.rs
index f263bec1576d0..dbe03e4ae8095 100644
--- a/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast.rs
@@ -15,7 +15,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
     }
 
     match cast_from.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => {
+        ty::FnDef(..) | ty::FnPtr(..) => {
             let mut applicability = Applicability::MaybeIncorrect;
             let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
             let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
diff --git a/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_any.rs b/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
index 75de53f73ee7a..5dc6df1e907d0 100644
--- a/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
@@ -14,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         _ => { /* continue to checks */ },
     }
 
-    if let ty::FnDef(..) | ty::FnPtr(_) = cast_from.kind() {
+    if let ty::FnDef(..) | ty::FnPtr(..) = cast_from.kind() {
         let mut applicability = Applicability::MaybeIncorrect;
         let from_snippet = snippet_with_applicability(cx, cast_expr.span, "..", &mut applicability);
 
diff --git a/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs b/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
index 0e11bcfb8ecdb..dfbae1618ac62 100644
--- a/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
@@ -14,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         _ => return,
     }
     match cast_from.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => {
+        ty::FnDef(..) | ty::FnPtr(..) => {
             let mut applicability = Applicability::MaybeIncorrect;
             let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
 
diff --git a/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs b/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs
index a74b3a8c8362c..05c3cd3c81407 100644
--- a/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs
+++ b/src/tools/clippy/clippy_lints/src/default_numeric_fallback.rs
@@ -236,7 +236,7 @@ fn fn_sig_opt<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<PolyFnSig<'
     // We can't use `Ty::fn_sig` because it automatically performs args, this may result in FNs.
     match node_ty.kind() {
         ty::FnDef(def_id, _) => Some(cx.tcx.fn_sig(*def_id).instantiate_identity()),
-        ty::FnPtr(fn_sig) => Some(*fn_sig),
+        ty::FnPtr(sig_tys, hdr) => Some(sig_tys.with(*hdr)),
         _ => None,
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/dereference.rs b/src/tools/clippy/clippy_lints/src/dereference.rs
index d0cb24884686a..0e55d3db469ae 100644
--- a/src/tools/clippy/clippy_lints/src/dereference.rs
+++ b/src/tools/clippy/clippy_lints/src/dereference.rs
@@ -872,7 +872,7 @@ impl TyCoercionStability {
                 | ty::Pat(..)
                 | ty::Float(_)
                 | ty::RawPtr(..)
-                | ty::FnPtr(_)
+                | ty::FnPtr(..)
                 | ty::Str
                 | ty::Slice(..)
                 | ty::Adt(..)
diff --git a/src/tools/clippy/clippy_lints/src/eta_reduction.rs b/src/tools/clippy/clippy_lints/src/eta_reduction.rs
index 5a7226d590c4d..a7e831fdc42a8 100644
--- a/src/tools/clippy/clippy_lints/src/eta_reduction.rs
+++ b/src/tools/clippy/clippy_lints/src/eta_reduction.rs
@@ -158,7 +158,7 @@ fn check_clousure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tc
 
                     cx.tcx.fn_sig(def).skip_binder().skip_binder()
                 },
-                ty::FnPtr(sig) => sig.skip_binder(),
+                ty::FnPtr(sig_tys, hdr) => sig_tys.with(*hdr).skip_binder(),
                 ty::Closure(_, subs) => cx
                     .tcx
                     .signature_unclosure(subs.as_closure().sig(), Safety::Safe)
diff --git a/src/tools/clippy/clippy_lints/src/methods/map_flatten.rs b/src/tools/clippy/clippy_lints/src/methods/map_flatten.rs
index def8be2ef73dc..22a03825194e0 100644
--- a/src/tools/clippy/clippy_lints/src/methods/map_flatten.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/map_flatten.rs
@@ -58,7 +58,7 @@ fn try_get_caller_ty_name_and_method_name(
 fn is_map_to_option(cx: &LateContext<'_>, map_arg: &Expr<'_>) -> bool {
     let map_closure_ty = cx.typeck_results().expr_ty(map_arg);
     match map_closure_ty.kind() {
-        ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(_) => {
+        ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(..) => {
             let map_closure_sig = match map_closure_ty.kind() {
                 ty::Closure(_, args) => args.as_closure().sig(),
                 _ => map_closure_ty.fn_sig(cx.tcx),
diff --git a/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs b/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs
index 6964d8c8dbb33..0b3769ecb7cc4 100644
--- a/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/src/tools/clippy/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -166,7 +166,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
             ExprKind::Call(func, _) => {
                 let typ = self.cx.typeck_results().expr_ty(func);
                 match typ.kind() {
-                    ty::FnDef(..) | ty::FnPtr(_) => {
+                    ty::FnDef(..) | ty::FnPtr(..) => {
                         let sig = typ.fn_sig(self.cx.tcx);
                         if self.cx.tcx.instantiate_bound_regions_with_erased(sig).output().kind() == &ty::Never {
                             self.report_diverging_sub_expr(e);
diff --git a/src/tools/clippy/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/src/tools/clippy/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index da74a7c7145a6..0bde0da3cd814 100644
--- a/src/tools/clippy/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/src/tools/clippy/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -130,7 +130,7 @@ fn collect_unsafe_exprs<'tcx>(
             ExprKind::Call(path_expr, _) => {
                 let sig = match *cx.typeck_results().expr_ty(path_expr).kind() {
                     ty::FnDef(id, _) => cx.tcx.fn_sig(id).skip_binder(),
-                    ty::FnPtr(sig) => sig,
+                    ty::FnPtr(sig_tys, hdr) => sig_tys.with(hdr),
                     _ => return Continue(Descend::Yes),
                 };
                 if sig.safety() == Safety::Unsafe {
diff --git a/src/tools/clippy/clippy_lints/src/mut_reference.rs b/src/tools/clippy/clippy_lints/src/mut_reference.rs
index 0a3b769c3e604..3c0f06f66d105 100644
--- a/src/tools/clippy/clippy_lints/src/mut_reference.rs
+++ b/src/tools/clippy/clippy_lints/src/mut_reference.rs
@@ -79,7 +79,7 @@ fn check_arguments<'tcx>(
     fn_kind: &str,
 ) {
     match type_definition.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => {
+        ty::FnDef(..) | ty::FnPtr(..) => {
             let parameters = type_definition.fn_sig(cx.tcx).skip_binder().inputs();
             for (argument, parameter) in iter::zip(arguments, parameters) {
                 match parameter.kind() {
diff --git a/src/tools/clippy/clippy_utils/src/ty.rs b/src/tools/clippy/clippy_utils/src/ty.rs
index bd48990aea95f..2f6faba073e95 100644
--- a/src/tools/clippy/clippy_utils/src/ty.rs
+++ b/src/tools/clippy/clippy_utils/src/ty.rs
@@ -541,7 +541,7 @@ pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
 /// Returns `true` if the given type is an `unsafe` function.
 pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     match ty.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).safety() == Safety::Unsafe,
+        ty::FnDef(..) | ty::FnPtr(..) => ty.fn_sig(cx.tcx).safety() == Safety::Unsafe,
         _ => false,
     }
 }
@@ -721,7 +721,7 @@ pub fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'t
             cx.tcx.item_super_predicates(def_id).iter_instantiated(cx.tcx, args),
             cx.tcx.opt_parent(def_id),
         ),
-        ty::FnPtr(sig) => Some(ExprFnSig::Sig(sig, None)),
+        ty::FnPtr(sig_tys, hdr) => Some(ExprFnSig::Sig(sig_tys.with(hdr), None)),
         ty::Dynamic(bounds, _, _) => {
             let lang_items = cx.tcx.lang_items();
             match bounds.principal() {
diff --git a/src/tools/clippy/clippy_utils/src/visitors.rs b/src/tools/clippy/clippy_utils/src/visitors.rs
index 2a5d3536ff6b7..e5b6d3965e930 100644
--- a/src/tools/clippy/clippy_utils/src/visitors.rs
+++ b/src/tools/clippy/clippy_utils/src/visitors.rs
@@ -441,7 +441,7 @@ pub fn is_expr_unsafe<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
                     ty::FnDef(id, _) if self.cx.tcx.fn_sig(id).skip_binder().safety() == Safety::Unsafe => {
                         self.is_unsafe = true;
                     },
-                    ty::FnPtr(sig) if sig.safety() == Safety::Unsafe => self.is_unsafe = true,
+                    ty::FnPtr(_, hdr) if hdr.safety == Safety::Unsafe => self.is_unsafe = true,
                     _ => walk_expr(self, e),
                 },
                 ExprKind::Path(ref p)

From e785219238e73f353f392afe30073180c5b2c5d6 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 8 Aug 2024 17:18:20 +1000
Subject: [PATCH 081/685] Shrink `TyKind::FnPtr`.

By splitting the `FnSig` within `TyKind::FnPtr` into `FnSigTys` and
`FnHeader`, which can be packed more efficiently. This reduces the size
of the hot `TyKind` type from 32 bytes to 24 bytes on 64-bit platforms.
This reduces peak memory usage by a few percent on some benchmarks. It
also reduces cache misses and page faults similarly, though this doesn't
translate to clear cycles or wall-time improvements on CI.
---
 clippy_lints/src/casts/fn_to_numeric_cast.rs                 | 2 +-
 clippy_lints/src/casts/fn_to_numeric_cast_any.rs             | 2 +-
 clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs | 2 +-
 clippy_lints/src/default_numeric_fallback.rs                 | 2 +-
 clippy_lints/src/dereference.rs                              | 2 +-
 clippy_lints/src/eta_reduction.rs                            | 2 +-
 clippy_lints/src/methods/map_flatten.rs                      | 2 +-
 clippy_lints/src/mixed_read_write_in_expression.rs           | 2 +-
 clippy_lints/src/multiple_unsafe_ops_per_block.rs            | 2 +-
 clippy_lints/src/mut_reference.rs                            | 2 +-
 clippy_utils/src/ty.rs                                       | 4 ++--
 clippy_utils/src/visitors.rs                                 | 2 +-
 12 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/clippy_lints/src/casts/fn_to_numeric_cast.rs b/clippy_lints/src/casts/fn_to_numeric_cast.rs
index f263bec1576d0..dbe03e4ae8095 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast.rs
@@ -15,7 +15,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
     }
 
     match cast_from.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => {
+        ty::FnDef(..) | ty::FnPtr(..) => {
             let mut applicability = Applicability::MaybeIncorrect;
             let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
             let to_nbits = utils::int_ty_to_nbits(cast_to, cx.tcx);
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_any.rs b/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
index 75de53f73ee7a..5dc6df1e907d0 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
@@ -14,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         _ => { /* continue to checks */ },
     }
 
-    if let ty::FnDef(..) | ty::FnPtr(_) = cast_from.kind() {
+    if let ty::FnDef(..) | ty::FnPtr(..) = cast_from.kind() {
         let mut applicability = Applicability::MaybeIncorrect;
         let from_snippet = snippet_with_applicability(cx, cast_expr.span, "..", &mut applicability);
 
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
index 0e11bcfb8ecdb..dfbae1618ac62 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_with_truncation.rs
@@ -14,7 +14,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         _ => return,
     }
     match cast_from.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => {
+        ty::FnDef(..) | ty::FnPtr(..) => {
             let mut applicability = Applicability::MaybeIncorrect;
             let from_snippet = snippet_with_applicability(cx, cast_expr.span, "x", &mut applicability);
 
diff --git a/clippy_lints/src/default_numeric_fallback.rs b/clippy_lints/src/default_numeric_fallback.rs
index a74b3a8c8362c..05c3cd3c81407 100644
--- a/clippy_lints/src/default_numeric_fallback.rs
+++ b/clippy_lints/src/default_numeric_fallback.rs
@@ -236,7 +236,7 @@ fn fn_sig_opt<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<PolyFnSig<'
     // We can't use `Ty::fn_sig` because it automatically performs args, this may result in FNs.
     match node_ty.kind() {
         ty::FnDef(def_id, _) => Some(cx.tcx.fn_sig(*def_id).instantiate_identity()),
-        ty::FnPtr(fn_sig) => Some(*fn_sig),
+        ty::FnPtr(sig_tys, hdr) => Some(sig_tys.with(*hdr)),
         _ => None,
     }
 }
diff --git a/clippy_lints/src/dereference.rs b/clippy_lints/src/dereference.rs
index d0cb24884686a..0e55d3db469ae 100644
--- a/clippy_lints/src/dereference.rs
+++ b/clippy_lints/src/dereference.rs
@@ -872,7 +872,7 @@ impl TyCoercionStability {
                 | ty::Pat(..)
                 | ty::Float(_)
                 | ty::RawPtr(..)
-                | ty::FnPtr(_)
+                | ty::FnPtr(..)
                 | ty::Str
                 | ty::Slice(..)
                 | ty::Adt(..)
diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 5a7226d590c4d..a7e831fdc42a8 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -158,7 +158,7 @@ fn check_clousure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tc
 
                     cx.tcx.fn_sig(def).skip_binder().skip_binder()
                 },
-                ty::FnPtr(sig) => sig.skip_binder(),
+                ty::FnPtr(sig_tys, hdr) => sig_tys.with(*hdr).skip_binder(),
                 ty::Closure(_, subs) => cx
                     .tcx
                     .signature_unclosure(subs.as_closure().sig(), Safety::Safe)
diff --git a/clippy_lints/src/methods/map_flatten.rs b/clippy_lints/src/methods/map_flatten.rs
index def8be2ef73dc..22a03825194e0 100644
--- a/clippy_lints/src/methods/map_flatten.rs
+++ b/clippy_lints/src/methods/map_flatten.rs
@@ -58,7 +58,7 @@ fn try_get_caller_ty_name_and_method_name(
 fn is_map_to_option(cx: &LateContext<'_>, map_arg: &Expr<'_>) -> bool {
     let map_closure_ty = cx.typeck_results().expr_ty(map_arg);
     match map_closure_ty.kind() {
-        ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(_) => {
+        ty::Closure(_, _) | ty::FnDef(_, _) | ty::FnPtr(..) => {
             let map_closure_sig = match map_closure_ty.kind() {
                 ty::Closure(_, args) => args.as_closure().sig(),
                 _ => map_closure_ty.fn_sig(cx.tcx),
diff --git a/clippy_lints/src/mixed_read_write_in_expression.rs b/clippy_lints/src/mixed_read_write_in_expression.rs
index 6964d8c8dbb33..0b3769ecb7cc4 100644
--- a/clippy_lints/src/mixed_read_write_in_expression.rs
+++ b/clippy_lints/src/mixed_read_write_in_expression.rs
@@ -166,7 +166,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DivergenceVisitor<'a, 'tcx> {
             ExprKind::Call(func, _) => {
                 let typ = self.cx.typeck_results().expr_ty(func);
                 match typ.kind() {
-                    ty::FnDef(..) | ty::FnPtr(_) => {
+                    ty::FnDef(..) | ty::FnPtr(..) => {
                         let sig = typ.fn_sig(self.cx.tcx);
                         if self.cx.tcx.instantiate_bound_regions_with_erased(sig).output().kind() == &ty::Never {
                             self.report_diverging_sub_expr(e);
diff --git a/clippy_lints/src/multiple_unsafe_ops_per_block.rs b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
index da74a7c7145a6..0bde0da3cd814 100644
--- a/clippy_lints/src/multiple_unsafe_ops_per_block.rs
+++ b/clippy_lints/src/multiple_unsafe_ops_per_block.rs
@@ -130,7 +130,7 @@ fn collect_unsafe_exprs<'tcx>(
             ExprKind::Call(path_expr, _) => {
                 let sig = match *cx.typeck_results().expr_ty(path_expr).kind() {
                     ty::FnDef(id, _) => cx.tcx.fn_sig(id).skip_binder(),
-                    ty::FnPtr(sig) => sig,
+                    ty::FnPtr(sig_tys, hdr) => sig_tys.with(hdr),
                     _ => return Continue(Descend::Yes),
                 };
                 if sig.safety() == Safety::Unsafe {
diff --git a/clippy_lints/src/mut_reference.rs b/clippy_lints/src/mut_reference.rs
index 0a3b769c3e604..3c0f06f66d105 100644
--- a/clippy_lints/src/mut_reference.rs
+++ b/clippy_lints/src/mut_reference.rs
@@ -79,7 +79,7 @@ fn check_arguments<'tcx>(
     fn_kind: &str,
 ) {
     match type_definition.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => {
+        ty::FnDef(..) | ty::FnPtr(..) => {
             let parameters = type_definition.fn_sig(cx.tcx).skip_binder().inputs();
             for (argument, parameter) in iter::zip(arguments, parameters) {
                 match parameter.kind() {
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index bd48990aea95f..2f6faba073e95 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -541,7 +541,7 @@ pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
 /// Returns `true` if the given type is an `unsafe` function.
 pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     match ty.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).safety() == Safety::Unsafe,
+        ty::FnDef(..) | ty::FnPtr(..) => ty.fn_sig(cx.tcx).safety() == Safety::Unsafe,
         _ => false,
     }
 }
@@ -721,7 +721,7 @@ pub fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'t
             cx.tcx.item_super_predicates(def_id).iter_instantiated(cx.tcx, args),
             cx.tcx.opt_parent(def_id),
         ),
-        ty::FnPtr(sig) => Some(ExprFnSig::Sig(sig, None)),
+        ty::FnPtr(sig_tys, hdr) => Some(ExprFnSig::Sig(sig_tys.with(hdr), None)),
         ty::Dynamic(bounds, _, _) => {
             let lang_items = cx.tcx.lang_items();
             match bounds.principal() {
diff --git a/clippy_utils/src/visitors.rs b/clippy_utils/src/visitors.rs
index 2a5d3536ff6b7..e5b6d3965e930 100644
--- a/clippy_utils/src/visitors.rs
+++ b/clippy_utils/src/visitors.rs
@@ -441,7 +441,7 @@ pub fn is_expr_unsafe<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
                     ty::FnDef(id, _) if self.cx.tcx.fn_sig(id).skip_binder().safety() == Safety::Unsafe => {
                         self.is_unsafe = true;
                     },
-                    ty::FnPtr(sig) if sig.safety() == Safety::Unsafe => self.is_unsafe = true,
+                    ty::FnPtr(_, hdr) if hdr.safety == Safety::Unsafe => self.is_unsafe = true,
                     _ => walk_expr(self, e),
                 },
                 ExprKind::Path(ref p)

From 7d2595f78315acf6b00c0a28b5fea623bbc44135 Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Thu, 8 Aug 2024 23:36:25 -0700
Subject: [PATCH 082/685] Review comments

---
 .../rustc/src/platform-support/wasm32-wasip1-threads.md   | 8 ++++----
 src/doc/rustc/src/platform-support/wasm32-wasip1.md       | 2 +-
 src/doc/rustc/src/platform-support/wasm32-wasip2.md       | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md b/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md
index aafb64e6778c2..994c0f4bbb3e9 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip1-threads.md
@@ -165,14 +165,14 @@ necessary to detect this target may change as the target becomes more stable.
 
 ## Enabled WebAssembly features
 
-The default set of WebAssembly features enabled for compilation is similar to
-[`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md) but two more features
-are included:
+The default set of WebAssembly features enabled for compilation includes two
+more features in addition to that which
+[`wasm32-unknown-unknown`](./wasm32-unknown-unknown.md) enables:
 
 * `bulk-memory`
 * `atomics`
 
 For more information about features see the documentation for
-[`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md), but note that the
+[`wasm32-unknown-unknown`](./wasm32-unknown-unknown.md), but note that the
 `mvp` CPU in LLVM does not support this target as it's required that
 `bulk-memory`, `atomics`, and `mutable-globals` are all enabled.
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip1.md b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
index 103cb38be09b0..0e4def6768dc4 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip1.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip1.md
@@ -136,5 +136,5 @@ to Rust 1.80 the `target_env` condition was not set.
 ## Enabled WebAssembly features
 
 The default set of WebAssembly features enabled for compilation is currently the
-same as [`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md). See the
+same as [`wasm32-unknown-unknown`](./wasm32-unknown-unknown.md). See the
 documentation there for more information.
diff --git a/src/doc/rustc/src/platform-support/wasm32-wasip2.md b/src/doc/rustc/src/platform-support/wasm32-wasip2.md
index 7d22e9e60d5ad..bb2348b201e39 100644
--- a/src/doc/rustc/src/platform-support/wasm32-wasip2.md
+++ b/src/doc/rustc/src/platform-support/wasm32-wasip2.md
@@ -65,5 +65,5 @@ It's recommended to conditionally compile code for this target with:
 ## Enabled WebAssembly features
 
 The default set of WebAssembly features enabled for compilation is currently the
-same as [`wasm32-unknown-unknokwn`](./wasm32-unknown-unknown.md). See the
+same as [`wasm32-unknown-unknown`](./wasm32-unknown-unknown.md). See the
 documentation there for more information.

From d85cf0bacd8ea565557317940d878a535189a6d9 Mon Sep 17 00:00:00 2001
From: rzvxa <rzvxa@protonmail.com>
Date: Fri, 9 Aug 2024 12:18:56 +0330
Subject: [PATCH 083/685] use `fulfill_or_allowed` over `is_lint_allowed`.

---
 .../src/inconsistent_struct_constructor.rs    | 23 ++++++++++---------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/clippy_lints/src/inconsistent_struct_constructor.rs b/clippy_lints/src/inconsistent_struct_constructor.rs
index da289225509bf..d386bfca6baa1 100644
--- a/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_lint_allowed;
+use clippy_utils::fulfill_or_allowed;
 use clippy_utils::source::snippet;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
@@ -74,7 +74,6 @@ impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
             && adt_def.is_struct()
             && let Some(local_def_id) = adt_def.did().as_local()
             && let ty_hir_id = cx.tcx.local_def_id_to_hir_id(local_def_id)
-            && !is_lint_allowed(cx, INCONSISTENT_STRUCT_CONSTRUCTOR, ty_hir_id)
             && let Some(variant) = adt_def.variants().iter().next()
         {
             let mut def_order_map = FxHashMap::default();
@@ -107,15 +106,17 @@ impl<'tcx> LateLintPass<'tcx> for InconsistentStructConstructor {
                 snippet(cx, qpath.span(), ".."),
             );
 
-            span_lint_and_sugg(
-                cx,
-                INCONSISTENT_STRUCT_CONSTRUCTOR,
-                expr.span,
-                "struct constructor field order is inconsistent with struct definition field order",
-                "try",
-                sugg,
-                Applicability::MachineApplicable,
-            );
+            if !fulfill_or_allowed(cx, INCONSISTENT_STRUCT_CONSTRUCTOR, Some(ty_hir_id)) {
+                span_lint_and_sugg(
+                    cx,
+                    INCONSISTENT_STRUCT_CONSTRUCTOR,
+                    expr.span,
+                    "struct constructor field order is inconsistent with struct definition field order",
+                    "try",
+                    sugg,
+                    Applicability::MachineApplicable,
+                );
+            }
         }
     }
 }

From dc54f1dccda757c2fb19c53914045da23672e457 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 9 Aug 2024 10:54:07 +0200
Subject: [PATCH 084/685] miri_print_borrow_state: show error when AllocId is
 invalid

---
 src/tools/miri/src/shims/foreign_items.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index 7f6f63ff5e79b..98e095447c39b 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -289,8 +289,12 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 let [id, show_unnamed] = this.check_shim(abi, Abi::Rust, link_name, args)?;
                 let id = this.read_scalar(id)?.to_u64()?;
                 let show_unnamed = this.read_scalar(show_unnamed)?.to_bool()?;
-                if let Some(id) = std::num::NonZero::new(id) {
-                    this.print_borrow_state(AllocId(id), show_unnamed)?;
+                if let Some(id) = std::num::NonZero::new(id).map(AllocId)
+                    && this.get_alloc_info(id).2 == AllocKind::LiveData
+                {
+                    this.print_borrow_state(id, show_unnamed)?;
+                } else {
+                    eprintln!("{id} is not the ID of a live data allocation");
                 }
             }
             "miri_pointer_name" => {

From acb024110f337e77c515ebcafffd6c4c09c29ee7 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Fri, 9 Aug 2024 01:32:13 +0000
Subject: [PATCH 085/685] Add windows-targets crate to std's sysroot

---
 library/Cargo.lock                                     |  7 ++++++-
 library/std/Cargo.toml                                 |  5 ++++-
 library/std/src/sys/pal/windows/alloc.rs               |  2 +-
 library/std/src/sys/pal/windows/c.rs                   |  2 --
 library/std/src/sys/pal/windows/c/windows_sys.rs       |  1 -
 library/windows_targets/Cargo.toml                     | 10 ++++++++++
 .../windows_targets.rs => windows_targets/src/lib.rs}  |  4 ++++
 src/tools/generate-windows-sys/src/main.rs             |  1 -
 src/tools/tidy/src/pal.rs                              |  1 +
 9 files changed, 26 insertions(+), 7 deletions(-)
 create mode 100644 library/windows_targets/Cargo.toml
 rename library/{std/src/sys/pal/windows/c/windows_targets.rs => windows_targets/src/lib.rs} (95%)

diff --git a/library/Cargo.lock b/library/Cargo.lock
index c5182516f7d14..8430b30ae9b79 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -339,6 +339,7 @@ dependencies = [
  "std_detect",
  "unwind",
  "wasi",
+ "windows-targets 0.0.0",
 ]
 
 [[package]]
@@ -421,9 +422,13 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.5",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.0.0"
+
 [[package]]
 name = "windows-targets"
 version = "0.52.5"
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 06e818fb7c09d..cea74f651acd8 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -57,6 +57,9 @@ object = { version = "0.36.0", default-features = false, optional = true, featur
     'archive',
 ] }
 
+[target.'cfg(windows)'.dependencies.windows-targets]
+path = "../windows_targets"
+
 [dev-dependencies]
 rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
 rand_xorshift = "0.3.0"
@@ -116,7 +119,7 @@ std_detect_env_override = ["std_detect/std_detect_env_override"]
 
 # Enable using raw-dylib for Windows imports.
 # This will eventually be the default.
-windows_raw_dylib = []
+windows_raw_dylib = ["windows-targets/windows_raw_dylib"]
 
 [package.metadata.fortanix-sgx]
 # Maximum possible number of threads when testing
diff --git a/library/std/src/sys/pal/windows/alloc.rs b/library/std/src/sys/pal/windows/alloc.rs
index 92b68b26032c6..2205885687dea 100644
--- a/library/std/src/sys/pal/windows/alloc.rs
+++ b/library/std/src/sys/pal/windows/alloc.rs
@@ -4,7 +4,7 @@ use crate::alloc::{GlobalAlloc, Layout, System};
 use crate::ffi::c_void;
 use crate::ptr;
 use crate::sync::atomic::{AtomicPtr, Ordering};
-use crate::sys::c::{self, windows_targets};
+use crate::sys::c;
 use crate::sys::common::alloc::{realloc_fallback, MIN_ALIGN};
 
 #[cfg(test)]
diff --git a/library/std/src/sys/pal/windows/c.rs b/library/std/src/sys/pal/windows/c.rs
index 08b75186aef90..2f5d75dc4bc23 100644
--- a/library/std/src/sys/pal/windows/c.rs
+++ b/library/std/src/sys/pal/windows/c.rs
@@ -8,8 +8,6 @@
 use core::ffi::{c_uint, c_ulong, c_ushort, c_void, CStr};
 use core::{mem, ptr};
 
-pub(super) mod windows_targets;
-
 mod windows_sys;
 pub use windows_sys::*;
 
diff --git a/library/std/src/sys/pal/windows/c/windows_sys.rs b/library/std/src/sys/pal/windows/c/windows_sys.rs
index 9f22f54819509..529c96a0e1e6b 100644
--- a/library/std/src/sys/pal/windows/c/windows_sys.rs
+++ b/library/std/src/sys/pal/windows/c/windows_sys.rs
@@ -3317,4 +3317,3 @@ pub struct WSADATA {
 #[cfg(target_arch = "arm")]
 pub enum CONTEXT {}
 // ignore-tidy-filelength
-use super::windows_targets;
diff --git a/library/windows_targets/Cargo.toml b/library/windows_targets/Cargo.toml
new file mode 100644
index 0000000000000..94d7c8210647c
--- /dev/null
+++ b/library/windows_targets/Cargo.toml
@@ -0,0 +1,10 @@
+[package]
+name = "windows-targets"
+description = "A drop-in replacement for the real windows-targets crate for use in std only."
+version = "0.0.0"
+edition = "2021"
+
+[features]
+# Enable using raw-dylib for Windows imports.
+# This will eventually be the default.
+windows_raw_dylib = []
diff --git a/library/std/src/sys/pal/windows/c/windows_targets.rs b/library/windows_targets/src/lib.rs
similarity index 95%
rename from library/std/src/sys/pal/windows/c/windows_targets.rs
rename to library/windows_targets/src/lib.rs
index 252bceb70942b..1965b6cf4ce8f 100644
--- a/library/std/src/sys/pal/windows/c/windows_targets.rs
+++ b/library/windows_targets/src/lib.rs
@@ -2,6 +2,10 @@
 //!
 //! This is a simple wrapper around an `extern` block with a `#[link]` attribute.
 //! It's very roughly equivalent to the windows-targets crate.
+#![no_std]
+#![no_core]
+#![feature(decl_macro)]
+#![feature(no_core)]
 
 #[cfg(feature = "windows_raw_dylib")]
 pub macro link {
diff --git a/src/tools/generate-windows-sys/src/main.rs b/src/tools/generate-windows-sys/src/main.rs
index fe1b1bd5ceb14..6dbf29d957f12 100644
--- a/src/tools/generate-windows-sys/src/main.rs
+++ b/src/tools/generate-windows-sys/src/main.rs
@@ -35,7 +35,6 @@ fn main() -> Result<(), Box<dyn Error>> {
     let mut f = std::fs::File::options().append(true).open("windows_sys.rs")?;
     f.write_all(ARM32_SHIM.as_bytes())?;
     writeln!(&mut f, "// ignore-tidy-filelength")?;
-    writeln!(&mut f, "use super::windows_targets;")?;
 
     Ok(())
 }
diff --git a/src/tools/tidy/src/pal.rs b/src/tools/tidy/src/pal.rs
index b7ddf47186d99..c650fd0eec6d8 100644
--- a/src/tools/tidy/src/pal.rs
+++ b/src/tools/tidy/src/pal.rs
@@ -36,6 +36,7 @@ use crate::walk::{filter_dirs, walk};
 
 // Paths that may contain platform-specific code.
 const EXCEPTION_PATHS: &[&str] = &[
+    "library/windows_targets",
     "library/panic_abort",
     "library/panic_unwind",
     "library/unwind",

From a1b2b7ff78b9dbaeffe8341b3616a8c8c4fd4351 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Fri, 9 Aug 2024 11:04:25 +0000
Subject: [PATCH 086/685] Exclude windows-targets from the workspace

---
 library/Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/Cargo.toml b/library/Cargo.toml
index c4513b4c127d8..d8ece6b0ebd3e 100644
--- a/library/Cargo.toml
+++ b/library/Cargo.toml
@@ -8,6 +8,7 @@ members = [
 exclude = [
   # stdarch has its own Cargo workspace
   "stdarch",
+  "windows_targets"
 ]
 
 [profile.release.package.compiler_builtins]

From b368dcb246c5aedb087034e0f62941d038799f38 Mon Sep 17 00:00:00 2001
From: Ding Xiang Fei <dingxiangfei2009@protonmail.ch>
Date: Mon, 29 Jul 2024 23:10:34 +0800
Subject: [PATCH 087/685] unconditionally allow shadow call-stack for AArch64
 whenever fixed-x18 is applied

---
 compiler/rustc_session/src/session.rs         |  7 ++++++-
 src/doc/rustc/src/platform-support/android.md |  5 +++++
 .../src/compiler-flags/fixed-x18.md           |  7 ++++++-
 .../src/compiler-flags/sanitizer.md           |  4 ++++
 ...arch64-shadow-call-stack-with-fixed-x18.rs | 19 +++++++++++++++++++
 .../shadow-call-stack-without-fixed-x18.rs    | 15 +++++++++++++++
 6 files changed, 55 insertions(+), 2 deletions(-)
 create mode 100644 tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
 create mode 100644 tests/ui/abi/shadow-call-stack-without-fixed-x18.rs

diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index be67baf57f6dc..8cce665677eb9 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -1187,7 +1187,12 @@ fn validate_commandline_args_with_session_available(sess: &Session) {
 
     // Sanitizers can only be used on platforms that we know have working sanitizer codegen.
     let supported_sanitizers = sess.target.options.supported_sanitizers;
-    let unsupported_sanitizers = sess.opts.unstable_opts.sanitizer - supported_sanitizers;
+    let mut unsupported_sanitizers = sess.opts.unstable_opts.sanitizer - supported_sanitizers;
+    // Niche: if `fixed-x18`, or effectively switching on `reserved-x18` flag, is enabled
+    // we should allow Shadow Call Stack sanitizer.
+    if sess.opts.unstable_opts.fixed_x18 && sess.target.arch == "aarch64" {
+        unsupported_sanitizers -= SanitizerSet::SHADOWCALLSTACK;
+    }
     match unsupported_sanitizers.into_iter().count() {
         0 => {}
         1 => {
diff --git a/src/doc/rustc/src/platform-support/android.md b/src/doc/rustc/src/platform-support/android.md
index 9ddf00e3a5053..96499b0d80148 100644
--- a/src/doc/rustc/src/platform-support/android.md
+++ b/src/doc/rustc/src/platform-support/android.md
@@ -61,3 +61,8 @@ Currently the `riscv64-linux-android` target requires the following architecture
 * `Zba` (address calculation instructions)
 * `Zbb` (base instructions)
 * `Zbs` (single-bit instructions)
+
+### aarch64-linux-android on Nightly compilers
+
+As soon as `-Zfixed-x18` compiler flag is supplied, the [`ShadowCallStack` sanitizer](https://releases.llvm.org/7.0.1/tools/clang/docs/ShadowCallStack.html)
+instrumentation is also made avaiable by supplying the second compiler flag `-Zsanitizer=shadow-call-stack`.
diff --git a/src/doc/unstable-book/src/compiler-flags/fixed-x18.md b/src/doc/unstable-book/src/compiler-flags/fixed-x18.md
index 8c8bff5fa296d..b215bc84fbb71 100644
--- a/src/doc/unstable-book/src/compiler-flags/fixed-x18.md
+++ b/src/doc/unstable-book/src/compiler-flags/fixed-x18.md
@@ -1,7 +1,7 @@
 # `fixed-x18`
 
 This option prevents the compiler from using the x18 register. It is only
-supported on aarch64.
+supported on `aarch64`.
 
 From the [ABI spec][arm-abi]:
 
@@ -23,6 +23,11 @@ Currently, the `-Zsanitizer=shadow-call-stack` flag is only supported on
 platforms that always treat x18 as a reserved register, and the `-Zfixed-x18`
 flag is not required to use the sanitizer on such platforms. However, the
 sanitizer may be supported on targets where this is not the case in the future.
+One way to do so now on Nightly compilers is to explicitly supply this `-Zfixed-x18`
+flag with `aarch64` targets, so that the sanitizer is available for instrumentation
+on targets like `aarch64-unknown-none`, for instance. However, discretion is still
+required to make sure that the runtime support is in place for this sanitizer
+to be effective.
 
 It is undefined behavior for `-Zsanitizer=shadow-call-stack` code to call into
 code where x18 is a temporary register. On the other hand, when you are *not*
diff --git a/src/doc/unstable-book/src/compiler-flags/sanitizer.md b/src/doc/unstable-book/src/compiler-flags/sanitizer.md
index 72b44e002b4d4..edc63a25ac1be 100644
--- a/src/doc/unstable-book/src/compiler-flags/sanitizer.md
+++ b/src/doc/unstable-book/src/compiler-flags/sanitizer.md
@@ -787,6 +787,10 @@ A runtime must be provided by the application or operating system.
 
 See the [Clang ShadowCallStack documentation][clang-scs] for more details.
 
+* `aarch64-unknown-none`
+
+In addition to support from a runtime by the application or operating system, the `-Zfixed-x18` flag is also mandatory.
+
 # ThreadSanitizer
 
 ThreadSanitizer is a data race detection tool. It is supported on the following
diff --git a/tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs b/tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
new file mode 100644
index 0000000000000..e2e14ab14a801
--- /dev/null
+++ b/tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
@@ -0,0 +1,19 @@
+//@ revisions: aarch64 android
+//@[aarch64] compile-flags: --target aarch64-unknown-none -Zfixed-x18 -Zsanitizer=shadow-call-stack
+//@[aarch64] needs-llvm-components: aarch64
+//@[android] compile-flags: --target aarch64-linux-android -Zsanitizer=shadow-call-stack
+//@[android] needs-llvm-components: aarch64
+
+#![allow(internal_features)]
+#![crate_type = "rlib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+#[lang = "sized"]
+trait Sized {}
+
+// CHECK: ; Function Attrs:{{.*}}shadowcallstack
+#[no_mangle]
+pub fn foo() {}
+
+// CHECK: attributes #0 = {{.*}}shadowcallstack{{.*}}
diff --git a/tests/ui/abi/shadow-call-stack-without-fixed-x18.rs b/tests/ui/abi/shadow-call-stack-without-fixed-x18.rs
new file mode 100644
index 0000000000000..d758c903087b6
--- /dev/null
+++ b/tests/ui/abi/shadow-call-stack-without-fixed-x18.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: --target aarch64-unknown-none -Zsanitizer=shadow-call-stack
+//@ error-pattern: shadow-call-stack sanitizer is not supported for this target
+//@ dont-check-compiler-stderr
+//@ needs-llvm-components: aarch64
+
+#![allow(internal_features)]
+#![crate_type = "rlib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+#[lang = "sized"]
+trait Sized {}
+
+#[no_mangle]
+pub fn foo() {}

From b32a0176faa3ff2aba07f38b7d7cf72304d6d4e0 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 9 Aug 2024 13:00:24 +0000
Subject: [PATCH 088/685] Replace `rustc_semver` with
 `rustc_session::RustcVersion`

---
 clippy_config/Cargo.toml                         |  1 -
 clippy_config/src/lib.rs                         |  1 +
 clippy_config/src/msrvs.rs                       | 16 ++++++++--------
 clippy_lints/Cargo.toml                          |  1 -
 clippy_lints/src/approx_const.rs                 |  3 +--
 clippy_lints/src/incompatible_msrv.rs            | 15 +++++++--------
 clippy_lints/src/manual_retain.rs                |  3 +--
 clippy_lints/src/std_instead_of_core.rs          |  5 +----
 .../internal_lints/lint_without_lint_pass.rs     | 10 +++++++---
 clippy_utils/Cargo.toml                          |  1 -
 clippy_utils/src/qualify_min_const_fn.rs         |  7 +------
 tests/ui/min_rust_version_invalid_attr.rs        |  2 +-
 tests/ui/min_rust_version_invalid_attr.stderr    |  4 ++--
 13 files changed, 30 insertions(+), 39 deletions(-)

diff --git a/clippy_config/Cargo.toml b/clippy_config/Cargo.toml
index d5b28e2532371..5c4e0761dbca7 100644
--- a/clippy_config/Cargo.toml
+++ b/clippy_config/Cargo.toml
@@ -7,7 +7,6 @@ edition = "2021"
 
 [dependencies]
 itertools = "0.12"
-rustc-semver = "1.1"
 serde = { version = "1.0", features = ["derive"] }
 toml = "0.7.3"
 
diff --git a/clippy_config/src/lib.rs b/clippy_config/src/lib.rs
index d2246f12029b3..3afe599c7b6e4 100644
--- a/clippy_config/src/lib.rs
+++ b/clippy_config/src/lib.rs
@@ -14,6 +14,7 @@
 )]
 
 extern crate rustc_ast;
+extern crate rustc_attr;
 extern crate rustc_data_structures;
 #[allow(unused_extern_crates)]
 extern crate rustc_driver;
diff --git a/clippy_config/src/msrvs.rs b/clippy_config/src/msrvs.rs
index fc56ac5179686..5b9707efd2634 100644
--- a/clippy_config/src/msrvs.rs
+++ b/clippy_config/src/msrvs.rs
@@ -1,6 +1,6 @@
 use rustc_ast::Attribute;
-use rustc_semver::RustcVersion;
-use rustc_session::Session;
+use rustc_attr::parse_version;
+use rustc_session::{RustcVersion, Session};
 use rustc_span::{sym, Symbol};
 use serde::Deserialize;
 use std::fmt;
@@ -10,7 +10,7 @@ macro_rules! msrv_aliases {
         $($name:ident),* $(,)?
     })*) => {
         $($(
-        pub const $name: RustcVersion = RustcVersion::new($major, $minor, $patch);
+        pub const $name: RustcVersion = RustcVersion { major: $major, minor :$minor, patch: $patch };
         )*)*
     };
 }
@@ -81,9 +81,9 @@ impl<'de> Deserialize<'de> for Msrv {
         D: serde::Deserializer<'de>,
     {
         let v = String::deserialize(deserializer)?;
-        RustcVersion::parse(&v)
+        parse_version(Symbol::intern(&v))
             .map(|v| Msrv { stack: vec![v] })
-            .map_err(|_| serde::de::Error::custom("not a valid Rust version"))
+            .ok_or_else(|| serde::de::Error::custom("not a valid Rust version"))
     }
 }
 
@@ -95,7 +95,7 @@ impl Msrv {
     pub fn read_cargo(&mut self, sess: &Session) {
         let cargo_msrv = std::env::var("CARGO_PKG_RUST_VERSION")
             .ok()
-            .and_then(|v| RustcVersion::parse(&v).ok());
+            .and_then(|v| parse_version(Symbol::intern(&v)));
 
         match (self.current(), cargo_msrv) {
             (None, Some(cargo_msrv)) => self.stack = vec![cargo_msrv],
@@ -115,7 +115,7 @@ impl Msrv {
     }
 
     pub fn meets(&self, required: RustcVersion) -> bool {
-        self.current().map_or(true, |version| version.meets(required))
+        self.current().map_or(true, |msrv| msrv >= required)
     }
 
     fn parse_attr(sess: &Session, attrs: &[Attribute]) -> Option<RustcVersion> {
@@ -131,7 +131,7 @@ impl Msrv {
             }
 
             if let Some(msrv) = msrv_attr.value_str() {
-                if let Ok(version) = RustcVersion::parse(msrv.as_str()) {
+                if let Some(version) = parse_version(msrv) {
                     return Some(version);
                 }
 
diff --git a/clippy_lints/Cargo.toml b/clippy_lints/Cargo.toml
index 99ed93468a01a..fbd4566da58c7 100644
--- a/clippy_lints/Cargo.toml
+++ b/clippy_lints/Cargo.toml
@@ -25,7 +25,6 @@ regex = { version = "1.5", optional = true }
 unicode-normalization = "0.1"
 unicode-script = { version = "0.5", default-features = false }
 semver = "1.0"
-rustc-semver = "1.1"
 url = "2.2"
 
 [dev-dependencies]
diff --git a/clippy_lints/src/approx_const.rs b/clippy_lints/src/approx_const.rs
index 3b4cc1134802d..56f5e903dc3e2 100644
--- a/clippy_lints/src/approx_const.rs
+++ b/clippy_lints/src/approx_const.rs
@@ -4,8 +4,7 @@ use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_ast::ast::{FloatTy, LitFloatType, LitKind};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
-use rustc_session::impl_lint_pass;
+use rustc_session::{impl_lint_pass, RustcVersion};
 use rustc_span::symbol;
 use std::f64::consts as f64;
 
diff --git a/clippy_lints/src/incompatible_msrv.rs b/clippy_lints/src/incompatible_msrv.rs
index 0ef5b803a89d6..2ad045e12686c 100644
--- a/clippy_lints/src/incompatible_msrv.rs
+++ b/clippy_lints/src/incompatible_msrv.rs
@@ -7,8 +7,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{Expr, ExprKind, HirId};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::TyCtxt;
-use rustc_semver::RustcVersion;
-use rustc_session::impl_lint_pass;
+use rustc_session::{impl_lint_pass, RustcVersion};
 use rustc_span::def_id::DefId;
 use rustc_span::{ExpnKind, Span};
 
@@ -65,18 +64,18 @@ impl IncompatibleMsrv {
                 StabilityLevel::Stable {
                     since: StableSince::Version(version),
                     ..
-                } => Some(RustcVersion::new(
-                    version.major.into(),
-                    version.minor.into(),
-                    version.patch.into(),
-                )),
+                } => Some(version),
                 _ => None,
             }) {
             version
         } else if let Some(parent_def_id) = tcx.opt_parent(def_id) {
             self.get_def_id_version(tcx, parent_def_id)
         } else {
-            RustcVersion::new(1, 0, 0)
+            RustcVersion {
+                major: 1,
+                minor: 0,
+                patch: 0,
+            }
         };
         self.is_above_msrv.insert(def_id, version);
         version
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index 09f6362b4ddc8..d549470ed47e1 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -9,8 +9,7 @@ use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_hir::ExprKind::Assign;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_semver::RustcVersion;
-use rustc_session::impl_lint_pass;
+use rustc_session::{impl_lint_pass, RustcVersion};
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 
diff --git a/clippy_lints/src/std_instead_of_core.rs b/clippy_lints/src/std_instead_of_core.rs
index 974e21df817a8..44283a49e84b9 100644
--- a/clippy_lints/src/std_instead_of_core.rs
+++ b/clippy_lints/src/std_instead_of_core.rs
@@ -9,7 +9,6 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{HirId, Path, PathSegment};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::lint::in_external_macro;
-use rustc_semver::RustcVersion;
 use rustc_session::impl_lint_pass;
 use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
@@ -185,9 +184,7 @@ fn is_stable(cx: &LateContext<'_>, mut def_id: DefId, msrv: &Msrv) -> bool {
             } = stability.level
         {
             let stable = match since {
-                StableSince::Version(v) => {
-                    msrv.meets(RustcVersion::new(v.major.into(), v.minor.into(), v.patch.into()))
-                },
+                StableSince::Version(v) => msrv.meets(v),
                 StableSince::Current => msrv.current().is_none(),
                 StableSince::Err => false,
             };
diff --git a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index df342e48d637f..20526113d69e3 100644
--- a/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -9,7 +9,6 @@ use rustc_hir::intravisit::Visitor;
 use rustc_hir::{ExprKind, HirId, Item, MutTy, Mutability, Path, TyKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::hir::nested_filter;
-use rustc_semver::RustcVersion;
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::Symbol;
@@ -92,7 +91,12 @@ pub struct LintWithoutLintPass {
     registered_lints: FxHashSet<Symbol>,
 }
 
-impl_lint_pass!(LintWithoutLintPass => [DEFAULT_LINT, LINT_WITHOUT_LINT_PASS, INVALID_CLIPPY_VERSION_ATTRIBUTE, MISSING_CLIPPY_VERSION_ATTRIBUTE]);
+impl_lint_pass!(LintWithoutLintPass => [
+    DEFAULT_LINT,
+    LINT_WITHOUT_LINT_PASS,
+    INVALID_CLIPPY_VERSION_ATTRIBUTE,
+    MISSING_CLIPPY_VERSION_ATTRIBUTE,
+]);
 
 impl<'tcx> LateLintPass<'tcx> for LintWithoutLintPass {
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) {
@@ -220,7 +224,7 @@ fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'
             return;
         }
 
-        if RustcVersion::parse(value.as_str()).is_err() {
+        if rustc_attr::parse_version(value).is_none() {
             span_lint_and_help(
                 cx,
                 INVALID_CLIPPY_VERSION_ATTRIBUTE,
diff --git a/clippy_utils/Cargo.toml b/clippy_utils/Cargo.toml
index 9fefd94d339be..629ce9d04d432 100644
--- a/clippy_utils/Cargo.toml
+++ b/clippy_utils/Cargo.toml
@@ -8,7 +8,6 @@ publish = false
 clippy_config = { path = "../clippy_config" }
 arrayvec = { version = "0.7", default-features = false }
 itertools = "0.12"
-rustc-semver = "1.1"
 # FIXME(f16_f128): remove when no longer needed for parsing
 rustc_apfloat = "0.2.0"
 
diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index f206b2ceebcb1..92b74355607a7 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -18,7 +18,6 @@ use rustc_middle::mir::{
 use rustc_middle::traits::{BuiltinImplSource, ImplSource, ObligationCause};
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::{self, GenericArgKind, TraitRef, Ty, TyCtxt};
-use rustc_semver::RustcVersion;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 use rustc_trait_selection::traits::{ObligationCtxt, SelectionContext};
@@ -391,11 +390,7 @@ fn is_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: &Msrv) -> bool {
                     StableSince::Err => return false,
                 };
 
-                msrv.meets(RustcVersion::new(
-                    u32::from(const_stab_rust_version.major),
-                    u32::from(const_stab_rust_version.minor),
-                    u32::from(const_stab_rust_version.patch),
-                ))
+                msrv.meets(const_stab_rust_version)
             } else {
                 // Unstable const fn with the feature enabled.
                 msrv.current().is_none()
diff --git a/tests/ui/min_rust_version_invalid_attr.rs b/tests/ui/min_rust_version_invalid_attr.rs
index 2dccadd9fceec..c8409d78ed77c 100644
--- a/tests/ui/min_rust_version_invalid_attr.rs
+++ b/tests/ui/min_rust_version_invalid_attr.rs
@@ -17,7 +17,7 @@ mod multiple {
     //~^ ERROR: `clippy::msrv` is defined multiple times
 
     mod foo {
-        #![clippy::msrv = "1"]
+        #![clippy::msrv = "1.0"]
         #![clippy::msrv = "1.0.0"]
         //~^ ERROR: `clippy::msrv` is defined multiple times
     }
diff --git a/tests/ui/min_rust_version_invalid_attr.stderr b/tests/ui/min_rust_version_invalid_attr.stderr
index b4cb1b5713f90..dbc276ed89df3 100644
--- a/tests/ui/min_rust_version_invalid_attr.stderr
+++ b/tests/ui/min_rust_version_invalid_attr.stderr
@@ -31,8 +31,8 @@ LL |         #![clippy::msrv = "1.0.0"]
 note: first definition found here
   --> tests/ui/min_rust_version_invalid_attr.rs:20:9
    |
-LL |         #![clippy::msrv = "1"]
-   |         ^^^^^^^^^^^^^^^^^^^^^^
+LL |         #![clippy::msrv = "1.0"]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 4 previous errors
 

From 9afab36ca9aac3ac8a685ead1982b8ad6e782f70 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 9 Aug 2024 09:01:41 -0400
Subject: [PATCH 089/685] Rename `get_source_text` to `get_source_range`. Add
 new `get_source_text` which returns a displayable string-like type.

---
 clippy_lints/src/matches/single_match.rs |  2 +-
 clippy_utils/src/consts.rs               |  2 +-
 clippy_utils/src/hir_utils.rs            |  4 +-
 clippy_utils/src/source.rs               | 71 ++++++++++++++++--------
 4 files changed, 53 insertions(+), 26 deletions(-)

diff --git a/clippy_lints/src/matches/single_match.rs b/clippy_lints/src/matches/single_match.rs
index 24dea03601c5f..b6930f7b9d10f 100644
--- a/clippy_lints/src/matches/single_match.rs
+++ b/clippy_lints/src/matches/single_match.rs
@@ -22,7 +22,7 @@ use super::{MATCH_BOOL, SINGLE_MATCH, SINGLE_MATCH_ELSE};
 /// span, e.g. a string literal `"//"`, but we know that this isn't the case for empty
 /// match arms.
 fn empty_arm_has_comment(cx: &LateContext<'_>, span: Span) -> bool {
-    if let Some(ff) = span.get_source_text(cx)
+    if let Some(ff) = span.get_source_range(cx)
         && let Some(text) = ff.as_str()
     {
         text.as_bytes().windows(2).any(|w| w == b"//" || w == b"/*")
diff --git a/clippy_utils/src/consts.rs b/clippy_utils/src/consts.rs
index e907e4058e5a2..760d5bc95f7fb 100644
--- a/clippy_utils/src/consts.rs
+++ b/clippy_utils/src/consts.rs
@@ -687,7 +687,7 @@ impl<'tcx> ConstEvalCtxt<'tcx> {
                 if let Some(expr_span) = walk_span_to_context(expr.span, span.ctxt)
                     && let expr_lo = expr_span.lo()
                     && expr_lo >= span.lo
-                    && let Some(src) = (span.lo..expr_lo).get_source_text(&self.tcx)
+                    && let Some(src) = (span.lo..expr_lo).get_source_range(&self.tcx)
                     && let Some(src) = src.as_str()
                 {
                     use rustc_lexer::TokenKind::{BlockComment, LineComment, OpenBrace, Semi, Whitespace};
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index f325e4eaf1544..b0a668329e920 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1191,9 +1191,9 @@ fn eq_span_tokens(
     pred: impl Fn(TokenKind) -> bool,
 ) -> bool {
     fn f(cx: &LateContext<'_>, left: Range<BytePos>, right: Range<BytePos>, pred: impl Fn(TokenKind) -> bool) -> bool {
-        if let Some(lsrc) = left.get_source_text(cx)
+        if let Some(lsrc) = left.get_source_range(cx)
             && let Some(lsrc) = lsrc.as_str()
-            && let Some(rsrc) = right.get_source_text(cx)
+            && let Some(rsrc) = right.get_source_range(cx)
             && let Some(rsrc) = rsrc.as_str()
         {
             let pred = |t: &(_, _)| pred(t.0);
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 96dd3c55d37ae..1be1a9b28b9ea 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -16,7 +16,7 @@ use rustc_span::{
 };
 use std::borrow::Cow;
 use std::fmt;
-use std::ops::Range;
+use std::ops::{Deref, Range};
 
 pub trait HasSession {
     fn sess(&self) -> &Session;
@@ -94,10 +94,16 @@ impl IntoSpan for Range<BytePos> {
 }
 
 pub trait SpanRangeExt: SpanRange {
+    /// Attempts to get a handle to the source text. Returns `None` if either the span is malformed,
+    /// or the source text is not accessible.
+    fn get_source_text(self, cx: &impl HasSession) -> Option<SourceText> {
+        get_source_range(cx.sess().source_map(), self.into_range()).and_then(SourceText::new)
+    }
+
     /// Gets the source file, and range in the file, of the given span. Returns `None` if the span
     /// extends through multiple files, or is malformed.
-    fn get_source_text(self, cx: &impl HasSession) -> Option<SourceFileRange> {
-        get_source_text(cx.sess().source_map(), self.into_range())
+    fn get_source_range(self, cx: &impl HasSession) -> Option<SourceFileRange> {
+        get_source_range(cx.sess().source_map(), self.into_range())
     }
 
     /// Calls the given function with the source text referenced and returns the value. Returns
@@ -144,21 +150,49 @@ pub trait SpanRangeExt: SpanRange {
     fn trim_start(self, cx: &impl HasSession) -> Range<BytePos> {
         trim_start(cx.sess().source_map(), self.into_range())
     }
+}
+impl<T: SpanRange> SpanRangeExt for T {}
 
-    /// Writes the referenced source text to the given writer. Will return `Err` if the source text
-    /// could not be retrieved.
-    fn write_source_text_to(self, cx: &impl HasSession, dst: &mut impl fmt::Write) -> fmt::Result {
-        write_source_text_to(cx.sess().source_map(), self.into_range(), dst)
+/// Handle to a range of text in a source file.
+pub struct SourceText(SourceFileRange);
+impl SourceText {
+    /// Takes ownership of the source file handle if the source text is accessible.
+    pub fn new(text: SourceFileRange) -> Option<Self> {
+        if text.as_str().is_some() {
+            Some(Self(text))
+        } else {
+            None
+        }
+    }
+
+    /// Gets the source text.
+    pub fn as_str(&self) -> &str {
+        self.0.as_str().unwrap()
     }
 
-    /// Extracts the referenced source text as an owned string.
-    fn source_text_to_string(self, cx: &impl HasSession) -> Option<String> {
-        self.with_source_text(cx, ToOwned::to_owned)
+    /// Converts this into an owned string.
+    pub fn to_owned(&self) -> String {
+        self.as_str().to_owned()
+    }
+}
+impl Deref for SourceText {
+    type Target = str;
+    fn deref(&self) -> &Self::Target {
+        self.as_str()
+    }
+}
+impl AsRef<str> for SourceText {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+impl fmt::Display for SourceText {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_str().fmt(f)
     }
 }
-impl<T: SpanRange> SpanRangeExt for T {}
 
-fn get_source_text(sm: &SourceMap, sp: Range<BytePos>) -> Option<SourceFileRange> {
+fn get_source_range(sm: &SourceMap, sp: Range<BytePos>) -> Option<SourceFileRange> {
     let start = sm.lookup_byte_offset(sp.start);
     let end = sm.lookup_byte_offset(sp.end);
     if !Lrc::ptr_eq(&start.sf, &end.sf) || start.pos > end.pos {
@@ -169,7 +203,7 @@ fn get_source_text(sm: &SourceMap, sp: Range<BytePos>) -> Option<SourceFileRange
 }
 
 fn with_source_text<T>(sm: &SourceMap, sp: Range<BytePos>, f: impl for<'a> FnOnce(&'a str) -> T) -> Option<T> {
-    if let Some(src) = get_source_text(sm, sp)
+    if let Some(src) = get_source_range(sm, sp)
         && let Some(src) = src.as_str()
     {
         Some(f(src))
@@ -183,7 +217,7 @@ fn with_source_text_and_range<T>(
     sp: Range<BytePos>,
     f: impl for<'a> FnOnce(&'a str, Range<usize>) -> T,
 ) -> Option<T> {
-    if let Some(src) = get_source_text(sm, sp)
+    if let Some(src) = get_source_range(sm, sp)
         && let Some(text) = &src.sf.src
     {
         Some(f(text, src.range))
@@ -198,7 +232,7 @@ fn map_range(
     sp: Range<BytePos>,
     f: impl for<'a> FnOnce(&'a str, Range<usize>) -> Option<Range<usize>>,
 ) -> Option<Range<BytePos>> {
-    if let Some(src) = get_source_text(sm, sp.clone())
+    if let Some(src) = get_source_range(sm, sp.clone())
         && let Some(text) = &src.sf.src
         && let Some(range) = f(text, src.range.clone())
     {
@@ -232,13 +266,6 @@ fn trim_start(sm: &SourceMap, sp: Range<BytePos>) -> Range<BytePos> {
     .unwrap_or(sp)
 }
 
-fn write_source_text_to(sm: &SourceMap, sp: Range<BytePos>, dst: &mut impl fmt::Write) -> fmt::Result {
-    match with_source_text(sm, sp, |src| dst.write_str(src)) {
-        Some(x) => x,
-        None => Err(fmt::Error),
-    }
-}
-
 pub struct SourceFileRange {
     pub sf: Lrc<SourceFile>,
     pub range: Range<usize>,

From d5a7c459662a4868f4a38cbafb72dce7885e027d Mon Sep 17 00:00:00 2001
From: Evan Jones <evan.jones@datadoghq.com>
Date: Fri, 9 Aug 2024 14:26:18 -0400
Subject: [PATCH 090/685] doc: std::env::var: Returns None for names with '='
 or NUL byte

The documentation incorrectly stated that std::env::var could return
an error for variable names containing '=' or the NUL byte. Copy the
correct documentation from var_os.

var_os was fixed in Commit 8a7a665, Pull Request #109894, which
closed Issue #109893.

This documentation was incorrectly added in commit f2c0f292, which
replaced a panic in var_os by returning None, but documented the
change as "May error if ...".

Reference the specific error values and link to them.
---
 library/std/src/env.rs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/library/std/src/env.rs b/library/std/src/env.rs
index 50ae83090c7e1..215b7b03f04c3 100644
--- a/library/std/src/env.rs
+++ b/library/std/src/env.rs
@@ -198,13 +198,16 @@ impl fmt::Debug for VarsOs {
 ///
 /// # Errors
 ///
-/// This function will return an error if the environment variable isn't set.
+/// This function returns [`VarError::NotPresent`] if the environment variable
+/// isn't set.
 ///
-/// This function may return an error if the environment variable's name contains
-/// the equal sign character (`=`) or the NUL character.
+/// This function may return [`VarError::NotPresent`] if the
+/// environment variable's name contains the equal sign character (`=`) or the
+/// NUL character.
 ///
-/// This function will return an error if the environment variable's value is
-/// not valid Unicode. If this is not desired, consider using [`var_os`].
+/// This function will return [`VarError::NotUnicode`] if the environment
+/// variable's value is not valid Unicode. If this is not desired, consider
+/// using [`var_os`].
 ///
 /// # Examples
 ///

From dda9eb9fa8c87dc3d807189491a7730810d005a4 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Thu, 11 Jul 2024 19:41:48 -0400
Subject: [PATCH 091/685] Paper over the clippy ICE

---
 tests/ui/borrow_interior_mutable_const/others.rs     | 3 +--
 tests/ui/borrow_interior_mutable_const/others.stderr | 6 +++---
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/tests/ui/borrow_interior_mutable_const/others.rs b/tests/ui/borrow_interior_mutable_const/others.rs
index 0ea93dd84625c..452d1b198133e 100644
--- a/tests/ui/borrow_interior_mutable_const/others.rs
+++ b/tests/ui/borrow_interior_mutable_const/others.rs
@@ -10,7 +10,7 @@ use std::sync::Once;
 
 const ATOMIC: AtomicUsize = AtomicUsize::new(5);
 const CELL: Cell<usize> = Cell::new(6);
-const ATOMIC_TUPLE: ([AtomicUsize; 1], Vec<AtomicUsize>, u8) = ([ATOMIC], Vec::new(), 7);
+const ATOMIC_TUPLE: ([AtomicUsize; 1], Option<Box<AtomicUsize>>, u8) = ([ATOMIC], None, 7);
 const INTEGER: u8 = 8;
 const STRING: String = String::new();
 const STR: &str = "012345";
@@ -74,7 +74,6 @@ fn main() {
     let _ = &(&&&&ATOMIC_TUPLE).0; //~ ERROR: interior mutability
     let _ = &ATOMIC_TUPLE.0[0]; //~ ERROR: interior mutability
     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst); //~ ERROR: interior mutability
-    let _ = &*ATOMIC_TUPLE.1;
     let _ = &ATOMIC_TUPLE.2;
     let _ = (&&&&ATOMIC_TUPLE).0;
     let _ = (&&&&ATOMIC_TUPLE).2;
diff --git a/tests/ui/borrow_interior_mutable_const/others.stderr b/tests/ui/borrow_interior_mutable_const/others.stderr
index 33c774667f942..9a9028c864986 100644
--- a/tests/ui/borrow_interior_mutable_const/others.stderr
+++ b/tests/ui/borrow_interior_mutable_const/others.stderr
@@ -92,7 +92,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst);
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:82:13
+  --> tests/ui/borrow_interior_mutable_const/others.rs:81:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0];
    |             ^^^^^^^^^^^^
@@ -100,7 +100,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0];
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:87:5
+  --> tests/ui/borrow_interior_mutable_const/others.rs:86:5
    |
 LL |     CELL.set(2);
    |     ^^^^
@@ -108,7 +108,7 @@ LL |     CELL.set(2);
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:88:16
+  --> tests/ui/borrow_interior_mutable_const/others.rs:87:16
    |
 LL |     assert_eq!(CELL.get(), 6);
    |                ^^^^

From f9509d3574a998bbfb664c5768d183f7d2af39a9 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Thu, 4 Jul 2024 19:00:17 -0400
Subject: [PATCH 092/685] Refactor `absolute_paths`: * Check the path length
 first * Use `is_from_proc_macro` * Use symbols instead of strings when
 checking crate names

---
 clippy_lints/src/absolute_paths.rs            |  95 +++++-----
 clippy_utils/src/check_proc_macro.rs          |  12 +-
 .../absolute_paths.allow_crates.stderr        |  45 +++--
 .../absolute_paths.allow_long.stderr          |  14 ++
 .../absolute_paths.default.stderr             |  80 ++++++++
 .../absolute_paths.disallow_crates.stderr     |  71 -------
 .../absolute_paths.no_short.stderr            |  98 ++++++++++
 .../ui-toml/absolute_paths/absolute_paths.rs  | 178 ++++++++++--------
 .../absolute_paths_2015.default.stderr        |  14 ++
 .../absolute_paths/absolute_paths_2015.rs     |  16 ++
 .../absolute_paths/allow_crates/clippy.toml   |   3 +-
 .../absolute_paths/allow_long/clippy.toml     |   1 +
 .../absolute_paths/auxiliary/helper.rs        |  11 --
 .../absolute_paths/default/clippy.toml        |   0
 .../disallow_crates/clippy.toml               |   1 -
 .../absolute_paths/no_short/clippy.toml       |   1 +
 16 files changed, 415 insertions(+), 225 deletions(-)
 create mode 100644 tests/ui-toml/absolute_paths/absolute_paths.allow_long.stderr
 create mode 100644 tests/ui-toml/absolute_paths/absolute_paths.default.stderr
 delete mode 100644 tests/ui-toml/absolute_paths/absolute_paths.disallow_crates.stderr
 create mode 100644 tests/ui-toml/absolute_paths/absolute_paths.no_short.stderr
 create mode 100644 tests/ui-toml/absolute_paths/absolute_paths_2015.default.stderr
 create mode 100644 tests/ui-toml/absolute_paths/absolute_paths_2015.rs
 create mode 100644 tests/ui-toml/absolute_paths/allow_long/clippy.toml
 delete mode 100644 tests/ui-toml/absolute_paths/auxiliary/helper.rs
 create mode 100644 tests/ui-toml/absolute_paths/default/clippy.toml
 delete mode 100644 tests/ui-toml/absolute_paths/disallow_crates/clippy.toml
 create mode 100644 tests/ui-toml/absolute_paths/no_short/clippy.toml

diff --git a/clippy_lints/src/absolute_paths.rs b/clippy_lints/src/absolute_paths.rs
index c0a9d888e0b0b..c72b3f1318c86 100644
--- a/clippy_lints/src/absolute_paths.rs
+++ b/clippy_lints/src/absolute_paths.rs
@@ -1,6 +1,6 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::is_from_proc_macro;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{DefId, CRATE_DEF_INDEX};
@@ -8,6 +8,7 @@ use rustc_hir::{HirId, ItemKind, Node, Path};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 use rustc_span::symbol::kw;
+use rustc_span::Symbol;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -24,6 +25,13 @@ declare_clippy_lint! {
     /// Note: One exception to this is code from macro expansion - this does not lint such cases, as
     /// using absolute paths is the proper way of referencing items in one.
     ///
+    /// ### Known issues
+    ///
+    /// There are currently a few cases which are not caught by this lint:
+    /// * Macro calls. e.g. `path::to::macro!()`
+    /// * Derive macros. e.g. `#[derive(path::to::macro)]`
+    /// * Attribute macros. e.g. `#[path::to::macro]`
+    ///
     /// ### Example
     /// ```no_run
     /// let x = std::f64::consts::PI;
@@ -48,63 +56,66 @@ impl_lint_pass!(AbsolutePaths => [ABSOLUTE_PATHS]);
 
 pub struct AbsolutePaths {
     pub absolute_paths_max_segments: u64,
-    pub absolute_paths_allowed_crates: &'static FxHashSet<String>,
+    pub absolute_paths_allowed_crates: FxHashSet<Symbol>,
 }
 
 impl AbsolutePaths {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
             absolute_paths_max_segments: conf.absolute_paths_max_segments,
-            absolute_paths_allowed_crates: &conf.absolute_paths_allowed_crates,
+            absolute_paths_allowed_crates: conf
+                .absolute_paths_allowed_crates
+                .iter()
+                .map(|x| Symbol::intern(x))
+                .collect(),
         }
     }
 }
 
-impl LateLintPass<'_> for AbsolutePaths {
+impl<'tcx> LateLintPass<'tcx> for AbsolutePaths {
     // We should only lint `QPath::Resolved`s, but since `Path` is only used in `Resolved` and `UsePath`
     // we don't need to use a visitor or anything as we can just check if the `Node` for `hir_id` isn't
     // a `Use`
-    #[expect(clippy::cast_possible_truncation)]
-    fn check_path(&mut self, cx: &LateContext<'_>, path: &Path<'_>, hir_id: HirId) {
-        let Self {
-            absolute_paths_max_segments,
-            absolute_paths_allowed_crates,
-        } = self;
-
-        if !path.span.from_expansion()
-            && let node = cx.tcx.hir_node(hir_id)
-            && !matches!(node, Node::Item(item) if matches!(item.kind, ItemKind::Use(_, _)))
-            && let [first, rest @ ..] = path.segments
-            // Handle `::std`
-            && let (segment, len) = if first.ident.name == kw::PathRoot {
-                // Indexing is fine as `PathRoot` must be followed by another segment. `len() - 1`
-                // is fine here for the same reason
-                (&rest[0], path.segments.len() - 1)
-            } else {
-                (first, path.segments.len())
-            }
-            && len > *absolute_paths_max_segments as usize
-            && let Some(segment_snippet) = snippet_opt(cx, segment.ident.span)
-            && segment_snippet == segment.ident.as_str()
-        {
-            let is_abs_external =
-                matches!(segment.res, Res::Def(DefKind::Mod, DefId { index, .. }) if index == CRATE_DEF_INDEX);
-            let is_abs_crate = segment.ident.name == kw::Crate;
-
-            if is_abs_external && absolute_paths_allowed_crates.contains(segment.ident.name.as_str())
-                || is_abs_crate && absolute_paths_allowed_crates.contains("crate")
+    fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, hir_id: HirId) {
+        let segments = match path.segments {
+            [] | [_] => return,
+            // Don't count enum variants and trait items as part of the length.
+            [rest @ .., _]
+                if let [.., s] = rest
+                    && matches!(s.res, Res::Def(DefKind::Enum | DefKind::Trait | DefKind::TraitAlias, _)) =>
+            {
+                rest
+            },
+            path => path,
+        };
+        if let [s1, s2, ..] = segments
+            && let has_root = s1.ident.name == kw::PathRoot
+            && let first = if has_root { s2 } else { s1 }
+            && let len = segments.len() - usize::from(has_root)
+            && len as u64 > self.absolute_paths_max_segments
+            && let crate_name = if let Res::Def(DefKind::Mod, DefId { index, .. }) = first.res
+                && index == CRATE_DEF_INDEX
             {
+                // `other_crate::foo` or `::other_crate::foo`
+                first.ident.name
+            } else if first.ident.name == kw::Crate || has_root {
+                // `::foo` or `crate::foo`
+                kw::Crate
+            } else {
                 return;
             }
-
-            if is_abs_external || is_abs_crate {
-                span_lint(
-                    cx,
-                    ABSOLUTE_PATHS,
-                    path.span,
-                    "consider bringing this path into scope with the `use` keyword",
-                );
-            }
+            && !path.span.from_expansion()
+            && let node = cx.tcx.hir_node(hir_id)
+            && !matches!(node, Node::Item(item) if matches!(item.kind, ItemKind::Use(..)))
+            && !self.absolute_paths_allowed_crates.contains(&crate_name)
+            && !is_from_proc_macro(cx, path)
+        {
+            span_lint(
+                cx,
+                ABSOLUTE_PATHS,
+                path.span,
+                "consider bringing this path into scope with the `use` keyword",
+            );
         }
     }
 }
diff --git a/clippy_utils/src/check_proc_macro.rs b/clippy_utils/src/check_proc_macro.rs
index 7f2234b310b42..2bd6837d973bb 100644
--- a/clippy_utils/src/check_proc_macro.rs
+++ b/clippy_utils/src/check_proc_macro.rs
@@ -123,16 +123,14 @@ fn qpath_search_pat(path: &QPath<'_>) -> (Pat, Pat) {
 
 fn path_search_pat(path: &Path<'_>) -> (Pat, Pat) {
     let (head, tail) = match path.segments {
-        [head, .., tail] => (head, tail),
-        [p] => (p, p),
         [] => return (Pat::Str(""), Pat::Str("")),
+        [p] => (Pat::Sym(p.ident.name), p),
+        // QPath::Resolved can have a path that looks like `<Foo as Bar>::baz` where
+        // the path (`Bar::baz`) has it's span covering the whole QPath.
+        [.., tail] => (Pat::Str(""), tail),
     };
     (
-        if head.ident.name == kw::PathRoot {
-            Pat::Str("::")
-        } else {
-            Pat::Sym(head.ident.name)
-        },
+        head,
         if tail.args.is_some() {
             Pat::Str(">")
         } else {
diff --git a/tests/ui-toml/absolute_paths/absolute_paths.allow_crates.stderr b/tests/ui-toml/absolute_paths/absolute_paths.allow_crates.stderr
index 1cc1034cd89b3..d24b0cd616294 100644
--- a/tests/ui-toml/absolute_paths/absolute_paths.allow_crates.stderr
+++ b/tests/ui-toml/absolute_paths/absolute_paths.allow_crates.stderr
@@ -1,29 +1,44 @@
 error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:40:5
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:14:13
    |
-LL |     std::f32::MAX;
-   |     ^^^^^^^^^^^^^
+LL |     let _ = std::path::is_separator(' ');
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `-D clippy::absolute-paths` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::absolute_paths)]`
+note: the lint level is defined here
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:7:9
+   |
+LL | #![deny(clippy::absolute_paths)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:20:13
+   |
+LL |     let _ = ::std::path::MAIN_SEPARATOR;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:25:13
+   |
+LL |     let _ = std::collections::hash_map::HashMap::<i32, i32>::new();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:41:5
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:28:31
    |
-LL |     core::f32::MAX;
-   |     ^^^^^^^^^^^^^^
+LL |     let _: &std::path::Path = std::path::Path::new("");
+   |                               ^^^^^^^^^^^^^^^
 
 error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:42:5
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:28:13
    |
-LL |     ::core::f32::MAX;
-   |     ^^^^^^^^^^^^^^^^
+LL |     let _: &std::path::Path = std::path::Path::new("");
+   |             ^^^^^^^^^^^^^^^
 
 error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:58:5
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:43:13
    |
-LL |     ::std::f32::MAX;
-   |     ^^^^^^^^^^^^^^^
+LL |     let _ = std::option::Option::None::<i32>;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 4 previous errors
+error: aborting due to 6 previous errors
 
diff --git a/tests/ui-toml/absolute_paths/absolute_paths.allow_long.stderr b/tests/ui-toml/absolute_paths/absolute_paths.allow_long.stderr
new file mode 100644
index 0000000000000..0cc6566af3a96
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/absolute_paths.allow_long.stderr
@@ -0,0 +1,14 @@
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:25:13
+   |
+LL |     let _ = std::collections::hash_map::HashMap::<i32, i32>::new();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:7:9
+   |
+LL | #![deny(clippy::absolute_paths)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui-toml/absolute_paths/absolute_paths.default.stderr b/tests/ui-toml/absolute_paths/absolute_paths.default.stderr
new file mode 100644
index 0000000000000..53aa9030e0dd5
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/absolute_paths.default.stderr
@@ -0,0 +1,80 @@
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:14:13
+   |
+LL |     let _ = std::path::is_separator(' ');
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:7:9
+   |
+LL | #![deny(clippy::absolute_paths)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:20:13
+   |
+LL |     let _ = ::std::path::MAIN_SEPARATOR;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:25:13
+   |
+LL |     let _ = std::collections::hash_map::HashMap::<i32, i32>::new();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:28:31
+   |
+LL |     let _: &std::path::Path = std::path::Path::new("");
+   |                               ^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:28:13
+   |
+LL |     let _: &std::path::Path = std::path::Path::new("");
+   |             ^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:37:13
+   |
+LL |     let _ = ::core::clone::Clone::clone(&0i32);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:40:13
+   |
+LL |     let _ = <i32 as core::clone::Clone>::clone(&0i32);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:43:13
+   |
+LL |     let _ = std::option::Option::None::<i32>;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:65:17
+   |
+LL |         impl<T: core::cmp::Eq> core::fmt::Display for X<T>
+   |                 ^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:70:18
+   |
+LL |         where T: core::clone::Clone
+   |                  ^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:65:32
+   |
+LL |         impl<T: core::cmp::Eq> core::fmt::Display for X<T>
+   |                                ^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:116:5
+   |
+LL |     crate::m1::S
+   |     ^^^^^^^^^^^^
+
+error: aborting due to 12 previous errors
+
diff --git a/tests/ui-toml/absolute_paths/absolute_paths.disallow_crates.stderr b/tests/ui-toml/absolute_paths/absolute_paths.disallow_crates.stderr
deleted file mode 100644
index f342ebf6632e8..0000000000000
--- a/tests/ui-toml/absolute_paths/absolute_paths.disallow_crates.stderr
+++ /dev/null
@@ -1,71 +0,0 @@
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:40:5
-   |
-LL |     std::f32::MAX;
-   |     ^^^^^^^^^^^^^
-   |
-   = note: `-D clippy::absolute-paths` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::absolute_paths)]`
-
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:41:5
-   |
-LL |     core::f32::MAX;
-   |     ^^^^^^^^^^^^^^
-
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:42:5
-   |
-LL |     ::core::f32::MAX;
-   |     ^^^^^^^^^^^^^^^^
-
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:43:5
-   |
-LL |     crate::a::b::c::C;
-   |     ^^^^^^^^^^^^^^^^^
-
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:44:5
-   |
-LL |     crate::a::b::c::d::e::f::F;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:45:5
-   |
-LL |     crate::a::A;
-   |     ^^^^^^^^^^^
-
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:46:5
-   |
-LL |     crate::a::b::B;
-   |     ^^^^^^^^^^^^^^
-
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:47:5
-   |
-LL |     crate::a::b::c::C::ZERO;
-   |     ^^^^^^^^^^^^^^^^^
-
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:48:5
-   |
-LL |     helper::b::c::d::e::f();
-   |     ^^^^^^^^^^^^^^^^^^^^^
-
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:49:5
-   |
-LL |     ::helper::b::c::d::e::f();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^
-
-error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths.rs:58:5
-   |
-LL |     ::std::f32::MAX;
-   |     ^^^^^^^^^^^^^^^
-
-error: aborting due to 11 previous errors
-
diff --git a/tests/ui-toml/absolute_paths/absolute_paths.no_short.stderr b/tests/ui-toml/absolute_paths/absolute_paths.no_short.stderr
new file mode 100644
index 0000000000000..70d71f6c4ea16
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/absolute_paths.no_short.stderr
@@ -0,0 +1,98 @@
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:14:13
+   |
+LL |     let _ = std::path::is_separator(' ');
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:7:9
+   |
+LL | #![deny(clippy::absolute_paths)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:20:13
+   |
+LL |     let _ = ::std::path::MAIN_SEPARATOR;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:25:13
+   |
+LL |     let _ = std::collections::hash_map::HashMap::<i32, i32>::new();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:28:31
+   |
+LL |     let _: &std::path::Path = std::path::Path::new("");
+   |                               ^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:28:13
+   |
+LL |     let _: &std::path::Path = std::path::Path::new("");
+   |             ^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:37:13
+   |
+LL |     let _ = ::core::clone::Clone::clone(&0i32);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:40:13
+   |
+LL |     let _ = <i32 as core::clone::Clone>::clone(&0i32);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:43:13
+   |
+LL |     let _ = std::option::Option::None::<i32>;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:65:17
+   |
+LL |         impl<T: core::cmp::Eq> core::fmt::Display for X<T>
+   |                 ^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:70:18
+   |
+LL |         where T: core::clone::Clone
+   |                  ^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:65:32
+   |
+LL |         impl<T: core::cmp::Eq> core::fmt::Display for X<T>
+   |                                ^^^^^^^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:113:14
+   |
+LL | pub const _: crate::S = {
+   |              ^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:114:9
+   |
+LL |     let crate::S = m1::S;
+   |         ^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:116:5
+   |
+LL |     crate::m1::S
+   |     ^^^^^^^^^^^^
+
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths.rs:122:14
+   |
+LL |     let _ = <crate::S as Clone>::clone(&m1::S);
+   |              ^^^^^^^^
+
+error: aborting due to 15 previous errors
+
diff --git a/tests/ui-toml/absolute_paths/absolute_paths.rs b/tests/ui-toml/absolute_paths/absolute_paths.rs
index a828701bcee9f..c024f2f513ced 100644
--- a/tests/ui-toml/absolute_paths/absolute_paths.rs
+++ b/tests/ui-toml/absolute_paths/absolute_paths.rs
@@ -1,97 +1,123 @@
 //@aux-build:../../ui/auxiliary/proc_macros.rs
-//@aux-build:helper.rs
-//@revisions: allow_crates disallow_crates
+//@revisions: default allow_crates allow_long no_short
+//@[default] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/default
 //@[allow_crates] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/allow_crates
-//@[disallow_crates] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/disallow_crates
-#![allow(clippy::no_effect, clippy::legacy_numeric_constants, unused)]
-#![warn(clippy::absolute_paths)]
-#![feature(decl_macro)]
+//@[allow_long] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/allow_long
+//@[no_short] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/no_short
+#![deny(clippy::absolute_paths)]
 
-extern crate helper;
-#[macro_use]
 extern crate proc_macros;
+use proc_macros::{external, inline_macros, with_span};
 
-pub mod a {
-    pub mod b {
-        pub mod c {
-            pub struct C;
+#[inline_macros]
+fn main() {
+    let _ = std::path::is_separator(' ');
+    //~[default]^ absolute_paths
+    //~[allow_crates]| absolute_paths
+    //~[no_short]| absolute_paths
 
-            impl C {
-                pub const ZERO: u32 = 0;
-            }
+    // Make sure this is treated as having three path segments, not four.
+    let _ = ::std::path::MAIN_SEPARATOR;
+    //~[default]^ absolute_paths
+    //~[allow_crates]| absolute_paths
+    //~[no_short]| absolute_paths
 
-            pub mod d {
-                pub mod e {
-                    pub mod f {
-                        pub struct F;
-                    }
-                }
-            }
-        }
+    let _ = std::collections::hash_map::HashMap::<i32, i32>::new(); //~ absolute_paths
 
-        pub struct B;
-    }
+    // Note `std::path::Path::new` is treated as having three parts
+    let _: &std::path::Path = std::path::Path::new("");
+    //~[default]^ absolute_paths
+    //~[default]| absolute_paths
+    //~[allow_crates]| absolute_paths
+    //~[allow_crates]| absolute_paths
+    //~[no_short]| absolute_paths
+    //~[no_short]| absolute_paths
 
-    pub struct A;
-}
+    // Treated as having three parts.
+    let _ = ::core::clone::Clone::clone(&0i32);
+    //~[default]^ absolute_paths
+    //~[no_short]| absolute_paths
+    let _ = <i32 as core::clone::Clone>::clone(&0i32);
+    //~[default]^ absolute_paths
+    //~[no_short]| absolute_paths
+    let _ = std::option::Option::None::<i32>;
+    //~[default]^ absolute_paths
+    //~[allow_crates]| absolute_paths
+    //~[no_short]| absolute_paths
 
-fn main() {
-    f32::max(1.0, 2.0);
-    std::f32::MAX;
-    core::f32::MAX;
-    ::core::f32::MAX;
-    crate::a::b::c::C;
-    crate::a::b::c::d::e::f::F;
-    crate::a::A;
-    crate::a::b::B;
-    crate::a::b::c::C::ZERO;
-    helper::b::c::d::e::f();
-    ::helper::b::c::d::e::f();
-    fn b() -> a::b::B {
-        todo!()
+    {
+        // FIXME: macro calls should be checked.
+        let x = 1i32;
+        let _ = core::ptr::addr_of!(x);
     }
-    std::println!("a");
-    let x = 1;
-    std::ptr::addr_of!(x);
-    // Test we handle max segments with `PathRoot` properly; this has 4 segments but we should say it
-    // has 3
-    ::std::f32::MAX;
-    // Do not lint due to the above
-    ::helper::a();
-    // Do not lint
-    helper::a();
-    use crate::a::b::c::C;
-    use a::b;
-    use std::f32::MAX;
-    a::b::c::d::e::f::F;
-    b::c::C;
-    fn a() -> a::A {
-        todo!()
-    }
-    use a::b::c;
 
-    fn c() -> c::C {
-        todo!()
+    {
+        // FIXME: derive macro paths should be checked.
+        #[derive(core::clone::Clone)]
+        struct S;
     }
-    fn d() -> Result<(), ()> {
-        todo!()
+
+    {
+        use core::fmt;
+        use core::marker::PhantomData;
+
+        struct X<T>(PhantomData<T>);
+        impl<T: core::cmp::Eq> core::fmt::Display for X<T>
+        //~[default]^ absolute_paths
+        //~[default]| absolute_paths
+        //~[no_short]| absolute_paths
+        //~[no_short]| absolute_paths
+        where T: core::clone::Clone
+        //~[no_short]^ absolute_paths
+        //~[default]| absolute_paths
+        {
+            fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
+                Ok(())
+            }
+        }
     }
-    external! {
-        crate::a::b::c::C::ZERO;
+
+    {
+        mod m1 {
+            pub(crate) mod m2 {
+                pub(crate) const FOO: i32 = 0;
+            }
+        }
+        let _ = m1::m2::FOO;
     }
-    // For some reason, `path.span.from_expansion()` takes care of this for us
+
     with_span! {
         span
-        crate::a::b::c::C::ZERO;
+        let _ = std::path::is_separator(' ');
     }
-    macro_rules! local_crate {
-        () => {
-            crate::a::b::c::C::ZERO;
-        };
+
+    external! {
+        let _ = std::path::is_separator(' ');
     }
-    macro local_crate_2_0() {
-        crate::a::b::c::C::ZERO;
+
+    inline! {
+        let _ = std::path::is_separator(' ');
     }
-    local_crate!();
-    local_crate_2_0!();
+}
+
+pub use core::cmp::Ordering;
+pub use std::fs::File;
+
+#[derive(Clone)]
+pub struct S;
+mod m1 {
+    pub use crate::S;
+}
+
+//~[no_short]v absolute_paths
+pub const _: crate::S = {
+    let crate::S = m1::S; //~[no_short] absolute_paths
+
+    crate::m1::S
+    //~[default]^ absolute_paths
+    //~[no_short]| absolute_paths
+};
+
+pub fn f() {
+    let _ = <crate::S as Clone>::clone(&m1::S); //~[no_short] absolute_paths
 }
diff --git a/tests/ui-toml/absolute_paths/absolute_paths_2015.default.stderr b/tests/ui-toml/absolute_paths/absolute_paths_2015.default.stderr
new file mode 100644
index 0000000000000..6fc495f018080
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/absolute_paths_2015.default.stderr
@@ -0,0 +1,14 @@
+error: consider bringing this path into scope with the `use` keyword
+  --> tests/ui-toml/absolute_paths/absolute_paths_2015.rs:15:13
+   |
+LL |     let _ = ::m1::m2::X;
+   |             ^^^^^^^^^^^
+   |
+note: the lint level is defined here
+  --> tests/ui-toml/absolute_paths/absolute_paths_2015.rs:6:9
+   |
+LL | #![deny(clippy::absolute_paths)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui-toml/absolute_paths/absolute_paths_2015.rs b/tests/ui-toml/absolute_paths/absolute_paths_2015.rs
new file mode 100644
index 0000000000000..033c47809191c
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/absolute_paths_2015.rs
@@ -0,0 +1,16 @@
+//@revisions: default allow_crates
+//@[default]rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/default
+//@[allow_crates]rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/allow_crates
+//@edition:2015
+
+#![deny(clippy::absolute_paths)]
+
+mod m1 {
+    pub mod m2 {
+        pub struct X;
+    }
+}
+
+fn main() {
+    let _ = ::m1::m2::X; //~[default] absolute_paths
+}
diff --git a/tests/ui-toml/absolute_paths/allow_crates/clippy.toml b/tests/ui-toml/absolute_paths/allow_crates/clippy.toml
index 59a621e9d1dba..9da49abcd31f6 100644
--- a/tests/ui-toml/absolute_paths/allow_crates/clippy.toml
+++ b/tests/ui-toml/absolute_paths/allow_crates/clippy.toml
@@ -1,2 +1 @@
-absolute-paths-max-segments = 2
-absolute-paths-allowed-crates = ["crate", "helper"]
+absolute-paths-allowed-crates = ["core", "crate"]
diff --git a/tests/ui-toml/absolute_paths/allow_long/clippy.toml b/tests/ui-toml/absolute_paths/allow_long/clippy.toml
new file mode 100644
index 0000000000000..5992fd1ed8219
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/allow_long/clippy.toml
@@ -0,0 +1 @@
+absolute-paths-max-segments = 3
diff --git a/tests/ui-toml/absolute_paths/auxiliary/helper.rs b/tests/ui-toml/absolute_paths/auxiliary/helper.rs
deleted file mode 100644
index 8e2678f5fe697..0000000000000
--- a/tests/ui-toml/absolute_paths/auxiliary/helper.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-pub fn a() {}
-
-pub mod b {
-    pub mod c {
-        pub mod d {
-            pub mod e {
-                pub fn f() {}
-            }
-        }
-    }
-}
diff --git a/tests/ui-toml/absolute_paths/default/clippy.toml b/tests/ui-toml/absolute_paths/default/clippy.toml
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/tests/ui-toml/absolute_paths/disallow_crates/clippy.toml b/tests/ui-toml/absolute_paths/disallow_crates/clippy.toml
deleted file mode 100644
index d44d648c64118..0000000000000
--- a/tests/ui-toml/absolute_paths/disallow_crates/clippy.toml
+++ /dev/null
@@ -1 +0,0 @@
-absolute-paths-max-segments = 2
diff --git a/tests/ui-toml/absolute_paths/no_short/clippy.toml b/tests/ui-toml/absolute_paths/no_short/clippy.toml
new file mode 100644
index 0000000000000..357524420c5a6
--- /dev/null
+++ b/tests/ui-toml/absolute_paths/no_short/clippy.toml
@@ -0,0 +1 @@
+absolute-paths-max-segments = 0

From 917ad034cc89ecdde85771238d0d8f89813290fb Mon Sep 17 00:00:00 2001
From: Nadrieril <nadrieril+git@gmail.com>
Date: Wed, 20 Mar 2024 22:51:29 +0100
Subject: [PATCH 093/685] Fixes in various places

---
 clippy_utils/src/lib.rs           | 1 +
 tests/ui/single_match_else.fixed  | 2 +-
 tests/ui/single_match_else.rs     | 2 +-
 tests/ui/single_match_else.stderr | 4 ++--
 4 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/clippy_utils/src/lib.rs b/clippy_utils/src/lib.rs
index af74e4b67c162..28755ae0710ca 100644
--- a/clippy_utils/src/lib.rs
+++ b/clippy_utils/src/lib.rs
@@ -2931,6 +2931,7 @@ pub fn expr_use_ctxt<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> ExprU
             moved_before_use,
             same_ctxt,
         },
+        #[allow(unreachable_patterns)]
         Some(ControlFlow::Break(_)) => unreachable!("type of node is ControlFlow<!>"),
         None => ExprUseCtxt {
             node: Node::Crate(cx.tcx.hir().root_module()),
diff --git a/tests/ui/single_match_else.fixed b/tests/ui/single_match_else.fixed
index e840adf0fa34b..163be16ad8be7 100644
--- a/tests/ui/single_match_else.fixed
+++ b/tests/ui/single_match_else.fixed
@@ -89,7 +89,7 @@ fn main() {
 
     // lint here
     use std::convert::Infallible;
-    if let Ok(a) = Result::<i32, Infallible>::Ok(1) { println!("${:?}", a) } else {
+    if let Ok(a) = Result::<i32, &Infallible>::Ok(1) { println!("${:?}", a) } else {
         println!("else block");
         return;
     }
diff --git a/tests/ui/single_match_else.rs b/tests/ui/single_match_else.rs
index 430c4da20f12a..3f1fd2b31832f 100644
--- a/tests/ui/single_match_else.rs
+++ b/tests/ui/single_match_else.rs
@@ -98,7 +98,7 @@ fn main() {
 
     // lint here
     use std::convert::Infallible;
-    match Result::<i32, Infallible>::Ok(1) {
+    match Result::<i32, &Infallible>::Ok(1) {
         Ok(a) => println!("${:?}", a),
         Err(_) => {
             println!("else block");
diff --git a/tests/ui/single_match_else.stderr b/tests/ui/single_match_else.stderr
index f8f88379d6d12..61c348260d05e 100644
--- a/tests/ui/single_match_else.stderr
+++ b/tests/ui/single_match_else.stderr
@@ -64,7 +64,7 @@ LL +     }
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
   --> tests/ui/single_match_else.rs:101:5
    |
-LL | /     match Result::<i32, Infallible>::Ok(1) {
+LL | /     match Result::<i32, &Infallible>::Ok(1) {
 LL | |         Ok(a) => println!("${:?}", a),
 LL | |         Err(_) => {
 LL | |             println!("else block");
@@ -75,7 +75,7 @@ LL | |     }
    |
 help: try
    |
-LL ~     if let Ok(a) = Result::<i32, Infallible>::Ok(1) { println!("${:?}", a) } else {
+LL ~     if let Ok(a) = Result::<i32, &Infallible>::Ok(1) { println!("${:?}", a) } else {
 LL +         println!("else block");
 LL +         return;
 LL +     }

From 4231e93bf7933aa1f2d923f9388090f63e649c2f Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 10 Aug 2024 10:50:47 +0000
Subject: [PATCH 094/685] Remove `find_format_arg_expr` AST fallback

---
 clippy_lints/src/format.rs      |  2 +-
 clippy_lints/src/format_args.rs | 29 ++++++-----------------------
 clippy_lints/src/format_impl.rs |  2 +-
 clippy_utils/src/macros.rs      |  9 ++-------
 4 files changed, 10 insertions(+), 32 deletions(-)

diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index 0b248f784b762..c14bd38a1f21c 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -73,7 +73,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                     span_useless_format(cx, call_site, sugg, applicability);
                 },
                 ([arg], [piece]) => {
-                    if let Ok(value) = find_format_arg_expr(expr, arg)
+                    if let Some(value) = find_format_arg_expr(expr, arg)
                         && let FormatArgsPiece::Placeholder(placeholder) = piece
                         && placeholder.format_trait == FormatTrait::Display
                         && placeholder.format_options == FormatOptions::default()
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index a31d5cb6ec77f..823992767e508 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -224,13 +224,11 @@ impl<'a, 'tcx> FormatArgsExpr<'a, 'tcx> {
             if let FormatArgsPiece::Placeholder(placeholder) = piece
                 && let Ok(index) = placeholder.argument.index
                 && let Some(arg) = self.format_args.arguments.all_args().get(index)
+                && let Some(arg_expr) = find_format_arg_expr(self.expr, arg)
             {
-                let arg_expr = find_format_arg_expr(self.expr, arg);
-
                 self.check_unused_format_specifier(placeholder, arg_expr);
 
-                if let Ok(arg_expr) = arg_expr
-                    && placeholder.format_trait == FormatTrait::Display
+                if placeholder.format_trait == FormatTrait::Display
                     && placeholder.format_options == FormatOptions::default()
                     && !self.is_aliased(index)
                 {
@@ -242,28 +240,13 @@ impl<'a, 'tcx> FormatArgsExpr<'a, 'tcx> {
         }
     }
 
-    fn check_unused_format_specifier(
-        &self,
-        placeholder: &FormatPlaceholder,
-        arg_expr: Result<&Expr<'_>, &rustc_ast::Expr>,
-    ) {
-        let ty_or_ast_expr = arg_expr.map(|expr| self.cx.typeck_results().expr_ty(expr).peel_refs());
-
-        let is_format_args = match ty_or_ast_expr {
-            Ok(ty) => is_type_lang_item(self.cx, ty, LangItem::FormatArguments),
-            Err(expr) => matches!(expr.peel_parens_and_refs().kind, rustc_ast::ExprKind::FormatArgs(_)),
-        };
-
+    fn check_unused_format_specifier(&self, placeholder: &FormatPlaceholder, arg: &Expr<'_>) {
         let options = &placeholder.format_options;
 
-        let arg_span = match arg_expr {
-            Ok(expr) => expr.span,
-            Err(expr) => expr.span,
-        };
-
         if let Some(placeholder_span) = placeholder.span
-            && is_format_args
             && *options != FormatOptions::default()
+            && let ty = self.cx.typeck_results().expr_ty(arg).peel_refs()
+            && is_type_lang_item(self.cx, ty, LangItem::FormatArguments)
         {
             span_lint_and_then(
                 self.cx,
@@ -274,7 +257,7 @@ impl<'a, 'tcx> FormatArgsExpr<'a, 'tcx> {
                     let mut suggest_format = |spec| {
                         let message = format!("for the {spec} to apply consider using `format!()`");
 
-                        if let Some(mac_call) = matching_root_macro_call(self.cx, arg_span, sym::format_args_macro) {
+                        if let Some(mac_call) = matching_root_macro_call(self.cx, arg.span, sym::format_args_macro) {
                             diag.span_suggestion(
                                 self.cx.sess().source_map().span_until_char(mac_call.span, '!'),
                                 message,
diff --git a/clippy_lints/src/format_impl.rs b/clippy_lints/src/format_impl.rs
index e6f27cb82d17a..7cd12ac7db852 100644
--- a/clippy_lints/src/format_impl.rs
+++ b/clippy_lints/src/format_impl.rs
@@ -196,7 +196,7 @@ impl<'a, 'tcx> FormatImplExpr<'a, 'tcx> {
                     && trait_name == self.format_trait_impl.name
                     && let Ok(index) = placeholder.argument.index
                     && let Some(arg) = format_args.arguments.all_args().get(index)
-                    && let Ok(arg_expr) = find_format_arg_expr(self.expr, arg)
+                    && let Some(arg_expr) = find_format_arg_expr(self.expr, arg)
                 {
                     self.check_format_arg_self(arg_expr);
                 }
diff --git a/clippy_utils/src/macros.rs b/clippy_utils/src/macros.rs
index 455239cc37f35..4a635535a4e0c 100644
--- a/clippy_utils/src/macros.rs
+++ b/clippy_utils/src/macros.rs
@@ -426,12 +426,8 @@ impl FormatArgsStorage {
     }
 }
 
-/// Attempt to find the [`rustc_hir::Expr`] that corresponds to the [`FormatArgument`]'s value, if
-/// it cannot be found it will return the [`rustc_ast::Expr`].
-pub fn find_format_arg_expr<'hir, 'ast>(
-    start: &'hir Expr<'hir>,
-    target: &'ast FormatArgument,
-) -> Result<&'hir Expr<'hir>, &'ast rustc_ast::Expr> {
+/// Attempt to find the [`rustc_hir::Expr`] that corresponds to the [`FormatArgument`]'s value
+pub fn find_format_arg_expr<'hir>(start: &'hir Expr<'hir>, target: &FormatArgument) -> Option<&'hir Expr<'hir>> {
     let SpanData {
         lo,
         hi,
@@ -449,7 +445,6 @@ pub fn find_format_arg_expr<'hir, 'ast>(
             ControlFlow::Continue(())
         }
     })
-    .ok_or(&target.expr)
 }
 
 /// Span of the `:` and format specifiers

From f7c938aaf0f497bb23e7338156435c3bf261e052 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 9 Aug 2024 23:54:02 +0200
Subject: [PATCH 095/685] miri-script: use --remap-path-prefix to print errors
 relative to the right root

---
 src/tools/miri/.cargo/config.toml          |  9 +++
 src/tools/miri/CONTRIBUTING.md             |  1 +
 src/tools/miri/cargo-miri/miri             |  4 --
 src/tools/miri/cargo-miri/src/util.rs      |  7 +-
 src/tools/miri/miri                        | 13 +++-
 src/tools/miri/miri-script/miri            |  4 --
 src/tools/miri/miri-script/src/commands.rs | 42 ++++++------
 src/tools/miri/miri-script/src/util.rs     | 75 +++++++++++++---------
 src/tools/miri/tests/ui.rs                 | 12 ++--
 9 files changed, 92 insertions(+), 75 deletions(-)
 create mode 100644 src/tools/miri/.cargo/config.toml
 delete mode 100755 src/tools/miri/cargo-miri/miri
 delete mode 100755 src/tools/miri/miri-script/miri

diff --git a/src/tools/miri/.cargo/config.toml b/src/tools/miri/.cargo/config.toml
new file mode 100644
index 0000000000000..42e7c2c48189a
--- /dev/null
+++ b/src/tools/miri/.cargo/config.toml
@@ -0,0 +1,9 @@
+[unstable]
+profile-rustflags = true
+
+# Add back the containing directory of the packages we have to refer to using --manifest-path.
+# Per-package profiles avoid adding this to build dependencies.
+[profile.dev.package."cargo-miri"]
+rustflags = ["--remap-path-prefix", "=cargo-miri"]
+[profile.dev.package."miri-script"]
+rustflags = ["--remap-path-prefix", "=miri-script"]
diff --git a/src/tools/miri/CONTRIBUTING.md b/src/tools/miri/CONTRIBUTING.md
index 9067cbc603261..8aca8d459ddca 100644
--- a/src/tools/miri/CONTRIBUTING.md
+++ b/src/tools/miri/CONTRIBUTING.md
@@ -309,6 +309,7 @@ anyone but Miri itself. They are used to communicate between different Miri
 binaries, and as such worth documenting:
 
 * `CARGO_EXTRA_FLAGS` is understood by `./miri` and passed to all host cargo invocations.
+  It is reserved for CI usage; setting the wrong flags this way can easily confuse the script.
 * `MIRI_BE_RUSTC` can be set to `host` or `target`. It tells the Miri driver to
   actually not interpret the code but compile it like rustc would. With `target`, Miri sets
   some compiler flags to prepare the code for interpretation; with `host`, this is not done.
diff --git a/src/tools/miri/cargo-miri/miri b/src/tools/miri/cargo-miri/miri
deleted file mode 100755
index cf3ad06788ab1..0000000000000
--- a/src/tools/miri/cargo-miri/miri
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/sh
-# RA invokes `./miri cargo ...` for each workspace, so we need to forward that to the main `miri`
-# script. See <https://github.com/rust-analyzer/rust-analyzer/issues/10793>.
-exec "$(dirname "$0")"/../miri "$@"
diff --git a/src/tools/miri/cargo-miri/src/util.rs b/src/tools/miri/cargo-miri/src/util.rs
index 5f2794e2244f4..56f38de8de620 100644
--- a/src/tools/miri/cargo-miri/src/util.rs
+++ b/src/tools/miri/cargo-miri/src/util.rs
@@ -93,12 +93,9 @@ pub fn find_miri() -> PathBuf {
     if let Some(path) = env::var_os("MIRI") {
         return path.into();
     }
+    // Assume it is in the same directory as ourselves.
     let mut path = std::env::current_exe().expect("current executable path invalid");
-    if cfg!(windows) {
-        path.set_file_name("miri.exe");
-    } else {
-        path.set_file_name("miri");
-    }
+    path.set_file_name(format!("miri{}", env::consts::EXE_SUFFIX));
     path
 }
 
diff --git a/src/tools/miri/miri b/src/tools/miri/miri
index 07383bb59ebcc..5d07ad9e249d6 100755
--- a/src/tools/miri/miri
+++ b/src/tools/miri/miri
@@ -1,8 +1,15 @@
 #!/usr/bin/env bash
 set -e
+# We want to call the binary directly, so we need to know where it ends up.
+MIRI_SCRIPT_TARGET_DIR="$(dirname "$0")"/miri-script/target
+# If stdout is not a terminal and we are not on CI, assume that we are being invoked by RA, and use JSON output.
+if ! [ -t 1 ] && [ -z "$CI" ]; then
+  MESSAGE_FORMAT="--message-format=json"
+fi
+# We need a nightly toolchain, for the `profile-rustflags` cargo feature.
+cargo +nightly build $CARGO_EXTRA_FLAGS --manifest-path "$(dirname "$0")"/miri-script/Cargo.toml \
+  -q --target-dir "$MIRI_SCRIPT_TARGET_DIR" $MESSAGE_FORMAT || \
+  ( echo "Failed to build miri-script. Is the 'nightly' toolchain installed?"; exit 1 )
 # Instead of doing just `cargo run --manifest-path .. $@`, we invoke miri-script binary directly. Invoking `cargo run` goes through
 # rustup (that sets it's own environmental variables), which is undesirable.
-MIRI_SCRIPT_TARGET_DIR="$(dirname "$0")"/miri-script/target
-cargo +stable build $CARGO_EXTRA_FLAGS -q --target-dir "$MIRI_SCRIPT_TARGET_DIR" --manifest-path "$(dirname "$0")"/miri-script/Cargo.toml || \
-  ( echo "Failed to build miri-script. Is the 'stable' toolchain installed?"; exit 1 )
 "$MIRI_SCRIPT_TARGET_DIR"/debug/miri-script "$@"
diff --git a/src/tools/miri/miri-script/miri b/src/tools/miri/miri-script/miri
deleted file mode 100755
index cf3ad06788ab1..0000000000000
--- a/src/tools/miri/miri-script/miri
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/sh
-# RA invokes `./miri cargo ...` for each workspace, so we need to forward that to the main `miri`
-# script. See <https://github.com/rust-analyzer/rust-analyzer/issues/10793>.
-exec "$(dirname "$0")"/../miri "$@"
diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index fc205040baf57..705ddaa9eadef 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -22,6 +22,7 @@ const JOSH_FILTER: &str =
 const JOSH_PORT: &str = "42042";
 
 impl MiriEnv {
+    /// Prepares the environment: builds miri and cargo-miri and a sysroot.
     /// Returns the location of the sysroot.
     ///
     /// If the target is None the sysroot will be built for the host machine.
@@ -35,7 +36,6 @@ impl MiriEnv {
             return Ok(miri_sysroot.into());
         }
         let manifest_path = path!(self.miri_dir / "cargo-miri" / "Cargo.toml");
-        let Self { toolchain, cargo_extra_flags, .. } = &self;
 
         // Make sure everything is built. Also Miri itself.
         self.build(path!(self.miri_dir / "Cargo.toml"), &[], quiet)?;
@@ -56,10 +56,12 @@ impl MiriEnv {
             eprintln!();
         }
 
-        let mut cmd = cmd!(self.sh,
-            "cargo +{toolchain} --quiet run {cargo_extra_flags...} --manifest-path {manifest_path} --
-             miri setup --print-sysroot {target_flag...}"
-        );
+        let mut cmd = self
+            .cargo_cmd(&manifest_path, "run")
+            .arg("--quiet")
+            .arg("--")
+            .args(&["miri", "setup", "--print-sysroot"])
+            .args(target_flag);
         cmd.set_quiet(quiet);
         let output = cmd.read()?;
         self.sh.set_var("MIRI_SYSROOT", &output);
@@ -459,7 +461,7 @@ impl Command {
     fn test(bless: bool, mut flags: Vec<String>, target: Option<String>) -> Result<()> {
         let mut e = MiriEnv::new()?;
 
-        // Prepare a sysroot.
+        // Prepare a sysroot. (Also builds cargo-miri, which we need.)
         e.build_miri_sysroot(/* quiet */ false, target.as_deref())?;
 
         // Forward information to test harness.
@@ -504,7 +506,7 @@ impl Command {
         early_flags.push("--edition".into());
         early_flags.push(edition.as_deref().unwrap_or("2021").into());
 
-        // Prepare a sysroot, add it to the flags.
+        // Prepare a sysroot, add it to the flags. (Also builds cargo-miri, which we need.)
         let miri_sysroot = e.build_miri_sysroot(/* quiet */ !verbose, target.as_deref())?;
         early_flags.push("--sysroot".into());
         early_flags.push(miri_sysroot.into());
@@ -513,23 +515,19 @@ impl Command {
         let miri_manifest = path!(e.miri_dir / "Cargo.toml");
         let miri_flags = e.sh.var("MIRIFLAGS").unwrap_or_default();
         let miri_flags = flagsplit(&miri_flags);
-        let toolchain = &e.toolchain;
-        let extra_flags = &e.cargo_extra_flags;
         let quiet_flag = if verbose { None } else { Some("--quiet") };
         // This closure runs the command with the given `seed_flag` added between the MIRIFLAGS and
         // the `flags` given on the command-line.
-        let run_miri = |sh: &Shell, seed_flag: Option<String>| -> Result<()> {
+        let run_miri = |e: &MiriEnv, seed_flag: Option<String>| -> Result<()> {
             // The basic command that executes the Miri driver.
             let mut cmd = if dep {
-                cmd!(
-                    sh,
-                    "cargo +{toolchain} {quiet_flag...} test {extra_flags...} --manifest-path {miri_manifest} --test ui -- --miri-run-dep-mode"
-                )
+                e.cargo_cmd(&miri_manifest, "test")
+                    .args(&["--test", "ui"])
+                    .args(quiet_flag)
+                    .arg("--")
+                    .args(&["--miri-run-dep-mode"])
             } else {
-                cmd!(
-                    sh,
-                    "cargo +{toolchain} {quiet_flag...} run {extra_flags...} --manifest-path {miri_manifest} --"
-                )
+                e.cargo_cmd(&miri_manifest, "run").args(quiet_flag).arg("--")
             };
             cmd.set_quiet(!verbose);
             // Add Miri flags
@@ -545,14 +543,14 @@ impl Command {
         };
         // Run the closure once or many times.
         if let Some(seed_range) = many_seeds {
-            e.run_many_times(seed_range, |sh, seed| {
+            e.run_many_times(seed_range, |e, seed| {
                 eprintln!("Trying seed: {seed}");
-                run_miri(sh, Some(format!("-Zmiri-seed={seed}"))).inspect_err(|_| {
+                run_miri(e, Some(format!("-Zmiri-seed={seed}"))).inspect_err(|_| {
                     eprintln!("FAILING SEED: {seed}");
                 })
             })?;
         } else {
-            run_miri(&e.sh, None)?;
+            run_miri(&e, None)?;
         }
         Ok(())
     }
@@ -579,6 +577,6 @@ impl Command {
             .filter_ok(|item| item.file_type().is_file())
             .map_ok(|item| item.into_path());
 
-        e.format_files(files, &e.toolchain[..], &config_path, &flags)
+        e.format_files(files, &config_path, &flags)
     }
 }
diff --git a/src/tools/miri/miri-script/src/util.rs b/src/tools/miri/miri-script/src/util.rs
index e1b77be192e31..568dc1ec0b38c 100644
--- a/src/tools/miri/miri-script/src/util.rs
+++ b/src/tools/miri/miri-script/src/util.rs
@@ -7,7 +7,7 @@ use std::thread;
 use anyhow::{anyhow, Context, Result};
 use dunce::canonicalize;
 use path_macro::path;
-use xshell::{cmd, Shell};
+use xshell::{cmd, Cmd, Shell};
 
 pub fn miri_dir() -> std::io::Result<PathBuf> {
     const MIRI_SCRIPT_ROOT_DIR: &str = env!("CARGO_MANIFEST_DIR");
@@ -28,13 +28,14 @@ pub fn flagsplit(flags: &str) -> Vec<String> {
 }
 
 /// Some extra state we track for building Miri, such as the right RUSTFLAGS.
+#[derive(Clone)]
 pub struct MiriEnv {
     /// miri_dir is the root of the miri repository checkout we are working in.
     pub miri_dir: PathBuf,
     /// active_toolchain is passed as `+toolchain` argument to cargo/rustc invocations.
     pub toolchain: String,
     /// Extra flags to pass to cargo.
-    pub cargo_extra_flags: Vec<String>,
+    cargo_extra_flags: Vec<String>,
     /// The rustc sysroot
     pub sysroot: PathBuf,
     /// The shell we use.
@@ -54,15 +55,14 @@ impl MiriEnv {
 
         // Determine some toolchain properties
         if !libdir.exists() {
-            println!("Something went wrong determining the library dir.");
-            println!("I got {} but that does not exist.", libdir.display());
-            println!("Please report a bug at https://github.com/rust-lang/miri/issues.");
+            eprintln!("Something went wrong determining the library dir.");
+            eprintln!("I got {} but that does not exist.", libdir.display());
+            eprintln!("Please report a bug at https://github.com/rust-lang/miri/issues.");
             std::process::exit(2);
         }
-        // Share target dir between `miri` and `cargo-miri`.
-        let target_dir = std::env::var_os("CARGO_TARGET_DIR")
-            .unwrap_or_else(|| path!(miri_dir / "target").into());
-        sh.set_var("CARGO_TARGET_DIR", target_dir);
+
+        // Hard-code the target dir, since we rely on all binaries ending up in the same spot.
+        sh.set_var("CARGO_TARGET_DIR", path!(miri_dir / "target"));
 
         // We configure dev builds to not be unusably slow.
         let devel_opt_level =
@@ -91,10 +91,26 @@ impl MiriEnv {
         // Get extra flags for cargo.
         let cargo_extra_flags = std::env::var("CARGO_EXTRA_FLAGS").unwrap_or_default();
         let cargo_extra_flags = flagsplit(&cargo_extra_flags);
+        if cargo_extra_flags.iter().any(|a| a == "--release" || a.starts_with("--profile")) {
+            // This makes binaries end up in different paths, let's not do that.
+            eprintln!(
+                "Passing `--release` or `--profile` in `CARGO_EXTRA_FLAGS` will totally confuse miri-script, please don't do that."
+            );
+            std::process::exit(1);
+        }
 
         Ok(MiriEnv { miri_dir, toolchain, sh, sysroot, cargo_extra_flags })
     }
 
+    pub fn cargo_cmd(&self, manifest_path: impl AsRef<OsStr>, cmd: &str) -> Cmd<'_> {
+        let MiriEnv { toolchain, cargo_extra_flags, .. } = self;
+        let manifest_path = Path::new(manifest_path.as_ref());
+        cmd!(
+            self.sh,
+            "cargo +{toolchain} {cmd} {cargo_extra_flags...} --manifest-path {manifest_path}"
+        )
+    }
+
     pub fn install_to_sysroot(
         &self,
         path: impl AsRef<OsStr>,
@@ -102,6 +118,7 @@ impl MiriEnv {
     ) -> Result<()> {
         let MiriEnv { sysroot, toolchain, cargo_extra_flags, .. } = self;
         // Install binaries to the miri toolchain's `sysroot` so they do not interact with other toolchains.
+        // (Not using `cargo_cmd` as `install` is special and doesn't use `--manifest-path`.)
         cmd!(self.sh, "cargo +{toolchain} install {cargo_extra_flags...} --path {path} --force --root {sysroot} {args...}").run()?;
         Ok(())
     }
@@ -112,40 +129,34 @@ impl MiriEnv {
         args: &[String],
         quiet: bool,
     ) -> Result<()> {
-        let MiriEnv { toolchain, cargo_extra_flags, .. } = self;
         let quiet_flag = if quiet { Some("--quiet") } else { None };
         // We build the tests as well, (a) to avoid having rebuilds when building the tests later
         // and (b) to have more parallelism during the build of Miri and its tests.
-        let mut cmd = cmd!(
-            self.sh,
-            "cargo +{toolchain} build --bins --tests {cargo_extra_flags...} --manifest-path {manifest_path} {quiet_flag...} {args...}"
-        );
+        // This means `./miri run` without `--dep` will build Miri twice (for the sysroot with
+        // dev-dependencies, and then for running without dev-dependencies), but the way more common
+        // `./miri test` will avoid building Miri twice.
+        let mut cmd = self
+            .cargo_cmd(manifest_path, "build")
+            .args(&["--bins", "--tests"])
+            .args(quiet_flag)
+            .args(args);
         cmd.set_quiet(quiet);
         cmd.run()?;
         Ok(())
     }
 
     pub fn check(&self, manifest_path: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
-        let MiriEnv { toolchain, cargo_extra_flags, .. } = self;
-        cmd!(self.sh, "cargo +{toolchain} check {cargo_extra_flags...} --manifest-path {manifest_path} --all-targets {args...}")
-            .run()?;
+        self.cargo_cmd(manifest_path, "check").arg("--all-targets").args(args).run()?;
         Ok(())
     }
 
     pub fn clippy(&self, manifest_path: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
-        let MiriEnv { toolchain, cargo_extra_flags, .. } = self;
-        cmd!(self.sh, "cargo +{toolchain} clippy {cargo_extra_flags...} --manifest-path {manifest_path} --all-targets {args...}")
-            .run()?;
+        self.cargo_cmd(manifest_path, "clippy").arg("--all-targets").args(args).run()?;
         Ok(())
     }
 
     pub fn test(&self, manifest_path: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
-        let MiriEnv { toolchain, cargo_extra_flags, .. } = self;
-        cmd!(
-            self.sh,
-            "cargo +{toolchain} test {cargo_extra_flags...} --manifest-path {manifest_path} {args...}"
-        )
-        .run()?;
+        self.cargo_cmd(manifest_path, "test").args(args).run()?;
         Ok(())
     }
 
@@ -155,7 +166,6 @@ impl MiriEnv {
     pub fn format_files(
         &self,
         files: impl Iterator<Item = Result<PathBuf, walkdir::Error>>,
-        toolchain: &str,
         config_path: &Path,
         flags: &[String],
     ) -> anyhow::Result<()> {
@@ -166,6 +176,7 @@ impl MiriEnv {
         // Format in batches as not all our files fit into Windows' command argument limit.
         for batch in &files.chunks(256) {
             // Build base command.
+            let toolchain = &self.toolchain;
             let mut cmd = cmd!(
                 self.sh,
                 "rustfmt +{toolchain} --edition=2021 --config-path {config_path} --unstable-features --skip-children {flags...}"
@@ -197,7 +208,7 @@ impl MiriEnv {
     pub fn run_many_times(
         &self,
         range: Range<u32>,
-        run: impl Fn(&Shell, u32) -> Result<()> + Sync,
+        run: impl Fn(&Self, u32) -> Result<()> + Sync,
     ) -> Result<()> {
         // `next` is atomic so threads can concurrently fetch their next value to run.
         let next = AtomicU32::new(range.start);
@@ -207,10 +218,10 @@ impl MiriEnv {
             let mut handles = Vec::new();
             // Spawn one worker per core.
             for _ in 0..thread::available_parallelism()?.get() {
-                // Create a copy of the shell for this thread.
-                let local_shell = self.sh.clone();
+                // Create a copy of the environment for this thread.
+                let local_miri = self.clone();
                 let handle = s.spawn(|| -> Result<()> {
-                    let local_shell = local_shell; // move the copy into this thread.
+                    let local_miri = local_miri; // move the copy into this thread.
                     // Each worker thread keeps asking for numbers until we're all done.
                     loop {
                         let cur = next.fetch_add(1, Ordering::Relaxed);
@@ -219,7 +230,7 @@ impl MiriEnv {
                             break;
                         }
                         // Run the command with this seed.
-                        run(&local_shell, cur).inspect_err(|_| {
+                        run(&local_miri, cur).inspect_err(|_| {
                             // If we failed, tell everyone about this.
                             failed.store(true, Ordering::Relaxed);
                         })?;
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index 95f8b05410293..9cbcf6e42a795 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -13,7 +13,7 @@ use ui_test::{
 };
 
 fn miri_path() -> PathBuf {
-    PathBuf::from(option_env!("MIRI").unwrap_or(env!("CARGO_BIN_EXE_miri")))
+    PathBuf::from(env::var("MIRI").unwrap_or_else(|_| env!("CARGO_BIN_EXE_miri").into()))
 }
 
 fn get_host() -> String {
@@ -29,7 +29,7 @@ pub fn flagsplit(flags: &str) -> Vec<String> {
 
 // Build the shared object file for testing native function calls.
 fn build_native_lib() -> PathBuf {
-    let cc = option_env!("CC").unwrap_or("cc");
+    let cc = env::var("CC").unwrap_or_else(|_| "cc".into());
     // Target directory that we can write to.
     let so_target_dir =
         Path::new(&env::var_os("CARGO_TARGET_DIR").unwrap()).join("miri-native-lib");
@@ -84,9 +84,11 @@ fn miri_config(target: &str, path: &str, mode: Mode, with_dependencies: bool) ->
     if with_dependencies {
         // Set the `cargo-miri` binary, which we expect to be in the same folder as the `miri` binary.
         // (It's a separate crate, so we don't get an env var from cargo.)
-        let mut prog = miri_path();
-        prog.set_file_name("cargo-miri");
-        config.dependency_builder.program = prog;
+        config.dependency_builder.program = {
+            let mut prog = miri_path();
+            prog.set_file_name(format!("cargo-miri{}", env::consts::EXE_SUFFIX));
+            prog
+        };
         let builder_args = ["miri", "run"]; // There is no `cargo miri build` so we just use `cargo miri run`.
         config.dependency_builder.args = builder_args.into_iter().map(Into::into).collect();
         config.dependencies_crate_manifest_path =

From d2e0970bde2c383ba75a44432db198d9a99e3808 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 9 Aug 2024 23:59:40 +0200
Subject: [PATCH 096/685] update suggested RA config; the './miri cargo'
 command is not needed any more

---
 src/tools/miri/CONTRIBUTING.md             |  8 ++++----
 src/tools/miri/miri-script/src/commands.rs | 13 +------------
 src/tools/miri/miri-script/src/main.rs     |  4 ----
 src/tools/miri/miri-script/src/util.rs     |  2 +-
 4 files changed, 6 insertions(+), 21 deletions(-)

diff --git a/src/tools/miri/CONTRIBUTING.md b/src/tools/miri/CONTRIBUTING.md
index 8aca8d459ddca..1c76354eaeea4 100644
--- a/src/tools/miri/CONTRIBUTING.md
+++ b/src/tools/miri/CONTRIBUTING.md
@@ -173,24 +173,24 @@ to `.vscode/settings.json` in your local Miri clone:
         "cargo-miri/Cargo.toml",
         "miri-script/Cargo.toml",
     ],
+    "rust-analyzer.check.invocationLocation": "root",
+    "rust-analyzer.check.invocationStrategy": "once",
     "rust-analyzer.check.overrideCommand": [
         "env",
         "MIRI_AUTO_OPS=no",
         "./miri",
-        "cargo",
         "clippy", // make this `check` when working with a locally built rustc
         "--message-format=json",
-        "--all-targets",
     ],
     // Contrary to what the name suggests, this also affects proc macros.
+    "rust-analyzer.cargo.buildScripts.invocationLocation": "root",
+    "rust-analyzer.cargo.buildScripts.invocationStrategy": "once",
     "rust-analyzer.cargo.buildScripts.overrideCommand": [
         "env",
         "MIRI_AUTO_OPS=no",
         "./miri",
-        "cargo",
         "check",
         "--message-format=json",
-        "--all-targets",
     ],
 }
 ```
diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index 705ddaa9eadef..d4e86b05fe414 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -153,8 +153,7 @@ impl Command {
             | Command::Test { .. }
             | Command::Run { .. }
             | Command::Fmt { .. }
-            | Command::Clippy { .. }
-            | Command::Cargo { .. } => Self::auto_actions()?,
+            | Command::Clippy { .. } => Self::auto_actions()?,
             | Command::Toolchain { .. }
             | Command::Bench { .. }
             | Command::RustcPull { .. }
@@ -170,7 +169,6 @@ impl Command {
                 Self::run(dep, verbose, many_seeds, target, edition, flags),
             Command::Fmt { flags } => Self::fmt(flags),
             Command::Clippy { flags } => Self::clippy(flags),
-            Command::Cargo { flags } => Self::cargo(flags),
             Command::Bench { target, benches } => Self::bench(target, benches),
             Command::Toolchain { flags } => Self::toolchain(flags),
             Command::RustcPull { commit } => Self::rustc_pull(commit.clone()),
@@ -449,15 +447,6 @@ impl Command {
         Ok(())
     }
 
-    fn cargo(flags: Vec<String>) -> Result<()> {
-        let e = MiriEnv::new()?;
-        let toolchain = &e.toolchain;
-        // We carefully kept the working dir intact, so this will run cargo *on the workspace in the
-        // current working dir*, not on the main Miri workspace. That is exactly what RA needs.
-        cmd!(e.sh, "cargo +{toolchain} {flags...}").run()?;
-        Ok(())
-    }
-
     fn test(bless: bool, mut flags: Vec<String>, target: Option<String>) -> Result<()> {
         let mut e = MiriEnv::new()?;
 
diff --git a/src/tools/miri/miri-script/src/main.rs b/src/tools/miri/miri-script/src/main.rs
index c4f0d808d93e1..1e181cad0840c 100644
--- a/src/tools/miri/miri-script/src/main.rs
+++ b/src/tools/miri/miri-script/src/main.rs
@@ -58,9 +58,6 @@ pub enum Command {
         /// Flags that are passed through to `cargo clippy`.
         flags: Vec<String>,
     },
-    /// Runs just `cargo <flags>` with the Miri-specific environment variables.
-    /// Mainly meant to be invoked by rust-analyzer.
-    Cargo { flags: Vec<String> },
     /// Runs the benchmarks from bench-cargo-miri in hyperfine. hyperfine needs to be installed.
     Bench {
         target: Option<String>,
@@ -205,7 +202,6 @@ fn main() -> Result<()> {
         }
         Some("fmt") => Command::Fmt { flags: args.remainder() },
         Some("clippy") => Command::Clippy { flags: args.remainder() },
-        Some("cargo") => Command::Cargo { flags: args.remainder() },
         Some("install") => Command::Install { flags: args.remainder() },
         Some("bench") => {
             let mut target = None;
diff --git a/src/tools/miri/miri-script/src/util.rs b/src/tools/miri/miri-script/src/util.rs
index 568dc1ec0b38c..df7c206a5ba8f 100644
--- a/src/tools/miri/miri-script/src/util.rs
+++ b/src/tools/miri/miri-script/src/util.rs
@@ -33,7 +33,7 @@ pub struct MiriEnv {
     /// miri_dir is the root of the miri repository checkout we are working in.
     pub miri_dir: PathBuf,
     /// active_toolchain is passed as `+toolchain` argument to cargo/rustc invocations.
-    pub toolchain: String,
+    toolchain: String,
     /// Extra flags to pass to cargo.
     cargo_extra_flags: Vec<String>,
     /// The rustc sysroot

From 118be4182cdf8049baf86da7c161c2ba6a8dcf7e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 10 Aug 2024 00:07:31 +0200
Subject: [PATCH 097/685] add './miri doc' command

---
 src/tools/miri/.github/workflows/ci.yml    | 2 +-
 src/tools/miri/miri-script/src/commands.rs | 9 +++++++++
 src/tools/miri/miri-script/src/main.rs     | 6 ++++++
 src/tools/miri/miri-script/src/util.rs     | 5 +++++
 4 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/.github/workflows/ci.yml b/src/tools/miri/.github/workflows/ci.yml
index fc4e484fa3898..efdeaeffe1592 100644
--- a/src/tools/miri/.github/workflows/ci.yml
+++ b/src/tools/miri/.github/workflows/ci.yml
@@ -60,7 +60,7 @@ jobs:
       - name: clippy (all features)
         run: ./miri clippy --all-features -- -D warnings
       - name: rustdoc
-        run: RUSTDOCFLAGS="-Dwarnings" ./miri cargo doc --document-private-items
+        run: RUSTDOCFLAGS="-Dwarnings" ./miri doc --document-private-items
 
   # These jobs doesn't actually test anything, but they're only used to tell
   # bors the build completed, as there is no practical way to detect when a
diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index d4e86b05fe414..d29e3b1788231 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -153,6 +153,7 @@ impl Command {
             | Command::Test { .. }
             | Command::Run { .. }
             | Command::Fmt { .. }
+            | Command::Doc { .. }
             | Command::Clippy { .. } => Self::auto_actions()?,
             | Command::Toolchain { .. }
             | Command::Bench { .. }
@@ -167,6 +168,7 @@ impl Command {
             Command::Test { bless, flags, target } => Self::test(bless, flags, target),
             Command::Run { dep, verbose, many_seeds, target, edition, flags } =>
                 Self::run(dep, verbose, many_seeds, target, edition, flags),
+            Command::Doc { flags } => Self::doc(flags),
             Command::Fmt { flags } => Self::fmt(flags),
             Command::Clippy { flags } => Self::clippy(flags),
             Command::Bench { target, benches } => Self::bench(target, benches),
@@ -439,6 +441,13 @@ impl Command {
         Ok(())
     }
 
+    fn doc(flags: Vec<String>) -> Result<()> {
+        let e = MiriEnv::new()?;
+        e.doc(path!(e.miri_dir / "Cargo.toml"), &flags)?;
+        e.doc(path!(e.miri_dir / "cargo-miri" / "Cargo.toml"), &flags)?;
+        Ok(())
+    }
+
     fn clippy(flags: Vec<String>) -> Result<()> {
         let e = MiriEnv::new()?;
         e.clippy(path!(e.miri_dir / "Cargo.toml"), &flags)?;
diff --git a/src/tools/miri/miri-script/src/main.rs b/src/tools/miri/miri-script/src/main.rs
index 1e181cad0840c..9214823710709 100644
--- a/src/tools/miri/miri-script/src/main.rs
+++ b/src/tools/miri/miri-script/src/main.rs
@@ -48,6 +48,11 @@ pub enum Command {
         /// Flags that are passed through to `miri`.
         flags: Vec<String>,
     },
+    /// Build documentation
+    Doc {
+        /// Flags that are passed through to `cargo doc`.
+        flags: Vec<String>,
+    },
     /// Format all sources and tests.
     Fmt {
         /// Flags that are passed through to `rustfmt`.
@@ -148,6 +153,7 @@ fn main() -> Result<()> {
     let command = match args.next_raw().as_deref() {
         Some("build") => Command::Build { flags: args.remainder() },
         Some("check") => Command::Check { flags: args.remainder() },
+        Some("doc") => Command::Doc { flags: args.remainder() },
         Some("test") => {
             let mut target = None;
             let mut bless = false;
diff --git a/src/tools/miri/miri-script/src/util.rs b/src/tools/miri/miri-script/src/util.rs
index df7c206a5ba8f..8fcf18e4a3875 100644
--- a/src/tools/miri/miri-script/src/util.rs
+++ b/src/tools/miri/miri-script/src/util.rs
@@ -150,6 +150,11 @@ impl MiriEnv {
         Ok(())
     }
 
+    pub fn doc(&self, manifest_path: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
+        self.cargo_cmd(manifest_path, "doc").args(args).run()?;
+        Ok(())
+    }
+
     pub fn clippy(&self, manifest_path: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
         self.cargo_cmd(manifest_path, "clippy").arg("--all-targets").args(args).run()?;
         Ok(())

From 8197f07e0ec61b2a7c9d53ca8047ecc35d09c378 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 10 Aug 2024 12:57:52 +0200
Subject: [PATCH 098/685] miri-script: pass around the relative crate dir, not
 the absolute path to the toml file

---
 src/tools/miri/miri-script/src/commands.rs | 32 ++++++++++------------
 src/tools/miri/miri-script/src/util.rs     | 30 +++++++++-----------
 2 files changed, 28 insertions(+), 34 deletions(-)

diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index d29e3b1788231..d72c1eb62046d 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -35,11 +35,10 @@ impl MiriEnv {
             // Sysroot already set, use that.
             return Ok(miri_sysroot.into());
         }
-        let manifest_path = path!(self.miri_dir / "cargo-miri" / "Cargo.toml");
 
         // Make sure everything is built. Also Miri itself.
-        self.build(path!(self.miri_dir / "Cargo.toml"), &[], quiet)?;
-        self.build(&manifest_path, &[], quiet)?;
+        self.build(".", &[], quiet)?;
+        self.build("cargo-miri", &[], quiet)?;
 
         let target_flag = if let Some(target) = &target {
             vec![OsStr::new("--target"), target.as_ref()]
@@ -57,7 +56,7 @@ impl MiriEnv {
         }
 
         let mut cmd = self
-            .cargo_cmd(&manifest_path, "run")
+            .cargo_cmd("cargo-miri", "run")
             .arg("--quiet")
             .arg("--")
             .args(&["miri", "setup", "--print-sysroot"])
@@ -429,30 +428,30 @@ impl Command {
 
     fn build(flags: Vec<String>) -> Result<()> {
         let e = MiriEnv::new()?;
-        e.build(path!(e.miri_dir / "Cargo.toml"), &flags, /* quiet */ false)?;
-        e.build(path!(e.miri_dir / "cargo-miri" / "Cargo.toml"), &flags, /* quiet */ false)?;
+        e.build(".", &flags, /* quiet */ false)?;
+        e.build("cargo-miri", &flags, /* quiet */ false)?;
         Ok(())
     }
 
     fn check(flags: Vec<String>) -> Result<()> {
         let e = MiriEnv::new()?;
-        e.check(path!(e.miri_dir / "Cargo.toml"), &flags)?;
-        e.check(path!(e.miri_dir / "cargo-miri" / "Cargo.toml"), &flags)?;
+        e.check(".", &flags)?;
+        e.check("cargo-miri", &flags)?;
         Ok(())
     }
 
     fn doc(flags: Vec<String>) -> Result<()> {
         let e = MiriEnv::new()?;
-        e.doc(path!(e.miri_dir / "Cargo.toml"), &flags)?;
-        e.doc(path!(e.miri_dir / "cargo-miri" / "Cargo.toml"), &flags)?;
+        e.doc(".", &flags)?;
+        e.doc("cargo-miri", &flags)?;
         Ok(())
     }
 
     fn clippy(flags: Vec<String>) -> Result<()> {
         let e = MiriEnv::new()?;
-        e.clippy(path!(e.miri_dir / "Cargo.toml"), &flags)?;
-        e.clippy(path!(e.miri_dir / "cargo-miri" / "Cargo.toml"), &flags)?;
-        e.clippy(path!(e.miri_dir / "miri-script" / "Cargo.toml"), &flags)?;
+        e.clippy(".", &flags)?;
+        e.clippy("cargo-miri", &flags)?;
+        e.clippy("miri-script", &flags)?;
         Ok(())
     }
 
@@ -476,7 +475,7 @@ impl Command {
 
         // Then test, and let caller control flags.
         // Only in root project as `cargo-miri` has no tests.
-        e.test(path!(e.miri_dir / "Cargo.toml"), &flags)?;
+        e.test(".", &flags)?;
         Ok(())
     }
 
@@ -510,7 +509,6 @@ impl Command {
         early_flags.push(miri_sysroot.into());
 
         // Compute everything needed to run the actual command. Also add MIRIFLAGS.
-        let miri_manifest = path!(e.miri_dir / "Cargo.toml");
         let miri_flags = e.sh.var("MIRIFLAGS").unwrap_or_default();
         let miri_flags = flagsplit(&miri_flags);
         let quiet_flag = if verbose { None } else { Some("--quiet") };
@@ -519,13 +517,13 @@ impl Command {
         let run_miri = |e: &MiriEnv, seed_flag: Option<String>| -> Result<()> {
             // The basic command that executes the Miri driver.
             let mut cmd = if dep {
-                e.cargo_cmd(&miri_manifest, "test")
+                e.cargo_cmd(".", "test")
                     .args(&["--test", "ui"])
                     .args(quiet_flag)
                     .arg("--")
                     .args(&["--miri-run-dep-mode"])
             } else {
-                e.cargo_cmd(&miri_manifest, "run").args(quiet_flag).arg("--")
+                e.cargo_cmd(".", "run").args(quiet_flag).arg("--")
             };
             cmd.set_quiet(!verbose);
             // Add Miri flags
diff --git a/src/tools/miri/miri-script/src/util.rs b/src/tools/miri/miri-script/src/util.rs
index 8fcf18e4a3875..35c604b407e1e 100644
--- a/src/tools/miri/miri-script/src/util.rs
+++ b/src/tools/miri/miri-script/src/util.rs
@@ -102,9 +102,9 @@ impl MiriEnv {
         Ok(MiriEnv { miri_dir, toolchain, sh, sysroot, cargo_extra_flags })
     }
 
-    pub fn cargo_cmd(&self, manifest_path: impl AsRef<OsStr>, cmd: &str) -> Cmd<'_> {
+    pub fn cargo_cmd(&self, crate_dir: impl AsRef<OsStr>, cmd: &str) -> Cmd<'_> {
         let MiriEnv { toolchain, cargo_extra_flags, .. } = self;
-        let manifest_path = Path::new(manifest_path.as_ref());
+        let manifest_path = path!(self.miri_dir / crate_dir.as_ref() / "Cargo.toml");
         cmd!(
             self.sh,
             "cargo +{toolchain} {cmd} {cargo_extra_flags...} --manifest-path {manifest_path}"
@@ -117,18 +117,14 @@ impl MiriEnv {
         args: impl IntoIterator<Item = impl AsRef<OsStr>>,
     ) -> Result<()> {
         let MiriEnv { sysroot, toolchain, cargo_extra_flags, .. } = self;
+        let path = path!(self.miri_dir / path.as_ref());
         // Install binaries to the miri toolchain's `sysroot` so they do not interact with other toolchains.
         // (Not using `cargo_cmd` as `install` is special and doesn't use `--manifest-path`.)
         cmd!(self.sh, "cargo +{toolchain} install {cargo_extra_flags...} --path {path} --force --root {sysroot} {args...}").run()?;
         Ok(())
     }
 
-    pub fn build(
-        &self,
-        manifest_path: impl AsRef<OsStr>,
-        args: &[String],
-        quiet: bool,
-    ) -> Result<()> {
+    pub fn build(&self, crate_dir: impl AsRef<OsStr>, args: &[String], quiet: bool) -> Result<()> {
         let quiet_flag = if quiet { Some("--quiet") } else { None };
         // We build the tests as well, (a) to avoid having rebuilds when building the tests later
         // and (b) to have more parallelism during the build of Miri and its tests.
@@ -136,7 +132,7 @@ impl MiriEnv {
         // dev-dependencies, and then for running without dev-dependencies), but the way more common
         // `./miri test` will avoid building Miri twice.
         let mut cmd = self
-            .cargo_cmd(manifest_path, "build")
+            .cargo_cmd(crate_dir, "build")
             .args(&["--bins", "--tests"])
             .args(quiet_flag)
             .args(args);
@@ -145,23 +141,23 @@ impl MiriEnv {
         Ok(())
     }
 
-    pub fn check(&self, manifest_path: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
-        self.cargo_cmd(manifest_path, "check").arg("--all-targets").args(args).run()?;
+    pub fn check(&self, crate_dir: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
+        self.cargo_cmd(crate_dir, "check").arg("--all-targets").args(args).run()?;
         Ok(())
     }
 
-    pub fn doc(&self, manifest_path: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
-        self.cargo_cmd(manifest_path, "doc").args(args).run()?;
+    pub fn doc(&self, crate_dir: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
+        self.cargo_cmd(crate_dir, "doc").args(args).run()?;
         Ok(())
     }
 
-    pub fn clippy(&self, manifest_path: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
-        self.cargo_cmd(manifest_path, "clippy").arg("--all-targets").args(args).run()?;
+    pub fn clippy(&self, crate_dir: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
+        self.cargo_cmd(crate_dir, "clippy").arg("--all-targets").args(args).run()?;
         Ok(())
     }
 
-    pub fn test(&self, manifest_path: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
-        self.cargo_cmd(manifest_path, "test").args(args).run()?;
+    pub fn test(&self, crate_dir: impl AsRef<OsStr>, args: &[String]) -> Result<()> {
+        self.cargo_cmd(crate_dir, "test").args(args).run()?;
         Ok(())
     }
 

From feab3240857e568b25d3950b6e5697bb4b0b7e6e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 10 Aug 2024 13:06:24 +0200
Subject: [PATCH 099/685] CI: we now need the nightly toolchain as well

---
 src/tools/miri/.github/workflows/setup/action.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/tools/miri/.github/workflows/setup/action.yml b/src/tools/miri/.github/workflows/setup/action.yml
index 8f54b5b8d81a9..bf5749a7b17eb 100644
--- a/src/tools/miri/.github/workflows/setup/action.yml
+++ b/src/tools/miri/.github/workflows/setup/action.yml
@@ -35,6 +35,10 @@ runs:
         run: cargo install -f rustup-toolchain-install-master hyperfine
         shell: bash
 
+      - name: Install nightly toolchain
+        run: rustup toolchain install nightly --profile minimal
+        shell: bash
+
       - name: Install "master" toolchain
         run: |
           if [[ ${{ github.event_name }} == 'schedule' ]]; then

From 1156d585d7bf41fb2f6fa2063a08fb46b6bc87b3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 10 Aug 2024 14:00:00 +0200
Subject: [PATCH 100/685] josh: wait until the socket is ready

---
 src/tools/miri/miri-script/src/commands.rs | 39 +++++++++++-----------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index fc205040baf57..8767d6970f001 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -1,12 +1,12 @@
 use std::env;
 use std::ffi::{OsStr, OsString};
 use std::io::Write;
+use std::net;
 use std::ops::Not;
 use std::ops::Range;
 use std::path::PathBuf;
 use std::process;
-use std::thread;
-use std::time;
+use std::time::Duration;
 
 use anyhow::{anyhow, bail, Context, Result};
 use path_macro::path;
@@ -19,7 +19,7 @@ use crate::Command;
 /// Used for rustc syncs.
 const JOSH_FILTER: &str =
     ":rev(75dd959a3a40eb5b4574f8d2e23aa6efbeb33573:prefix=src/tools/miri):/src/tools/miri";
-const JOSH_PORT: &str = "42042";
+const JOSH_PORT: u16 = 42042;
 
 impl MiriEnv {
     /// Returns the location of the sysroot.
@@ -105,13 +105,11 @@ impl Command {
         let mut cmd = process::Command::new("josh-proxy");
         cmd.arg("--local").arg(local_dir);
         cmd.arg("--remote").arg("https://github.com");
-        cmd.arg("--port").arg(JOSH_PORT);
+        cmd.arg("--port").arg(JOSH_PORT.to_string());
         cmd.arg("--no-background");
         cmd.stdout(process::Stdio::null());
         cmd.stderr(process::Stdio::null());
         let josh = cmd.spawn().context("failed to start josh-proxy, make sure it is installed")?;
-        // Give it some time so hopefully the port is open. (100ms was not enough.)
-        thread::sleep(time::Duration::from_millis(200));
 
         // Create a wrapper that stops it on drop.
         struct Josh(process::Child);
@@ -125,7 +123,7 @@ impl Command {
                         .output()
                         .expect("failed to SIGINT josh-proxy");
                     // Sadly there is no "wait with timeout"... so we just give it some time to finish.
-                    thread::sleep(time::Duration::from_millis(100));
+                    std::thread::sleep(Duration::from_millis(100));
                     // Now hopefully it is gone.
                     if self.0.try_wait().expect("failed to wait for josh-proxy").is_some() {
                         return;
@@ -139,6 +137,14 @@ impl Command {
             }
         }
 
+        // Wait until the port is open.
+        let josh_ready = net::TcpStream::connect_timeout(
+            &net::SocketAddr::from(([127, 0, 0, 1], JOSH_PORT)),
+            Duration::from_secs(1),
+        )
+        .context("failed to connect to josh-proxy")?;
+        drop(josh_ready);
+
         Ok(Josh(josh))
     }
 
@@ -236,6 +242,8 @@ impl Command {
         }
         // Make sure josh is running.
         let josh = Self::start_josh()?;
+        let josh_url =
+            format!("http://localhost:{JOSH_PORT}/rust-lang/rust.git@{commit}{JOSH_FILTER}.git");
 
         // Update rust-version file. As a separate commit, since making it part of
         // the merge has confused the heck out of josh in the past.
@@ -250,7 +258,7 @@ impl Command {
             .context("FAILED to commit rust-version file, something went wrong")?;
 
         // Fetch given rustc commit.
-        cmd!(sh, "git fetch http://localhost:{JOSH_PORT}/rust-lang/rust.git@{commit}{JOSH_FILTER}.git")
+        cmd!(sh, "git fetch {josh_url}")
             .run()
             .inspect_err(|_| {
                 // Try to un-do the previous `git commit`, to leave the repo in the state we found it.
@@ -294,6 +302,8 @@ impl Command {
         }
         // Make sure josh is running.
         let josh = Self::start_josh()?;
+        let josh_url =
+            format!("http://localhost:{JOSH_PORT}/{github_user}/rust.git{JOSH_FILTER}.git");
 
         // Find a repo we can do our preparation in.
         if let Ok(rustc_git) = env::var("RUSTC_GIT") {
@@ -338,20 +348,11 @@ impl Command {
         // Do the actual push.
         sh.change_dir(miri_dir()?);
         println!("Pushing miri changes...");
-        cmd!(
-            sh,
-            "git push http://localhost:{JOSH_PORT}/{github_user}/rust.git{JOSH_FILTER}.git HEAD:{branch}"
-        )
-        .run()?;
+        cmd!(sh, "git push {josh_url} HEAD:{branch}").run()?;
         println!();
 
         // Do a round-trip check to make sure the push worked as expected.
-        cmd!(
-            sh,
-            "git fetch http://localhost:{JOSH_PORT}/{github_user}/rust.git{JOSH_FILTER}.git {branch}"
-        )
-        .ignore_stderr()
-        .read()?;
+        cmd!(sh, "git fetch {josh_url} {branch}").ignore_stderr().read()?;
         let head = cmd!(sh, "git rev-parse HEAD").read()?;
         let fetch_head = cmd!(sh, "git rev-parse FETCH_HEAD").read()?;
         if head != fetch_head {

From 10ef6661bc6fe9430cc199a30d6c8a9c428c75f0 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sat, 10 Aug 2024 20:15:52 +0300
Subject: [PATCH 101/685] Add more test cases for untranslatable_diagnostic
 lint

---
 .../ui-fulldeps/internal-lints/diagnostics.rs |  7 +++++
 .../internal-lints/diagnostics.stderr         | 28 ++++++++++++++++++-
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/tests/ui-fulldeps/internal-lints/diagnostics.rs b/tests/ui-fulldeps/internal-lints/diagnostics.rs
index 5fcff74064a6b..442f9d72c3f19 100644
--- a/tests/ui-fulldeps/internal-lints/diagnostics.rs
+++ b/tests/ui-fulldeps/internal-lints/diagnostics.rs
@@ -117,4 +117,11 @@ pub fn skipped_because_of_annotation<'a>(dcx: DiagCtxtHandle<'a>) {
 fn f(_x: impl Into<DiagMessage>, _y: impl Into<SubdiagMessage>) {}
 fn g() {
     f(crate::fluent_generated::no_crate_example, crate::fluent_generated::no_crate_example);
+    f("untranslatable diagnostic", crate::fluent_generated::no_crate_example);
+    //~^ ERROR diagnostics should be created using translatable messages
+    f(crate::fluent_generated::no_crate_example, "untranslatable diagnostic");
+    //~^ ERROR diagnostics should be created using translatable messages
+    f("untranslatable diagnostic", "untranslatable diagnostic");
+    //~^ ERROR diagnostics should be created using translatable messages
+    //~^^ ERROR diagnostics should be created using translatable messages
 }
diff --git a/tests/ui-fulldeps/internal-lints/diagnostics.stderr b/tests/ui-fulldeps/internal-lints/diagnostics.stderr
index 669324ce5d4c1..c23da981ea2ec 100644
--- a/tests/ui-fulldeps/internal-lints/diagnostics.stderr
+++ b/tests/ui-fulldeps/internal-lints/diagnostics.stderr
@@ -46,5 +46,31 @@ error: diagnostics should be created using translatable messages
 LL |     let _diag = dcx.struct_err("untranslatable diagnostic");
    |                     ^^^^^^^^^^
 
-error: aborting due to 6 previous errors
+error: diagnostics should be created using translatable messages
+  --> $DIR/diagnostics.rs:120:5
+   |
+LL |     f("untranslatable diagnostic", crate::fluent_generated::no_crate_example);
+   |     ^
+
+error: diagnostics should be created using translatable messages
+  --> $DIR/diagnostics.rs:122:5
+   |
+LL |     f(crate::fluent_generated::no_crate_example, "untranslatable diagnostic");
+   |     ^
+
+error: diagnostics should be created using translatable messages
+  --> $DIR/diagnostics.rs:124:5
+   |
+LL |     f("untranslatable diagnostic", "untranslatable diagnostic");
+   |     ^
+
+error: diagnostics should be created using translatable messages
+  --> $DIR/diagnostics.rs:124:5
+   |
+LL |     f("untranslatable diagnostic", "untranslatable diagnostic");
+   |     ^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 10 previous errors
 

From 3cc2a6fdcbbb3e6a80419521409665794522bb83 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sat, 10 Aug 2024 19:29:20 +0300
Subject: [PATCH 102/685] `untranslatable_diagnostic` lint: point at the
 untranslated thing

and not the function/method call
---
 compiler/rustc_lint/src/internal.rs           | 22 ++++++------
 .../internal-lints/diagnostics.stderr         | 34 +++++++++----------
 2 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs
index 044c9413f0b31..2133fd25b67a4 100644
--- a/compiler/rustc_lint/src/internal.rs
+++ b/compiler/rustc_lint/src/internal.rs
@@ -415,14 +415,17 @@ declare_lint_pass!(Diagnostics => [UNTRANSLATABLE_DIAGNOSTIC, DIAGNOSTIC_OUTSIDE
 
 impl LateLintPass<'_> for Diagnostics {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
+        let collect_args_tys_and_spans = |args: &[Expr<'_>], reserve_one_extra: bool| {
+            let mut result = Vec::with_capacity(args.len() + usize::from(reserve_one_extra));
+            result.extend(args.iter().map(|arg| (cx.typeck_results().expr_ty(arg), arg.span)));
+            result
+        };
         // Only check function calls and method calls.
-        let (span, def_id, fn_gen_args, call_tys) = match expr.kind {
+        let (span, def_id, fn_gen_args, arg_tys_and_spans) = match expr.kind {
             ExprKind::Call(callee, args) => {
                 match cx.typeck_results().node_type(callee.hir_id).kind() {
                     &ty::FnDef(def_id, fn_gen_args) => {
-                        let call_tys: Vec<_> =
-                            args.iter().map(|arg| cx.typeck_results().expr_ty(arg)).collect();
-                        (callee.span, def_id, fn_gen_args, call_tys)
+                        (callee.span, def_id, fn_gen_args, collect_args_tys_and_spans(args, false))
                     }
                     _ => return, // occurs for fns passed as args
                 }
@@ -432,10 +435,9 @@ impl LateLintPass<'_> for Diagnostics {
                 else {
                     return;
                 };
-                let mut call_tys: Vec<_> =
-                    args.iter().map(|arg| cx.typeck_results().expr_ty(arg)).collect();
-                call_tys.insert(0, cx.tcx.types.self_param); // dummy inserted for `self`
-                (span, def_id, fn_gen_args, call_tys)
+                let mut args = collect_args_tys_and_spans(args, true);
+                args.insert(0, (cx.tcx.types.self_param, _recv.span)); // dummy inserted for `self`
+                (span, def_id, fn_gen_args, args)
             }
             _ => return,
         };
@@ -525,11 +527,11 @@ impl LateLintPass<'_> for Diagnostics {
         // `UNTRANSLATABLE_DIAGNOSTIC` lint.
         for (param_i, param_i_p_name) in impl_into_diagnostic_message_params {
             // Is the arg type `{Sub,D}iagMessage`or `impl Into<{Sub,D}iagMessage>`?
-            let arg_ty = call_tys[param_i];
+            let (arg_ty, arg_span) = arg_tys_and_spans[param_i];
             let is_translatable = is_diag_message(arg_ty)
                 || matches!(arg_ty.kind(), ty::Param(p) if p.name == param_i_p_name);
             if !is_translatable {
-                cx.emit_span_lint(UNTRANSLATABLE_DIAGNOSTIC, span, UntranslatableDiag);
+                cx.emit_span_lint(UNTRANSLATABLE_DIAGNOSTIC, arg_span, UntranslatableDiag);
             }
         }
     }
diff --git a/tests/ui-fulldeps/internal-lints/diagnostics.stderr b/tests/ui-fulldeps/internal-lints/diagnostics.stderr
index c23da981ea2ec..36dd3cf4be798 100644
--- a/tests/ui-fulldeps/internal-lints/diagnostics.stderr
+++ b/tests/ui-fulldeps/internal-lints/diagnostics.stderr
@@ -1,8 +1,8 @@
 error: diagnostics should be created using translatable messages
-  --> $DIR/diagnostics.rs:43:9
+  --> $DIR/diagnostics.rs:43:31
    |
 LL |         Diag::new(dcx, level, "untranslatable diagnostic")
-   |         ^^^^^^^^^
+   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> $DIR/diagnostics.rs:7:9
@@ -11,16 +11,16 @@ LL | #![deny(rustc::untranslatable_diagnostic)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: diagnostics should be created using translatable messages
-  --> $DIR/diagnostics.rs:64:14
+  --> $DIR/diagnostics.rs:64:19
    |
 LL |         diag.note("untranslatable diagnostic");
-   |              ^^^^
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: diagnostics should be created using translatable messages
-  --> $DIR/diagnostics.rs:85:14
+  --> $DIR/diagnostics.rs:85:19
    |
 LL |         diag.note("untranslatable diagnostic");
-   |              ^^^^
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: diagnostics should only be created in `Diagnostic`/`Subdiagnostic`/`LintDiagnostic` impls
   --> $DIR/diagnostics.rs:99:21
@@ -41,36 +41,34 @@ LL |     let _diag = dcx.struct_err("untranslatable diagnostic");
    |                     ^^^^^^^^^^
 
 error: diagnostics should be created using translatable messages
-  --> $DIR/diagnostics.rs:102:21
+  --> $DIR/diagnostics.rs:102:32
    |
 LL |     let _diag = dcx.struct_err("untranslatable diagnostic");
-   |                     ^^^^^^^^^^
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: diagnostics should be created using translatable messages
-  --> $DIR/diagnostics.rs:120:5
+  --> $DIR/diagnostics.rs:120:7
    |
 LL |     f("untranslatable diagnostic", crate::fluent_generated::no_crate_example);
-   |     ^
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: diagnostics should be created using translatable messages
-  --> $DIR/diagnostics.rs:122:5
+  --> $DIR/diagnostics.rs:122:50
    |
 LL |     f(crate::fluent_generated::no_crate_example, "untranslatable diagnostic");
-   |     ^
+   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: diagnostics should be created using translatable messages
-  --> $DIR/diagnostics.rs:124:5
+  --> $DIR/diagnostics.rs:124:7
    |
 LL |     f("untranslatable diagnostic", "untranslatable diagnostic");
-   |     ^
+   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: diagnostics should be created using translatable messages
-  --> $DIR/diagnostics.rs:124:5
+  --> $DIR/diagnostics.rs:124:36
    |
 LL |     f("untranslatable diagnostic", "untranslatable diagnostic");
-   |     ^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 10 previous errors
 

From 4f8042e22ebaf962ebbffc6056373b387dc65515 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sat, 10 Aug 2024 17:42:56 +0000
Subject: [PATCH 103/685] Support reading thin archives in ArArchiveBuilder

---
 compiler/rustc_codegen_ssa/src/back/archive.rs | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs
index ce55d99f506d5..a35aff096a453 100644
--- a/compiler/rustc_codegen_ssa/src/back/archive.rs
+++ b/compiler/rustc_codegen_ssa/src/back/archive.rs
@@ -307,10 +307,17 @@ impl<'a> ArchiveBuilder for ArArchiveBuilder<'a> {
             let file_name = String::from_utf8(entry.name().to_vec())
                 .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
             if !skip(&file_name) {
-                self.entries.push((
-                    file_name.into_bytes(),
-                    ArchiveEntry::FromArchive { archive_index, file_range: entry.file_range() },
-                ));
+                if entry.is_thin() {
+                    self.entries.push((
+                        file_name.clone().into_bytes(),
+                        ArchiveEntry::File(PathBuf::from(file_name)),
+                    ));
+                } else {
+                    self.entries.push((
+                        file_name.into_bytes(),
+                        ArchiveEntry::FromArchive { archive_index, file_range: entry.file_range() },
+                    ));
+                }
             }
         }
 

From a57f73d32060ac27bfdb6635b98025f362598574 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sat, 10 Aug 2024 17:43:22 +0000
Subject: [PATCH 104/685] Add test for thin archive reading support

---
 .../run-make-support/src/external_deps/llvm.rs      |  6 ++++++
 tests/run-make/staticlib-thin-archive/bin.rs        | 10 ++++++++++
 tests/run-make/staticlib-thin-archive/rmake.rs      | 13 +++++++++++++
 .../run-make/staticlib-thin-archive/rust_archive.rs |  4 ++++
 tests/run-make/staticlib-thin-archive/simple_obj.rs |  4 ++++
 5 files changed, 37 insertions(+)
 create mode 100644 tests/run-make/staticlib-thin-archive/bin.rs
 create mode 100644 tests/run-make/staticlib-thin-archive/rmake.rs
 create mode 100644 tests/run-make/staticlib-thin-archive/rust_archive.rs
 create mode 100644 tests/run-make/staticlib-thin-archive/simple_obj.rs

diff --git a/src/tools/run-make-support/src/external_deps/llvm.rs b/src/tools/run-make-support/src/external_deps/llvm.rs
index dc651fdd8205a..4003287d7629d 100644
--- a/src/tools/run-make-support/src/external_deps/llvm.rs
+++ b/src/tools/run-make-support/src/external_deps/llvm.rs
@@ -271,6 +271,12 @@ impl LlvmAr {
         self
     }
 
+    /// Like `obj_to_ar` except creating a thin archive.
+    pub fn obj_to_thin_ar(&mut self) -> &mut Self {
+        self.cmd.arg("rcus").arg("--thin");
+        self
+    }
+
     /// Extract archive members back to files.
     pub fn extract(&mut self) -> &mut Self {
         self.cmd.arg("x");
diff --git a/tests/run-make/staticlib-thin-archive/bin.rs b/tests/run-make/staticlib-thin-archive/bin.rs
new file mode 100644
index 0000000000000..b37107d9c9435
--- /dev/null
+++ b/tests/run-make/staticlib-thin-archive/bin.rs
@@ -0,0 +1,10 @@
+#[link(name = "rust_archive", kind = "static")]
+extern "C" {
+    fn simple_fn();
+}
+
+fn main() {
+    unsafe {
+        simple_fn();
+    }
+}
diff --git a/tests/run-make/staticlib-thin-archive/rmake.rs b/tests/run-make/staticlib-thin-archive/rmake.rs
new file mode 100644
index 0000000000000..137dffcc33fc6
--- /dev/null
+++ b/tests/run-make/staticlib-thin-archive/rmake.rs
@@ -0,0 +1,13 @@
+// Regression test for https://github.com/rust-lang/rust/issues/107407
+
+use run_make_support::{llvm_ar, rustc, static_lib_name};
+
+fn main() {
+    rustc().input("simple_obj.rs").emit("obj").run();
+    llvm_ar().obj_to_thin_ar().output_input(static_lib_name("thin_archive"), "simple_obj.o").run();
+    rustc().input("rust_archive.rs").run();
+    // Disable lld as it ignores the symbol table in the archive file.
+    rustc()
+        .input("bin.rs") /*.arg("-Zlinker-features=-lld")*/
+        .run();
+}
diff --git a/tests/run-make/staticlib-thin-archive/rust_archive.rs b/tests/run-make/staticlib-thin-archive/rust_archive.rs
new file mode 100644
index 0000000000000..3d11f02df2016
--- /dev/null
+++ b/tests/run-make/staticlib-thin-archive/rust_archive.rs
@@ -0,0 +1,4 @@
+#![crate_type = "staticlib"]
+
+#[link(name = "thin_archive", kind = "static")]
+extern "C" {}
diff --git a/tests/run-make/staticlib-thin-archive/simple_obj.rs b/tests/run-make/staticlib-thin-archive/simple_obj.rs
new file mode 100644
index 0000000000000..a120c9b3e676b
--- /dev/null
+++ b/tests/run-make/staticlib-thin-archive/simple_obj.rs
@@ -0,0 +1,4 @@
+#![crate_type = "staticlib"]
+
+#[no_mangle]
+extern "C" fn simple_fn() {}

From c1f5350df5559709506510c1334f9664b0a171e1 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sat, 10 Aug 2024 17:45:39 +0000
Subject: [PATCH 105/685] Use ArArchiveBuilder with the LLVM backend too

All regressions that were blocking usage of ArArchiveBuilder should now
be fixed.
---
 compiler/rustc_codegen_llvm/src/back/archive.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/archive.rs b/compiler/rustc_codegen_llvm/src/back/archive.rs
index a2ab19ac800b7..ce05336f07191 100644
--- a/compiler/rustc_codegen_llvm/src/back/archive.rs
+++ b/compiler/rustc_codegen_llvm/src/back/archive.rs
@@ -106,9 +106,7 @@ pub struct LlvmArchiveBuilderBuilder;
 
 impl ArchiveBuilderBuilder for LlvmArchiveBuilderBuilder {
     fn new_archive_builder<'a>(&self, sess: &'a Session) -> Box<dyn ArchiveBuilder + 'a> {
-        // FIXME use ArArchiveBuilder on most targets again once reading thin archives is
-        // implemented
-        if true {
+        if false {
             Box::new(LlvmArchiveBuilder { sess, additions: Vec::new() })
         } else {
             Box::new(ArArchiveBuilder::new(sess, &LLVM_OBJECT_READER))

From d63a067bfd9d0674e637fbfc83e0cbd526fb92b5 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sat, 10 Aug 2024 18:49:36 +0000
Subject: [PATCH 106/685] Add fixme for removing LlvmArchiveBuilder in the
 future

---
 compiler/rustc_codegen_llvm/src/back/archive.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/compiler/rustc_codegen_llvm/src/back/archive.rs b/compiler/rustc_codegen_llvm/src/back/archive.rs
index ce05336f07191..0a8728c385ca1 100644
--- a/compiler/rustc_codegen_llvm/src/back/archive.rs
+++ b/compiler/rustc_codegen_llvm/src/back/archive.rs
@@ -106,6 +106,10 @@ pub struct LlvmArchiveBuilderBuilder;
 
 impl ArchiveBuilderBuilder for LlvmArchiveBuilderBuilder {
     fn new_archive_builder<'a>(&self, sess: &'a Session) -> Box<dyn ArchiveBuilder + 'a> {
+        // Keeping LlvmArchiveBuilder around in case of a regression caused by using
+        // ArArchiveBuilder.
+        // FIXME remove a couple of months after #128936 gets merged in case no
+        // regression is found.
         if false {
             Box::new(LlvmArchiveBuilder { sess, additions: Vec::new() })
         } else {

From e94a4ee219e6c91d78bc3dd76298c5be6139a909 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sat, 10 Aug 2024 21:40:07 +0300
Subject: [PATCH 107/685] Refactor: `diagnostic_outside_of_impl`,
 `untranslatable_diagnostic`

1. Decouple them.
2. Make logic around `diagnostic_outside_of_impl`'s early exits simpler.
3. Make `untranslatable_diagnostic` run one loop instead of two
   and not allocate an intermediate vec.
4. Overall, reduce the amount of code executed
   when the lints do not end up firing.
---
 compiler/rustc_lint/src/internal.rs | 134 +++++++++++++++-------------
 1 file changed, 74 insertions(+), 60 deletions(-)

diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs
index 2133fd25b67a4..65571815019ea 100644
--- a/compiler/rustc_lint/src/internal.rs
+++ b/compiler/rustc_lint/src/internal.rs
@@ -8,7 +8,7 @@ use rustc_hir::{
     BinOp, BinOpKind, Expr, ExprKind, GenericArg, HirId, Impl, Item, ItemKind, Node, Pat, PatKind,
     Path, PathSegment, QPath, Ty, TyKind,
 };
-use rustc_middle::ty::{self, Ty as MiddleTy};
+use rustc_middle::ty::{self, GenericArgsRef, Ty as MiddleTy};
 use rustc_session::{declare_lint_pass, declare_tool_lint};
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::symbol::{kw, sym, Symbol};
@@ -442,30 +442,33 @@ impl LateLintPass<'_> for Diagnostics {
             _ => return,
         };
 
-        // Is the callee marked with `#[rustc_lint_diagnostics]`?
-        let has_attr = ty::Instance::try_resolve(cx.tcx, cx.param_env, def_id, fn_gen_args)
-            .ok()
-            .flatten()
-            .is_some_and(|inst| cx.tcx.has_attr(inst.def_id(), sym::rustc_lint_diagnostics));
-
-        // Closure: is the type `{D,Subd}iagMessage`?
-        let is_diag_message = |ty: MiddleTy<'_>| {
-            if let Some(adt_def) = ty.ty_adt_def()
-                && let Some(name) = cx.tcx.get_diagnostic_name(adt_def.did())
-                && matches!(name, sym::DiagMessage | sym::SubdiagMessage)
-            {
-                true
-            } else {
-                false
-            }
-        };
+        Self::diagnostic_outside_of_impl(cx, span, expr.hir_id, def_id, fn_gen_args);
+        Self::untranslatable_diagnostic(cx, def_id, &arg_tys_and_spans);
+    }
+}
 
-        // Does the callee have one or more `impl Into<{D,Subd}iagMessage>` parameters?
-        let mut impl_into_diagnostic_message_params = vec![];
+impl Diagnostics {
+    // Is the type `{D,Subd}iagMessage`?
+    fn is_diag_message<'cx>(cx: &LateContext<'cx>, ty: MiddleTy<'cx>) -> bool {
+        if let Some(adt_def) = ty.ty_adt_def()
+            && let Some(name) = cx.tcx.get_diagnostic_name(adt_def.did())
+            && matches!(name, sym::DiagMessage | sym::SubdiagMessage)
+        {
+            true
+        } else {
+            false
+        }
+    }
+
+    fn untranslatable_diagnostic<'cx>(
+        cx: &LateContext<'cx>,
+        def_id: DefId,
+        arg_tys_and_spans: &[(MiddleTy<'cx>, Span)],
+    ) {
         let fn_sig = cx.tcx.fn_sig(def_id).instantiate_identity().skip_binder();
         let predicates = cx.tcx.predicates_of(def_id).instantiate_identity(cx.tcx).predicates;
         for (i, &param_ty) in fn_sig.inputs().iter().enumerate() {
-            if let ty::Param(p) = param_ty.kind() {
+            if let ty::Param(sig_param) = param_ty.kind() {
                 // It is a type parameter. Check if it is `impl Into<{D,Subd}iagMessage>`.
                 for pred in predicates.iter() {
                     if let Some(trait_pred) = pred.as_trait_clause()
@@ -473,27 +476,53 @@ impl LateLintPass<'_> for Diagnostics {
                         && trait_ref.self_ty() == param_ty // correct predicate for the param?
                         && cx.tcx.is_diagnostic_item(sym::Into, trait_ref.def_id)
                         && let ty1 = trait_ref.args.type_at(1)
-                        && is_diag_message(ty1)
+                        && Self::is_diag_message(cx, ty1)
                     {
-                        impl_into_diagnostic_message_params.push((i, p.name));
+                        // Calls to methods with an `impl Into<{D,Subd}iagMessage>` parameter must be passed an arg
+                        // with type `{D,Subd}iagMessage` or `impl Into<{D,Subd}iagMessage>`. Otherwise, emit an
+                        // `UNTRANSLATABLE_DIAGNOSTIC` lint.
+                        let (arg_ty, arg_span) = arg_tys_and_spans[i];
+
+                        // Is the arg type `{Sub,D}iagMessage`or `impl Into<{Sub,D}iagMessage>`?
+                        let is_translatable = Self::is_diag_message(cx, arg_ty)
+                            || matches!(arg_ty.kind(), ty::Param(arg_param) if arg_param.name == sig_param.name);
+                        if !is_translatable {
+                            cx.emit_span_lint(
+                                UNTRANSLATABLE_DIAGNOSTIC,
+                                arg_span,
+                                UntranslatableDiag,
+                            );
+                        }
                     }
                 }
             }
         }
+    }
 
-        // Is the callee interesting?
-        if !has_attr && impl_into_diagnostic_message_params.is_empty() {
+    fn diagnostic_outside_of_impl<'cx>(
+        cx: &LateContext<'cx>,
+        span: Span,
+        current_id: HirId,
+        def_id: DefId,
+        fn_gen_args: GenericArgsRef<'cx>,
+    ) {
+        // Is the callee marked with `#[rustc_lint_diagnostics]`?
+        let Some(inst) =
+            ty::Instance::try_resolve(cx.tcx, cx.param_env, def_id, fn_gen_args).ok().flatten()
+        else {
             return;
-        }
+        };
+        let has_attr = cx.tcx.has_attr(inst.def_id(), sym::rustc_lint_diagnostics);
+        if !has_attr {
+            return;
+        };
 
-        // Is the parent method marked with `#[rustc_lint_diagnostics]`?
-        let mut parent_has_attr = false;
-        for (hir_id, _parent) in cx.tcx.hir().parent_iter(expr.hir_id) {
+        for (hir_id, _parent) in cx.tcx.hir().parent_iter(current_id) {
             if let Some(owner_did) = hir_id.as_owner()
                 && cx.tcx.has_attr(owner_did, sym::rustc_lint_diagnostics)
             {
-                parent_has_attr = true;
-                break;
+                // The parent method is marked with `#[rustc_lint_diagnostics]`
+                return;
             }
         }
 
@@ -502,37 +531,22 @@ impl LateLintPass<'_> for Diagnostics {
         // - inside a parent function that is itself marked with `#[rustc_lint_diagnostics]`.
         //
         // Otherwise, emit a `DIAGNOSTIC_OUTSIDE_OF_IMPL` lint.
-        if has_attr && !parent_has_attr {
-            let mut is_inside_appropriate_impl = false;
-            for (_hir_id, parent) in cx.tcx.hir().parent_iter(expr.hir_id) {
-                debug!(?parent);
-                if let Node::Item(Item { kind: ItemKind::Impl(impl_), .. }) = parent
-                    && let Impl { of_trait: Some(of_trait), .. } = impl_
-                    && let Some(def_id) = of_trait.trait_def_id()
-                    && let Some(name) = cx.tcx.get_diagnostic_name(def_id)
-                    && matches!(name, sym::Diagnostic | sym::Subdiagnostic | sym::LintDiagnostic)
-                {
-                    is_inside_appropriate_impl = true;
-                    break;
-                }
-            }
-            debug!(?is_inside_appropriate_impl);
-            if !is_inside_appropriate_impl {
-                cx.emit_span_lint(DIAGNOSTIC_OUTSIDE_OF_IMPL, span, DiagOutOfImpl);
+        let mut is_inside_appropriate_impl = false;
+        for (_hir_id, parent) in cx.tcx.hir().parent_iter(current_id) {
+            debug!(?parent);
+            if let Node::Item(Item { kind: ItemKind::Impl(impl_), .. }) = parent
+                && let Impl { of_trait: Some(of_trait), .. } = impl_
+                && let Some(def_id) = of_trait.trait_def_id()
+                && let Some(name) = cx.tcx.get_diagnostic_name(def_id)
+                && matches!(name, sym::Diagnostic | sym::Subdiagnostic | sym::LintDiagnostic)
+            {
+                is_inside_appropriate_impl = true;
+                break;
             }
         }
-
-        // Calls to methods with an `impl Into<{D,Subd}iagMessage>` parameter must be passed an arg
-        // with type `{D,Subd}iagMessage` or `impl Into<{D,Subd}iagMessage>`. Otherwise, emit an
-        // `UNTRANSLATABLE_DIAGNOSTIC` lint.
-        for (param_i, param_i_p_name) in impl_into_diagnostic_message_params {
-            // Is the arg type `{Sub,D}iagMessage`or `impl Into<{Sub,D}iagMessage>`?
-            let (arg_ty, arg_span) = arg_tys_and_spans[param_i];
-            let is_translatable = is_diag_message(arg_ty)
-                || matches!(arg_ty.kind(), ty::Param(p) if p.name == param_i_p_name);
-            if !is_translatable {
-                cx.emit_span_lint(UNTRANSLATABLE_DIAGNOSTIC, arg_span, UntranslatableDiag);
-            }
+        debug!(?is_inside_appropriate_impl);
+        if !is_inside_appropriate_impl {
+            cx.emit_span_lint(DIAGNOSTIC_OUTSIDE_OF_IMPL, span, DiagOutOfImpl);
         }
     }
 }

From 6de27a027223b3fed221d256ed6e8a9abf4b6b51 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 10 Aug 2024 18:36:52 +0000
Subject: [PATCH 108/685] lintcheck: key lints on line start rather than byte
 start/end

---
 lintcheck/src/json.rs   | 39 +++++++++++++++++++++------------------
 lintcheck/src/output.rs | 14 +++++++-------
 2 files changed, 28 insertions(+), 25 deletions(-)

diff --git a/lintcheck/src/json.rs b/lintcheck/src/json.rs
index 4211bce90b2fb..ee0c80aea522e 100644
--- a/lintcheck/src/json.rs
+++ b/lintcheck/src/json.rs
@@ -12,21 +12,21 @@ const TRUNCATION_TOTAL_TARGET: usize = 1000;
 
 #[derive(Debug, Deserialize, Serialize)]
 struct LintJson {
-    lint: String,
-    krate: String,
-    file_name: String,
-    byte_pos: (u32, u32),
-    file_link: String,
+    /// The lint name e.g. `clippy::bytes_nth`
+    name: String,
+    /// The filename and line number e.g. `anyhow-1.0.86/src/error.rs:42`
+    file_line: String,
+    file_url: String,
     rendered: String,
 }
 
 impl LintJson {
     fn key(&self) -> impl Ord + '_ {
-        (self.lint.as_str(), self.file_name.as_str(), self.byte_pos)
+        (self.name.as_str(), self.file_line.as_str())
     }
 
     fn info_text(&self, action: &str) -> String {
-        format!("{action} `{}` in `{}` at {}", self.lint, self.krate, self.file_link)
+        format!("{action} `{}` at [`{}`]({})", self.name, self.file_line, self.file_url)
     }
 }
 
@@ -36,13 +36,16 @@ pub(crate) fn output(clippy_warnings: Vec<ClippyWarning>) -> String {
         .into_iter()
         .map(|warning| {
             let span = warning.span();
+            let file_name = span
+                .file_name
+                .strip_prefix("target/lintcheck/sources/")
+                .unwrap_or(&span.file_name);
+            let file_line = format!("{file_name}:{}", span.line_start);
             LintJson {
-                file_name: span.file_name.clone(),
-                byte_pos: (span.byte_start, span.byte_end),
-                krate: warning.krate,
-                file_link: warning.url,
-                lint: warning.lint,
-                rendered: warning.diag.rendered.unwrap(),
+                name: warning.name,
+                file_line,
+                file_url: warning.url,
+                rendered: warning.diag.rendered.unwrap().trim().to_string(),
             }
         })
         .collect();
@@ -63,7 +66,7 @@ pub(crate) fn diff(old_path: &Path, new_path: &Path, truncate: bool) {
     let mut lint_warnings = vec![];
 
     for (name, changes) in &itertools::merge_join_by(old_warnings, new_warnings, |old, new| old.key().cmp(&new.key()))
-        .chunk_by(|change| change.as_ref().into_left().lint.to_string())
+        .chunk_by(|change| change.as_ref().into_left().name.clone())
     {
         let mut added = Vec::new();
         let mut removed = Vec::new();
@@ -162,7 +165,7 @@ fn print_warnings(title: &str, warnings: &[LintJson], truncate_after: usize) {
         return;
     }
 
-    print_h3(&warnings[0].lint, title);
+    print_h3(&warnings[0].name, title);
     println!();
 
     let warnings = truncate(warnings, truncate_after);
@@ -171,7 +174,7 @@ fn print_warnings(title: &str, warnings: &[LintJson], truncate_after: usize) {
         println!("{}", warning.info_text(title));
         println!();
         println!("```");
-        println!("{}", warning.rendered.trim_end());
+        println!("{}", warning.rendered);
         println!("```");
         println!();
     }
@@ -182,7 +185,7 @@ fn print_changed_diff(changed: &[(LintJson, LintJson)], truncate_after: usize) {
         return;
     }
 
-    print_h3(&changed[0].0.lint, "Changed");
+    print_h3(&changed[0].0.name, "Changed");
     println!();
 
     let changed = truncate(changed, truncate_after);
@@ -191,7 +194,7 @@ fn print_changed_diff(changed: &[(LintJson, LintJson)], truncate_after: usize) {
         println!("{}", new.info_text("Changed"));
         println!();
         println!("```diff");
-        for change in diff::lines(old.rendered.trim_end(), new.rendered.trim_end()) {
+        for change in diff::lines(&old.rendered, &new.rendered) {
             use diff::Result::{Both, Left, Right};
 
             match change {
diff --git a/lintcheck/src/output.rs b/lintcheck/src/output.rs
index 153786306956a..e38036315c2ce 100644
--- a/lintcheck/src/output.rs
+++ b/lintcheck/src/output.rs
@@ -51,7 +51,7 @@ impl RustcIce {
 /// A single warning that clippy issued while checking a `Crate`
 #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct ClippyWarning {
-    pub lint: String,
+    pub name: String,
     pub diag: Diagnostic,
     pub krate: String,
     /// The URL that points to the file and line of the lint emission
@@ -60,8 +60,8 @@ pub struct ClippyWarning {
 
 impl ClippyWarning {
     pub fn new(mut diag: Diagnostic, base_url: &str, krate: &str) -> Option<Self> {
-        let lint = diag.code.clone()?.code;
-        if !(lint.contains("clippy") || diag.message.contains("clippy"))
+        let name = diag.code.clone()?.code;
+        if !(name.contains("clippy") || diag.message.contains("clippy"))
             || diag.message.contains("could not read cargo metadata")
         {
             return None;
@@ -92,7 +92,7 @@ impl ClippyWarning {
         };
 
         Some(Self {
-            lint,
+            name,
             diag,
             url,
             krate: krate.to_string(),
@@ -108,7 +108,7 @@ impl ClippyWarning {
         let mut file = span.file_name.clone();
         let file_with_pos = format!("{file}:{}:{}", span.line_start, span.line_end);
         match format {
-            OutputFormat::Text => format!("{file_with_pos} {} \"{}\"\n", self.lint, self.diag.message),
+            OutputFormat::Text => format!("{file_with_pos} {} \"{}\"\n", self.name, self.diag.message),
             OutputFormat::Markdown => {
                 if file.starts_with("target") {
                     file.insert_str(0, "../");
@@ -116,7 +116,7 @@ impl ClippyWarning {
 
                 let mut output = String::from("| ");
                 write!(output, "[`{file_with_pos}`]({file}#L{})", span.line_start).unwrap();
-                write!(output, r#" | `{:<50}` | "{}" |"#, self.lint, self.diag.message).unwrap();
+                write!(output, r#" | `{:<50}` | "{}" |"#, self.name, self.diag.message).unwrap();
                 output.push('\n');
                 output
             },
@@ -164,7 +164,7 @@ fn gather_stats(warnings: &[ClippyWarning]) -> (String, HashMap<&String, usize>)
     let mut counter: HashMap<&String, usize> = HashMap::new();
     warnings
         .iter()
-        .for_each(|wrn| *counter.entry(&wrn.lint).or_insert(0) += 1);
+        .for_each(|wrn| *counter.entry(&wrn.name).or_insert(0) += 1);
 
     // collect into a tupled list for sorting
     let mut stats: Vec<(&&String, &usize)> = counter.iter().collect();

From ba620344301aaa3b2733575a0696cdfd877edbdf Mon Sep 17 00:00:00 2001
From: Orson Peters <orsonpeters@gmail.com>
Date: Sat, 10 Aug 2024 23:52:35 +0200
Subject: [PATCH 109/685] Hash Ipv*Addr as an integer

---
 library/core/src/net/ip_addr.rs | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index 3e036b88128c7..6dc8018d80d62 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -1,6 +1,7 @@
 use super::display_buffer::DisplayBuffer;
 use crate::cmp::Ordering;
 use crate::fmt::{self, Write};
+use crate::hash::{Hash, Hasher};
 use crate::iter;
 use crate::mem::transmute;
 use crate::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, Not};
@@ -67,12 +68,20 @@ pub enum IpAddr {
 /// assert!("0000000.0.0.0".parse::<Ipv4Addr>().is_err()); // first octet is a zero in octal
 /// assert!("0xcb.0x0.0x71.0x00".parse::<Ipv4Addr>().is_err()); // all octets are in hex
 /// ```
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Ipv4Addr {
     octets: [u8; 4],
 }
 
+impl Hash for Ipv4Addr {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        // Hashers are often more efficient at hashing a fixed-width integer
+        // than a bytestring, so convert before hashing.
+        u32::from_le_bytes(self.octets).hash(state);
+    }
+}
+
 /// An IPv6 address.
 ///
 /// IPv6 addresses are defined as 128-bit integers in [IETF RFC 4291].
@@ -149,12 +158,20 @@ pub struct Ipv4Addr {
 /// assert_eq!("::1".parse(), Ok(localhost));
 /// assert_eq!(localhost.is_loopback(), true);
 /// ```
-#[derive(Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Ipv6Addr {
     octets: [u8; 16],
 }
 
+impl Hash for Ipv6Addr {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        // Hashers are often more efficient at hashing a fixed-width integer
+        // than a bytestring, so convert before hashing.
+        u128::from_le_bytes(self.octets).hash(state);
+    }
+}
+
 /// Scope of an [IPv6 multicast address] as defined in [IETF RFC 7346 section 2].
 ///
 /// # Stability Guarantees

From a04a1e464f6c83e1472d3b20141fabd631a5c178 Mon Sep 17 00:00:00 2001
From: Orson Peters <orsonpeters@gmail.com>
Date: Sun, 11 Aug 2024 01:28:30 +0200
Subject: [PATCH 110/685] Fix stability annotation and expand comment

---
 library/core/src/net/ip_addr.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index 6dc8018d80d62..495e9ade383f7 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -74,10 +74,13 @@ pub struct Ipv4Addr {
     octets: [u8; 4],
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
 impl Hash for Ipv4Addr {
     fn hash<H: Hasher>(&self, state: &mut H) {
         // Hashers are often more efficient at hashing a fixed-width integer
-        // than a bytestring, so convert before hashing.
+        // than a bytestring, so convert before hashing. We don't use to_bits()
+        // here as that involves a byteswap on little-endian machines, which are
+        // more common than big-endian machines.
         u32::from_le_bytes(self.octets).hash(state);
     }
 }
@@ -164,10 +167,13 @@ pub struct Ipv6Addr {
     octets: [u8; 16],
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
 impl Hash for Ipv6Addr {
     fn hash<H: Hasher>(&self, state: &mut H) {
         // Hashers are often more efficient at hashing a fixed-width integer
-        // than a bytestring, so convert before hashing.
+        // than a bytestring, so convert before hashing. We don't use to_bits()
+        // here as that involves byteswaps on little-endian machines, which are
+        // more common than big-endian machines.
         u128::from_le_bytes(self.octets).hash(state);
     }
 }

From 837d9045c5cf40b2ebf4b4ae2a02f35f8c7e0825 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20K=C3=A5re=20Alsaker?= <john.kare.alsaker@gmail.com>
Date: Tue, 12 Mar 2024 02:12:28 +0100
Subject: [PATCH 111/685] Link `std` statically in `rustc_driver`

---
 src/main.rs           | 3 +++
 tests/compile-test.rs | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/src/main.rs b/src/main.rs
index c9af2138a7233..c9853e53f3b38 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,3 +1,6 @@
+// We need this feature as it changes `dylib` linking behavior and allows us to link to
+// `rustc_driver`.
+#![feature(rustc_private)]
 // warn on lints, that are included in `rust-lang/rust`s bootstrap
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index c7080e5dcdc9e..64253514fbe67 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -1,3 +1,6 @@
+// We need this feature as it changes `dylib` linking behavior and allows us to link to
+// `rustc_driver`.
+#![feature(rustc_private)]
 #![warn(rust_2018_idioms, unused_lifetimes)]
 #![allow(unused_extern_crates)]
 

From 0a777090d80747fc841784c5a6944f2a792f845c Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 20:26:17 +1000
Subject: [PATCH 112/685] Avoid matching on `PatKind::Wild` in
 `write_struct_like`

---
 compiler/rustc_pattern_analysis/src/rustc.rs       | 6 +++++-
 compiler/rustc_pattern_analysis/src/rustc/print.rs | 9 +++++----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 10b7968a1a7e3..22b7ca18f840a 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -847,7 +847,11 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 let subpatterns = pat
                     .iter_fields()
                     .enumerate()
-                    .map(|(i, pat)| FieldPat { field: FieldIdx::new(i), pattern: hoist(pat) })
+                    .map(|(i, pat)| FieldPat {
+                        field: FieldIdx::new(i),
+                        pattern: hoist(pat),
+                        is_wildcard: would_print_as_wildcard(cx.tcx, pat),
+                    })
                     .collect::<Vec<_>>();
 
                 PatKind::StructLike { enum_info, subpatterns }
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index 7d6387146054e..94f625e015326 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -21,6 +21,7 @@ use rustc_target::abi::{FieldIdx, VariantIdx};
 pub(crate) struct FieldPat<'tcx> {
     pub(crate) field: FieldIdx,
     pub(crate) pattern: Box<Pat<'tcx>>,
+    pub(crate) is_wildcard: bool,
 }
 
 #[derive(Clone, Debug)]
@@ -139,12 +140,12 @@ fn write_struct_like<'tcx>(
             write!(f, " {{ ")?;
 
             let mut printed = 0;
-            for p in subpatterns {
-                if let PatKind::Wild = p.pattern.kind {
+            for &FieldPat { field, ref pattern, is_wildcard } in subpatterns {
+                if is_wildcard {
                     continue;
                 }
-                let name = variant.fields[p.field].name;
-                write!(f, "{}{}: {}", start_or_comma(), name, p.pattern)?;
+                let field_name = variant.fields[field].name;
+                write!(f, "{}{field_name}: {pattern}", start_or_comma())?;
                 printed += 1;
             }
 

From f53eb2724de4e1a7ec0985d035c208c55c37dd78 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 20:30:25 +1000
Subject: [PATCH 113/685] Add `print::PatKind::Print`

This will allow for the gradual removal of all other variants.
---
 compiler/rustc_pattern_analysis/src/rustc/print.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index 94f625e015326..c929b9b808ab9 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -62,6 +62,8 @@ pub(crate) enum PatKind<'tcx> {
     },
 
     Never,
+
+    Print(String),
 }
 
 impl<'tcx> fmt::Display for Pat<'tcx> {
@@ -79,6 +81,7 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
             PatKind::Slice { ref prefix, has_dot_dot, ref suffix } => {
                 write_slice_like(f, prefix, has_dot_dot, suffix)
             }
+            PatKind::Print(ref string) => write!(f, "{string}"),
         }
     }
 }

From 92eb159d04f8fd6009899d978c504ee8522baccb Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 20:45:12 +1000
Subject: [PATCH 114/685] Remove `PatKind::Wild`

---
 compiler/rustc_pattern_analysis/src/rustc.rs       | 6 ++++--
 compiler/rustc_pattern_analysis/src/rustc/print.rs | 3 ---
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 22b7ca18f840a..6cf3680b3e8dd 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -780,7 +780,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
         use MaybeInfiniteInt::*;
         let cx = self;
         let kind = if matches!((range.lo, range.hi), (NegInfinity, PosInfinity)) {
-            PatKind::Wild
+            PatKind::Print("_".to_string())
         } else if range.is_singleton() {
             let lo = cx.hoist_pat_range_bdy(range.lo, ty);
             let value = lo.as_finite().unwrap();
@@ -890,7 +890,9 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
             }
             &Str(value) => PatKind::Constant { value },
             Never if self.tcx.features().never_patterns => PatKind::Never,
-            Never | Wildcard | NonExhaustive | Hidden | PrivateUninhabited => PatKind::Wild,
+            Never | Wildcard | NonExhaustive | Hidden | PrivateUninhabited => {
+                PatKind::Print("_".to_string())
+            }
             Missing { .. } => bug!(
                 "trying to convert a `Missing` constructor into a `Pat`; this is probably a bug,
                 `Missing` should have been processed in `apply_constructors`"
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index c929b9b808ab9..d8e282ae326a9 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -32,8 +32,6 @@ pub(crate) struct Pat<'tcx> {
 
 #[derive(Clone, Debug)]
 pub(crate) enum PatKind<'tcx> {
-    Wild,
-
     StructLike {
         enum_info: EnumInfo<'tcx>,
         subpatterns: Vec<FieldPat<'tcx>>,
@@ -69,7 +67,6 @@ pub(crate) enum PatKind<'tcx> {
 impl<'tcx> fmt::Display for Pat<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
-            PatKind::Wild => write!(f, "_"),
             PatKind::Never => write!(f, "!"),
             PatKind::Box { ref subpattern } => write!(f, "box {subpattern}"),
             PatKind::StructLike { ref enum_info, ref subpatterns } => {

From ed3e38f33697efd2272b2df6a31b450e1e6ee12b Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 20:47:21 +1000
Subject: [PATCH 115/685] Remove `PatKind::StructLike`

---
 compiler/rustc_pattern_analysis/src/rustc.rs       | 11 ++++++++++-
 compiler/rustc_pattern_analysis/src/rustc/print.rs | 10 +---------
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 6cf3680b3e8dd..1d687cc1065dc 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -854,7 +854,16 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                     })
                     .collect::<Vec<_>>();
 
-                PatKind::StructLike { enum_info, subpatterns }
+                let mut s = String::new();
+                print::write_struct_like(
+                    &mut s,
+                    self.tcx,
+                    pat.ty().inner(),
+                    &enum_info,
+                    &subpatterns,
+                )
+                .unwrap();
+                PatKind::Print(s)
             }
             Ref => PatKind::Deref { subpattern: hoist(&pat.fields[0]) },
             Slice(slice) => {
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index d8e282ae326a9..dd37cd80ad262 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -32,11 +32,6 @@ pub(crate) struct Pat<'tcx> {
 
 #[derive(Clone, Debug)]
 pub(crate) enum PatKind<'tcx> {
-    StructLike {
-        enum_info: EnumInfo<'tcx>,
-        subpatterns: Vec<FieldPat<'tcx>>,
-    },
-
     Box {
         subpattern: Box<Pat<'tcx>>,
     },
@@ -69,9 +64,6 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
         match self.kind {
             PatKind::Never => write!(f, "!"),
             PatKind::Box { ref subpattern } => write!(f, "box {subpattern}"),
-            PatKind::StructLike { ref enum_info, ref subpatterns } => {
-                ty::tls::with(|tcx| write_struct_like(f, tcx, self.ty, enum_info, subpatterns))
-            }
             PatKind::Deref { ref subpattern } => write_ref_like(f, self.ty, subpattern),
             PatKind::Constant { value } => write!(f, "{value}"),
             PatKind::Range(ref range) => write!(f, "{range}"),
@@ -104,7 +96,7 @@ pub(crate) enum EnumInfo<'tcx> {
     NotEnum,
 }
 
-fn write_struct_like<'tcx>(
+pub(crate) fn write_struct_like<'tcx>(
     f: &mut impl fmt::Write,
     tcx: TyCtxt<'_>,
     ty: Ty<'tcx>,

From 15cc0e1b5cb9cc84ce017b656a75d9954f394f03 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 20:48:52 +1000
Subject: [PATCH 116/685] Remove `PatKind::Box`

---
 compiler/rustc_pattern_analysis/src/rustc.rs       | 2 +-
 compiler/rustc_pattern_analysis/src/rustc/print.rs | 5 -----
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 1d687cc1065dc..91650c7531a91 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -832,7 +832,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
             Struct if pat.ty().is_box() => {
                 // Outside of the `alloc` crate, the only way to create a struct pattern
                 // of type `Box` is to use a `box` pattern via #[feature(box_patterns)].
-                PatKind::Box { subpattern: hoist(&pat.fields[0]) }
+                PatKind::Print(format!("box {}", hoist(&pat.fields[0])))
             }
             Struct | Variant(_) | UnionField => {
                 let enum_info = match *pat.ty().kind() {
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index dd37cd80ad262..d03c68442cd5e 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -32,10 +32,6 @@ pub(crate) struct Pat<'tcx> {
 
 #[derive(Clone, Debug)]
 pub(crate) enum PatKind<'tcx> {
-    Box {
-        subpattern: Box<Pat<'tcx>>,
-    },
-
     Deref {
         subpattern: Box<Pat<'tcx>>,
     },
@@ -63,7 +59,6 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
             PatKind::Never => write!(f, "!"),
-            PatKind::Box { ref subpattern } => write!(f, "box {subpattern}"),
             PatKind::Deref { ref subpattern } => write_ref_like(f, self.ty, subpattern),
             PatKind::Constant { value } => write!(f, "{value}"),
             PatKind::Range(ref range) => write!(f, "{range}"),

From 283243ac5a3bcf68627491ea64b0d725db8c62f3 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 20:51:32 +1000
Subject: [PATCH 117/685] Remove `PatKind::Ref`

---
 compiler/rustc_pattern_analysis/src/rustc.rs       | 6 +++++-
 compiler/rustc_pattern_analysis/src/rustc/print.rs | 8 ++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 91650c7531a91..97d4a94756dae 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -865,7 +865,11 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 .unwrap();
                 PatKind::Print(s)
             }
-            Ref => PatKind::Deref { subpattern: hoist(&pat.fields[0]) },
+            Ref => {
+                let mut s = String::new();
+                print::write_ref_like(&mut s, pat.ty().inner(), &hoist(&pat.fields[0])).unwrap();
+                PatKind::Print(s)
+            }
             Slice(slice) => {
                 let (prefix_len, has_dot_dot) = match slice.kind {
                     SliceKind::FixedLen(len) => (len, false),
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index d03c68442cd5e..f147d62ed9bbc 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -26,16 +26,13 @@ pub(crate) struct FieldPat<'tcx> {
 
 #[derive(Clone, Debug)]
 pub(crate) struct Pat<'tcx> {
+    #[allow(dead_code)]
     pub(crate) ty: Ty<'tcx>,
     pub(crate) kind: PatKind<'tcx>,
 }
 
 #[derive(Clone, Debug)]
 pub(crate) enum PatKind<'tcx> {
-    Deref {
-        subpattern: Box<Pat<'tcx>>,
-    },
-
     Constant {
         value: mir::Const<'tcx>,
     },
@@ -59,7 +56,6 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
             PatKind::Never => write!(f, "!"),
-            PatKind::Deref { ref subpattern } => write_ref_like(f, self.ty, subpattern),
             PatKind::Constant { value } => write!(f, "{value}"),
             PatKind::Range(ref range) => write!(f, "{range}"),
             PatKind::Slice { ref prefix, has_dot_dot, ref suffix } => {
@@ -172,7 +168,7 @@ pub(crate) fn write_struct_like<'tcx>(
     Ok(())
 }
 
-fn write_ref_like<'tcx>(
+pub(crate) fn write_ref_like<'tcx>(
     f: &mut impl fmt::Write,
     ty: Ty<'tcx>,
     subpattern: &Pat<'tcx>,

From 9952e4d4c8ba5def2861e1a39af61506f0a91655 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 20:55:50 +1000
Subject: [PATCH 118/685] Remove `PatKind::Constant`

---
 compiler/rustc_pattern_analysis/src/rustc.rs       | 6 +++---
 compiler/rustc_pattern_analysis/src/rustc/print.rs | 7 +------
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 97d4a94756dae..9bd17b822af35 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -784,7 +784,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
         } else if range.is_singleton() {
             let lo = cx.hoist_pat_range_bdy(range.lo, ty);
             let value = lo.as_finite().unwrap();
-            PatKind::Constant { value }
+            PatKind::Print(value.to_string())
         } else {
             // We convert to an inclusive range for diagnostics.
             let mut end = rustc_hir::RangeEnd::Included;
@@ -827,7 +827,8 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
         let cx = self;
         let hoist = |p| Box::new(cx.hoist_witness_pat(p));
         let kind = match pat.ctor() {
-            Bool(b) => PatKind::Constant { value: mir::Const::from_bool(cx.tcx, *b) },
+            Bool(b) => PatKind::Print(b.to_string()),
+            Str(s) => PatKind::Print(s.to_string()),
             IntRange(range) => return self.hoist_pat_range(range, *pat.ty()),
             Struct if pat.ty().is_box() => {
                 // Outside of the `alloc` crate, the only way to create a struct pattern
@@ -901,7 +902,6 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
 
                 PatKind::Slice { prefix, has_dot_dot, suffix }
             }
-            &Str(value) => PatKind::Constant { value },
             Never if self.tcx.features().never_patterns => PatKind::Never,
             Never | Wildcard | NonExhaustive | Hidden | PrivateUninhabited => {
                 PatKind::Print("_".to_string())
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index f147d62ed9bbc..9e24ef58e8bc0 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -11,9 +11,9 @@
 
 use std::fmt;
 
+use rustc_middle::bug;
 use rustc_middle::thir::PatRange;
 use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt};
-use rustc_middle::{bug, mir};
 use rustc_span::sym;
 use rustc_target::abi::{FieldIdx, VariantIdx};
 
@@ -33,10 +33,6 @@ pub(crate) struct Pat<'tcx> {
 
 #[derive(Clone, Debug)]
 pub(crate) enum PatKind<'tcx> {
-    Constant {
-        value: mir::Const<'tcx>,
-    },
-
     Range(Box<PatRange<'tcx>>),
 
     Slice {
@@ -56,7 +52,6 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
             PatKind::Never => write!(f, "!"),
-            PatKind::Constant { value } => write!(f, "{value}"),
             PatKind::Range(ref range) => write!(f, "{range}"),
             PatKind::Slice { ref prefix, has_dot_dot, ref suffix } => {
                 write_slice_like(f, prefix, has_dot_dot, suffix)

From 2b6f4386ebdedd62a093577dafe5082e4f63b316 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 20:59:02 +1000
Subject: [PATCH 119/685] Remove `PatKind::Range`

---
 compiler/rustc_pattern_analysis/src/rustc.rs       | 2 +-
 compiler/rustc_pattern_analysis/src/rustc/print.rs | 4 ----
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 9bd17b822af35..d7c14348b1b7b 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -807,7 +807,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 range.hi
             };
             let hi = cx.hoist_pat_range_bdy(hi, ty);
-            PatKind::Range(Box::new(PatRange { lo, hi, end, ty: ty.inner() }))
+            PatKind::Print(PatRange { lo, hi, end, ty: ty.inner() }.to_string())
         };
 
         Pat { ty: ty.inner(), kind }
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index 9e24ef58e8bc0..fab71b421f8b6 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -12,7 +12,6 @@
 use std::fmt;
 
 use rustc_middle::bug;
-use rustc_middle::thir::PatRange;
 use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt};
 use rustc_span::sym;
 use rustc_target::abi::{FieldIdx, VariantIdx};
@@ -33,8 +32,6 @@ pub(crate) struct Pat<'tcx> {
 
 #[derive(Clone, Debug)]
 pub(crate) enum PatKind<'tcx> {
-    Range(Box<PatRange<'tcx>>),
-
     Slice {
         prefix: Box<[Box<Pat<'tcx>>]>,
         /// True if this slice-like pattern should include a `..` between the
@@ -52,7 +49,6 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
             PatKind::Never => write!(f, "!"),
-            PatKind::Range(ref range) => write!(f, "{range}"),
             PatKind::Slice { ref prefix, has_dot_dot, ref suffix } => {
                 write_slice_like(f, prefix, has_dot_dot, suffix)
             }

From ec1483bf2e317b4a8d073881c3e942f7a011ff1a Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 21:02:00 +1000
Subject: [PATCH 120/685] Remove `PatKind::Slice`

---
 compiler/rustc_pattern_analysis/src/rustc.rs    |  8 +++++---
 .../rustc_pattern_analysis/src/rustc/print.rs   | 17 +++--------------
 2 files changed, 8 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index d7c14348b1b7b..653097314f7fa 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -897,10 +897,12 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                     }
                 }
 
-                let prefix = prefix.iter().map(hoist).collect();
-                let suffix = suffix.iter().map(hoist).collect();
+                let prefix = prefix.iter().map(hoist).collect::<Vec<_>>();
+                let suffix = suffix.iter().map(hoist).collect::<Vec<_>>();
 
-                PatKind::Slice { prefix, has_dot_dot, suffix }
+                let mut s = String::new();
+                print::write_slice_like(&mut s, &prefix, has_dot_dot, &suffix).unwrap();
+                PatKind::Print(s)
             }
             Never if self.tcx.features().never_patterns => PatKind::Never,
             Never | Wildcard | NonExhaustive | Hidden | PrivateUninhabited => {
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index fab71b421f8b6..adda21a8b2582 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -27,19 +27,11 @@ pub(crate) struct FieldPat<'tcx> {
 pub(crate) struct Pat<'tcx> {
     #[allow(dead_code)]
     pub(crate) ty: Ty<'tcx>,
-    pub(crate) kind: PatKind<'tcx>,
+    pub(crate) kind: PatKind,
 }
 
 #[derive(Clone, Debug)]
-pub(crate) enum PatKind<'tcx> {
-    Slice {
-        prefix: Box<[Box<Pat<'tcx>>]>,
-        /// True if this slice-like pattern should include a `..` between the
-        /// prefix and suffix.
-        has_dot_dot: bool,
-        suffix: Box<[Box<Pat<'tcx>>]>,
-    },
-
+pub(crate) enum PatKind {
     Never,
 
     Print(String),
@@ -49,9 +41,6 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
             PatKind::Never => write!(f, "!"),
-            PatKind::Slice { ref prefix, has_dot_dot, ref suffix } => {
-                write_slice_like(f, prefix, has_dot_dot, suffix)
-            }
             PatKind::Print(ref string) => write!(f, "{string}"),
         }
     }
@@ -173,7 +162,7 @@ pub(crate) fn write_ref_like<'tcx>(
     write!(f, "{subpattern}")
 }
 
-fn write_slice_like<'tcx>(
+pub(crate) fn write_slice_like<'tcx>(
     f: &mut impl fmt::Write,
     prefix: &[Box<Pat<'tcx>>],
     has_dot_dot: bool,

From bfe88a3bd0d0af92405655495a40aefbbed29b23 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 21:04:51 +1000
Subject: [PATCH 121/685] Remove `PatKind::Never`

---
 compiler/rustc_pattern_analysis/src/rustc.rs       | 2 +-
 compiler/rustc_pattern_analysis/src/rustc/print.rs | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 653097314f7fa..35391ebec822a 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -904,7 +904,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 print::write_slice_like(&mut s, &prefix, has_dot_dot, &suffix).unwrap();
                 PatKind::Print(s)
             }
-            Never if self.tcx.features().never_patterns => PatKind::Never,
+            Never if self.tcx.features().never_patterns => PatKind::Print("!".to_string()),
             Never | Wildcard | NonExhaustive | Hidden | PrivateUninhabited => {
                 PatKind::Print("_".to_string())
             }
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index adda21a8b2582..b2ecfa2ae28c2 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -32,15 +32,12 @@ pub(crate) struct Pat<'tcx> {
 
 #[derive(Clone, Debug)]
 pub(crate) enum PatKind {
-    Never,
-
     Print(String),
 }
 
 impl<'tcx> fmt::Display for Pat<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.kind {
-            PatKind::Never => write!(f, "!"),
             PatKind::Print(ref string) => write!(f, "{string}"),
         }
     }

From fc55129774c8209d46d89b8a27b13fb7d8ce2b44 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 3 Aug 2024 21:20:22 +1000
Subject: [PATCH 122/685] Remove `print::Pat` entirely, replacing it with
 `String`

---
 compiler/rustc_pattern_analysis/src/rustc.rs  | 70 ++++++++-----------
 .../rustc_pattern_analysis/src/rustc/print.rs | 34 ++-------
 2 files changed, 35 insertions(+), 69 deletions(-)

diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 35391ebec822a..4ad6da5535071 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -774,17 +774,16 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
         }
     }
 
-    /// Convert to a [`print::Pat`] for diagnostic purposes.
-    fn hoist_pat_range(&self, range: &IntRange, ty: RevealedTy<'tcx>) -> print::Pat<'tcx> {
-        use print::{Pat, PatKind};
+    /// Prints an [`IntRange`] to a string for diagnostic purposes.
+    fn print_pat_range(&self, range: &IntRange, ty: RevealedTy<'tcx>) -> String {
         use MaybeInfiniteInt::*;
         let cx = self;
-        let kind = if matches!((range.lo, range.hi), (NegInfinity, PosInfinity)) {
-            PatKind::Print("_".to_string())
+        if matches!((range.lo, range.hi), (NegInfinity, PosInfinity)) {
+            "_".to_string()
         } else if range.is_singleton() {
             let lo = cx.hoist_pat_range_bdy(range.lo, ty);
             let value = lo.as_finite().unwrap();
-            PatKind::Print(value.to_string())
+            value.to_string()
         } else {
             // We convert to an inclusive range for diagnostics.
             let mut end = rustc_hir::RangeEnd::Included;
@@ -807,33 +806,24 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 range.hi
             };
             let hi = cx.hoist_pat_range_bdy(hi, ty);
-            PatKind::Print(PatRange { lo, hi, end, ty: ty.inner() }.to_string())
-        };
-
-        Pat { ty: ty.inner(), kind }
+            PatRange { lo, hi, end, ty: ty.inner() }.to_string()
+        }
     }
 
     /// Prints a [`WitnessPat`] to an owned string, for diagnostic purposes.
+    ///
+    /// This panics for patterns that don't appear in diagnostics, like float ranges.
     pub fn print_witness_pat(&self, pat: &WitnessPat<'p, 'tcx>) -> String {
-        // This works by converting the witness pattern to a `print::Pat`
-        // and then printing that, but callers don't need to know that.
-        self.hoist_witness_pat(pat).to_string()
-    }
-
-    /// Convert to a [`print::Pat`] for diagnostic purposes. This panics for patterns that don't
-    /// appear in diagnostics, like float ranges.
-    fn hoist_witness_pat(&self, pat: &WitnessPat<'p, 'tcx>) -> print::Pat<'tcx> {
-        use print::{FieldPat, Pat, PatKind};
         let cx = self;
-        let hoist = |p| Box::new(cx.hoist_witness_pat(p));
-        let kind = match pat.ctor() {
-            Bool(b) => PatKind::Print(b.to_string()),
-            Str(s) => PatKind::Print(s.to_string()),
-            IntRange(range) => return self.hoist_pat_range(range, *pat.ty()),
+        let print = |p| cx.print_witness_pat(p);
+        match pat.ctor() {
+            Bool(b) => b.to_string(),
+            Str(s) => s.to_string(),
+            IntRange(range) => return self.print_pat_range(range, *pat.ty()),
             Struct if pat.ty().is_box() => {
                 // Outside of the `alloc` crate, the only way to create a struct pattern
                 // of type `Box` is to use a `box` pattern via #[feature(box_patterns)].
-                PatKind::Print(format!("box {}", hoist(&pat.fields[0])))
+                format!("box {}", print(&pat.fields[0]))
             }
             Struct | Variant(_) | UnionField => {
                 let enum_info = match *pat.ty().kind() {
@@ -848,9 +838,9 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 let subpatterns = pat
                     .iter_fields()
                     .enumerate()
-                    .map(|(i, pat)| FieldPat {
+                    .map(|(i, pat)| print::FieldPat {
                         field: FieldIdx::new(i),
-                        pattern: hoist(pat),
+                        pattern: print(pat),
                         is_wildcard: would_print_as_wildcard(cx.tcx, pat),
                     })
                     .collect::<Vec<_>>();
@@ -864,12 +854,12 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                     &subpatterns,
                 )
                 .unwrap();
-                PatKind::Print(s)
+                s
             }
             Ref => {
                 let mut s = String::new();
-                print::write_ref_like(&mut s, pat.ty().inner(), &hoist(&pat.fields[0])).unwrap();
-                PatKind::Print(s)
+                print::write_ref_like(&mut s, pat.ty().inner(), &print(&pat.fields[0])).unwrap();
+                s
             }
             Slice(slice) => {
                 let (prefix_len, has_dot_dot) = match slice.kind {
@@ -897,17 +887,15 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                     }
                 }
 
-                let prefix = prefix.iter().map(hoist).collect::<Vec<_>>();
-                let suffix = suffix.iter().map(hoist).collect::<Vec<_>>();
+                let prefix = prefix.iter().map(print).collect::<Vec<_>>();
+                let suffix = suffix.iter().map(print).collect::<Vec<_>>();
 
                 let mut s = String::new();
                 print::write_slice_like(&mut s, &prefix, has_dot_dot, &suffix).unwrap();
-                PatKind::Print(s)
-            }
-            Never if self.tcx.features().never_patterns => PatKind::Print("!".to_string()),
-            Never | Wildcard | NonExhaustive | Hidden | PrivateUninhabited => {
-                PatKind::Print("_".to_string())
+                s
             }
+            Never if self.tcx.features().never_patterns => "!".to_string(),
+            Never | Wildcard | NonExhaustive | Hidden | PrivateUninhabited => "_".to_string(),
             Missing { .. } => bug!(
                 "trying to convert a `Missing` constructor into a `Pat`; this is probably a bug,
                 `Missing` should have been processed in `apply_constructors`"
@@ -915,9 +903,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
             F16Range(..) | F32Range(..) | F64Range(..) | F128Range(..) | Opaque(..) | Or => {
                 bug!("can't convert to pattern: {:?}", pat)
             }
-        };
-
-        Pat { ty: pat.ty().inner(), kind }
+        }
     }
 }
 
@@ -993,7 +979,7 @@ impl<'p, 'tcx: 'p> PatCx for RustcPatCtxt<'p, 'tcx> {
         overlaps_on: IntRange,
         overlaps_with: &[&crate::pat::DeconstructedPat<Self>],
     ) {
-        let overlap_as_pat = self.hoist_pat_range(&overlaps_on, *pat.ty());
+        let overlap_as_pat = self.print_pat_range(&overlaps_on, *pat.ty());
         let overlaps: Vec<_> = overlaps_with
             .iter()
             .map(|pat| pat.data().span)
@@ -1033,7 +1019,7 @@ impl<'p, 'tcx: 'p> PatCx for RustcPatCtxt<'p, 'tcx> {
             suggested_range.end = rustc_hir::RangeEnd::Included;
             suggested_range.to_string()
         };
-        let gap_as_pat = self.hoist_pat_range(&gap, *pat.ty());
+        let gap_as_pat = self.print_pat_range(&gap, *pat.ty());
         if gapped_with.is_empty() {
             // If `gapped_with` is empty, `gap == T::MAX`.
             self.tcx.emit_node_span_lint(
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index b2ecfa2ae28c2..17e389df17ed2 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -17,32 +17,12 @@ use rustc_span::sym;
 use rustc_target::abi::{FieldIdx, VariantIdx};
 
 #[derive(Clone, Debug)]
-pub(crate) struct FieldPat<'tcx> {
+pub(crate) struct FieldPat {
     pub(crate) field: FieldIdx,
-    pub(crate) pattern: Box<Pat<'tcx>>,
+    pub(crate) pattern: String,
     pub(crate) is_wildcard: bool,
 }
 
-#[derive(Clone, Debug)]
-pub(crate) struct Pat<'tcx> {
-    #[allow(dead_code)]
-    pub(crate) ty: Ty<'tcx>,
-    pub(crate) kind: PatKind,
-}
-
-#[derive(Clone, Debug)]
-pub(crate) enum PatKind {
-    Print(String),
-}
-
-impl<'tcx> fmt::Display for Pat<'tcx> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.kind {
-            PatKind::Print(ref string) => write!(f, "{string}"),
-        }
-    }
-}
-
 /// Returns a closure that will return `""` when called the first time,
 /// and then return `", "` when called any subsequent times.
 /// Useful for printing comma-separated lists.
@@ -69,7 +49,7 @@ pub(crate) fn write_struct_like<'tcx>(
     tcx: TyCtxt<'_>,
     ty: Ty<'tcx>,
     enum_info: &EnumInfo<'tcx>,
-    subpatterns: &[FieldPat<'tcx>],
+    subpatterns: &[FieldPat],
 ) -> fmt::Result {
     let variant_and_name = match *enum_info {
         EnumInfo::Enum { adt_def, variant_index } => {
@@ -148,7 +128,7 @@ pub(crate) fn write_struct_like<'tcx>(
 pub(crate) fn write_ref_like<'tcx>(
     f: &mut impl fmt::Write,
     ty: Ty<'tcx>,
-    subpattern: &Pat<'tcx>,
+    subpattern: &str,
 ) -> fmt::Result {
     match ty.kind() {
         ty::Ref(_, _, mutbl) => {
@@ -159,11 +139,11 @@ pub(crate) fn write_ref_like<'tcx>(
     write!(f, "{subpattern}")
 }
 
-pub(crate) fn write_slice_like<'tcx>(
+pub(crate) fn write_slice_like(
     f: &mut impl fmt::Write,
-    prefix: &[Box<Pat<'tcx>>],
+    prefix: &[String],
     has_dot_dot: bool,
-    suffix: &[Box<Pat<'tcx>>],
+    suffix: &[String],
 ) -> fmt::Result {
     let mut start_or_comma = start_or_comma();
     write!(f, "[")?;

From db68a19b619ffc4b4ee9d1118d064d184d0bcd37 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Sun, 11 Aug 2024 10:29:32 +0000
Subject: [PATCH 123/685] Fix review comments and other improvements

---
 .../rustc_codegen_llvm/src/back/archive.rs    |  4 +--
 .../rustc_codegen_ssa/src/back/archive.rs     |  6 ++--
 tests/run-make/staticlib-thin-archive/bin.rs  |  7 +----
 .../run-make/staticlib-thin-archive/rmake.rs  | 31 ++++++++++++++-----
 .../staticlib-thin-archive/rust_archive.rs    |  4 ---
 .../staticlib-thin-archive/rust_lib.rs        |  6 ++++
 6 files changed, 34 insertions(+), 24 deletions(-)
 delete mode 100644 tests/run-make/staticlib-thin-archive/rust_archive.rs
 create mode 100644 tests/run-make/staticlib-thin-archive/rust_lib.rs

diff --git a/compiler/rustc_codegen_llvm/src/back/archive.rs b/compiler/rustc_codegen_llvm/src/back/archive.rs
index 0a8728c385ca1..60e6346254877 100644
--- a/compiler/rustc_codegen_llvm/src/back/archive.rs
+++ b/compiler/rustc_codegen_llvm/src/back/archive.rs
@@ -108,8 +108,8 @@ impl ArchiveBuilderBuilder for LlvmArchiveBuilderBuilder {
     fn new_archive_builder<'a>(&self, sess: &'a Session) -> Box<dyn ArchiveBuilder + 'a> {
         // Keeping LlvmArchiveBuilder around in case of a regression caused by using
         // ArArchiveBuilder.
-        // FIXME remove a couple of months after #128936 gets merged in case no
-        // regression is found.
+        // FIXME(#128955) remove a couple of months after #128936 gets merged in case
+        // no regression is found.
         if false {
             Box::new(LlvmArchiveBuilder { sess, additions: Vec::new() })
         } else {
diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs
index a35aff096a453..8eb44d1201640 100644
--- a/compiler/rustc_codegen_ssa/src/back/archive.rs
+++ b/compiler/rustc_codegen_ssa/src/back/archive.rs
@@ -308,10 +308,8 @@ impl<'a> ArchiveBuilder for ArArchiveBuilder<'a> {
                 .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?;
             if !skip(&file_name) {
                 if entry.is_thin() {
-                    self.entries.push((
-                        file_name.clone().into_bytes(),
-                        ArchiveEntry::File(PathBuf::from(file_name)),
-                    ));
+                    let member_path = archive_path.parent().unwrap().join(Path::new(&file_name));
+                    self.entries.push((file_name.into_bytes(), ArchiveEntry::File(member_path)));
                 } else {
                     self.entries.push((
                         file_name.into_bytes(),
diff --git a/tests/run-make/staticlib-thin-archive/bin.rs b/tests/run-make/staticlib-thin-archive/bin.rs
index b37107d9c9435..97a2751f20bcc 100644
--- a/tests/run-make/staticlib-thin-archive/bin.rs
+++ b/tests/run-make/staticlib-thin-archive/bin.rs
@@ -1,10 +1,5 @@
-#[link(name = "rust_archive", kind = "static")]
-extern "C" {
-    fn simple_fn();
-}
-
 fn main() {
     unsafe {
-        simple_fn();
+        rust_lib::simple_fn();
     }
 }
diff --git a/tests/run-make/staticlib-thin-archive/rmake.rs b/tests/run-make/staticlib-thin-archive/rmake.rs
index 137dffcc33fc6..f7e3e43d53581 100644
--- a/tests/run-make/staticlib-thin-archive/rmake.rs
+++ b/tests/run-make/staticlib-thin-archive/rmake.rs
@@ -1,13 +1,28 @@
-// Regression test for https://github.com/rust-lang/rust/issues/107407
+// Regression test for https://github.com/rust-lang/rust/issues/107407 which
+// checks that rustc can read thin archive. Before the object crate added thin
+// archive support rustc would add emit object files to the staticlib and after
+// the object crate added thin archive support it would previously crash the
+// compiler due to a missing special case for thin archive members.
+use std::path::Path;
 
-use run_make_support::{llvm_ar, rustc, static_lib_name};
+use run_make_support::{llvm_ar, rust_lib_name, rustc, static_lib_name};
 
 fn main() {
-    rustc().input("simple_obj.rs").emit("obj").run();
-    llvm_ar().obj_to_thin_ar().output_input(static_lib_name("thin_archive"), "simple_obj.o").run();
-    rustc().input("rust_archive.rs").run();
-    // Disable lld as it ignores the symbol table in the archive file.
-    rustc()
-        .input("bin.rs") /*.arg("-Zlinker-features=-lld")*/
+    std::fs::create_dir("archive").unwrap();
+
+    // Build a thin archive
+    rustc().input("simple_obj.rs").emit("obj").output("archive/simple_obj.o").run();
+    llvm_ar()
+        .obj_to_thin_ar()
+        .output_input(
+            Path::new("archive").join(static_lib_name("thin_archive")),
+            "archive/simple_obj.o",
+        )
         .run();
+
+    // Build an rlib which includes the members of this thin archive
+    rustc().input("rust_lib.rs").library_search_path("archive").run();
+
+    // Build a binary which requires a symbol from the thin archive
+    rustc().input("bin.rs").extern_("rust_lib", rust_lib_name("rust_lib")).run();
 }
diff --git a/tests/run-make/staticlib-thin-archive/rust_archive.rs b/tests/run-make/staticlib-thin-archive/rust_archive.rs
deleted file mode 100644
index 3d11f02df2016..0000000000000
--- a/tests/run-make/staticlib-thin-archive/rust_archive.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-#![crate_type = "staticlib"]
-
-#[link(name = "thin_archive", kind = "static")]
-extern "C" {}
diff --git a/tests/run-make/staticlib-thin-archive/rust_lib.rs b/tests/run-make/staticlib-thin-archive/rust_lib.rs
new file mode 100644
index 0000000000000..c76b0f2543376
--- /dev/null
+++ b/tests/run-make/staticlib-thin-archive/rust_lib.rs
@@ -0,0 +1,6 @@
+#![crate_type = "rlib"]
+
+#[link(name = "thin_archive", kind = "static")]
+extern "C" {
+    pub fn simple_fn();
+}

From fce1decc3c6508aa72f590d024e583dd5c0cf04d Mon Sep 17 00:00:00 2001
From: Orson Peters <orsonpeters@gmail.com>
Date: Sun, 11 Aug 2024 14:55:29 +0200
Subject: [PATCH 124/685] Do not use unnecessary endian conversion.

---
 library/core/src/net/ip_addr.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/library/core/src/net/ip_addr.rs b/library/core/src/net/ip_addr.rs
index 495e9ade383f7..919f681f911f9 100644
--- a/library/core/src/net/ip_addr.rs
+++ b/library/core/src/net/ip_addr.rs
@@ -79,9 +79,8 @@ impl Hash for Ipv4Addr {
     fn hash<H: Hasher>(&self, state: &mut H) {
         // Hashers are often more efficient at hashing a fixed-width integer
         // than a bytestring, so convert before hashing. We don't use to_bits()
-        // here as that involves a byteswap on little-endian machines, which are
-        // more common than big-endian machines.
-        u32::from_le_bytes(self.octets).hash(state);
+        // here as that may involve a byteswap which is unnecessary.
+        u32::from_ne_bytes(self.octets).hash(state);
     }
 }
 
@@ -172,9 +171,8 @@ impl Hash for Ipv6Addr {
     fn hash<H: Hasher>(&self, state: &mut H) {
         // Hashers are often more efficient at hashing a fixed-width integer
         // than a bytestring, so convert before hashing. We don't use to_bits()
-        // here as that involves byteswaps on little-endian machines, which are
-        // more common than big-endian machines.
-        u128::from_le_bytes(self.octets).hash(state);
+        // here as that may involve unnecessary byteswaps.
+        u128::from_ne_bytes(self.octets).hash(state);
     }
 }
 

From f93fb9a41716b0aae160900999170dc1a83e670b Mon Sep 17 00:00:00 2001
From: Alexey Semenyuk <alexsemenyuk88@gmail.com>
Date: Sun, 11 Aug 2024 20:33:28 +0500
Subject: [PATCH 125/685] Clarify message for unwrap lint

---
 clippy_lints/src/unwrap.rs                    |  6 ++---
 .../complex_conditionals_nested.stderr        |  2 +-
 .../checked_unwrap/simple_conditionals.stderr | 26 +++++++++----------
 3 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/clippy_lints/src/unwrap.rs b/clippy_lints/src/unwrap.rs
index c0d9bcdd259c7..0b4ea0752b6ba 100644
--- a/clippy_lints/src/unwrap.rs
+++ b/clippy_lints/src/unwrap.rs
@@ -89,15 +89,15 @@ enum UnwrappableKind {
 impl UnwrappableKind {
     fn success_variant_pattern(self) -> &'static str {
         match self {
-            UnwrappableKind::Option => "Some(..)",
-            UnwrappableKind::Result => "Ok(..)",
+            UnwrappableKind::Option => "Some(<item>)",
+            UnwrappableKind::Result => "Ok(<item>)",
         }
     }
 
     fn error_variant_pattern(self) -> &'static str {
         match self {
             UnwrappableKind::Option => "None",
-            UnwrappableKind::Result => "Err(..)",
+            UnwrappableKind::Result => "Err(<item>)",
         }
     }
 }
diff --git a/tests/ui/checked_unwrap/complex_conditionals_nested.stderr b/tests/ui/checked_unwrap/complex_conditionals_nested.stderr
index f7e659b10de07..329be4d366210 100644
--- a/tests/ui/checked_unwrap/complex_conditionals_nested.stderr
+++ b/tests/ui/checked_unwrap/complex_conditionals_nested.stderr
@@ -2,7 +2,7 @@ error: called `unwrap` on `x` after checking its variant with `is_some`
   --> tests/ui/checked_unwrap/complex_conditionals_nested.rs:13:13
    |
 LL |         if x.is_some() {
-   |         -------------- help: try: `if let Some(..) = x`
+   |         -------------- help: try: `if let Some(<item>) = x`
 LL |             // unnecessary
 LL |             x.unwrap();
    |             ^^^^^^^^^^
diff --git a/tests/ui/checked_unwrap/simple_conditionals.stderr b/tests/ui/checked_unwrap/simple_conditionals.stderr
index ddd600418afec..f7e338935a770 100644
--- a/tests/ui/checked_unwrap/simple_conditionals.stderr
+++ b/tests/ui/checked_unwrap/simple_conditionals.stderr
@@ -2,7 +2,7 @@ error: called `unwrap` on `x` after checking its variant with `is_some`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:46:9
    |
 LL |     if x.is_some() {
-   |     -------------- help: try: `if let Some(..) = x`
+   |     -------------- help: try: `if let Some(<item>) = x`
 LL |         // unnecessary
 LL |         x.unwrap();
    |         ^^^^^^^^^^
@@ -17,7 +17,7 @@ error: called `expect` on `x` after checking its variant with `is_some`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:49:9
    |
 LL |     if x.is_some() {
-   |     -------------- help: try: `if let Some(..) = x`
+   |     -------------- help: try: `if let Some(<item>) = x`
 ...
 LL |         x.expect("an error message");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -59,7 +59,7 @@ error: called `unwrap` on `x` after checking its variant with `is_none`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:65:9
    |
 LL |     if x.is_none() {
-   |     -------------- help: try: `if let Some(..) = x`
+   |     -------------- help: try: `if let Some(<item>) = x`
 ...
 LL |         x.unwrap();
    |         ^^^^^^^^^^
@@ -68,7 +68,7 @@ error: called `unwrap` on `x` after checking its variant with `is_some`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:13:13
    |
 LL |         if $a.is_some() {
-   |         --------------- help: try: `if let Some(..) = x`
+   |         --------------- help: try: `if let Some(<item>) = x`
 LL |             // unnecessary
 LL |             $a.unwrap();
    |             ^^^^^^^^^^^
@@ -82,7 +82,7 @@ error: called `unwrap` on `x` after checking its variant with `is_ok`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:78:9
    |
 LL |     if x.is_ok() {
-   |     ------------ help: try: `if let Ok(..) = x`
+   |     ------------ help: try: `if let Ok(<item>) = x`
 LL |         // unnecessary
 LL |         x.unwrap();
    |         ^^^^^^^^^^
@@ -91,7 +91,7 @@ error: called `expect` on `x` after checking its variant with `is_ok`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:81:9
    |
 LL |     if x.is_ok() {
-   |     ------------ help: try: `if let Ok(..) = x`
+   |     ------------ help: try: `if let Ok(<item>) = x`
 ...
 LL |         x.expect("an error message");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -127,7 +127,7 @@ error: called `unwrap_err` on `x` after checking its variant with `is_ok`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:94:9
    |
 LL |     if x.is_ok() {
-   |     ------------ help: try: `if let Err(..) = x`
+   |     ------------ help: try: `if let Err(<item>) = x`
 ...
 LL |         x.unwrap_err();
    |         ^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ error: called `unwrap_err` on `x` after checking its variant with `is_err`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:102:9
    |
 LL |     if x.is_err() {
-   |     ------------- help: try: `if let Err(..) = x`
+   |     ------------- help: try: `if let Err(<item>) = x`
 ...
 LL |         x.unwrap_err();
    |         ^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ error: called `unwrap` on `x` after checking its variant with `is_err`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:106:9
    |
 LL |     if x.is_err() {
-   |     ------------- help: try: `if let Ok(..) = x`
+   |     ------------- help: try: `if let Ok(<item>) = x`
 ...
 LL |         x.unwrap();
    |         ^^^^^^^^^^
@@ -172,7 +172,7 @@ error: called `unwrap` on `option` after checking its variant with `is_some`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:134:9
    |
 LL |     if option.is_some() {
-   |     ------------------- help: try: `if let Some(..) = &option`
+   |     ------------------- help: try: `if let Some(<item>) = &option`
 LL |         option.as_ref().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -189,7 +189,7 @@ error: called `unwrap` on `result` after checking its variant with `is_ok`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:144:9
    |
 LL |     if result.is_ok() {
-   |     ----------------- help: try: `if let Ok(..) = &result`
+   |     ----------------- help: try: `if let Ok(<item>) = &result`
 LL |         result.as_ref().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -206,7 +206,7 @@ error: called `unwrap` on `option` after checking its variant with `is_some`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:153:9
    |
 LL |     if option.is_some() {
-   |     ------------------- help: try: `if let Some(..) = &mut option`
+   |     ------------------- help: try: `if let Some(<item>) = &mut option`
 LL |         option.as_mut().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -223,7 +223,7 @@ error: called `unwrap` on `result` after checking its variant with `is_ok`
   --> tests/ui/checked_unwrap/simple_conditionals.rs:162:9
    |
 LL |     if result.is_ok() {
-   |     ----------------- help: try: `if let Ok(..) = &mut result`
+   |     ----------------- help: try: `if let Ok(<item>) = &mut result`
 LL |         result.as_mut().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 

From 934e98d59135b64647e9756dafbd2151d67dd234 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Tue, 6 Aug 2024 21:38:14 +0200
Subject: [PATCH 126/685] Unify theme and settings menus

---
 util/gh-pages/index.html | 30 ++++---------
 util/gh-pages/script.js  | 93 +++++++++++++++++++---------------------
 util/gh-pages/style.css  | 47 ++++++++------------
 3 files changed, 72 insertions(+), 98 deletions(-)

diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index 12c9608f6f5f7..845e37feaddd3 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -26,27 +26,15 @@
     <link rel="stylesheet" href="style.css">
 </head>
 <body ng-app="clippy" ng-controller="lintList">
-    <div id="settings">
-        <div theme-dropdown class="theme-dropdown">
-            <div class="menu-container">
-                <div id="theme-icon" class="theme-icon">&#128396;</div>
-                <ul id="theme-menu" class="theme-choice">
-                    <li id="{{id}}" ng-repeat="(id, name) in themes" ng-click="selectTheme(id)">{{name}}</li>
-                </ul>
-            </div>
-        </div>
-        <div settings-dropdown class="settings-dropdown">
-            <div class="menu-container">
-                <div id="settings-icon" class="settings-icon"></div>
-                <ul id="settings-menu" class="settings-choice">
-                    <li>
-                        <label>
-                            <input type="checkbox" id="disable-shortcuts" onchange="changeSetting(this)">
-                            <span>Disable keyboard shortcuts</span>
-                        </label>
-                    </li>
-                </ul>
-            </div>
+    <div id="settings-dropdown">
+        <div class="settings-icon" tabindex="-1"></div>
+        <div class="settings-menu" tabindex="-1">
+            <div class="setting-radio-name">Theme</div>
+            <select id="theme-choice" onchange="setTheme(this.value, true)"></select>
+            <label>
+                <input type="checkbox" id="disable-shortcuts" onchange="changeSetting(this)">
+                <span>Disable keyboard shortcuts</span>
+            </label>
         </div>
     </div>
 
diff --git a/util/gh-pages/script.js b/util/gh-pages/script.js
index f072327bc340f..fc643309db366 100644
--- a/util/gh-pages/script.js
+++ b/util/gh-pages/script.js
@@ -50,42 +50,6 @@
                 );
             };
         })
-        .directive('themeDropdown', function ($document) {
-            return {
-                restrict: 'A',
-                link: function ($scope, $element, $attr) {
-                    $element.bind('click', function () {
-                        $element.toggleClass('open');
-                        $element.addClass('open-recent');
-                    });
-
-                    $document.bind('click', function () {
-                        if (!$element.hasClass('open-recent')) {
-                            $element.removeClass('open');
-                        }
-                        $element.removeClass('open-recent');
-                    })
-                }
-            }
-        })
-        .directive('settingsDropdown', function ($document) {
-            return {
-                restrict: 'A',
-                link: function ($scope, $element, $attr) {
-                    $element.bind('click', function () {
-                        $element.toggleClass('open');
-                        $element.addClass('open-recent');
-                    });
-
-                    $document.bind('click', function () {
-                        if (!$element.hasClass('open-recent')) {
-                            $element.removeClass('open');
-                        }
-                        $element.removeClass('open-recent');
-                    })
-                }
-            }
-        })
         .directive('filterDropdown', function ($document) {
             return {
                 restrict: 'A',
@@ -145,15 +109,6 @@
                 ...GROUPS_FILTER_DEFAULT
             };
 
-            const THEMES_DEFAULT = {
-                light: "Light",
-                rust: "Rust",
-                coal: "Coal",
-                navy: "Navy",
-                ayu: "Ayu"
-            };
-            $scope.themes = THEMES_DEFAULT;
-
             $scope.versionFilters = {
                 "≥": {enabled: false, minorVersion: null },
                 "≤": {enabled: false, minorVersion: null },
@@ -339,10 +294,6 @@
                 $location.path($scope.search);
             }
 
-            $scope.selectTheme = function (theme) {
-                setTheme(theme, true);
-            }
-
             $scope.toggleLevels = function (value) {
                 const levels = $scope.levels;
                 for (const key in levels) {
@@ -598,6 +549,8 @@ function setTheme(theme, store) {
 
     if (store) {
         storeValue("theme", theme);
+    } else {
+        document.getElementById(`theme-choice`).value = theme;
     }
 }
 
@@ -634,6 +587,48 @@ function changeSetting(elem) {
     }
 }
 
+function onEachLazy(lazyArray, func) {
+    const arr = Array.prototype.slice.call(lazyArray);
+    for (const el of arr) {
+        func(el);
+    }
+}
+
+function handleBlur(event) {
+    const parent = document.getElementById("settings-dropdown");
+    if (!parent.contains(document.activeElement) &&
+        !parent.contains(event.relatedTarget)
+    ) {
+        parent.classList.remove("open");
+    }
+}
+
+function generateSettings() {
+    const THEMES = ["Ayu", "Coal", "Light", "Navy", "Rust"];
+    const themesElem = document.getElementById("theme-choice");
+    let children = '';
+
+    for (const theme of THEMES) {
+        const id = theme.toLowerCase();
+        children += `<option value="${id}">${theme}</option>`;
+    }
+    themesElem.innerHTML = children;
+    themesElem.onblur = handleBlur;
+
+    const settings = document.getElementById("settings-dropdown");
+    const settingsButton = settings.querySelector(".settings-icon")
+    settingsButton.onclick = () => settings.classList.toggle("open");
+    settingsButton.onblur = handleBlur;
+    const settingsMenu = settings.querySelector(".settings-menu");
+    settingsMenu.onblur = handleBlur;
+    onEachLazy(
+        settingsMenu.querySelectorAll("input"),
+        el => el.onblur = handleBlur,
+    );
+}
+
+generateSettings();
+
 // loading the theme after the initial load
 const prefersDark = window.matchMedia("(prefers-color-scheme: dark)");
 const theme = loadValue('theme');
diff --git a/util/gh-pages/style.css b/util/gh-pages/style.css
index 4ad8b502dd82f..a9485d511047a 100644
--- a/util/gh-pages/style.css
+++ b/util/gh-pages/style.css
@@ -220,20 +220,15 @@ details[open] {
     --inline-code-bg: #191f26;
 }
 
-#settings {
+#settings-dropdown {
     position: absolute;
     margin: 0.7em;
     z-index: 10;
     display: flex;
 }
 
-.menu-container {
-    position: relative;
-    width: 28px;
-}
-
 /* Applying the mdBook theme */
-.theme-icon, .settings-icon {
+.settings-icon {
     text-align: center;
     width: 2em;
     height: 2em;
@@ -242,24 +237,20 @@ details[open] {
     border-radius: 5px;
     user-select: none;
     cursor: pointer;
-}
-.theme-icon:hover, .settings-icon:hover {
     background: var(--theme-hover);
 }
-.theme-choice, .settings-choice {
+.settings-menu {
     display: none;
     list-style: none;
     border: 1px solid var(--theme-popup-border);
     border-radius: 5px;
     color: var(--fg);
     background: var(--theme-popup-bg);
-    padding: 0 0;
     overflow: hidden;
+    padding: 9px;
+    width: 207px;
     position: absolute;
-}
-
-.settings-dropdown {
-    margin-left: 4px;
+    top: 28px;
 }
 
 .settings-icon::before {
@@ -285,28 +276,28 @@ L4.75,12h2.5l0.5393066-2.1572876  c0.2276001-0.1062012,0.4459839-0.2269287,0.649
   padding-top: 3px;
 }
 
-.settings-choice {
-    padding: 4px;
-    width: 212px;
+.settings-menu * {
+    font-weight: normal;
 }
 
-.settings-choice label {
+.settings-menu label {
     cursor: pointer;
 }
 
-.theme-dropdown.open .theme-choice, .settings-dropdown.open .settings-choice {
+#settings-dropdown.open .settings-menu {
     display: block;
 }
 
-.theme-choice > li {
-    padding: 5px 10px;
-    font-size: 0.8em;
-    user-select: none;
+#theme-choice {
+    margin-bottom: 10px;
+    background: var(--searchbar-bg);
+    color: var(--searchbar-fg);
+    border-color: var(--theme-popup-border);
+    border-radius: 5px;
     cursor: pointer;
-}
-
-.theme-choice > li:hover {
-    background: var(--theme-hover);
+    width: 100%;
+    border-width: 1px;
+    padding: 5px;
 }
 
 .alert {

From 2ae6a4954b21e26bfc3d612c8e4dd8b23dc483a1 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 11 Aug 2024 19:44:14 +0200
Subject: [PATCH 127/685] Move themes directly into HTML

---
 util/gh-pages/index.html |  8 +++++++-
 util/gh-pages/script.js  | 11 -----------
 2 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index 845e37feaddd3..37f964c226c99 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -30,7 +30,13 @@
         <div class="settings-icon" tabindex="-1"></div>
         <div class="settings-menu" tabindex="-1">
             <div class="setting-radio-name">Theme</div>
-            <select id="theme-choice" onchange="setTheme(this.value, true)"></select>
+            <select id="theme-choice" onchange="setTheme(this.value, true)">
+                <option value="ayu">Ayu</option>
+                <option value="coal">Coal</option>
+                <option value="light">Light</option>
+                <option value="navy">Navy</option>
+                <option value="rust">Rust</option>
+            </select>
             <label>
                 <input type="checkbox" id="disable-shortcuts" onchange="changeSetting(this)">
                 <span>Disable keyboard shortcuts</span>
diff --git a/util/gh-pages/script.js b/util/gh-pages/script.js
index fc643309db366..d54b5e851c7c0 100644
--- a/util/gh-pages/script.js
+++ b/util/gh-pages/script.js
@@ -604,17 +604,6 @@ function handleBlur(event) {
 }
 
 function generateSettings() {
-    const THEMES = ["Ayu", "Coal", "Light", "Navy", "Rust"];
-    const themesElem = document.getElementById("theme-choice");
-    let children = '';
-
-    for (const theme of THEMES) {
-        const id = theme.toLowerCase();
-        children += `<option value="${id}">${theme}</option>`;
-    }
-    themesElem.innerHTML = children;
-    themesElem.onblur = handleBlur;
-
     const settings = document.getElementById("settings-dropdown");
     const settingsButton = settings.querySelector(".settings-icon")
     settingsButton.onclick = () => settings.classList.toggle("open");

From a561484b819711117ec81abc3a9f66f5659f3642 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Fri, 9 Aug 2024 22:33:40 -0400
Subject: [PATCH 128/685] Enable debuginfo tests that have been temporarily
 disabled for years

---
 .../debuginfo/basic-types-globals-metadata.rs |  1 -
 tests/debuginfo/basic-types-metadata.rs       | 21 +++++++-------
 tests/debuginfo/basic-types.rs                |  3 --
 .../by-value-non-immediate-argument.rs        | 15 ++++++----
 tests/debuginfo/c-style-enum.rs               |  1 -
 tests/debuginfo/cross-crate-spans.rs          |  4 ---
 .../destructured-for-loop-variable.rs         |  4 ---
 tests/debuginfo/drop-locations.rs             |  5 ++--
 .../debuginfo/function-arg-initialization.rs  |  7 ++---
 .../function-prologue-stepping-regular.rs     |  3 +-
 .../lexical-scopes-in-block-expression.rs     |  1 -
 tests/debuginfo/limited-debuginfo.rs          |  1 -
 tests/debuginfo/macro-stepping.rs             |  3 +-
 tests/debuginfo/method-on-enum.rs             |  4 +--
 tests/debuginfo/option-like-enum.rs           | 11 ++++----
 tests/debuginfo/pretty-std-collections.rs     |  1 +
 tests/debuginfo/pretty-std.rs                 | 28 +++++++++----------
 tests/debuginfo/rc_arc.rs                     |  2 +-
 tests/debuginfo/simple-struct.rs              |  1 -
 tests/debuginfo/simple-tuple.rs               |  1 -
 tests/debuginfo/struct-in-enum.rs             |  3 +-
 tests/debuginfo/union-smoke.rs                |  1 -
 tests/debuginfo/vec.rs                        |  1 -
 23 files changed, 51 insertions(+), 71 deletions(-)

diff --git a/tests/debuginfo/basic-types-globals-metadata.rs b/tests/debuginfo/basic-types-globals-metadata.rs
index d346b405555bc..13678c31e765b 100644
--- a/tests/debuginfo/basic-types-globals-metadata.rs
+++ b/tests/debuginfo/basic-types-globals-metadata.rs
@@ -1,5 +1,4 @@
 //@ min-lldb-version: 310
-//@ ignore-gdb // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 
 //@ compile-flags:-g
 // gdb-command:run
diff --git a/tests/debuginfo/basic-types-metadata.rs b/tests/debuginfo/basic-types-metadata.rs
index 5f953c81a138d..3aebf2577b6b3 100644
--- a/tests/debuginfo/basic-types-metadata.rs
+++ b/tests/debuginfo/basic-types-metadata.rs
@@ -1,5 +1,4 @@
 //@ min-lldb-version: 310
-//@ ignore-gdb // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 
 //@ compile-flags:-g
 // gdb-command:run
@@ -36,12 +35,12 @@
 // gdb-command:whatis f64
 // gdb-check:type = f64
 // gdb-command:whatis fnptr
-// gdb-check:type = [...] (*)([...])
+// gdb-check:type = *mut fn ()
 // gdb-command:info functions _yyy
 // gdbg-check:[...]![...]_yyy([...]);
-// gdbr-check:static fn basic_types_metadata::_yyy() -> !;
+// gdbr-check:static fn basic_types_metadata::_yyy();
 // gdb-command:ptype closure_0
-// gdbr-check: type = struct closure
+// gdbr-check: type = struct basic_types_metadata::main::{closure_env#0}
 // gdbg-check: type = struct closure {
 // gdbg-check:     <no data fields>
 // gdbg-check: }
@@ -49,18 +48,18 @@
 // gdbg-check: type = struct closure {
 // gdbg-check:     bool *__0;
 // gdbg-check: }
-// gdbr-check: type = struct closure (
-// gdbr-check:     bool *,
-// gdbr-check: )
+// gdbr-check: type = struct basic_types_metadata::main::{closure_env#1} {
+// gdbr-check:     *mut bool,
+// gdbr-check: }
 // gdb-command:ptype closure_2
 // gdbg-check: type = struct closure {
 // gdbg-check:     bool *__0;
 // gdbg-check:     isize *__1;
 // gdbg-check: }
-// gdbr-check: type = struct closure (
-// gdbr-check:     bool *,
-// gdbr-check:     isize *,
-// gdbr-check: )
+// gdbr-check: type = struct basic_types_metadata::main::{closure_env#2} {
+// gdbr-check:     *mut bool,
+// gdbr-check:     *mut isize,
+// gdbr-check: }
 
 //
 // gdb-command:continue
diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs
index 10ffd74d3e909..d836525240ae2 100644
--- a/tests/debuginfo/basic-types.rs
+++ b/tests/debuginfo/basic-types.rs
@@ -6,9 +6,6 @@
 
 //@ min-lldb-version: 310
 
-// This fails on lldb 6.0.1 on x86-64 Fedora 28; so ignore Linux for now.
-//@ ignore-linux
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/by-value-non-immediate-argument.rs b/tests/debuginfo/by-value-non-immediate-argument.rs
index e0ae4458d03e5..cf1008387cbb9 100644
--- a/tests/debuginfo/by-value-non-immediate-argument.rs
+++ b/tests/debuginfo/by-value-non-immediate-argument.rs
@@ -1,6 +1,11 @@
-//@ ignore-test // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
-//@ min-lldb-version: 310
-
+// The gdb that we use in CI for aarch64-unknown-linux-gnu and x86_64-pc-windows-gnu seems unable
+// to handle by-value non-immediate arguments, which is the whole point of this test.
+// gdb on those platforms (or the version we test) just prints <optimized out> for structs/tuples
+// and attempts to read memory at 0x0 for enums.
+//@ ignore-aarch64: #128973
+//@ ignore-windows-gnu
+
+//@ min-lldb-version: 1800
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
@@ -42,11 +47,11 @@
 // lldb-command:run
 
 // lldb-command:v s
-// lldb-check:[...] Struct { a: 1, b: 2.5 }
+// lldb-check:[...] Struct { a = 1 b = 2.5 }
 // lldb-command:continue
 
 // lldb-command:v x
-// lldb-check:[...] Struct { a: 3, b: 4.5 }
+// lldb-check:[...] Struct { a = 3 b = 4.5 }
 // lldb-command:v y
 // lldb-check:[...] 5
 // lldb-command:v z
diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs
index 395b94c59a445..2ab5d5ccf2cbe 100644
--- a/tests/debuginfo/c-style-enum.rs
+++ b/tests/debuginfo/c-style-enum.rs
@@ -1,5 +1,4 @@
 //@ ignore-aarch64
-//@ ignore-gdb // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 //@ min-lldb-version: 310
 
 //@ compile-flags:-g
diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs
index cf3f8e1eadf40..a93c8f46930e5 100644
--- a/tests/debuginfo/cross-crate-spans.rs
+++ b/tests/debuginfo/cross-crate-spans.rs
@@ -3,10 +3,6 @@
 
 //@ min-lldb-version: 310
 
-// This fails on lldb 6.0.1 on x86-64 Fedora 28; so mark it macOS-only
-// for now.
-//@ only-macos
-
 //@ aux-build:cross_crate_spans.rs
 extern crate cross_crate_spans;
 
diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs
index 1cad8bcfacbe4..a8c7cc1489f62 100644
--- a/tests/debuginfo/destructured-for-loop-variable.rs
+++ b/tests/debuginfo/destructured-for-loop-variable.rs
@@ -1,9 +1,5 @@
 //@ min-lldb-version: 310
 
-// This fails on lldb 6.0.1 on x86-64 Fedora 28; so mark it macOS-only
-// for now.
-//@ only-macos
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/drop-locations.rs b/tests/debuginfo/drop-locations.rs
index 15b2d0de7fe99..0777313d19804 100644
--- a/tests/debuginfo/drop-locations.rs
+++ b/tests/debuginfo/drop-locations.rs
@@ -1,12 +1,11 @@
 //@ ignore-windows
 //@ ignore-android
-//@ ignore-test // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 //@ min-lldb-version: 310
+//@ ignore-test: #128971
 
 #![allow(unused)]
 
-//@ compile-flags:-g -O -C no-prepopulate-passes
-// -O -C no-prepopulate-passes added to work around https://bugs.llvm.org/show_bug.cgi?id=32123
+//@ compile-flags:-g
 
 // This test checks that drop glue code gets attributed to scope's closing brace,
 // and function epilogues - to function's closing brace.
diff --git a/tests/debuginfo/function-arg-initialization.rs b/tests/debuginfo/function-arg-initialization.rs
index 05935c30bea5d..c641a35c9a58c 100644
--- a/tests/debuginfo/function-arg-initialization.rs
+++ b/tests/debuginfo/function-arg-initialization.rs
@@ -1,6 +1,3 @@
-//@ ignore-test // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
-//@ min-lldb-version: 310
-
 // This test case checks if function arguments already have the correct value
 // when breaking at the first line of the function, that is if the function
 // prologue has already been executed at the first line. Note that because of
@@ -8,7 +5,9 @@
 // arguments have been properly loaded when setting the breakpoint via the
 // function name.
 
-//@ compile-flags:-g
+//@ min-lldb-version: 1800
+//@ compile-flags:-g -Zmir-enable-passes=-SingleUseConsts
+// SingleUseConsts shouldn't need to be disabled, see #128945
 
 // === GDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/function-prologue-stepping-regular.rs b/tests/debuginfo/function-prologue-stepping-regular.rs
index a1f44105bb94a..07b9356fb507f 100644
--- a/tests/debuginfo/function-prologue-stepping-regular.rs
+++ b/tests/debuginfo/function-prologue-stepping-regular.rs
@@ -1,9 +1,8 @@
 // This test case checks if function arguments already have the correct value when breaking at the
 // beginning of a function.
 
-//@ min-lldb-version: 310
+//@ min-lldb-version: 1800
 //@ ignore-gdb
-//@ ignore-test // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 //@ compile-flags:-g
 
 // lldb-command:breakpoint set --name immediate_args
diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs
index 5ff70270ea62a..bd5a607586dc5 100644
--- a/tests/debuginfo/lexical-scopes-in-block-expression.rs
+++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs
@@ -1,5 +1,4 @@
 //@ min-lldb-version: 310
-//@ ignore-gdb // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/limited-debuginfo.rs b/tests/debuginfo/limited-debuginfo.rs
index 32f14955bfa31..2e49acd240170 100644
--- a/tests/debuginfo/limited-debuginfo.rs
+++ b/tests/debuginfo/limited-debuginfo.rs
@@ -1,5 +1,4 @@
 //@ ignore-lldb
-//@ ignore-gdb // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 
 //@ compile-flags:-C debuginfo=1
 
diff --git a/tests/debuginfo/macro-stepping.rs b/tests/debuginfo/macro-stepping.rs
index 5f8d82871681f..bb465d9fb2932 100644
--- a/tests/debuginfo/macro-stepping.rs
+++ b/tests/debuginfo/macro-stepping.rs
@@ -2,7 +2,6 @@
 //@ ignore-android
 //@ ignore-aarch64
 //@ min-lldb-version: 310
-//@ ignore-gdb // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 
 //@ aux-build:macro-stepping.rs
 
@@ -11,7 +10,7 @@
 #[macro_use]
 extern crate macro_stepping; // exports new_scope!()
 
-//@ compile-flags:-g
+//@ compile-flags:-g -Zmir-enable-passes=-SingleUseConsts
 
 // === GDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/method-on-enum.rs b/tests/debuginfo/method-on-enum.rs
index 8a57060717e47..c84dc34850780 100644
--- a/tests/debuginfo/method-on-enum.rs
+++ b/tests/debuginfo/method-on-enum.rs
@@ -1,5 +1,5 @@
-//@ min-lldb-version: 310
-//@ ignore-test // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
+//@ min-lldb-version: 1800
+//@ ignore-i686-pc-windows-gnu
 
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/option-like-enum.rs b/tests/debuginfo/option-like-enum.rs
index c782796f47316..10e512a16c5da 100644
--- a/tests/debuginfo/option-like-enum.rs
+++ b/tests/debuginfo/option-like-enum.rs
@@ -1,6 +1,5 @@
-//@ ignore-test // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
-
-//@ min-lldb-version: 310
+//@ min-lldb-version: 1800
+//@ ignore-i686-pc-windows-gnu
 
 //@ compile-flags:-g
 
@@ -22,7 +21,7 @@
 
 // gdbg-command:print empty_gdb->discr
 // gdbr-command:print empty_gdb.discr
-// gdb-check:$4 = (isize *) 0x0
+// gdb-check:$4 = (*mut isize) 0x1
 
 // gdb-command:print droid
 // gdbg-check:$5 = {RUST$ENCODED$ENUM$2$Void = {id = 675675, range = 10000001, internals = 0x43218765}}
@@ -30,11 +29,11 @@
 
 // gdbg-command:print void_droid_gdb->internals
 // gdbr-command:print void_droid_gdb.internals
-// gdb-check:$6 = (isize *) 0x0
+// gdb-check:$6 = (*mut isize) 0x1
 
 // gdb-command:print nested_non_zero_yep
 // gdbg-check:$7 = {RUST$ENCODED$ENUM$1$2$Nope = {__0 = 10.5, __1 = {a = 10, b = 20, c = [...]}}}
-// gdbr-check:$7 = option_like_enum::NestedNonZero::Yep(10.5, option_like_enum::NestedNonZeroField {a: 10, b: 20, c: 0x[...] "x[...]"})
+// gdbr-check:$7 = option_like_enum::NestedNonZero::Yep(10.5, option_like_enum::NestedNonZeroField {a: 10, b: 20, c: 0x[...]})
 
 // gdb-command:print nested_non_zero_nope
 // gdbg-check:$8 = {RUST$ENCODED$ENUM$1$2$Nope = {__0 = [...], __1 = {a = [...], b = [...], c = 0x0}}}
diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs
index e9c2c4f2a1dab..7f518a886d700 100644
--- a/tests/debuginfo/pretty-std-collections.rs
+++ b/tests/debuginfo/pretty-std-collections.rs
@@ -1,6 +1,7 @@
 //@ ignore-windows failing on win32 bot
 //@ ignore-freebsd: gdb package too new
 //@ ignore-android: FIXME(#10381)
+//@ ignore-windows-gnu: #128981
 //@ compile-flags:-g
 
 // The pretty printers being tested here require the patch from
diff --git a/tests/debuginfo/pretty-std.rs b/tests/debuginfo/pretty-std.rs
index 70827d551ca39..0fbd763c61c3a 100644
--- a/tests/debuginfo/pretty-std.rs
+++ b/tests/debuginfo/pretty-std.rs
@@ -1,10 +1,10 @@
 // ignore-tidy-linelength
 //@ ignore-freebsd: gdb package too new
-//@ only-cdb // "Temporarily" ignored on GDB/LLDB due to debuginfo tests being disabled, see PR 47155
+//@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
 //@ min-gdb-version: 7.7
-//@ min-lldb-version: 310
+//@ min-lldb-version: 1800
 //@ min-cdb-version: 10.0.18317.1001
 
 // === GDB TESTS ===================================================================================
@@ -12,10 +12,10 @@
 // gdb-command: run
 
 // gdb-command: print slice
-// gdb-check:$1 = &[i32](len: 4) = {0, 1, 2, 3}
+// gdb-check:$1 = &[i32](size=4) = {0, 1, 2, 3}
 
 // gdb-command: print vec
-// gdb-check:$2 = Vec<u64, alloc::alloc::Global>(len: 4, cap: [...]) = {4, 5, 6, 7}
+// gdb-check:$2 = Vec(size=4) = {4, 5, 6, 7}
 
 // gdb-command: print str_slice
 // gdb-check:$3 = "IAMA string slice!"
@@ -24,37 +24,37 @@
 // gdb-check:$4 = "IAMA string!"
 
 // gdb-command: print some
-// gdb-check:$5 = Some = {8}
+// gdb-check:$5 = core::option::Option<i16>::Some(8)
 
 // gdb-command: print none
 // gdbg-check:$6 = None
-// gdbr-check:$6 = core::option::Option::None
+// gdbr-check:$6 = core::option::Option<i64>::None
 
 // gdb-command: print os_string
 // gdb-check:$7 = "IAMA OS string 😃"
 
 // gdb-command: print some_string
-// gdb-check:$8 = Some = {"IAMA optional string!"}
+// gdb-check:$8 = core::option::Option<alloc::string::String>::Some("IAMA optional string!")
 
-// gdb-command: set print length 5
+// gdb-command: set print elements 5
 // gdb-command: print some_string
-// gdb-check:$8 = Some = {"IAMA "...}
+// gdb-check:$9 = core::option::Option<alloc::string::String>::Some("IAMA "...)
 
 // === LLDB TESTS ==================================================================================
 
 // lldb-command:run
 
 // lldb-command:v slice
-// lldb-check:[...] slice = &[0, 1, 2, 3]
+// lldb-check:[...] slice = size=4 { [0] = 0 [1] = 1 [2] = 2 [3] = 3 }
 
 // lldb-command:v vec
-// lldb-check:[...] vec = vec![4, 5, 6, 7]
+// lldb-check:[...] vec = size=4 { [0] = 4 [1] = 5 [2] = 6 [3] = 7 }
 
 // lldb-command:v str_slice
-// lldb-check:[...] str_slice = "IAMA string slice!"
+// lldb-check:[...] str_slice = "IAMA string slice!" { [0] = 'I' [1] = 'A' [2] = 'M' [3] = 'A' [4] = ' ' [5] = 's' [6] = 't' [7] = 'r' [8] = 'i' [9] = 'n' [10] = 'g' [11] = ' ' [12] = 's' [13] = 'l' [14] = 'i' [15] = 'c' [16] = 'e' [17] = '!' }
 
 // lldb-command:v string
-// lldb-check:[...] string = "IAMA string!"
+// lldb-check:[...] string = "IAMA string!" { vec = size=12 { [0] = 'I' [1] = 'A' [2] = 'M' [3] = 'A' [4] = ' ' [5] = 's' [6] = 't' [7] = 'r' [8] = 'i' [9] = 'n' [10] = 'g' [11] = '!' } }
 
 // lldb-command:v some
 // lldb-check:[...] some = Some(8)
@@ -63,7 +63,7 @@
 // lldb-check:[...] none = None
 
 // lldb-command:v os_string
-// lldb-check:[...] os_string = "IAMA OS string 😃"[...]
+// lldb-check:[...] os_string = "IAMA OS string 😃" { inner = { inner = size=19 { [0] = 'I' [1] = 'A' [2] = 'M' [3] = 'A' [4] = ' ' [5] = 'O' [6] = 'S' [7] = ' ' [8] = 's' [9] = 't' [10] = 'r' [11] = 'i' [12] = 'n' [13] = 'g' [14] = ' ' [15] = '\xf0' [16] = '\x9f' [17] = '\x98' [18] = '\x83' } } }
 
 // === CDB TESTS ==================================================================================
 
diff --git a/tests/debuginfo/rc_arc.rs b/tests/debuginfo/rc_arc.rs
index ca0feb1f465b6..688dc625ce44d 100644
--- a/tests/debuginfo/rc_arc.rs
+++ b/tests/debuginfo/rc_arc.rs
@@ -1,4 +1,4 @@
-//@ ignore-windows-gnu: pretty-printers are not loaded
+//@ ignore-windows-gnu: #128981
 //@ compile-flags:-g
 
 //@ min-gdb-version: 8.1
diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs
index 968a5c63e89a3..aaa654aeb7a67 100644
--- a/tests/debuginfo/simple-struct.rs
+++ b/tests/debuginfo/simple-struct.rs
@@ -1,5 +1,4 @@
 //@ min-lldb-version: 310
-//@ ignore-gdb // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 
 //@ compile-flags: -g -Zmir-enable-passes=-CheckAlignment
 
diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs
index 86003105f360e..9d809a11cac52 100644
--- a/tests/debuginfo/simple-tuple.rs
+++ b/tests/debuginfo/simple-tuple.rs
@@ -1,5 +1,4 @@
 //@ min-lldb-version: 310
-//@ ignore-gdb // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/struct-in-enum.rs b/tests/debuginfo/struct-in-enum.rs
index 52e419e6b4745..e4b647a4ac16b 100644
--- a/tests/debuginfo/struct-in-enum.rs
+++ b/tests/debuginfo/struct-in-enum.rs
@@ -1,6 +1,5 @@
-//@ min-lldb-version: 310
+//@ min-lldb-version: 1800
 //@ ignore-gdb-version: 7.11.90 - 7.12.9
-//@ ignore-test // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs
index 9b1cf6e1e95c9..d786ba612714a 100644
--- a/tests/debuginfo/union-smoke.rs
+++ b/tests/debuginfo/union-smoke.rs
@@ -1,5 +1,4 @@
 //@ min-lldb-version: 310
-//@ ignore-gdb // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 
 //@ ignore-gdb-version: 7.11.90 - 7.12.9
 
diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs
index cf7de0b9b5519..20cfd785ca7f0 100644
--- a/tests/debuginfo/vec.rs
+++ b/tests/debuginfo/vec.rs
@@ -1,5 +1,4 @@
 //@ min-lldb-version: 310
-//@ ignore-gdb // Test temporarily ignored due to debuginfo tests being disabled, see PR 47155
 
 //@ compile-flags:-g
 

From ddf2ba58860b5858a8e57e39595133b2509e955a Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sun, 11 Aug 2024 17:59:35 -0400
Subject: [PATCH 129/685] Remove more instances of `snippet_opt`.

---
 clippy_lints/src/attrs/empty_line_after.rs    |  4 +--
 clippy_lints/src/attrs/non_minimal_cfg.rs     | 11 +++++---
 .../src/attrs/unnecessary_clippy_cfg.rs       | 11 +++-----
 clippy_lints/src/attrs/useless_attribute.rs   | 10 ++++----
 clippy_lints/src/casts/as_ptr_cast_mut.rs     |  4 +--
 clippy_lints/src/manual_async_fn.rs           |  8 +++---
 clippy_lints/src/needless_pass_by_value.rs    | 10 ++++----
 clippy_lints/src/pathbuf_init_then_push.rs    |  8 +++---
 clippy_lints/src/ptr.rs                       | 14 ++++++-----
 clippy_lints/src/ptr_offset_with_cast.rs      |  6 ++---
 clippy_lints/src/redundant_clone.rs           |  4 +--
 clippy_lints/src/reference.rs                 | 10 ++++----
 clippy_lints/src/regex.rs                     |  4 +--
 clippy_lints/src/returns.rs                   | 25 +++++++++++--------
 clippy_lints/src/single_range_in_vec_init.rs  |  8 +++---
 clippy_lints/src/trait_bounds.rs              | 10 +++-----
 clippy_lints/src/unused_unit.rs               | 22 ++++++++--------
 clippy_lints/src/visibility.rs                | 14 +++++------
 clippy_lints/src/write.rs                     |  8 +++---
 clippy_utils/src/source.rs                    | 11 +++++++-
 20 files changed, 109 insertions(+), 93 deletions(-)

diff --git a/clippy_lints/src/attrs/empty_line_after.rs b/clippy_lints/src/attrs/empty_line_after.rs
index ca43e76ac5780..7ff644b4c445f 100644
--- a/clippy_lints/src/attrs/empty_line_after.rs
+++ b/clippy_lints/src/attrs/empty_line_after.rs
@@ -1,6 +1,6 @@
 use super::{EMPTY_LINE_AFTER_DOC_COMMENTS, EMPTY_LINE_AFTER_OUTER_ATTR};
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::source::{is_present_in_source, snippet_opt, without_block_comments};
+use clippy_utils::source::{is_present_in_source, without_block_comments, SpanRangeExt};
 use rustc_ast::{AttrKind, AttrStyle};
 use rustc_lint::EarlyContext;
 use rustc_span::Span;
@@ -26,7 +26,7 @@ pub(super) fn check(cx: &EarlyContext<'_>, item: &rustc_ast::Item) {
                 item.span.parent(),
             );
 
-            if let Some(snippet) = snippet_opt(cx, end_of_attr_to_next_attr_or_item) {
+            if let Some(snippet) = end_of_attr_to_next_attr_or_item.get_source_text(cx) {
                 let lines = snippet.split('\n').collect::<Vec<_>>();
                 let lines = without_block_comments(lines);
 
diff --git a/clippy_lints/src/attrs/non_minimal_cfg.rs b/clippy_lints/src/attrs/non_minimal_cfg.rs
index 3fde70615853d..877025cce4c2b 100644
--- a/clippy_lints/src/attrs/non_minimal_cfg.rs
+++ b/clippy_lints/src/attrs/non_minimal_cfg.rs
@@ -1,6 +1,6 @@
 use super::{Attribute, NON_MINIMAL_CFG};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_ast::{MetaItemKind, NestedMetaItem};
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;
@@ -29,8 +29,13 @@ fn check_nested_cfg(cx: &EarlyContext<'_>, items: &[NestedMetaItem]) {
                         meta.span,
                         "unneeded sub `cfg` when there is only one condition",
                         |diag| {
-                            if let Some(snippet) = snippet_opt(cx, list[0].span()) {
-                                diag.span_suggestion(meta.span, "try", snippet, Applicability::MaybeIncorrect);
+                            if let Some(snippet) = list[0].span().get_source_text(cx) {
+                                diag.span_suggestion(
+                                    meta.span,
+                                    "try",
+                                    snippet.to_owned(),
+                                    Applicability::MaybeIncorrect,
+                                );
                             }
                         },
                     );
diff --git a/clippy_lints/src/attrs/unnecessary_clippy_cfg.rs b/clippy_lints/src/attrs/unnecessary_clippy_cfg.rs
index 486e7c6ec4f4a..478ba7a187be5 100644
--- a/clippy_lints/src/attrs/unnecessary_clippy_cfg.rs
+++ b/clippy_lints/src/attrs/unnecessary_clippy_cfg.rs
@@ -1,6 +1,7 @@
 use super::{Attribute, UNNECESSARY_CLIPPY_CFG};
 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_sugg};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
+use itertools::Itertools;
 use rustc_ast::AttrStyle;
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, Level};
@@ -31,7 +32,7 @@ pub(super) fn check(
             return;
         }
         if nb_items == clippy_lints.len() {
-            if let Some(snippet) = snippet_opt(cx, behind_cfg_attr.span) {
+            if let Some(snippet) = behind_cfg_attr.span.get_source_text(cx) {
                 span_lint_and_sugg(
                     cx,
                     UNNECESSARY_CLIPPY_CFG,
@@ -47,11 +48,7 @@ pub(super) fn check(
                 );
             }
         } else {
-            let snippet = clippy_lints
-                .iter()
-                .filter_map(|sp| snippet_opt(cx, *sp))
-                .collect::<Vec<_>>()
-                .join(",");
+            let snippet = clippy_lints.iter().filter_map(|sp| sp.get_source_text(cx)).join(",");
             span_lint_and_note(
                 cx,
                 UNNECESSARY_CLIPPY_CFG,
diff --git a/clippy_lints/src/attrs/useless_attribute.rs b/clippy_lints/src/attrs/useless_attribute.rs
index f0868231d01a3..67ba605a59fa5 100644
--- a/clippy_lints/src/attrs/useless_attribute.rs
+++ b/clippy_lints/src/attrs/useless_attribute.rs
@@ -1,7 +1,7 @@
 use super::utils::{extract_clippy_lint, is_lint_level, is_word};
 use super::{Attribute, USELESS_ATTRIBUTE};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::{first_line_of_span, snippet_opt};
+use clippy_utils::source::{first_line_of_span, SpanRangeExt};
 use rustc_ast::NestedMetaItem;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
@@ -69,14 +69,14 @@ pub(super) fn check(cx: &LateContext<'_>, item: &Item<'_>, attrs: &[Attribute])
                 }
                 let line_span = first_line_of_span(cx, attr.span);
 
-                if let Some(mut sugg) = snippet_opt(cx, line_span) {
-                    if sugg.contains("#[") {
+                if let Some(src) = line_span.get_source_text(cx) {
+                    if src.contains("#[") {
+                        #[expect(clippy::collapsible_span_lint_calls)]
                         span_lint_and_then(cx, USELESS_ATTRIBUTE, line_span, "useless lint attribute", |diag| {
-                            sugg = sugg.replacen("#[", "#![", 1);
                             diag.span_suggestion(
                                 line_span,
                                 "if you just forgot a `!`, use",
-                                sugg,
+                                src.replacen("#[", "#![", 1),
                                 Applicability::MaybeIncorrect,
                             );
                         });
diff --git a/clippy_lints/src/casts/as_ptr_cast_mut.rs b/clippy_lints/src/casts/as_ptr_cast_mut.rs
index f05fd3fcde500..15ecba20a0bc4 100644
--- a/clippy_lints/src/casts/as_ptr_cast_mut.rs
+++ b/clippy_lints/src/casts/as_ptr_cast_mut.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -19,7 +19,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         && let as_ptr_sig = cx.tcx.fn_sig(as_ptr_did).instantiate_identity()
         && let Some(first_param_ty) = as_ptr_sig.skip_binder().inputs().iter().next()
         && let ty::Ref(_, _, Mutability::Not) = first_param_ty.kind()
-        && let Some(recv) = snippet_opt(cx, receiver.span)
+        && let Some(recv) = receiver.span.get_source_text(cx)
     {
         // `as_mut_ptr` might not exist
         let applicability = Applicability::MaybeIncorrect;
diff --git a/clippy_lints/src/manual_async_fn.rs b/clippy_lints/src/manual_async_fn.rs
index 25c7e5d38b319..61723aec59049 100644
--- a/clippy_lints/src/manual_async_fn.rs
+++ b/clippy_lints/src/manual_async_fn.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::{position_before_rarrow, snippet_block, snippet_opt};
+use clippy_utils::source::{position_before_rarrow, snippet_block, SpanRangeExt};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
@@ -68,8 +68,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
                 header_span,
                 "this function can be simplified using the `async fn` syntax",
                 |diag| {
-                    if let Some(vis_snip) = snippet_opt(cx, *vis_span)
-                        && let Some(header_snip) = snippet_opt(cx, header_span)
+                    if let Some(vis_snip) = vis_span.get_source_text(cx)
+                        && let Some(header_snip) = header_span.get_source_text(cx)
                         && let Some(ret_pos) = position_before_rarrow(&header_snip)
                         && let Some((ret_sugg, ret_snip)) = suggested_ret(cx, output)
                     {
@@ -190,6 +190,6 @@ fn suggested_ret(cx: &LateContext<'_>, output: &Ty<'_>) -> Option<(&'static str,
         Some((sugg, String::new()))
     } else {
         let sugg = "return the output of the future directly";
-        snippet_opt(cx, output.span).map(|snip| (sugg, format!(" -> {snip}")))
+        output.span.get_source_text(cx).map(|src| (sugg, format!(" -> {src}")))
     }
 }
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
index a0bbf6b14b217..addb4b1aee807 100644
--- a/clippy_lints/src/needless_pass_by_value.rs
+++ b/clippy_lints/src/needless_pass_by_value.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_self;
 use clippy_utils::ptr::get_spans;
-use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::source::{snippet, SpanRangeExt};
 use clippy_utils::ty::{
     implements_trait, implements_trait_with_env_from_iter, is_copy, is_type_diagnostic_item, is_type_lang_item,
 };
@@ -242,8 +242,8 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                         for (span, suggestion) in clone_spans {
                             diag.span_suggestion(
                                 span,
-                                snippet_opt(cx, span)
-                                    .map_or("change the call to".into(), |x| format!("change `{x}` to")),
+                                span.get_source_text(cx)
+                                    .map_or("change the call to".to_owned(), |src| format!("change `{src}` to")),
                                 suggestion,
                                 Applicability::Unspecified,
                             );
@@ -267,8 +267,8 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
                             for (span, suggestion) in clone_spans {
                                 diag.span_suggestion(
                                     span,
-                                    snippet_opt(cx, span)
-                                        .map_or("change the call to".into(), |x| format!("change `{x}` to")),
+                                    span.get_source_text(cx)
+                                        .map_or("change the call to".to_owned(), |src| format!("change `{src}` to")),
                                     suggestion,
                                     Applicability::Unspecified,
                                 );
diff --git a/clippy_lints/src/pathbuf_init_then_push.rs b/clippy_lints/src/pathbuf_init_then_push.rs
index 18bfb588a1187..d7fa48c1e38dd 100644
--- a/clippy_lints/src/pathbuf_init_then_push.rs
+++ b/clippy_lints/src/pathbuf_init_then_push.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::path_to_local_id;
-use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::source::{snippet, SpanRangeExt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::{LitKind, StrStyle};
 use rustc_errors::Applicability;
@@ -74,7 +74,7 @@ impl<'tcx> PathbufPushSearcher<'tcx> {
             && let Some(arg) = self.arg
             && let ExprKind::Lit(x) = arg.kind
             && let LitKind::Str(_, StrStyle::Cooked) = x.node
-            && let Some(s) = snippet_opt(cx, arg.span)
+            && let Some(s) = arg.span.get_source_text(cx)
         {
             Some(format!(" = PathBuf::from({s});"))
         } else {
@@ -84,8 +84,8 @@ impl<'tcx> PathbufPushSearcher<'tcx> {
 
     fn gen_pathbuf_join(&self, cx: &LateContext<'_>) -> Option<String> {
         let arg = self.arg?;
-        let arg_str = snippet_opt(cx, arg.span)?;
-        let init_val = snippet_opt(cx, self.init_val.span)?;
+        let arg_str = arg.span.get_source_text(cx)?;
+        let init_val = self.init_val.span.get_source_text(cx)?;
         Some(format!(" = {init_val}.join({arg_str});"))
     }
 
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 02c05e0aaf9ce..1e824681fa12f 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -1,7 +1,7 @@
 //! Checks for usage of  `&Vec[_]` and `&String`.
 
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::expr_sig;
 use clippy_utils::visitors::contains_unsafe_block;
 use clippy_utils::{get_expr_use_or_unification_node, is_lint_allowed, path_def_id, path_to_local};
@@ -243,7 +243,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr {
                         .chain(result.replacements.iter().map(|r| {
                             (
                                 r.expr_span,
-                                format!("{}{}", snippet_opt(cx, r.self_span).unwrap(), r.replacement),
+                                format!("{}{}", r.self_span.get_source_text(cx).unwrap(), r.replacement),
                             )
                         }))
                         .collect(),
@@ -372,7 +372,7 @@ impl fmt::Display for DerefTyDisplay<'_, '_> {
             DerefTy::Path => f.write_str("Path"),
             DerefTy::Slice(hir_ty, ty) => {
                 f.write_char('[')?;
-                match hir_ty.and_then(|s| snippet_opt(self.0, s)) {
+                match hir_ty.and_then(|s| s.get_source_text(self.0)) {
                     Some(s) => f.write_str(&s)?,
                     None => ty.fmt(f)?,
                 }
@@ -413,6 +413,7 @@ impl<'tcx> DerefTy<'tcx> {
     }
 }
 
+#[expect(clippy::too_many_lines)]
 fn check_fn_args<'cx, 'tcx: 'cx>(
     cx: &'cx LateContext<'tcx>,
     fn_sig: ty::FnSig<'tcx>,
@@ -488,8 +489,6 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                                 return None;
                             }
 
-                            let ty_name = snippet_opt(cx, ty.span()).unwrap_or_else(|| args.type_at(1).to_string());
-
                             span_lint_hir_and_then(
                                 cx,
                                 PTR_ARG,
@@ -500,7 +499,10 @@ fn check_fn_args<'cx, 'tcx: 'cx>(
                                     diag.span_suggestion(
                                         hir_ty.span,
                                         "change this to",
-                                        format!("&{}{ty_name}", mutability.prefix_str()),
+                                        match ty.span().get_source_text(cx) {
+                                            Some(s) => format!("&{}{s}", mutability.prefix_str()),
+                                            None => format!("&{}{}", mutability.prefix_str(), args.type_at(1)),
+                                        },
                                         Applicability::Unspecified,
                                     );
                                 },
diff --git a/clippy_lints/src/ptr_offset_with_cast.rs b/clippy_lints/src/ptr_offset_with_cast.rs
index 7c82895d60919..87a52cb2186c5 100644
--- a/clippy_lints/src/ptr_offset_with_cast.rs
+++ b/clippy_lints/src/ptr_offset_with_cast.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -120,8 +120,8 @@ fn build_suggestion(
     receiver_expr: &Expr<'_>,
     cast_lhs_expr: &Expr<'_>,
 ) -> Option<String> {
-    let receiver = snippet_opt(cx, receiver_expr.span)?;
-    let cast_lhs = snippet_opt(cx, cast_lhs_expr.span)?;
+    let receiver = receiver_expr.span.get_source_text(cx)?;
+    let cast_lhs = cast_lhs_expr.span.get_source_text(cx)?;
     Some(format!("{receiver}.{}({cast_lhs})", method.suggestion()))
 }
 
diff --git a/clippy_lints/src/redundant_clone.rs b/clippy_lints/src/redundant_clone.rs
index a1231c082e68a..bfdc1cbeed7e1 100644
--- a/clippy_lints/src/redundant_clone.rs
+++ b/clippy_lints/src/redundant_clone.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
 use clippy_utils::mir::{visit_local_usage, LocalUsage, PossibleBorrowerMap};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::{has_drop, is_copy, is_type_diagnostic_item, is_type_lang_item, walk_ptrs_ty_depth};
 use clippy_utils::{fn_has_unsatisfiable_preds, match_def_path, paths};
 use rustc_errors::Applicability;
@@ -208,7 +208,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantClone {
                 .assert_crate_local()
                 .lint_root;
 
-            if let Some(snip) = snippet_opt(cx, span)
+            if let Some(snip) = span.get_source_text(cx)
                 && let Some(dot) = snip.rfind('.')
             {
                 let sugg_span = span.with_lo(span.lo() + BytePos(u32::try_from(dot).unwrap()));
diff --git a/clippy_lints/src/reference.rs b/clippy_lints/src/reference.rs
index 8f32cf5f2a1db..2b4ef21fc48e1 100644
--- a/clippy_lints/src/reference.rs
+++ b/clippy_lints/src/reference.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{snippet_opt, snippet_with_applicability};
+use clippy_utils::source::{snippet_with_applicability, SpanRangeExt};
 use rustc_ast::ast::{Expr, ExprKind, Mutability, UnOp};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::BytePos;
+use rustc_span::{BytePos, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -56,11 +56,11 @@ impl EarlyLintPass for DerefAddrOf {
         {
             let mut applicability = Applicability::MachineApplicable;
             let sugg = if e.span.from_expansion() {
-                if let Some(macro_source) = snippet_opt(cx, e.span) {
+                if let Some(macro_source) = e.span.get_source_text(cx) {
                     // Remove leading whitespace from the given span
                     // e.g: ` $visitor` turns into `$visitor`
-                    let trim_leading_whitespaces = |span| {
-                        snippet_opt(cx, span)
+                    let trim_leading_whitespaces = |span: Span| {
+                        span.get_source_text(cx)
                             .and_then(|snip| {
                                 #[expect(clippy::cast_possible_truncation)]
                                 snip.find(|c: char| !c.is_whitespace())
diff --git a/clippy_lints/src/regex.rs b/clippy_lints/src/regex.rs
index 95014b230431c..f6ef02b7c2330 100644
--- a/clippy_lints/src/regex.rs
+++ b/clippy_lints/src/regex.rs
@@ -2,7 +2,7 @@ use std::fmt::Display;
 
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::{def_path_def_ids, path_def_id, paths};
 use rustc_ast::ast::{LitKind, StrStyle};
 use rustc_hir::def_id::DefIdMap;
@@ -122,7 +122,7 @@ fn lint_syntax_error(cx: &LateContext<'_>, error: &regex_syntax::Error, unescape
     };
 
     if let Some((primary, auxiliary, kind)) = parts
-        && let Some(literal_snippet) = snippet_opt(cx, base)
+        && let Some(literal_snippet) = base.get_source_text(cx)
         && let Some(inner) = literal_snippet.get(offset as usize..)
         // Only convert to native rustc spans if the parsed regex matches the
         // source snippet exactly, to ensure the span offsets are correct
diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index 13016cdadb072..ffc9475cf9cdf 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
-use clippy_utils::source::{snippet_opt, snippet_with_context};
+use clippy_utils::source::{snippet_with_context, SpanRangeExt};
 use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::visitors::{for_each_expr, Descend};
 use clippy_utils::{
@@ -250,20 +250,25 @@ impl<'tcx> LateLintPass<'tcx> for Return {
                 |err| {
                     err.span_label(local.span, "unnecessary `let` binding");
 
-                    if let Some(mut snippet) = snippet_opt(cx, initexpr.span) {
-                        if binary_expr_needs_parentheses(initexpr) {
-                            if !has_enclosing_paren(&snippet) {
-                                snippet = format!("({snippet})");
+                    if let Some(src) = initexpr.span.get_source_text(cx) {
+                        let sugg = if binary_expr_needs_parentheses(initexpr) {
+                            if has_enclosing_paren(&src) {
+                                src.to_owned()
+                            } else {
+                                format!("({src})")
                             }
                         } else if !cx.typeck_results().expr_adjustments(retexpr).is_empty() {
-                            if !has_enclosing_paren(&snippet) {
-                                snippet = format!("({snippet})");
+                            if has_enclosing_paren(&src) {
+                                format!("{src} as _")
+                            } else {
+                                format!("({src}) as _")
                             }
-                            snippet.push_str(" as _");
-                        }
+                        } else {
+                            src.to_owned()
+                        };
                         err.multipart_suggestion(
                             "return the expression directly",
-                            vec![(local.span, String::new()), (retexpr.span, snippet)],
+                            vec![(local.span, String::new()), (retexpr.span, sugg)],
                             Applicability::MachineApplicable,
                         );
                     } else {
diff --git a/clippy_lints/src/single_range_in_vec_init.rs b/clippy_lints/src/single_range_in_vec_init.rs
index e05584296381c..44e585953bfb9 100644
--- a/clippy_lints/src/single_range_in_vec_init.rs
+++ b/clippy_lints/src/single_range_in_vec_init.rs
@@ -2,7 +2,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::get_trait_def_id;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::macros::root_macro_call_first_node;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::implements_trait;
 use rustc_ast::{LitIntType, LitKind, UintTy};
 use rustc_errors::Applicability;
@@ -92,12 +92,12 @@ impl LateLintPass<'_> for SingleRangeInVecInit {
 
         if matches!(lang_item, LangItem::Range)
             && let ty = cx.typeck_results().expr_ty(start.expr)
-            && let Some(snippet) = snippet_opt(cx, span)
+            && let Some(snippet) = span.get_source_text(cx)
             // `is_from_proc_macro` will skip any `vec![]`. Let's not!
             && snippet.starts_with(suggested_type.starts_with())
             && snippet.ends_with(suggested_type.ends_with())
-            && let Some(start_snippet) = snippet_opt(cx, start.span)
-            && let Some(end_snippet) = snippet_opt(cx, end.span)
+            && let Some(start_snippet) = start.span.get_source_text(cx)
+            && let Some(end_snippet) = end.span.get_source_text(cx)
         {
             let should_emit_every_value = if let Some(step_def_id) = get_trait_def_id(cx.tcx, &["core", "iter", "Step"])
                 && implements_trait(cx, ty, step_def_id, &[])
diff --git a/clippy_lints/src/trait_bounds.rs b/clippy_lints/src/trait_bounds.rs
index 59b74122f3084..2e87d36df3121 100644
--- a/clippy_lints/src/trait_bounds.rs
+++ b/clippy_lints/src/trait_bounds.rs
@@ -1,7 +1,7 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_sugg};
-use clippy_utils::source::{snippet, snippet_opt, snippet_with_applicability};
+use clippy_utils::source::{snippet, snippet_with_applicability, SpanRangeExt};
 use clippy_utils::{is_from_proc_macro, SpanlessEq, SpanlessHash};
 use core::hash::{Hash, Hasher};
 use itertools::Itertools;
@@ -206,8 +206,7 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
 
                 let fixed_trait_snippet = unique_traits
                     .iter()
-                    .filter_map(|b| snippet_opt(cx, b.span))
-                    .collect::<Vec<_>>()
+                    .filter_map(|b| b.span.get_source_text(cx))
                     .join(" + ");
 
                 span_lint_and_sugg(
@@ -462,9 +461,8 @@ fn rollup_traits(
 
         let traits = comparable_bounds
             .iter()
-            .filter_map(|&(_, span)| snippet_opt(cx, span))
-            .collect::<Vec<_>>();
-        let traits = traits.join(" + ");
+            .filter_map(|&(_, span)| span.get_source_text(cx))
+            .join(" + ");
 
         span_lint_and_sugg(
             cx,
diff --git a/clippy_lints/src/unused_unit.rs b/clippy_lints/src/unused_unit.rs
index b70aa768b46b1..65f431d338bdb 100644
--- a/clippy_lints/src/unused_unit.rs
+++ b/clippy_lints/src/unused_unit.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{position_before_rarrow, snippet_opt};
+use clippy_utils::source::{position_before_rarrow, SpanRangeExt};
 use rustc_ast::visit::FnKind;
 use rustc_ast::{ast, ClosureBinder};
 use rustc_errors::Applicability;
@@ -128,15 +128,17 @@ fn is_unit_expr(expr: &ast::Expr) -> bool {
 
 fn lint_unneeded_unit_return(cx: &EarlyContext<'_>, ty: &ast::Ty, span: Span) {
     let (ret_span, appl) =
-        snippet_opt(cx, span.with_hi(ty.span.hi())).map_or((ty.span, Applicability::MaybeIncorrect), |fn_source| {
-            position_before_rarrow(&fn_source).map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
-                (
-                    #[expect(clippy::cast_possible_truncation)]
-                    ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
-                    Applicability::MachineApplicable,
-                )
-            })
-        });
+        span.with_hi(ty.span.hi())
+            .get_source_text(cx)
+            .map_or((ty.span, Applicability::MaybeIncorrect), |src| {
+                position_before_rarrow(&src).map_or((ty.span, Applicability::MaybeIncorrect), |rpos| {
+                    (
+                        #[expect(clippy::cast_possible_truncation)]
+                        ty.span.with_lo(BytePos(span.lo().0 + rpos as u32)),
+                        Applicability::MachineApplicable,
+                    )
+                })
+            });
     span_lint_and_sugg(
         cx,
         UNUSED_UNIT,
diff --git a/clippy_lints/src/visibility.rs b/clippy_lints/src/visibility.rs
index 63f3a5d7f8305..7a85196cecaaa 100644
--- a/clippy_lints/src/visibility.rs
+++ b/clippy_lints/src/visibility.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_ast::ast::{Item, VisibilityKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
@@ -82,9 +82,7 @@ impl EarlyLintPass for Visibility {
         if !in_external_macro(cx.sess(), item.span)
             && let VisibilityKind::Restricted { path, shorthand, .. } = &item.vis.kind
         {
-            if **path == kw::SelfLower
-                && let Some(false) = is_from_proc_macro(cx, item.vis.span)
-            {
+            if **path == kw::SelfLower && !is_from_proc_macro(cx, item.vis.span) {
                 span_lint_and_then(
                     cx,
                     NEEDLESS_PUB_SELF,
@@ -104,7 +102,7 @@ impl EarlyLintPass for Visibility {
             if (**path == kw::Super || **path == kw::SelfLower || **path == kw::Crate)
                 && !*shorthand
                 && let [.., last] = &*path.segments
-                && let Some(false) = is_from_proc_macro(cx, item.vis.span)
+                && !is_from_proc_macro(cx, item.vis.span)
             {
                 #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
                 span_lint_and_then(
@@ -125,7 +123,7 @@ impl EarlyLintPass for Visibility {
 
             if *shorthand
                 && let [.., last] = &*path.segments
-                && let Some(false) = is_from_proc_macro(cx, item.vis.span)
+                && !is_from_proc_macro(cx, item.vis.span)
             {
                 #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
                 span_lint_and_then(
@@ -147,6 +145,6 @@ impl EarlyLintPass for Visibility {
     }
 }
 
-fn is_from_proc_macro(cx: &EarlyContext<'_>, span: Span) -> Option<bool> {
-    snippet_opt(cx, span).map(|s| !s.starts_with("pub"))
+fn is_from_proc_macro(cx: &EarlyContext<'_>, span: Span) -> bool {
+    !span.check_source_text(cx, |src| src.starts_with("pub"))
 }
diff --git a/clippy_lints/src/write.rs b/clippy_lints/src/write.rs
index 54e7e92f0c45d..ec5a5896fb2bf 100644
--- a/clippy_lints/src/write.rs
+++ b/clippy_lints/src/write.rs
@@ -2,7 +2,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::is_in_test;
 use clippy_utils::macros::{format_arg_removal_span, root_macro_call_first_node, FormatArgsStorage, MacroCall};
-use clippy_utils::source::{expand_past_previous_comma, snippet_opt};
+use clippy_utils::source::{expand_past_previous_comma, SpanRangeExt};
 use rustc_ast::token::LitKind;
 use rustc_ast::{
     FormatArgPosition, FormatArgPositionKind, FormatArgs, FormatArgsPiece, FormatOptions, FormatPlaceholder,
@@ -397,7 +397,7 @@ fn check_newline(cx: &LateContext<'_>, format_args: &FormatArgs, macro_call: &Ma
             format!("using `{name}!()` with a format string that ends in a single newline"),
             |diag| {
                 let name_span = cx.sess().source_map().span_until_char(macro_call.span, '!');
-                let Some(format_snippet) = snippet_opt(cx, format_string_span) else {
+                let Some(format_snippet) = format_string_span.get_source_text(cx) else {
                     return;
                 };
 
@@ -492,7 +492,7 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
             && let Some(arg) = format_args.arguments.by_index(index)
             && let rustc_ast::ExprKind::Lit(lit) = &arg.expr.kind
             && !arg.expr.span.from_expansion()
-            && let Some(value_string) = snippet_opt(cx, arg.expr.span)
+            && let Some(value_string) = arg.expr.span.get_source_text(cx)
         {
             let (replacement, replace_raw) = match lit.kind {
                 LitKind::Str | LitKind::StrRaw(_) => match extract_str_literal(&value_string) {
@@ -515,7 +515,7 @@ fn check_literal(cx: &LateContext<'_>, format_args: &FormatArgs, name: &str) {
                 _ => continue,
             };
 
-            let Some(format_string_snippet) = snippet_opt(cx, format_args.span) else {
+            let Some(format_string_snippet) = format_args.span.get_source_text(cx) else {
                 continue;
             };
             let format_string_is_raw = format_string_snippet.starts_with('r');
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 1be1a9b28b9ea..8b49b013e0313 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -16,7 +16,7 @@ use rustc_span::{
 };
 use std::borrow::Cow;
 use std::fmt;
-use std::ops::{Deref, Range};
+use std::ops::{Deref, Index, Range};
 
 pub trait HasSession {
     fn sess(&self) -> &Session;
@@ -186,6 +186,15 @@ impl AsRef<str> for SourceText {
         self.as_str()
     }
 }
+impl<T> Index<T> for SourceText
+where
+    str: Index<T>,
+{
+    type Output = <str as Index<T>>::Output;
+    fn index(&self, idx: T) -> &Self::Output {
+        &self.as_str()[idx]
+    }
+}
 impl fmt::Display for SourceText {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.as_str().fmt(f)

From 9e95a2b9a5c434db5ad42fe3f8848cbbd161e642 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 12 Aug 2024 15:20:58 +1000
Subject: [PATCH 130/685] Remove some unnecessary `skip_binder` calls.

`is_fn_trait_compatible` is defined on both `FnSig` and `Binder<FnSig>`.
---
 .../src/solve/assembly/structural_traits.rs                   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index f32531821ec47..a57338acaab29 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -461,7 +461,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I:
 
         ty::FnDef(def_id, _) => {
             let sig = self_ty.fn_sig(cx);
-            if sig.skip_binder().is_fn_trait_compatible() && !cx.has_target_features(def_id) {
+            if sig.is_fn_trait_compatible() && !cx.has_target_features(def_id) {
                 fn_item_to_async_callable(cx, sig)
             } else {
                 Err(NoSolution)
@@ -469,7 +469,7 @@ pub(in crate::solve) fn extract_tupled_inputs_and_output_from_async_callable<I:
         }
         ty::FnPtr(..) => {
             let sig = self_ty.fn_sig(cx);
-            if sig.skip_binder().is_fn_trait_compatible() {
+            if sig.is_fn_trait_compatible() {
                 fn_item_to_async_callable(cx, sig)
             } else {
                 Err(NoSolution)

From f4a3ed02439adb6b168e6979fcfef7dc2a9fc33a Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 12 Aug 2024 15:37:28 +1000
Subject: [PATCH 131/685] Avoid a `FnPtr` deconstruct-and-recreate.

---
 compiler/rustc_middle/src/ty/layout.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 55511d0833ce0..f16f4baf723ed 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -986,10 +986,11 @@ where
                     safe: None,
                 })
             }
-            ty::FnPtr(sig_tys, hdr) if offset.bytes() == 0 => {
-                let fn_sig = sig_tys.with(hdr);
-                tcx.layout_of(param_env.and(Ty::new_fn_ptr(tcx, fn_sig))).ok().map(|layout| {
-                    PointeeInfo { size: layout.size, align: layout.align.abi, safe: None }
+            ty::FnPtr(..) if offset.bytes() == 0 => {
+                tcx.layout_of(param_env.and(this.ty)).ok().map(|layout| PointeeInfo {
+                    size: layout.size,
+                    align: layout.align.abi,
+                    safe: None,
                 })
             }
             ty::Ref(_, ty, mt) if offset.bytes() == 0 => {

From b9f3db6adb77cce9ec5a5476003a5cf1803b6262 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 12 Aug 2024 15:51:04 +1000
Subject: [PATCH 132/685] Give the field in `FnSigTys` a name.

---
 compiler/rustc_type_ir/src/fast_reject.rs |  4 ++--
 compiler/rustc_type_ir/src/ty_kind.rs     | 14 ++++++++------
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_type_ir/src/fast_reject.rs b/compiler/rustc_type_ir/src/fast_reject.rs
index 718e13ffe943f..fab4a0991175d 100644
--- a/compiler/rustc_type_ir/src/fast_reject.rs
+++ b/compiler/rustc_type_ir/src/fast_reject.rs
@@ -311,8 +311,8 @@ impl<I: Interner> DeepRejectCtxt<I> {
             }
             ty::FnPtr(obl_sig_tys, obl_hdr) => match k {
                 ty::FnPtr(impl_sig_tys, impl_hdr) => {
-                    let obl_sig_tys = obl_sig_tys.skip_binder().0;
-                    let impl_sig_tys = impl_sig_tys.skip_binder().0;
+                    let obl_sig_tys = obl_sig_tys.skip_binder().inputs_and_output;
+                    let impl_sig_tys = impl_sig_tys.skip_binder().inputs_and_output;
 
                     obl_hdr == impl_hdr
                         && obl_sig_tys.len() == impl_sig_tys.len()
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 8640a6019800a..328b6739d9756 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -928,7 +928,7 @@ impl<I: Interner> ty::Binder<I, FnSig<I>> {
     pub fn split(self) -> (ty::Binder<I, FnSigTys<I>>, FnHeader<I>) {
         let hdr =
             FnHeader { c_variadic: self.c_variadic(), safety: self.safety(), abi: self.abi() };
-        (self.map_bound(|sig| FnSigTys(sig.inputs_and_output)), hdr)
+        (self.map_bound(|sig| FnSigTys { inputs_and_output: sig.inputs_and_output }), hdr)
     }
 }
 
@@ -971,15 +971,17 @@ impl<I: Interner> fmt::Debug for FnSig<I> {
 #[derive_where(Clone, Copy, Debug, PartialEq, Eq, Hash; I: Interner)]
 #[cfg_attr(feature = "nightly", derive(TyEncodable, TyDecodable, HashStable_NoContext))]
 #[derive(TypeVisitable_Generic, TypeFoldable_Generic, Lift_Generic)]
-pub struct FnSigTys<I: Interner>(pub I::Tys);
+pub struct FnSigTys<I: Interner> {
+    pub inputs_and_output: I::Tys,
+}
 
 impl<I: Interner> FnSigTys<I> {
     pub fn inputs(self) -> I::FnInputTys {
-        self.0.inputs()
+        self.inputs_and_output.inputs()
     }
 
     pub fn output(self) -> I::Ty {
-        self.0.output()
+        self.inputs_and_output.output()
     }
 }
 
@@ -987,7 +989,7 @@ impl<I: Interner> ty::Binder<I, FnSigTys<I>> {
     // Used to combine the two fields in `TyKind::FnPtr` into a single value.
     pub fn with(self, hdr: FnHeader<I>) -> ty::Binder<I, FnSig<I>> {
         self.map_bound(|sig_tys| FnSig {
-            inputs_and_output: sig_tys.0,
+            inputs_and_output: sig_tys.inputs_and_output,
             c_variadic: hdr.c_variadic,
             safety: hdr.safety,
             abi: hdr.abi,
@@ -1006,7 +1008,7 @@ impl<I: Interner> ty::Binder<I, FnSigTys<I>> {
     }
 
     pub fn inputs_and_output(self) -> ty::Binder<I, I::Tys> {
-        self.map_bound(|sig_tys| sig_tys.0)
+        self.map_bound(|sig_tys| sig_tys.inputs_and_output)
     }
 
     #[inline]

From bbd1c3ab73a931bf4823eec836de57e837d2161c Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 12 Aug 2024 15:53:45 +1000
Subject: [PATCH 133/685] Streamline some inputs/output traversals.

---
 compiler/rustc_middle/src/ty/flags.rs | 3 +--
 compiler/rustc_middle/src/ty/walk.rs  | 6 ++----
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/flags.rs b/compiler/rustc_middle/src/ty/flags.rs
index 1e38e30628aa9..fc079592583e6 100644
--- a/compiler/rustc_middle/src/ty/flags.rs
+++ b/compiler/rustc_middle/src/ty/flags.rs
@@ -251,8 +251,7 @@ impl FlagComputation {
             }
 
             &ty::FnPtr(sig_tys, _) => self.bound_computation(sig_tys, |computation, sig_tys| {
-                computation.add_tys(sig_tys.inputs());
-                computation.add_ty(sig_tys.output());
+                computation.add_tys(sig_tys.inputs_and_output);
             }),
         }
     }
diff --git a/compiler/rustc_middle/src/ty/walk.rs b/compiler/rustc_middle/src/ty/walk.rs
index 0a328352e2e97..abd6df17514bb 100644
--- a/compiler/rustc_middle/src/ty/walk.rs
+++ b/compiler/rustc_middle/src/ty/walk.rs
@@ -189,11 +189,9 @@ fn push_inner<'tcx>(stack: &mut TypeWalkerStack<'tcx>, parent: GenericArg<'tcx>)
                 stack.extend(args.iter().rev());
             }
             ty::Tuple(ts) => stack.extend(ts.iter().rev().map(GenericArg::from)),
-            ty::FnPtr(sig_tys, hdr) => {
-                let fn_sig = sig_tys.with(hdr);
-                stack.push(fn_sig.skip_binder().output().into());
+            ty::FnPtr(sig_tys, _hdr) => {
                 stack.extend(
-                    fn_sig.skip_binder().inputs().iter().copied().rev().map(|ty| ty.into()),
+                    sig_tys.skip_binder().inputs_and_output.iter().rev().map(|ty| ty.into()),
                 );
             }
         },

From 2b83935192050f7990234ea29089f0e6c62bdd27 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 12 Aug 2024 10:07:53 +0200
Subject: [PATCH 134/685] josh-proxy: fix wait-for-josh logic

---
 src/tools/miri/miri-script/src/commands.rs | 23 +++++++++++++---------
 1 file changed, 14 insertions(+), 9 deletions(-)

diff --git a/src/tools/miri/miri-script/src/commands.rs b/src/tools/miri/miri-script/src/commands.rs
index 8767d6970f001..a05b3517f235e 100644
--- a/src/tools/miri/miri-script/src/commands.rs
+++ b/src/tools/miri/miri-script/src/commands.rs
@@ -137,15 +137,20 @@ impl Command {
             }
         }
 
-        // Wait until the port is open.
-        let josh_ready = net::TcpStream::connect_timeout(
-            &net::SocketAddr::from(([127, 0, 0, 1], JOSH_PORT)),
-            Duration::from_secs(1),
-        )
-        .context("failed to connect to josh-proxy")?;
-        drop(josh_ready);
-
-        Ok(Josh(josh))
+        // Wait until the port is open. We try every 10ms until 1s passed.
+        for _ in 0..100 {
+            // This will generally fail immediately when the port is still closed.
+            let josh_ready = net::TcpStream::connect_timeout(
+                &net::SocketAddr::from(([127, 0, 0, 1], JOSH_PORT)),
+                Duration::from_millis(1),
+            );
+            if josh_ready.is_ok() {
+                return Ok(Josh(josh));
+            }
+            // Not ready yet.
+            std::thread::sleep(Duration::from_millis(10));
+        }
+        bail!("Even after waiting for 1s, josh-proxy is still not available.")
     }
 
     pub fn exec(self) -> Result<()> {

From 3652011f54f007855b33a4411234f0a4612d1814 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 12 Aug 2024 10:07:58 +0200
Subject: [PATCH 135/685] 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 699a17a4943aa..9dad0df254cb8 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-6696447f784a888446d13bb400a8d507a68331c9
+1d8f135b20fac63c493d5963ce02963b46ca0986

From 7383401e08ee5e0195b44ebcd0b2dc9a026f7964 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 12 Aug 2024 10:11:39 +0200
Subject: [PATCH 136/685] clippy fix

---
 src/tools/miri/src/eval.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index d781188cd0c2c..d75202b0a3018 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -460,12 +460,8 @@ pub fn eval_entry<'tcx>(
         ecx.handle_ice();
         panic::resume_unwind(panic_payload)
     });
-    let res = match res {
-        Err(res) => res,
-        // `Ok` can never happen
-        #[cfg(bootstrap)]
-        Ok(never) => match never {},
-    };
+    // `Ok` can never happen.
+    let Err(res) = res;
 
     // Machine cleanup. Only do this if all threads have terminated; threads that are still running
     // might cause Stacked Borrows errors (https://github.com/rust-lang/miri/issues/2396).

From 14f9284ebecc4d7a6e68bf782720563a5e317888 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 12 Aug 2024 10:23:39 +0200
Subject: [PATCH 137/685] fix tree borrows Unique test

---
 src/tools/miri/tests/pass/tree_borrows/vec_unique.rs   | 10 ++++------
 .../tests/pass/tree_borrows/vec_unique.uniq.stderr     |  8 +++-----
 2 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/src/tools/miri/tests/pass/tree_borrows/vec_unique.rs b/src/tools/miri/tests/pass/tree_borrows/vec_unique.rs
index 9debe224d4583..af4c3b0693191 100644
--- a/src/tools/miri/tests/pass/tree_borrows/vec_unique.rs
+++ b/src/tools/miri/tests/pass/tree_borrows/vec_unique.rs
@@ -1,5 +1,3 @@
-// FIXME: This test is broken since https://github.com/rust-lang/rust/pull/126793,
-// possibly related to the additional struct between Vec and Unique.
 //@revisions: default uniq
 // We disable the GC for this test because it would change what is printed.
 //@compile-flags: -Zmiri-tree-borrows -Zmiri-provenance-gc=0
@@ -32,20 +30,20 @@ fn main() {
         // whether we got the distance correct:
         // If the output shows
         //
-        //    |- <XYZ: uniq>
-        //    '- <XYZ: uniq>
+        //    ├─ <TAG=base.as_ptr()>
+        //    └─ <TAG=base.as_ptr()>
         //
         // then `nth_parent` is not big enough.
         // The correct value for `nth_parent` should be the minimum
         // integer for which the output shows
         //
-        //    '- <XYZ: uniq, uniq>
+        //    └─ <TAG=base.as_ptr(), base.as_ptr(), ...>
         // )
         //
         // Ultimately we want pointers obtained through independent
         // calls of `as_ptr` to be able to alias, which will probably involve
         // a new permission that allows aliasing when there is no protector.
-        let nth_parent = if cfg!(uniq) { 2 } else { 0 };
+        let nth_parent = if cfg!(uniq) { 9 } else { 0 };
         name!(base.as_ptr()=>nth_parent);
         name!(base.as_ptr()=>nth_parent);
 
diff --git a/src/tools/miri/tests/pass/tree_borrows/vec_unique.uniq.stderr b/src/tools/miri/tests/pass/tree_borrows/vec_unique.uniq.stderr
index e3796a742e9ae..7942e9884f401 100644
--- a/src/tools/miri/tests/pass/tree_borrows/vec_unique.uniq.stderr
+++ b/src/tools/miri/tests/pass/tree_borrows/vec_unique.uniq.stderr
@@ -2,9 +2,7 @@
 Warning: this tree is indicative only. Some tags may have been hidden.
 0..   2
 | Act |    └─┬──<TAG=root of the allocation>
-|-----|      ├────<TAG=base.as_ptr()>
-|-----|      ├────<TAG=base.as_ptr()>
-|-----|      └─┬──<TAG=raw_parts.0>
-|-----|        ├────<TAG=reconstructed.as_ptr()>
-|-----|        └────<TAG=reconstructed.as_ptr()>
+|-----|      └─┬──<TAG=base.as_ptr(), base.as_ptr()>
+|-----|        └─┬──<TAG=raw_parts.0>
+|-----|          └────<TAG=reconstructed.as_ptr(), reconstructed.as_ptr()>
 ──────────────────────────────────────────────────

From 7b86c98068f0b4280598f36e655b5e83d21f9258 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Jul 2024 14:21:52 +0200
Subject: [PATCH 138/685] do not use the global solver cache for proof trees

doing so requires overwriting global cache entries and
generally adds significant complexity to the solver. This is
also only ever done for root goals, so it feels easier to wrap
the `evaluate_canonical_goal` in an ordinary query if
necessary.
---
 compiler/rustc_middle/src/arena.rs            |   4 -
 compiler/rustc_middle/src/ty/context.rs       |   9 --
 .../src/solve/inspect/build.rs                | 106 +++---------------
 .../src/solve/search_graph.rs                 |   7 +-
 .../src/solve/inspect/analyse.rs              |  10 +-
 compiler/rustc_type_ir/src/interner.rs        |  12 --
 .../src/search_graph/global_cache.rs          |  36 ++----
 .../rustc_type_ir/src/search_graph/mod.rs     |  87 +++++++-------
 compiler/rustc_type_ir/src/solve/inspect.rs   |   4 +-
 compiler/rustc_type_ir/src/solve/mod.rs       |   8 --
 10 files changed, 74 insertions(+), 209 deletions(-)

diff --git a/compiler/rustc_middle/src/arena.rs b/compiler/rustc_middle/src/arena.rs
index e3d7dff3c66bb..37c10b14054c5 100644
--- a/compiler/rustc_middle/src/arena.rs
+++ b/compiler/rustc_middle/src/arena.rs
@@ -61,10 +61,6 @@ macro_rules! arena_types {
             [] dtorck_constraint: rustc_middle::traits::query::DropckConstraint<'tcx>,
             [] candidate_step: rustc_middle::traits::query::CandidateStep<'tcx>,
             [] autoderef_bad_ty: rustc_middle::traits::query::MethodAutoderefBadTy<'tcx>,
-            [] canonical_goal_evaluation:
-                rustc_type_ir::solve::inspect::CanonicalGoalEvaluationStep<
-                    rustc_middle::ty::TyCtxt<'tcx>
-                >,
             [] query_region_constraints: rustc_middle::infer::canonical::QueryRegionConstraints<'tcx>,
             [] type_op_subtype:
                 rustc_middle::infer::canonical::Canonical<'tcx,
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 8f8fd09c9e4d9..8198b2fdc8930 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -107,8 +107,6 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.mk_predefined_opaques_in_body(data)
     }
     type DefiningOpaqueTypes = &'tcx ty::List<LocalDefId>;
-    type CanonicalGoalEvaluationStepRef =
-        &'tcx solve::inspect::CanonicalGoalEvaluationStep<TyCtxt<'tcx>>;
     type CanonicalVars = CanonicalVarInfos<'tcx>;
     fn mk_canonical_var_infos(self, infos: &[ty::CanonicalVarInfo<Self>]) -> Self::CanonicalVars {
         self.mk_canonical_var_infos(infos)
@@ -277,13 +275,6 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.debug_assert_args_compatible(def_id, args);
     }
 
-    fn intern_canonical_goal_evaluation_step(
-        self,
-        step: solve::inspect::CanonicalGoalEvaluationStep<TyCtxt<'tcx>>,
-    ) -> &'tcx solve::inspect::CanonicalGoalEvaluationStep<TyCtxt<'tcx>> {
-        self.arena.alloc(step)
-    }
-
     fn mk_type_list_from_iter<I, T>(self, args: I) -> T::Output
     where
         I: Iterator<Item = T>,
diff --git a/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs b/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs
index a3c21666bd67c..86fb036cd3df8 100644
--- a/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs
@@ -5,11 +5,10 @@
 //! see the comment on [ProofTreeBuilder].
 
 use std::marker::PhantomData;
-use std::mem;
 
 use derive_where::derive_where;
 use rustc_type_ir::inherent::*;
-use rustc_type_ir::{self as ty, search_graph, Interner};
+use rustc_type_ir::{self as ty, Interner};
 
 use crate::delegate::SolverDelegate;
 use crate::solve::eval_ctxt::canonical;
@@ -94,31 +93,10 @@ impl<I: Interner> WipGoalEvaluation<I> {
     }
 }
 
-#[derive_where(PartialEq, Eq; I: Interner)]
-pub(in crate::solve) enum WipCanonicalGoalEvaluationKind<I: Interner> {
-    Overflow,
-    CycleInStack,
-    ProvisionalCacheHit,
-    Interned { final_revision: I::CanonicalGoalEvaluationStepRef },
-}
-
-impl<I: Interner> std::fmt::Debug for WipCanonicalGoalEvaluationKind<I> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Overflow => write!(f, "Overflow"),
-            Self::CycleInStack => write!(f, "CycleInStack"),
-            Self::ProvisionalCacheHit => write!(f, "ProvisionalCacheHit"),
-            Self::Interned { final_revision: _ } => {
-                f.debug_struct("Interned").finish_non_exhaustive()
-            }
-        }
-    }
-}
-
 #[derive_where(PartialEq, Eq, Debug; I: Interner)]
 struct WipCanonicalGoalEvaluation<I: Interner> {
     goal: CanonicalInput<I>,
-    kind: Option<WipCanonicalGoalEvaluationKind<I>>,
+    encountered_overflow: bool,
     /// Only used for uncached goals. After we finished evaluating
     /// the goal, this is interned and moved into `kind`.
     final_revision: Option<WipCanonicalGoalEvaluationStep<I>>,
@@ -127,25 +105,17 @@ struct WipCanonicalGoalEvaluation<I: Interner> {
 
 impl<I: Interner> WipCanonicalGoalEvaluation<I> {
     fn finalize(self) -> inspect::CanonicalGoalEvaluation<I> {
-        // We've already interned the final revision in
-        // `fn finalize_canonical_goal_evaluation`.
-        assert!(self.final_revision.is_none());
-        let kind = match self.kind.unwrap() {
-            WipCanonicalGoalEvaluationKind::Overflow => {
+        inspect::CanonicalGoalEvaluation {
+            goal: self.goal,
+            kind: if self.encountered_overflow {
+                assert!(self.final_revision.is_none());
                 inspect::CanonicalGoalEvaluationKind::Overflow
-            }
-            WipCanonicalGoalEvaluationKind::CycleInStack => {
-                inspect::CanonicalGoalEvaluationKind::CycleInStack
-            }
-            WipCanonicalGoalEvaluationKind::ProvisionalCacheHit => {
-                inspect::CanonicalGoalEvaluationKind::ProvisionalCacheHit
-            }
-            WipCanonicalGoalEvaluationKind::Interned { final_revision } => {
+            } else {
+                let final_revision = self.final_revision.unwrap().finalize();
                 inspect::CanonicalGoalEvaluationKind::Evaluation { final_revision }
-            }
-        };
-
-        inspect::CanonicalGoalEvaluation { goal: self.goal, kind, result: self.result.unwrap() }
+            },
+            result: self.result.unwrap(),
+        }
     }
 }
 
@@ -308,7 +278,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
     ) -> ProofTreeBuilder<D> {
         self.nested(|| WipCanonicalGoalEvaluation {
             goal,
-            kind: None,
+            encountered_overflow: false,
             final_revision: None,
             result: None,
         })
@@ -329,11 +299,11 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
         }
     }
 
-    pub fn canonical_goal_evaluation_kind(&mut self, kind: WipCanonicalGoalEvaluationKind<I>) {
+    pub fn canonical_goal_evaluation_overflow(&mut self) {
         if let Some(this) = self.as_mut() {
             match this {
                 DebugSolver::CanonicalGoalEvaluation(canonical_goal_evaluation) => {
-                    assert_eq!(canonical_goal_evaluation.kind.replace(kind), None);
+                    canonical_goal_evaluation.encountered_overflow = true;
                 }
                 _ => unreachable!(),
             };
@@ -547,51 +517,3 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
         }
     }
 }
-
-impl<D, I> search_graph::ProofTreeBuilder<I> for ProofTreeBuilder<D>
-where
-    D: SolverDelegate<Interner = I>,
-    I: Interner,
-{
-    fn try_apply_proof_tree(
-        &mut self,
-        proof_tree: Option<I::CanonicalGoalEvaluationStepRef>,
-    ) -> bool {
-        if !self.is_noop() {
-            if let Some(final_revision) = proof_tree {
-                let kind = WipCanonicalGoalEvaluationKind::Interned { final_revision };
-                self.canonical_goal_evaluation_kind(kind);
-                true
-            } else {
-                false
-            }
-        } else {
-            true
-        }
-    }
-
-    fn on_provisional_cache_hit(&mut self) {
-        self.canonical_goal_evaluation_kind(WipCanonicalGoalEvaluationKind::ProvisionalCacheHit);
-    }
-
-    fn on_cycle_in_stack(&mut self) {
-        self.canonical_goal_evaluation_kind(WipCanonicalGoalEvaluationKind::CycleInStack);
-    }
-
-    fn finalize_canonical_goal_evaluation(
-        &mut self,
-        tcx: I,
-    ) -> Option<I::CanonicalGoalEvaluationStepRef> {
-        self.as_mut().map(|this| match this {
-            DebugSolver::CanonicalGoalEvaluation(evaluation) => {
-                let final_revision = mem::take(&mut evaluation.final_revision).unwrap();
-                let final_revision =
-                    tcx.intern_canonical_goal_evaluation_step(final_revision.finalize());
-                let kind = WipCanonicalGoalEvaluationKind::Interned { final_revision };
-                assert_eq!(evaluation.kind.replace(kind), None);
-                final_revision
-            }
-            _ => unreachable!(),
-        })
-    }
-}
diff --git a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
index fe053a506e712..1f2c65191a618 100644
--- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
@@ -5,7 +5,7 @@ use rustc_type_ir::search_graph::{self, CycleKind, UsageKind};
 use rustc_type_ir::solve::{CanonicalInput, Certainty, QueryResult};
 use rustc_type_ir::Interner;
 
-use super::inspect::{self, ProofTreeBuilder};
+use super::inspect::ProofTreeBuilder;
 use super::FIXPOINT_STEP_LIMIT;
 use crate::delegate::SolverDelegate;
 
@@ -25,6 +25,9 @@ where
     const FIXPOINT_STEP_LIMIT: usize = FIXPOINT_STEP_LIMIT;
 
     type ProofTreeBuilder = ProofTreeBuilder<D>;
+    fn inspect_is_noop(inspect: &mut Self::ProofTreeBuilder) -> bool {
+        inspect.is_noop()
+    }
 
     fn recursion_limit(cx: I) -> usize {
         cx.recursion_limit()
@@ -68,7 +71,7 @@ where
         inspect: &mut ProofTreeBuilder<D>,
         input: CanonicalInput<I>,
     ) -> QueryResult<I> {
-        inspect.canonical_goal_evaluation_kind(inspect::WipCanonicalGoalEvaluationKind::Overflow);
+        inspect.canonical_goal_evaluation_overflow();
         response_no_constraints(cx, input, Certainty::overflow(true))
     }
 
diff --git a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
index e8de8457440ff..4e4022830d46e 100644
--- a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
+++ b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs
@@ -332,13 +332,9 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
 
     pub fn candidates(&'a self) -> Vec<InspectCandidate<'a, 'tcx>> {
         let mut candidates = vec![];
-        let last_eval_step = match self.evaluation_kind {
-            inspect::CanonicalGoalEvaluationKind::Overflow
-            | inspect::CanonicalGoalEvaluationKind::CycleInStack
-            | inspect::CanonicalGoalEvaluationKind::ProvisionalCacheHit => {
-                warn!("unexpected root evaluation: {:?}", self.evaluation_kind);
-                return vec![];
-            }
+        let last_eval_step = match &self.evaluation_kind {
+            // An annoying edge case in case the recursion limit is 0.
+            inspect::CanonicalGoalEvaluationKind::Overflow => return vec![],
             inspect::CanonicalGoalEvaluationKind::Evaluation { final_revision } => final_revision,
         };
 
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index c251540c0fc29..f2492ede4f5ea 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -11,7 +11,6 @@ use crate::inherent::*;
 use crate::ir_print::IrPrint;
 use crate::lang_items::TraitSolverLangItem;
 use crate::relate::Relate;
-use crate::solve::inspect::CanonicalGoalEvaluationStep;
 use crate::solve::{
     CanonicalInput, ExternalConstraintsData, PredefinedOpaquesData, QueryResult, SolverMode,
 };
@@ -65,11 +64,6 @@ pub trait Interner:
         + Eq
         + TypeVisitable<Self>
         + SliceLike<Item = Self::LocalDefId>;
-    type CanonicalGoalEvaluationStepRef: Copy
-        + Debug
-        + Hash
-        + Eq
-        + Deref<Target = CanonicalGoalEvaluationStep<Self>>;
 
     type CanonicalVars: Copy
         + Debug
@@ -177,11 +171,6 @@ pub trait Interner:
 
     fn debug_assert_args_compatible(self, def_id: Self::DefId, args: Self::GenericArgs);
 
-    fn intern_canonical_goal_evaluation_step(
-        self,
-        step: CanonicalGoalEvaluationStep<Self>,
-    ) -> Self::CanonicalGoalEvaluationStepRef;
-
     fn mk_type_list_from_iter<I, T>(self, args: I) -> T::Output
     where
         I: Iterator<Item = T>,
@@ -390,7 +379,6 @@ impl<T, R, E> CollectAndApply<T, R> for Result<T, E> {
 }
 
 impl<I: Interner> search_graph::Cx for I {
-    type ProofTree = Option<I::CanonicalGoalEvaluationStepRef>;
     type Input = CanonicalInput<I>;
     type Result = QueryResult<I>;
 
diff --git a/compiler/rustc_type_ir/src/search_graph/global_cache.rs b/compiler/rustc_type_ir/src/search_graph/global_cache.rs
index be4f1069cd167..d63a8d16bea73 100644
--- a/compiler/rustc_type_ir/src/search_graph/global_cache.rs
+++ b/compiler/rustc_type_ir/src/search_graph/global_cache.rs
@@ -4,14 +4,8 @@ use rustc_index::IndexVec;
 use super::{AvailableDepth, Cx, StackDepth, StackEntry};
 use crate::data_structures::{HashMap, HashSet};
 
-#[derive_where(Debug, Clone, Copy; X: Cx)]
-struct QueryData<X: Cx> {
-    result: X::Result,
-    proof_tree: X::ProofTree,
-}
-
 struct Success<X: Cx> {
-    data: X::Tracked<QueryData<X>>,
+    result: X::Tracked<X::Result>,
     additional_depth: usize,
 }
 
@@ -28,13 +22,12 @@ struct CacheEntry<X: Cx> {
     /// See the doc comment of `StackEntry::cycle_participants` for more
     /// details.
     nested_goals: HashSet<X::Input>,
-    with_overflow: HashMap<usize, X::Tracked<QueryData<X>>>,
+    with_overflow: HashMap<usize, X::Tracked<X::Result>>,
 }
 
 #[derive_where(Debug; X: Cx)]
 pub(super) struct CacheData<'a, X: Cx> {
     pub(super) result: X::Result,
-    pub(super) proof_tree: X::ProofTree,
     pub(super) additional_depth: usize,
     pub(super) encountered_overflow: bool,
     // FIXME: This is currently unused, but impacts the design
@@ -55,20 +48,19 @@ impl<X: Cx> GlobalCache<X> {
         input: X::Input,
 
         result: X::Result,
-        proof_tree: X::ProofTree,
         dep_node: X::DepNodeIndex,
 
         additional_depth: usize,
         encountered_overflow: bool,
         nested_goals: &HashSet<X::Input>,
     ) {
-        let data = cx.mk_tracked(QueryData { result, proof_tree }, dep_node);
+        let result = cx.mk_tracked(result, dep_node);
         let entry = self.map.entry(input).or_default();
         entry.nested_goals.extend(nested_goals);
         if encountered_overflow {
-            entry.with_overflow.insert(additional_depth, data);
+            entry.with_overflow.insert(additional_depth, result);
         } else {
-            entry.success = Some(Success { data, additional_depth });
+            entry.success = Some(Success { result, additional_depth });
         }
     }
 
@@ -90,10 +82,8 @@ impl<X: Cx> GlobalCache<X> {
 
         if let Some(ref success) = entry.success {
             if available_depth.cache_entry_is_applicable(success.additional_depth) {
-                let QueryData { result, proof_tree } = cx.get_tracked(&success.data);
                 return Some(CacheData {
-                    result,
-                    proof_tree,
+                    result: cx.get_tracked(&success.result),
                     additional_depth: success.additional_depth,
                     encountered_overflow: false,
                     nested_goals: &entry.nested_goals,
@@ -101,15 +91,11 @@ impl<X: Cx> GlobalCache<X> {
             }
         }
 
-        entry.with_overflow.get(&available_depth.0).map(|e| {
-            let QueryData { result, proof_tree } = cx.get_tracked(e);
-            CacheData {
-                result,
-                proof_tree,
-                additional_depth: available_depth.0,
-                encountered_overflow: true,
-                nested_goals: &entry.nested_goals,
-            }
+        entry.with_overflow.get(&available_depth.0).map(|e| CacheData {
+            result: cx.get_tracked(e),
+            additional_depth: available_depth.0,
+            encountered_overflow: true,
+            nested_goals: &entry.nested_goals,
         })
     }
 }
diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 4abf99b1ded8a..8e0c668b6b5bd 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -22,7 +22,6 @@ mod validate;
 /// about `Input` and `Result` as they are implementation details
 /// of the search graph.
 pub trait Cx: Copy {
-    type ProofTree: Debug + Copy;
     type Input: Debug + Eq + Hash + Copy;
     type Result: Debug + Eq + Hash + Copy;
 
@@ -43,17 +42,12 @@ pub trait Cx: Copy {
     ) -> R;
 }
 
-pub trait ProofTreeBuilder<X: Cx> {
-    fn try_apply_proof_tree(&mut self, proof_tree: X::ProofTree) -> bool;
-    fn on_provisional_cache_hit(&mut self);
-    fn on_cycle_in_stack(&mut self);
-    fn finalize_canonical_goal_evaluation(&mut self, cx: X) -> X::ProofTree;
-}
-
 pub trait Delegate {
     type Cx: Cx;
     const FIXPOINT_STEP_LIMIT: usize;
-    type ProofTreeBuilder: ProofTreeBuilder<Self::Cx>;
+
+    type ProofTreeBuilder;
+    fn inspect_is_noop(inspect: &mut Self::ProofTreeBuilder) -> bool;
 
     fn recursion_limit(cx: Self::Cx) -> usize;
 
@@ -362,8 +356,10 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             return D::on_stack_overflow(cx, inspect, input);
         };
 
-        if let Some(result) = self.lookup_global_cache(cx, input, available_depth, inspect) {
-            return result;
+        if D::inspect_is_noop(inspect) {
+            if let Some(result) = self.lookup_global_cache(cx, input, available_depth) {
+                return result;
+            }
         }
 
         // Check whether the goal is in the provisional cache.
@@ -386,7 +382,6 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             // We have a nested goal which is already in the provisional cache, use
             // its result. We do not provide any usage kind as that should have been
             // already set correctly while computing the cache entry.
-            inspect.on_provisional_cache_hit();
             Self::tag_cycle_participants(&mut self.stack, None, entry.head);
             return entry.result;
         } else if let Some(stack_depth) = cache_entry.stack_depth {
@@ -397,8 +392,6 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             //
             // Finally we can return either the provisional response or the initial response
             // in case we're in the first fixpoint iteration for this goal.
-            inspect.on_cycle_in_stack();
-
             let is_coinductive_cycle = Self::stack_coinductive_from(cx, &self.stack, stack_depth);
             let cycle_kind =
                 if is_coinductive_cycle { CycleKind::Coinductive } else { CycleKind::Inductive };
@@ -453,8 +446,6 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             (current_entry, result)
         });
 
-        let proof_tree = inspect.finalize_canonical_goal_evaluation(cx);
-
         self.update_parent_goal(final_entry.reached_depth, final_entry.encountered_overflow);
 
         // We're now done with this goal. In case this goal is involved in a larger cycle
@@ -471,28 +462,10 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                 entry.with_inductive_stack = Some(DetachedEntry { head, result });
             }
         } else {
-            // When encountering a cycle, both inductive and coinductive, we only
-            // move the root into the global cache. We also store all other cycle
-            // participants involved.
-            //
-            // We must not use the global cache entry of a root goal if a cycle
-            // participant is on the stack. This is necessary to prevent unstable
-            // results. See the comment of `StackEntry::nested_goals` for
-            // more details.
             self.provisional_cache.remove(&input);
-            let additional_depth = final_entry.reached_depth.as_usize() - self.stack.len();
-            cx.with_global_cache(self.mode, |cache| {
-                cache.insert(
-                    cx,
-                    input,
-                    result,
-                    proof_tree,
-                    dep_node,
-                    additional_depth,
-                    final_entry.encountered_overflow,
-                    &final_entry.nested_goals,
-                )
-            })
+            if D::inspect_is_noop(inspect) {
+                self.insert_global_cache(cx, input, final_entry, result, dep_node)
+            }
         }
 
         self.check_invariants();
@@ -508,25 +481,15 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         cx: X,
         input: X::Input,
         available_depth: AvailableDepth,
-        inspect: &mut D::ProofTreeBuilder,
     ) -> Option<X::Result> {
         cx.with_global_cache(self.mode, |cache| {
             let CacheData {
                 result,
-                proof_tree,
                 additional_depth,
                 encountered_overflow,
                 nested_goals: _, // FIXME: consider nested goals here.
             } = cache.get(cx, input, &self.stack, available_depth)?;
 
-            // If we're building a proof tree and the current cache entry does not
-            // contain a proof tree, we do not use the entry but instead recompute
-            // the goal. We simply overwrite the existing entry once we're done,
-            // caching the proof tree.
-            if !inspect.try_apply_proof_tree(proof_tree) {
-                return None;
-            }
-
             // Update the reached depth of the current goal to make sure
             // its state is the same regardless of whether we've used the
             // global cache or not.
@@ -537,6 +500,36 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             Some(result)
         })
     }
+
+    /// When encountering a cycle, both inductive and coinductive, we only
+    /// move the root into the global cache. We also store all other cycle
+    /// participants involved.
+    ///
+    /// We must not use the global cache entry of a root goal if a cycle
+    /// participant is on the stack. This is necessary to prevent unstable
+    /// results. See the comment of `StackEntry::nested_goals` for
+    /// more details.
+    fn insert_global_cache(
+        &mut self,
+        cx: X,
+        input: X::Input,
+        final_entry: StackEntry<X>,
+        result: X::Result,
+        dep_node: X::DepNodeIndex,
+    ) {
+        let additional_depth = final_entry.reached_depth.as_usize() - self.stack.len();
+        cx.with_global_cache(self.mode, |cache| {
+            cache.insert(
+                cx,
+                input,
+                result,
+                dep_node,
+                additional_depth,
+                final_entry.encountered_overflow,
+                &final_entry.nested_goals,
+            )
+        })
+    }
 }
 
 enum StepResult<X: Cx> {
diff --git a/compiler/rustc_type_ir/src/solve/inspect.rs b/compiler/rustc_type_ir/src/solve/inspect.rs
index 47d5e0dace71f..099c66f6bdc81 100644
--- a/compiler/rustc_type_ir/src/solve/inspect.rs
+++ b/compiler/rustc_type_ir/src/solve/inspect.rs
@@ -69,9 +69,7 @@ pub struct CanonicalGoalEvaluation<I: Interner> {
 #[derive_where(PartialEq, Eq, Hash, Debug; I: Interner)]
 pub enum CanonicalGoalEvaluationKind<I: Interner> {
     Overflow,
-    CycleInStack,
-    ProvisionalCacheHit,
-    Evaluation { final_revision: I::CanonicalGoalEvaluationStepRef },
+    Evaluation { final_revision: CanonicalGoalEvaluationStep<I> },
 }
 
 #[derive_where(PartialEq, Eq, Hash, Debug; I: Interner)]
diff --git a/compiler/rustc_type_ir/src/solve/mod.rs b/compiler/rustc_type_ir/src/solve/mod.rs
index 444fd01f01281..00fc6ba1c5c8f 100644
--- a/compiler/rustc_type_ir/src/solve/mod.rs
+++ b/compiler/rustc_type_ir/src/solve/mod.rs
@@ -340,11 +340,3 @@ impl MaybeCause {
         }
     }
 }
-
-#[derive_where(PartialEq, Eq, Debug; I: Interner)]
-pub struct CacheData<I: Interner> {
-    pub result: QueryResult<I>,
-    pub proof_tree: Option<I::CanonicalGoalEvaluationStepRef>,
-    pub additional_depth: usize,
-    pub encountered_overflow: bool,
-}

From 51338ca0eb9a6b83fa3b743e102155ef145faf1f Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Jul 2024 13:12:23 +0200
Subject: [PATCH 139/685] expand fuzzing support

this allows us to only sometimes disable the global cache.
---
 .../src/solve/search_graph.rs                 |  9 +++
 .../rustc_type_ir/src/search_graph/mod.rs     | 56 ++++++++++++++++---
 2 files changed, 56 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
index 1f2c65191a618..0994d0e3b3d88 100644
--- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
@@ -1,3 +1,4 @@
+use std::convert::Infallible;
 use std::marker::PhantomData;
 
 use rustc_type_ir::inherent::*;
@@ -22,6 +23,14 @@ where
 {
     type Cx = D::Interner;
 
+    type ValidationScope = Infallible;
+    fn enter_validation_scope(
+        _cx: Self::Cx,
+        _input: <Self::Cx as search_graph::Cx>::Input,
+    ) -> Option<Self::ValidationScope> {
+        None
+    }
+
     const FIXPOINT_STEP_LIMIT: usize = FIXPOINT_STEP_LIMIT;
 
     type ProofTreeBuilder = ProofTreeBuilder<D>;
diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 8e0c668b6b5bd..7d4ddb71461d1 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -44,6 +44,19 @@ pub trait Cx: Copy {
 
 pub trait Delegate {
     type Cx: Cx;
+    type ValidationScope;
+    /// Returning `Some` disables the global cache for the current goal.
+    ///
+    /// The `ValidationScope` is used when fuzzing the search graph to track
+    /// for which goals the global cache has been disabled. This is necessary
+    /// as we may otherwise ignore the global cache entry for some goal `G`
+    /// only to later use it, failing to detect a cycle goal and potentially
+    /// changing the result.
+    fn enter_validation_scope(
+        cx: Self::Cx,
+        input: <Self::Cx as Cx>::Input,
+    ) -> Option<Self::ValidationScope>;
+
     const FIXPOINT_STEP_LIMIT: usize;
 
     type ProofTreeBuilder;
@@ -356,11 +369,21 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             return D::on_stack_overflow(cx, inspect, input);
         };
 
-        if D::inspect_is_noop(inspect) {
-            if let Some(result) = self.lookup_global_cache(cx, input, available_depth) {
-                return result;
-            }
-        }
+        let validate_cache = if !D::inspect_is_noop(inspect) {
+            None
+        } else if let Some(scope) = D::enter_validation_scope(cx, input) {
+            // When validating the global cache we need to track the goals for which the
+            // global cache has been disabled as it may otherwise change the result for
+            // cyclic goals. We don't care about goals which are not on the current stack
+            // so it's fine to drop their scope eagerly.
+            self.lookup_global_cache_untracked(cx, input, available_depth)
+                .inspect(|expected| debug!(?expected, "validate cache entry"))
+                .map(|r| (scope, r))
+        } else if let Some(result) = self.lookup_global_cache(cx, input, available_depth) {
+            return result;
+        } else {
+            None
+        };
 
         // Check whether the goal is in the provisional cache.
         // The provisional result may rely on the path to its cycle roots,
@@ -452,6 +475,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         // do not remove it from the provisional cache and update its provisional result.
         // We only add the root of cycles to the global cache.
         if let Some(head) = final_entry.non_root_cycle_participant {
+            debug_assert!(validate_cache.is_none());
             let coinductive_stack = Self::stack_coinductive_from(cx, &self.stack, head);
 
             let entry = self.provisional_cache.get_mut(&input).unwrap();
@@ -463,16 +487,29 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             }
         } else {
             self.provisional_cache.remove(&input);
-            if D::inspect_is_noop(inspect) {
+            if let Some((_scope, expected)) = validate_cache {
+                // Do not try to move a goal into the cache again if we're testing
+                // the global cache.
+                assert_eq!(result, expected, "input={input:?}");
+            } else if D::inspect_is_noop(inspect) {
                 self.insert_global_cache(cx, input, final_entry, result, dep_node)
             }
         }
 
-        self.check_invariants();
-
         result
     }
 
+    fn lookup_global_cache_untracked(
+        &self,
+        cx: X,
+        input: X::Input,
+        available_depth: AvailableDepth,
+    ) -> Option<X::Result> {
+        cx.with_global_cache(self.mode, |cache| {
+            cache.get(cx, input, &self.stack, available_depth).map(|c| c.result)
+        })
+    }
+
     /// Try to fetch a previously computed result from the global cache,
     /// making sure to only do so if it would match the result of reevaluating
     /// this goal.
@@ -496,7 +533,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             let reached_depth = self.stack.next_index().plus(additional_depth);
             self.update_parent_goal(reached_depth, encountered_overflow);
 
-            debug!("global cache hit");
+            debug!(?additional_depth, "global cache hit");
             Some(result)
         })
     }
@@ -518,6 +555,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         dep_node: X::DepNodeIndex,
     ) {
         let additional_depth = final_entry.reached_depth.as_usize() - self.stack.len();
+        debug!(?final_entry, ?result, "insert global cache");
         cx.with_global_cache(self.mode, |cache| {
             cache.insert(
                 cx,

From e87157ba2a63edae640f294531d1b9f3e8d37a2e Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Jul 2024 13:14:19 +0200
Subject: [PATCH 140/685] simplify match + move `debug!` call

---
 compiler/rustc_type_ir/src/search_graph/mod.rs | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 7d4ddb71461d1..6c67bf13ac73e 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -106,6 +106,7 @@ pub enum UsageKind {
 impl UsageKind {
     fn merge(self, other: Self) -> Self {
         match (self, other) {
+            (UsageKind::Mixed, _) | (_, UsageKind::Mixed) => UsageKind::Mixed,
             (UsageKind::Single(lhs), UsageKind::Single(rhs)) => {
                 if lhs == rhs {
                     UsageKind::Single(lhs)
@@ -113,9 +114,6 @@ impl UsageKind {
                     UsageKind::Mixed
                 }
             }
-            (UsageKind::Mixed, UsageKind::Mixed)
-            | (UsageKind::Mixed, UsageKind::Single(_))
-            | (UsageKind::Single(_), UsageKind::Mixed) => UsageKind::Mixed,
         }
     }
 }
@@ -458,7 +456,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             for _ in 0..D::FIXPOINT_STEP_LIMIT {
                 match self.fixpoint_step_in_task(cx, input, inspect, &mut prove_goal) {
                     StepResult::Done(final_entry, result) => return (final_entry, result),
-                    StepResult::HasChanged => debug!("fixpoint changed provisional results"),
+                    StepResult::HasChanged => {}
                 }
             }
 
@@ -623,6 +621,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         if D::reached_fixpoint(cx, usage_kind, input, stack_entry.provisional_result, result) {
             StepResult::Done(stack_entry, result)
         } else {
+            debug!(?result, "fixpoint changed provisional results");
             let depth = self.stack.push(StackEntry {
                 has_been_used: None,
                 provisional_result: Some(result),

From 9308401df57318cf3b3ad72bd3674516fe9d1c6c Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Jul 2024 14:59:01 +0200
Subject: [PATCH 141/685] tracing: debug to trace

---
 compiler/rustc_type_ir/src/binder.rs | 24 ++++++++----------------
 compiler/rustc_type_ir/src/fold.rs   | 11 +++++------
 2 files changed, 13 insertions(+), 22 deletions(-)

diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
index c1f6fb36324ed..8797288070e71 100644
--- a/compiler/rustc_type_ir/src/binder.rs
+++ b/compiler/rustc_type_ir/src/binder.rs
@@ -8,7 +8,7 @@ use derive_where::derive_where;
 use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
 #[cfg(feature = "nightly")]
 use rustc_serialize::Decodable;
-use tracing::debug;
+use tracing::instrument;
 
 use crate::data_structures::SsoHashSet;
 use crate::fold::{FallibleTypeFolder, TypeFoldable, TypeFolder, TypeSuperFoldable};
@@ -831,28 +831,20 @@ impl<'a, I: Interner> ArgFolder<'a, I> {
     /// As indicated in the diagram, here the same type `&'a i32` is instantiated once, but in the
     /// first case we do not increase the De Bruijn index and in the second case we do. The reason
     /// is that only in the second case have we passed through a fn binder.
+    #[instrument(level = "trace", skip(self), fields(binders_passed = self.binders_passed), ret)]
     fn shift_vars_through_binders<T: TypeFoldable<I>>(&self, val: T) -> T {
-        debug!(
-            "shift_vars(val={:?}, binders_passed={:?}, has_escaping_bound_vars={:?})",
-            val,
-            self.binders_passed,
-            val.has_escaping_bound_vars()
-        );
-
         if self.binders_passed == 0 || !val.has_escaping_bound_vars() {
-            return val;
+            val
+        } else {
+            ty::fold::shift_vars(self.cx, val, self.binders_passed)
         }
-
-        let result = ty::fold::shift_vars(TypeFolder::cx(self), val, self.binders_passed);
-        debug!("shift_vars: shifted result = {:?}", result);
-
-        result
     }
 
     fn shift_region_through_binders(&self, region: I::Region) -> I::Region {
         if self.binders_passed == 0 || !region.has_escaping_bound_vars() {
-            return region;
+            region
+        } else {
+            ty::fold::shift_region(self.cx, region, self.binders_passed)
         }
-        ty::fold::shift_region(self.cx, region, self.binders_passed)
     }
 }
diff --git a/compiler/rustc_type_ir/src/fold.rs b/compiler/rustc_type_ir/src/fold.rs
index d37bacc7d359f..8e3534b0e9eb4 100644
--- a/compiler/rustc_type_ir/src/fold.rs
+++ b/compiler/rustc_type_ir/src/fold.rs
@@ -48,7 +48,7 @@
 use std::mem;
 
 use rustc_index::{Idx, IndexVec};
-use tracing::debug;
+use tracing::instrument;
 
 use crate::data_structures::Lrc;
 use crate::inherent::*;
@@ -417,15 +417,14 @@ pub fn shift_region<I: Interner>(cx: I, region: I::Region, amount: u32) -> I::Re
     }
 }
 
+#[instrument(level = "trace", skip(cx), ret)]
 pub fn shift_vars<I: Interner, T>(cx: I, value: T, amount: u32) -> T
 where
     T: TypeFoldable<I>,
 {
-    debug!("shift_vars(value={:?}, amount={})", value, amount);
-
     if amount == 0 || !value.has_escaping_bound_vars() {
-        return value;
+        value
+    } else {
+        value.fold_with(&mut Shifter::new(cx, amount))
     }
-
-    value.fold_with(&mut Shifter::new(cx, amount))
 }

From e83eacdfaa9002559d3a301a0d1a0f54fa253f1d Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Jul 2024 23:03:34 +0200
Subject: [PATCH 142/685] move behavior out of shared fn

---
 .../rustc_type_ir/src/search_graph/mod.rs     | 25 +++++++------------
 1 file changed, 9 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 6c67bf13ac73e..18a5a85dfa83a 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -300,17 +300,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
     // We update both the head of this cycle to rerun its evaluation until
     // we reach a fixpoint and all other cycle participants to make sure that
     // their result does not get moved to the global cache.
-    fn tag_cycle_participants(
-        stack: &mut IndexVec<StackDepth, StackEntry<X>>,
-        usage_kind: Option<UsageKind>,
-        head: StackDepth,
-    ) {
-        if let Some(usage_kind) = usage_kind {
-            stack[head].has_been_used =
-                Some(stack[head].has_been_used.map_or(usage_kind, |prev| prev.merge(usage_kind)));
-        }
-        debug_assert!(stack[head].has_been_used.is_some());
-
+    fn tag_cycle_participants(stack: &mut IndexVec<StackDepth, StackEntry<X>>, head: StackDepth) {
         // The current root of these cycles. Note that this may not be the final
         // root in case a later goal depends on a goal higher up the stack.
         let mut current_root = head;
@@ -403,7 +393,8 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             // We have a nested goal which is already in the provisional cache, use
             // its result. We do not provide any usage kind as that should have been
             // already set correctly while computing the cache entry.
-            Self::tag_cycle_participants(&mut self.stack, None, entry.head);
+            debug_assert!(self.stack[entry.head].has_been_used.is_some());
+            Self::tag_cycle_participants(&mut self.stack, entry.head);
             return entry.result;
         } else if let Some(stack_depth) = cache_entry.stack_depth {
             debug!("encountered cycle with depth {stack_depth:?}");
@@ -416,11 +407,13 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             let is_coinductive_cycle = Self::stack_coinductive_from(cx, &self.stack, stack_depth);
             let cycle_kind =
                 if is_coinductive_cycle { CycleKind::Coinductive } else { CycleKind::Inductive };
-            Self::tag_cycle_participants(
-                &mut self.stack,
-                Some(UsageKind::Single(cycle_kind)),
-                stack_depth,
+            let usage_kind = UsageKind::Single(cycle_kind);
+            self.stack[stack_depth].has_been_used = Some(
+                self.stack[stack_depth]
+                    .has_been_used
+                    .map_or(usage_kind, |prev| prev.merge(usage_kind)),
             );
+            Self::tag_cycle_participants(&mut self.stack, stack_depth);
 
             // Return the provisional result or, if we're in the first iteration,
             // start with no constraints.

From 0c75c080a7d0662d79c9392ea4a57a805d3b1883 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Jul 2024 23:08:14 +0200
Subject: [PATCH 143/685] merge impl blocks

---
 compiler/rustc_type_ir/src/search_graph/mod.rs | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 18a5a85dfa83a..bd93c86b0860b 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -118,6 +118,11 @@ impl UsageKind {
     }
 }
 
+enum StepResult<X: Cx> {
+    Done(StackEntry<X>, X::Result),
+    HasChanged,
+}
+
 #[derive(Debug, Clone, Copy)]
 struct AvailableDepth(usize);
 impl AvailableDepth {
@@ -559,14 +564,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             )
         })
     }
-}
 
-enum StepResult<X: Cx> {
-    Done(StackEntry<X>, X::Result),
-    HasChanged,
-}
-
-impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
     /// When we encounter a coinductive cycle, we have to fetch the
     /// result of that cycle while we are still computing it. Because
     /// of this we continuously recompute the cycle until the result

From f860873983d1db578aea09d47cd594d9da512e49 Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Tue, 23 Jul 2024 23:19:29 +0200
Subject: [PATCH 144/685] split provisional cache and stack lookup

this makes it easier to maintain and modify going forward.
There may be a small performance cost as we now need to
access the provisional cache *and* walk through the stack
to detect cycles. However, the provisional cache should be
mostly empty and the stack should only have a few elements
so the performance impact is likely minimal.

Given the complexity of the search graph maintainability
trumps linear performance improvements.
---
 .../rustc_type_ir/src/search_graph/mod.rs     | 204 +++++++++---------
 .../src/search_graph/validate.rs              |  18 +-
 2 files changed, 104 insertions(+), 118 deletions(-)

diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index bd93c86b0860b..a1aa63c2e7d75 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -224,8 +224,8 @@ struct DetachedEntry<X: Cx> {
     result: X::Result,
 }
 
-/// Stores the stack depth of a currently evaluated goal *and* already
-/// computed results for goals which depend on other goals still on the stack.
+/// Stores the provisional result of already computed results for goals which
+/// depend on other goals still on the stack.
 ///
 /// The provisional result may depend on whether the stack above it is inductive
 /// or coinductive. Because of this, we store separate provisional results for
@@ -238,16 +238,13 @@ struct DetachedEntry<X: Cx> {
 /// see tests/ui/traits/next-solver/cycles/provisional-cache-impacts-behavior.rs.
 #[derive_where(Default; X: Cx)]
 struct ProvisionalCacheEntry<X: Cx> {
-    stack_depth: Option<StackDepth>,
     with_inductive_stack: Option<DetachedEntry<X>>,
     with_coinductive_stack: Option<DetachedEntry<X>>,
 }
 
 impl<X: Cx> ProvisionalCacheEntry<X> {
     fn is_empty(&self) -> bool {
-        self.stack_depth.is_none()
-            && self.with_inductive_stack.is_none()
-            && self.with_coinductive_stack.is_none()
+        self.with_inductive_stack.is_none() && self.with_coinductive_stack.is_none()
     }
 }
 
@@ -378,71 +375,26 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             None
         };
 
-        // Check whether the goal is in the provisional cache.
-        // The provisional result may rely on the path to its cycle roots,
-        // so we have to check the path of the current goal matches that of
-        // the cache entry.
-        let cache_entry = self.provisional_cache.entry(input).or_default();
-        if let Some(entry) = cache_entry
-            .with_coinductive_stack
-            .as_ref()
-            .filter(|p| Self::stack_coinductive_from(cx, &self.stack, p.head))
-            .or_else(|| {
-                cache_entry
-                    .with_inductive_stack
-                    .as_ref()
-                    .filter(|p| !Self::stack_coinductive_from(cx, &self.stack, p.head))
-            })
-        {
-            debug!("provisional cache hit");
-            // We have a nested goal which is already in the provisional cache, use
-            // its result. We do not provide any usage kind as that should have been
-            // already set correctly while computing the cache entry.
-            debug_assert!(self.stack[entry.head].has_been_used.is_some());
-            Self::tag_cycle_participants(&mut self.stack, entry.head);
-            return entry.result;
-        } else if let Some(stack_depth) = cache_entry.stack_depth {
-            debug!("encountered cycle with depth {stack_depth:?}");
-            // We have a nested goal which directly relies on a goal deeper in the stack.
-            //
-            // We start by tagging all cycle participants, as that's necessary for caching.
-            //
-            // Finally we can return either the provisional response or the initial response
-            // in case we're in the first fixpoint iteration for this goal.
-            let is_coinductive_cycle = Self::stack_coinductive_from(cx, &self.stack, stack_depth);
-            let cycle_kind =
-                if is_coinductive_cycle { CycleKind::Coinductive } else { CycleKind::Inductive };
-            let usage_kind = UsageKind::Single(cycle_kind);
-            self.stack[stack_depth].has_been_used = Some(
-                self.stack[stack_depth]
-                    .has_been_used
-                    .map_or(usage_kind, |prev| prev.merge(usage_kind)),
-            );
-            Self::tag_cycle_participants(&mut self.stack, stack_depth);
-
-            // Return the provisional result or, if we're in the first iteration,
-            // start with no constraints.
-            return if let Some(result) = self.stack[stack_depth].provisional_result {
-                result
-            } else {
-                D::initial_provisional_result(cx, cycle_kind, input)
-            };
-        } else {
-            // No entry, we push this goal on the stack and try to prove it.
-            let depth = self.stack.next_index();
-            let entry = StackEntry {
-                input,
-                available_depth,
-                reached_depth: depth,
-                non_root_cycle_participant: None,
-                encountered_overflow: false,
-                has_been_used: None,
-                nested_goals: Default::default(),
-                provisional_result: None,
-            };
-            assert_eq!(self.stack.push(entry), depth);
-            cache_entry.stack_depth = Some(depth);
+        if let Some(result) = self.lookup_provisional_cache(cx, input) {
+            return result;
+        }
+
+        if let Some(result) = self.check_cycle_on_stack(cx, input) {
+            return result;
+        }
+
+        let depth = self.stack.next_index();
+        let entry = StackEntry {
+            input,
+            available_depth,
+            reached_depth: depth,
+            non_root_cycle_participant: None,
+            encountered_overflow: false,
+            has_been_used: None,
+            nested_goals: Default::default(),
+            provisional_result: None,
         };
+        assert_eq!(self.stack.push(entry), depth);
 
         // This is for global caching, so we properly track query dependencies.
         // Everything that affects the `result` should be performed within this
@@ -474,8 +426,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             debug_assert!(validate_cache.is_none());
             let coinductive_stack = Self::stack_coinductive_from(cx, &self.stack, head);
 
-            let entry = self.provisional_cache.get_mut(&input).unwrap();
-            entry.stack_depth = None;
+            let entry = self.provisional_cache.entry(input).or_default();
             if coinductive_stack {
                 entry.with_coinductive_stack = Some(DetachedEntry { head, result });
             } else {
@@ -534,35 +485,52 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         })
     }
 
-    /// When encountering a cycle, both inductive and coinductive, we only
-    /// move the root into the global cache. We also store all other cycle
-    /// participants involved.
-    ///
-    /// We must not use the global cache entry of a root goal if a cycle
-    /// participant is on the stack. This is necessary to prevent unstable
-    /// results. See the comment of `StackEntry::nested_goals` for
-    /// more details.
-    fn insert_global_cache(
-        &mut self,
-        cx: X,
-        input: X::Input,
-        final_entry: StackEntry<X>,
-        result: X::Result,
-        dep_node: X::DepNodeIndex,
-    ) {
-        let additional_depth = final_entry.reached_depth.as_usize() - self.stack.len();
-        debug!(?final_entry, ?result, "insert global cache");
-        cx.with_global_cache(self.mode, |cache| {
-            cache.insert(
-                cx,
-                input,
-                result,
-                dep_node,
-                additional_depth,
-                final_entry.encountered_overflow,
-                &final_entry.nested_goals,
-            )
-        })
+    fn lookup_provisional_cache(&mut self, cx: X, input: X::Input) -> Option<X::Result> {
+        let cache_entry = self.provisional_cache.get(&input)?;
+        let &DetachedEntry { head, result } = cache_entry
+            .with_coinductive_stack
+            .as_ref()
+            .filter(|p| Self::stack_coinductive_from(cx, &self.stack, p.head))
+            .or_else(|| {
+                cache_entry
+                    .with_inductive_stack
+                    .as_ref()
+                    .filter(|p| !Self::stack_coinductive_from(cx, &self.stack, p.head))
+            })?;
+
+        debug!("provisional cache hit");
+        // We have a nested goal which is already in the provisional cache, use
+        // its result. We do not provide any usage kind as that should have been
+        // already set correctly while computing the cache entry.
+        Self::tag_cycle_participants(&mut self.stack, head);
+        debug_assert!(self.stack[head].has_been_used.is_some());
+        Some(result)
+    }
+
+    fn check_cycle_on_stack(&mut self, cx: X, input: X::Input) -> Option<X::Result> {
+        let (head, _stack_entry) = self.stack.iter_enumerated().find(|(_, e)| e.input == input)?;
+        debug!("encountered cycle with depth {head:?}");
+        // We have a nested goal which directly relies on a goal deeper in the stack.
+        //
+        // We start by tagging all cycle participants, as that's necessary for caching.
+        //
+        // Finally we can return either the provisional response or the initial response
+        // in case we're in the first fixpoint iteration for this goal.
+        let is_coinductive_cycle = Self::stack_coinductive_from(cx, &self.stack, head);
+        let cycle_kind =
+            if is_coinductive_cycle { CycleKind::Coinductive } else { CycleKind::Inductive };
+        let usage_kind = UsageKind::Single(cycle_kind);
+        self.stack[head].has_been_used =
+            Some(self.stack[head].has_been_used.map_or(usage_kind, |prev| prev.merge(usage_kind)));
+        Self::tag_cycle_participants(&mut self.stack, head);
+
+        // Return the provisional result or, if we're in the first iteration,
+        // start with no constraints.
+        if let Some(result) = self.stack[head].provisional_result {
+            Some(result)
+        } else {
+            Some(D::initial_provisional_result(cx, cycle_kind, input))
+        }
     }
 
     /// When we encounter a coinductive cycle, we have to fetch the
@@ -613,13 +581,43 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             StepResult::Done(stack_entry, result)
         } else {
             debug!(?result, "fixpoint changed provisional results");
-            let depth = self.stack.push(StackEntry {
+            self.stack.push(StackEntry {
                 has_been_used: None,
                 provisional_result: Some(result),
                 ..stack_entry
             });
-            debug_assert_eq!(self.provisional_cache[&input].stack_depth, Some(depth));
             StepResult::HasChanged
         }
     }
+
+    /// When encountering a cycle, both inductive and coinductive, we only
+    /// move the root into the global cache. We also store all other cycle
+    /// participants involved.
+    ///
+    /// We must not use the global cache entry of a root goal if a cycle
+    /// participant is on the stack. This is necessary to prevent unstable
+    /// results. See the comment of `StackEntry::nested_goals` for
+    /// more details.
+    fn insert_global_cache(
+        &mut self,
+        cx: X,
+        input: X::Input,
+        final_entry: StackEntry<X>,
+        result: X::Result,
+        dep_node: X::DepNodeIndex,
+    ) {
+        let additional_depth = final_entry.reached_depth.as_usize() - self.stack.len();
+        debug!(?final_entry, ?result, "insert global cache");
+        cx.with_global_cache(self.mode, |cache| {
+            cache.insert(
+                cx,
+                input,
+                result,
+                dep_node,
+                additional_depth,
+                final_entry.encountered_overflow,
+                &final_entry.nested_goals,
+            )
+        })
+    }
 }
diff --git a/compiler/rustc_type_ir/src/search_graph/validate.rs b/compiler/rustc_type_ir/src/search_graph/validate.rs
index 1ae806834ba7d..b4802811b0f57 100644
--- a/compiler/rustc_type_ir/src/search_graph/validate.rs
+++ b/compiler/rustc_type_ir/src/search_graph/validate.rs
@@ -23,8 +23,6 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                 ref nested_goals,
                 provisional_result,
             } = *entry;
-            let cache_entry = provisional_cache.get(&entry.input).unwrap();
-            assert_eq!(cache_entry.stack_depth, Some(depth));
             if let Some(head) = non_root_cycle_participant {
                 assert!(head < depth);
                 assert!(nested_goals.is_empty());
@@ -45,19 +43,9 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             }
         }
 
-        for (&input, entry) in &self.provisional_cache {
-            let ProvisionalCacheEntry { stack_depth, with_coinductive_stack, with_inductive_stack } =
-                entry;
-            assert!(
-                stack_depth.is_some()
-                    || with_coinductive_stack.is_some()
-                    || with_inductive_stack.is_some()
-            );
-
-            if let &Some(stack_depth) = stack_depth {
-                assert_eq!(stack[stack_depth].input, input);
-            }
-
+        for (&_input, entry) in &self.provisional_cache {
+            let ProvisionalCacheEntry { with_coinductive_stack, with_inductive_stack } = entry;
+            assert!(with_coinductive_stack.is_some() || with_inductive_stack.is_some());
             let check_detached = |detached_entry: &DetachedEntry<X>| {
                 let DetachedEntry { head, result: _ } = *detached_entry;
                 assert_ne!(stack[head].has_been_used, None);

From 8b18c6bdd3d61dda5fe8c4ed378286abec2a9bc4 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 10 Aug 2024 21:54:44 +0200
Subject: [PATCH 145/685] miri weak memory emulation: initialize store buffer
 only on atomic writes; pre-fill with previous value

---
 .../rustc_const_eval/src/interpret/memory.rs  |   2 +-
 src/tools/miri/src/concurrency/data_race.rs   |  19 +-
 src/tools/miri/src/concurrency/weak_memory.rs | 164 ++++++++----------
 .../tests/fail/weak_memory/weak_uninit.rs     |  43 +++++
 .../tests/fail/weak_memory/weak_uninit.stderr |  15 ++
 src/tools/miri/tests/pass/weak_memory/weak.rs |  19 +-
 6 files changed, 153 insertions(+), 109 deletions(-)
 create mode 100644 src/tools/miri/tests/fail/weak_memory/weak_uninit.rs
 create mode 100644 src/tools/miri/tests/fail/weak_memory/weak_uninit.stderr

diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 2e5d0ae773654..b0a583f136fd7 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -1011,7 +1011,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     ///
     /// We do this so Miri's allocation access tracking does not show the validation
     /// reads as spurious accesses.
-    pub(super) fn run_for_validation<R>(&self, f: impl FnOnce() -> R) -> R {
+    pub fn run_for_validation<R>(&self, f: impl FnOnce() -> R) -> R {
         // This deliberately uses `==` on `bool` to follow the pattern
         // `assert!(val.replace(new) == old)`.
         assert!(
diff --git a/src/tools/miri/src/concurrency/data_race.rs b/src/tools/miri/src/concurrency/data_race.rs
index 9df0d95f1f275..6fd207c92b937 100644
--- a/src/tools/miri/src/concurrency/data_race.rs
+++ b/src/tools/miri/src/concurrency/data_race.rs
@@ -617,9 +617,10 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         // the *value* (including the associated provenance if this is an AtomicPtr) at this location.
         // Only metadata on the location itself is used.
         let scalar = this.allow_data_races_ref(move |this| this.read_scalar(place))?;
-        this.buffered_atomic_read(place, atomic, scalar, || {
+        let buffered_scalar = this.buffered_atomic_read(place, atomic, scalar, || {
             this.validate_atomic_load(place, atomic)
-        })
+        })?;
+        Ok(buffered_scalar.ok_or_else(|| err_ub!(InvalidUninitBytes(None)))?)
     }
 
     /// Perform an atomic write operation at the memory location.
@@ -632,14 +633,14 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
         let this = self.eval_context_mut();
         this.atomic_access_check(dest, AtomicAccessType::Store)?;
 
+        // Read the previous value so we can put it in the store buffer later.
+        // The program didn't actually do a read, so suppress the memory access hooks.
+        // This is also a very special exception where we just ignore an error -- if this read
+        // was UB e.g. because the memory is uninitialized, we don't want to know!
+        let old_val = this.run_for_validation(|| this.read_scalar(dest)).ok();
         this.allow_data_races_mut(move |this| this.write_scalar(val, dest))?;
         this.validate_atomic_store(dest, atomic)?;
-        // FIXME: it's not possible to get the value before write_scalar. A read_scalar will cause
-        // side effects from a read the program did not perform. So we have to initialise
-        // the store buffer with the value currently being written
-        // ONCE this is fixed please remove the hack in buffered_atomic_write() in weak_memory.rs
-        // https://github.com/rust-lang/miri/issues/2164
-        this.buffered_atomic_write(val, dest, atomic, val)
+        this.buffered_atomic_write(val, dest, atomic, old_val)
     }
 
     /// Perform an atomic RMW operation on a memory location.
@@ -768,7 +769,7 @@ pub trait EvalContextExt<'tcx>: MiriInterpCxExt<'tcx> {
             // in the modification order.
             // Since `old` is only a value and not the store element, we need to separately
             // find it in our store buffer and perform load_impl on it.
-            this.perform_read_on_buffered_latest(place, fail, old.to_scalar())?;
+            this.perform_read_on_buffered_latest(place, fail)?;
         }
 
         // Return the old value.
diff --git a/src/tools/miri/src/concurrency/weak_memory.rs b/src/tools/miri/src/concurrency/weak_memory.rs
index 6f4171584a8f7..0605b744e6afd 100644
--- a/src/tools/miri/src/concurrency/weak_memory.rs
+++ b/src/tools/miri/src/concurrency/weak_memory.rs
@@ -39,11 +39,10 @@
 //! to attach store buffers to atomic objects. However, Rust follows LLVM in that it only has
 //! 'atomic accesses'. Therefore Miri cannot know when and where atomic 'objects' are being
 //! created or destroyed, to manage its store buffers. Instead, we hence lazily create an
-//! atomic object on the first atomic access to a given region, and we destroy that object
-//! on the next non-atomic or imperfectly overlapping atomic access to that region.
+//! atomic object on the first atomic write to a given region, and we destroy that object
+//! on the next non-atomic or imperfectly overlapping atomic write to that region.
 //! These lazy (de)allocations happen in memory_accessed() on non-atomic accesses, and
-//! get_or_create_store_buffer() on atomic accesses. This mostly works well, but it does
-//! lead to some issues (<https://github.com/rust-lang/miri/issues/2164>).
+//! get_or_create_store_buffer_mut() on atomic writes.
 //!
 //! One consequence of this difference is that safe/sound Rust allows for more operations on atomic locations
 //! than the C++20 atomic API was intended to allow, such as non-atomically accessing
@@ -144,11 +143,9 @@ struct StoreElement {
 
     /// The timestamp of the storing thread when it performed the store
     timestamp: VTimestamp,
-    /// The value of this store
-    // FIXME: this means the store must be fully initialized;
-    // we will have to change this if we want to support atomics on
-    // (partially) uninitialized data.
-    val: Scalar,
+    /// The value of this store. `None` means uninitialized.
+    // FIXME: Currently, we cannot represent partial initialization.
+    val: Option<Scalar>,
 
     /// Metadata about loads from this store element,
     /// behind a RefCell to keep load op take &self
@@ -170,7 +167,7 @@ impl StoreBufferAlloc {
 
     /// When a non-atomic access happens on a location that has been atomically accessed
     /// before without data race, we can determine that the non-atomic access fully happens
-    /// after all the prior atomic accesses so the location no longer needs to exhibit
+    /// after all the prior atomic writes so the location no longer needs to exhibit
     /// any weak memory behaviours until further atomic accesses.
     pub fn memory_accessed(&self, range: AllocRange, global: &DataRaceState) {
         if !global.ongoing_action_data_race_free() {
@@ -192,37 +189,29 @@ impl StoreBufferAlloc {
         }
     }
 
-    /// Gets a store buffer associated with an atomic object in this allocation,
-    /// or creates one with the specified initial value if no atomic object exists yet.
-    fn get_or_create_store_buffer<'tcx>(
+    /// Gets a store buffer associated with an atomic object in this allocation.
+    /// Returns `None` if there is no store buffer.
+    fn get_store_buffer<'tcx>(
         &self,
         range: AllocRange,
-        init: Scalar,
-    ) -> InterpResult<'tcx, Ref<'_, StoreBuffer>> {
+    ) -> InterpResult<'tcx, Option<Ref<'_, StoreBuffer>>> {
         let access_type = self.store_buffers.borrow().access_type(range);
         let pos = match access_type {
             AccessType::PerfectlyOverlapping(pos) => pos,
-            AccessType::Empty(pos) => {
-                let mut buffers = self.store_buffers.borrow_mut();
-                buffers.insert_at_pos(pos, range, StoreBuffer::new(init));
-                pos
-            }
-            AccessType::ImperfectlyOverlapping(pos_range) => {
-                // Once we reach here we would've already checked that this access is not racy.
-                let mut buffers = self.store_buffers.borrow_mut();
-                buffers.remove_pos_range(pos_range.clone());
-                buffers.insert_at_pos(pos_range.start, range, StoreBuffer::new(init));
-                pos_range.start
-            }
+            // If there is nothing here yet, that means there wasn't an atomic write yet so
+            // we can't return anything outdated.
+            _ => return Ok(None),
         };
-        Ok(Ref::map(self.store_buffers.borrow(), |buffer| &buffer[pos]))
+        let store_buffer = Ref::map(self.store_buffers.borrow(), |buffer| &buffer[pos]);
+        Ok(Some(store_buffer))
     }
 
-    /// Gets a mutable store buffer associated with an atomic object in this allocation
+    /// Gets a mutable store buffer associated with an atomic object in this allocation,
+    /// or creates one with the specified initial value if no atomic object exists yet.
     fn get_or_create_store_buffer_mut<'tcx>(
         &mut self,
         range: AllocRange,
-        init: Scalar,
+        init: Option<Scalar>,
     ) -> InterpResult<'tcx, &mut StoreBuffer> {
         let buffers = self.store_buffers.get_mut();
         let access_type = buffers.access_type(range);
@@ -244,10 +233,8 @@ impl StoreBufferAlloc {
 }
 
 impl<'tcx> StoreBuffer {
-    fn new(init: Scalar) -> Self {
+    fn new(init: Option<Scalar>) -> Self {
         let mut buffer = VecDeque::new();
-        buffer.reserve(STORE_BUFFER_LIMIT);
-        let mut ret = Self { buffer };
         let store_elem = StoreElement {
             // The thread index and timestamp of the initialisation write
             // are never meaningfully used, so it's fine to leave them as 0
@@ -257,11 +244,11 @@ impl<'tcx> StoreBuffer {
             is_seqcst: false,
             load_info: RefCell::new(LoadInfo::default()),
         };
-        ret.buffer.push_back(store_elem);
-        ret
+        buffer.push_back(store_elem);
+        Self { buffer }
     }
 
-    /// Reads from the last store in modification order
+    /// Reads from the last store in modification order, if any.
     fn read_from_last_store(
         &self,
         global: &DataRaceState,
@@ -282,7 +269,7 @@ impl<'tcx> StoreBuffer {
         is_seqcst: bool,
         rng: &mut (impl rand::Rng + ?Sized),
         validate: impl FnOnce() -> InterpResult<'tcx>,
-    ) -> InterpResult<'tcx, (Scalar, LoadRecency)> {
+    ) -> InterpResult<'tcx, (Option<Scalar>, LoadRecency)> {
         // Having a live borrow to store_buffer while calling validate_atomic_load is fine
         // because the race detector doesn't touch store_buffer
 
@@ -419,15 +406,15 @@ impl<'tcx> StoreBuffer {
             // In the language provided in the paper, an atomic store takes the value from a
             // non-atomic memory location.
             // But we already have the immediate value here so we don't need to do the memory
-            // access
-            val,
+            // access.
+            val: Some(val),
             is_seqcst,
             load_info: RefCell::new(LoadInfo::default()),
         };
-        self.buffer.push_back(store_elem);
-        if self.buffer.len() > STORE_BUFFER_LIMIT {
+        if self.buffer.len() >= STORE_BUFFER_LIMIT {
             self.buffer.pop_front();
         }
+        self.buffer.push_back(store_elem);
         if is_seqcst {
             // Every store that happens before this needs to be marked as SC
             // so that in a later SC load, only the last SC store (i.e. this one) or stores that
@@ -450,7 +437,12 @@ impl StoreElement {
     /// buffer regardless of subsequent loads by the same thread; if the earliest load of another
     /// thread doesn't happen before the current one, then no subsequent load by the other thread
     /// can happen before the current one.
-    fn load_impl(&self, index: VectorIdx, clocks: &ThreadClockSet, is_seqcst: bool) -> Scalar {
+    fn load_impl(
+        &self,
+        index: VectorIdx,
+        clocks: &ThreadClockSet,
+        is_seqcst: bool,
+    ) -> Option<Scalar> {
         let mut load_info = self.load_info.borrow_mut();
         load_info.sc_loaded |= is_seqcst;
         let _ = load_info.timestamps.try_insert(index, clocks.clock[index]);
@@ -479,7 +471,7 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 global.sc_write(threads);
             }
             let range = alloc_range(base_offset, place.layout.size);
-            let buffer = alloc_buffers.get_or_create_store_buffer_mut(range, init)?;
+            let buffer = alloc_buffers.get_or_create_store_buffer_mut(range, Some(init))?;
             buffer.read_from_last_store(global, threads, atomic == AtomicRwOrd::SeqCst);
             buffer.buffered_write(new_val, global, threads, atomic == AtomicRwOrd::SeqCst)?;
         }
@@ -492,47 +484,55 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         atomic: AtomicReadOrd,
         latest_in_mo: Scalar,
         validate: impl FnOnce() -> InterpResult<'tcx>,
-    ) -> InterpResult<'tcx, Scalar> {
+    ) -> InterpResult<'tcx, Option<Scalar>> {
         let this = self.eval_context_ref();
-        if let Some(global) = &this.machine.data_race {
-            let (alloc_id, base_offset, ..) = this.ptr_get_alloc_id(place.ptr(), 0)?;
-            if let Some(alloc_buffers) = this.get_alloc_extra(alloc_id)?.weak_memory.as_ref() {
-                if atomic == AtomicReadOrd::SeqCst {
-                    global.sc_read(&this.machine.threads);
-                }
-                let mut rng = this.machine.rng.borrow_mut();
-                let buffer = alloc_buffers.get_or_create_store_buffer(
-                    alloc_range(base_offset, place.layout.size),
-                    latest_in_mo,
-                )?;
-                let (loaded, recency) = buffer.buffered_read(
-                    global,
-                    &this.machine.threads,
-                    atomic == AtomicReadOrd::SeqCst,
-                    &mut *rng,
-                    validate,
-                )?;
-                if global.track_outdated_loads && recency == LoadRecency::Outdated {
-                    this.emit_diagnostic(NonHaltingDiagnostic::WeakMemoryOutdatedLoad {
-                        ptr: place.ptr(),
-                    });
+        'fallback: {
+            if let Some(global) = &this.machine.data_race {
+                let (alloc_id, base_offset, ..) = this.ptr_get_alloc_id(place.ptr(), 0)?;
+                if let Some(alloc_buffers) = this.get_alloc_extra(alloc_id)?.weak_memory.as_ref() {
+                    if atomic == AtomicReadOrd::SeqCst {
+                        global.sc_read(&this.machine.threads);
+                    }
+                    let mut rng = this.machine.rng.borrow_mut();
+                    let Some(buffer) = alloc_buffers
+                        .get_store_buffer(alloc_range(base_offset, place.layout.size))?
+                    else {
+                        // No old writes available, fall back to base case.
+                        break 'fallback;
+                    };
+                    let (loaded, recency) = buffer.buffered_read(
+                        global,
+                        &this.machine.threads,
+                        atomic == AtomicReadOrd::SeqCst,
+                        &mut *rng,
+                        validate,
+                    )?;
+                    if global.track_outdated_loads && recency == LoadRecency::Outdated {
+                        this.emit_diagnostic(NonHaltingDiagnostic::WeakMemoryOutdatedLoad {
+                            ptr: place.ptr(),
+                        });
+                    }
+
+                    return Ok(loaded);
                 }
-
-                return Ok(loaded);
             }
         }
 
         // Race detector or weak memory disabled, simply read the latest value
         validate()?;
-        Ok(latest_in_mo)
+        Ok(Some(latest_in_mo))
     }
 
+    /// Add the given write to the store buffer. (Does not change machine memory.)
+    ///
+    /// `init` says with which value to initialize the store buffer in case there wasn't a store
+    /// buffer for this memory range before.
     fn buffered_atomic_write(
         &mut self,
         val: Scalar,
         dest: &MPlaceTy<'tcx>,
         atomic: AtomicWriteOrd,
-        init: Scalar,
+        init: Option<Scalar>,
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
         let (alloc_id, base_offset, ..) = this.ptr_get_alloc_id(dest.ptr(), 0)?;
@@ -545,23 +545,8 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 global.sc_write(threads);
             }
 
-            // UGLY HACK: in write_scalar_atomic() we don't know the value before our write,
-            // so init == val always. If the buffer is fresh then we would've duplicated an entry,
-            // so we need to remove it.
-            // See https://github.com/rust-lang/miri/issues/2164
-            let was_empty = matches!(
-                alloc_buffers
-                    .store_buffers
-                    .borrow()
-                    .access_type(alloc_range(base_offset, dest.layout.size)),
-                AccessType::Empty(_)
-            );
             let buffer = alloc_buffers
                 .get_or_create_store_buffer_mut(alloc_range(base_offset, dest.layout.size), init)?;
-            if was_empty {
-                buffer.buffer.pop_front();
-            }
-
             buffer.buffered_write(val, global, threads, atomic == AtomicWriteOrd::SeqCst)?;
         }
 
@@ -576,7 +561,6 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         &self,
         place: &MPlaceTy<'tcx>,
         atomic: AtomicReadOrd,
-        init: Scalar,
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_ref();
 
@@ -587,8 +571,12 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             let size = place.layout.size;
             let (alloc_id, base_offset, ..) = this.ptr_get_alloc_id(place.ptr(), 0)?;
             if let Some(alloc_buffers) = this.get_alloc_extra(alloc_id)?.weak_memory.as_ref() {
-                let buffer = alloc_buffers
-                    .get_or_create_store_buffer(alloc_range(base_offset, size), init)?;
+                let Some(buffer) =
+                    alloc_buffers.get_store_buffer(alloc_range(base_offset, size))?
+                else {
+                    // No store buffer, nothing to do.
+                    return Ok(());
+                };
                 buffer.read_from_last_store(
                     global,
                     &this.machine.threads,
diff --git a/src/tools/miri/tests/fail/weak_memory/weak_uninit.rs b/src/tools/miri/tests/fail/weak_memory/weak_uninit.rs
new file mode 100644
index 0000000000000..54bea6c6908e3
--- /dev/null
+++ b/src/tools/miri/tests/fail/weak_memory/weak_uninit.rs
@@ -0,0 +1,43 @@
+//@compile-flags: -Zmiri-ignore-leaks -Zmiri-preemption-rate=0
+
+// Tests showing weak memory behaviours are exhibited. All tests
+// return true when the desired behaviour is seen.
+// This is scheduler and pseudo-RNG dependent, so each test is
+// run multiple times until one try returns true.
+// Spurious failure is possible, if you are really unlucky with
+// the RNG and always read the latest value from the store buffer.
+#![feature(new_uninit)]
+
+use std::sync::atomic::*;
+use std::thread::spawn;
+
+#[allow(dead_code)]
+#[derive(Copy, Clone)]
+struct EvilSend<T>(pub T);
+
+unsafe impl<T> Send for EvilSend<T> {}
+unsafe impl<T> Sync for EvilSend<T> {}
+
+// We can't create static items because we need to run each test multiple times.
+fn static_uninit_atomic() -> &'static AtomicUsize {
+    unsafe { Box::leak(Box::new_uninit()).assume_init_ref() }
+}
+
+fn relaxed() {
+    let x = static_uninit_atomic();
+    let j1 = spawn(move || {
+        x.store(1, Ordering::Relaxed);
+    });
+
+    let j2 = spawn(move || x.load(Ordering::Relaxed)); //~ERROR: using uninitialized data
+
+    j1.join().unwrap();
+    j2.join().unwrap();
+}
+
+pub fn main() {
+    // If we try often enough, we should hit UB.
+    for _ in 0..100 {
+        relaxed();
+    }
+}
diff --git a/src/tools/miri/tests/fail/weak_memory/weak_uninit.stderr b/src/tools/miri/tests/fail/weak_memory/weak_uninit.stderr
new file mode 100644
index 0000000000000..9aa5bc2fa76df
--- /dev/null
+++ b/src/tools/miri/tests/fail/weak_memory/weak_uninit.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
+  --> $DIR/weak_uninit.rs:LL:CC
+   |
+LL |     let j2 = spawn(move || x.load(Ordering::Relaxed));
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^ using uninitialized data, but this operation requires initialized memory
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: BACKTRACE on thread `unnamed-ID`:
+   = note: inside closure at $DIR/weak_uninit.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/pass/weak_memory/weak.rs b/src/tools/miri/tests/pass/weak_memory/weak.rs
index dac63eeeb0b24..1b5c98cd51826 100644
--- a/src/tools/miri/tests/pass/weak_memory/weak.rs
+++ b/src/tools/miri/tests/pass/weak_memory/weak.rs
@@ -18,11 +18,9 @@ struct EvilSend<T>(pub T);
 unsafe impl<T> Send for EvilSend<T> {}
 unsafe impl<T> Sync for EvilSend<T> {}
 
-// We can't create static items because we need to run each test
-// multiple times
+// We can't create static items because we need to run each test multiple times.
 fn static_atomic(val: usize) -> &'static AtomicUsize {
-    let ret = Box::leak(Box::new(AtomicUsize::new(val)));
-    ret
+    Box::leak(Box::new(AtomicUsize::new(val)))
 }
 
 // Spins until it reads the given value
@@ -33,7 +31,7 @@ fn reads_value(loc: &AtomicUsize, val: usize) -> usize {
     val
 }
 
-fn relaxed() -> bool {
+fn relaxed(initial_read: bool) -> bool {
     let x = static_atomic(0);
     let j1 = spawn(move || {
         x.store(1, Relaxed);
@@ -47,7 +45,9 @@ fn relaxed() -> bool {
     j1.join().unwrap();
     let r2 = j2.join().unwrap();
 
-    r2 == 1
+    // There are three possible values here: 0 (from the initial read), 1 (from the first relaxed
+    // read), and 2 (the last read). The last case is boring and we cover the other two.
+    r2 == if initial_read { 0 } else { 1 }
 }
 
 // https://www.doc.ic.ac.uk/~afd/homepages/papers/pdfs/2017/POPL.pdf Figure 8
@@ -74,7 +74,6 @@ fn seq_cst() -> bool {
 
 fn initialization_write(add_fence: bool) -> bool {
     let x = static_atomic(11);
-    assert_eq!(x.load(Relaxed), 11); // work around https://github.com/rust-lang/miri/issues/2164
 
     let wait = static_atomic(0);
 
@@ -112,11 +111,8 @@ fn faa_replaced_by_load() -> bool {
     }
 
     let x = static_atomic(0);
-    assert_eq!(x.load(Relaxed), 0); // work around https://github.com/rust-lang/miri/issues/2164
     let y = static_atomic(0);
-    assert_eq!(y.load(Relaxed), 0); // work around https://github.com/rust-lang/miri/issues/2164
     let z = static_atomic(0);
-    assert_eq!(z.load(Relaxed), 0); // work around https://github.com/rust-lang/miri/issues/2164
 
     // Since each thread is so short, we need to make sure that they truely run at the same time
     // Otherwise t1 will finish before t2 even starts
@@ -146,7 +142,8 @@ fn assert_once(f: fn() -> bool) {
 }
 
 pub fn main() {
-    assert_once(relaxed);
+    assert_once(|| relaxed(false));
+    assert_once(|| relaxed(true));
     assert_once(seq_cst);
     assert_once(|| initialization_write(false));
     assert_once(|| initialization_write(true));

From 72ef357ea31ed9b8c926bea6c1ae608ccc9dc0d2 Mon Sep 17 00:00:00 2001
From: burlinchen <chenbeiliuhuo@gmail.com>
Date: Mon, 12 Aug 2024 17:34:00 +0800
Subject: [PATCH 146/685] chore(lib): Enhance documentation for
 core::fmt::Formatter's write_fmt method

---
 library/core/src/fmt/mod.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index 60c0dc7685253..8143ff4addcdd 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -1626,6 +1626,11 @@ impl<'a> Formatter<'a> {
         self.buf.write_str(data)
     }
 
+    /// Glue for usage of the [`write!`] macro with implementors of this trait.
+    ///
+    /// This method should generally not be invoked manually, but rather through
+    /// the [`write!`] macro itself.
+    /// 
     /// Writes some formatted information into this instance.
     ///
     /// # Examples

From 18d62008d4196630da20c91f3ee95e93816d613d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sun, 11 Aug 2024 11:49:47 +0200
Subject: [PATCH 147/685] Add possibility to generate rustdoc JSON output to
 stdout

---
 src/librustdoc/config.rs   | 15 ++++++++----
 src/librustdoc/json/mod.rs | 47 +++++++++++++++++++++++++-------------
 2 files changed, 41 insertions(+), 21 deletions(-)

diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index 9c7a9f8467f5a..cd2892e7a252d 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -286,6 +286,9 @@ pub(crate) struct RenderOptions {
     pub(crate) no_emit_shared: bool,
     /// If `true`, HTML source code pages won't be generated.
     pub(crate) html_no_source: bool,
+    /// This field is only used for the JSON output. If it's set to true, no file will be created
+    /// and content will be displayed in stdout directly.
+    pub(crate) output_to_stdout: bool,
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -548,16 +551,17 @@ impl Options {
             dcx.fatal("the `--test` flag must be passed to enable `--no-run`");
         }
 
+        let mut output_to_stdout = false;
         let test_builder_wrappers =
             matches.opt_strs("test-builder-wrapper").iter().map(PathBuf::from).collect();
-        let out_dir = matches.opt_str("out-dir").map(|s| PathBuf::from(&s));
-        let output = matches.opt_str("output").map(|s| PathBuf::from(&s));
-        let output = match (out_dir, output) {
+        let output = match (matches.opt_str("out-dir"), matches.opt_str("output")) {
             (Some(_), Some(_)) => {
                 dcx.fatal("cannot use both 'out-dir' and 'output' at once");
             }
-            (Some(out_dir), None) => out_dir,
-            (None, Some(output)) => output,
+            (Some(out_dir), None) | (None, Some(out_dir)) => {
+                output_to_stdout = out_dir == "-";
+                PathBuf::from(out_dir)
+            }
             (None, None) => PathBuf::from("doc"),
         };
 
@@ -816,6 +820,7 @@ impl Options {
             call_locations,
             no_emit_shared: false,
             html_no_source,
+            output_to_stdout,
         };
         Some((options, render_options))
     }
diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs
index ea191dc89cfde..860672443f2e8 100644
--- a/src/librustdoc/json/mod.rs
+++ b/src/librustdoc/json/mod.rs
@@ -9,7 +9,7 @@ mod import_finder;
 
 use std::cell::RefCell;
 use std::fs::{create_dir_all, File};
-use std::io::{BufWriter, Write};
+use std::io::{stdout, BufWriter, Write};
 use std::path::PathBuf;
 use std::rc::Rc;
 
@@ -37,7 +37,7 @@ pub(crate) struct JsonRenderer<'tcx> {
     /// level field of the JSON blob.
     index: Rc<RefCell<FxHashMap<types::Id, types::Item>>>,
     /// The directory where the blob will be written to.
-    out_path: PathBuf,
+    out_path: Option<PathBuf>,
     cache: Rc<Cache>,
     imported_items: DefIdSet,
 }
@@ -97,6 +97,20 @@ impl<'tcx> JsonRenderer<'tcx> {
             })
             .unwrap_or_default()
     }
+
+    fn write<T: Write>(
+        &self,
+        output: types::Crate,
+        mut writer: BufWriter<T>,
+        path: &str,
+    ) -> Result<(), Error> {
+        self.tcx
+            .sess
+            .time("rustdoc_json_serialization", || serde_json::ser::to_writer(&mut writer, &output))
+            .unwrap();
+        try_err!(writer.flush(), path);
+        Ok(())
+    }
 }
 
 impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
@@ -120,7 +134,7 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
             JsonRenderer {
                 tcx,
                 index: Rc::new(RefCell::new(FxHashMap::default())),
-                out_path: options.output,
+                out_path: if options.output_to_stdout { None } else { Some(options.output) },
                 cache: Rc::new(cache),
                 imported_items,
             },
@@ -264,20 +278,21 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
                 .collect(),
             format_version: types::FORMAT_VERSION,
         };
-        let out_dir = self.out_path.clone();
-        try_err!(create_dir_all(&out_dir), out_dir);
+        if let Some(ref out_path) = self.out_path {
+            let out_dir = out_path.clone();
+            try_err!(create_dir_all(&out_dir), out_dir);
 
-        let mut p = out_dir;
-        p.push(output.index.get(&output.root).unwrap().name.clone().unwrap());
-        p.set_extension("json");
-        let mut file = BufWriter::new(try_err!(File::create(&p), p));
-        self.tcx
-            .sess
-            .time("rustdoc_json_serialization", || serde_json::ser::to_writer(&mut file, &output))
-            .unwrap();
-        try_err!(file.flush(), p);
-
-        Ok(())
+            let mut p = out_dir;
+            p.push(output.index.get(&output.root).unwrap().name.clone().unwrap());
+            p.set_extension("json");
+            self.write(
+                output,
+                BufWriter::new(try_err!(File::create(&p), p)),
+                &p.display().to_string(),
+            )
+        } else {
+            self.write(output, BufWriter::new(stdout()), "<stdout>")
+        }
     }
 
     fn cache(&self) -> &Cache {

From e2fd0c0f9affa65bf2291a83d48b16919d59fd7c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 12 Aug 2024 14:19:29 +0200
Subject: [PATCH 148/685] Add `read_dir_entries_recursive` in
 `run_make_support`

---
 src/tools/run-make-support/src/path_helpers.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/tools/run-make-support/src/path_helpers.rs b/src/tools/run-make-support/src/path_helpers.rs
index b788bc6ef302c..1e6e44c458423 100644
--- a/src/tools/run-make-support/src/path_helpers.rs
+++ b/src/tools/run-make-support/src/path_helpers.rs
@@ -84,3 +84,18 @@ pub fn has_suffix<P: AsRef<Path>>(path: P, suffix: &str) -> bool {
 pub fn filename_contains<P: AsRef<Path>>(path: P, needle: &str) -> bool {
     path.as_ref().file_name().is_some_and(|name| name.to_str().unwrap().contains(needle))
 }
+
+/// Helper for reading entries in a given directory and its children.
+pub fn read_dir_entries_recursive<P: AsRef<Path>, F: FnMut(&Path)>(dir: P, mut callback: F) {
+    fn read_dir_entries_recursive_inner<P: AsRef<Path>, F: FnMut(&Path)>(dir: P, callback: &mut F) {
+        for entry in rfs::read_dir(dir) {
+            let path = entry.unwrap().path();
+            callback(&path);
+            if path.is_dir() {
+                read_dir_entries_recursive_inner(path, callback);
+            }
+        }
+    }
+
+    read_dir_entries_recursive_inner(dir, &mut callback);
+}

From 7882575a8cfaa322dddb1fcf3261b470ca485ead Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 12 Aug 2024 14:20:21 +0200
Subject: [PATCH 149/685] Add `run-make` test for `-` for `-o` option

---
 tests/run-make/rustdoc-output-stdout/foo.rs   |  1 +
 tests/run-make/rustdoc-output-stdout/rmake.rs | 25 +++++++++++++++++++
 2 files changed, 26 insertions(+)
 create mode 100644 tests/run-make/rustdoc-output-stdout/foo.rs
 create mode 100644 tests/run-make/rustdoc-output-stdout/rmake.rs

diff --git a/tests/run-make/rustdoc-output-stdout/foo.rs b/tests/run-make/rustdoc-output-stdout/foo.rs
new file mode 100644
index 0000000000000..4a835673a596b
--- /dev/null
+++ b/tests/run-make/rustdoc-output-stdout/foo.rs
@@ -0,0 +1 @@
+pub struct Foo;
diff --git a/tests/run-make/rustdoc-output-stdout/rmake.rs b/tests/run-make/rustdoc-output-stdout/rmake.rs
new file mode 100644
index 0000000000000..e7dfb66602cf3
--- /dev/null
+++ b/tests/run-make/rustdoc-output-stdout/rmake.rs
@@ -0,0 +1,25 @@
+// This test verifies that rustdoc `-o -` prints JSON on stdout and doesn't generate
+// a JSON file.
+
+use std::path::PathBuf;
+
+use run_make_support::path_helpers::{cwd, has_extension, read_dir_entries_recursive};
+use run_make_support::rustdoc;
+
+fn main() {
+    // First we check that we generate the JSON in the stdout.
+    rustdoc()
+        .input("foo.rs")
+        .output("-")
+        .arg("-Zunstable-options")
+        .output_format("json")
+        .run()
+        .assert_stdout_contains("{\"");
+
+    // Then we check it didn't generate any JSON file.
+    read_dir_entries_recursive(cwd(), |path| {
+        if path.is_file() && has_extension(path, "json") {
+            panic!("Found a JSON file {path:?}");
+        }
+    });
+}

From 63ab7b59573a4e8d660b4c0235af6b8789c3753e Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 12 Aug 2024 14:22:05 +0200
Subject: [PATCH 150/685] Add documentation for `-o -`

---
 src/doc/rustdoc/src/unstable-features.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/doc/rustdoc/src/unstable-features.md b/src/doc/rustdoc/src/unstable-features.md
index 39f24a13143c8..ebbe141b6f540 100644
--- a/src/doc/rustdoc/src/unstable-features.md
+++ b/src/doc/rustdoc/src/unstable-features.md
@@ -515,6 +515,9 @@ pub fn no_documentation() {}
 
 Note that the third item is the crate root, which in this case is undocumented.
 
+If you want the JSON output to be displayed on `stdout` instead of having a file generated, you can
+use `-o -`.
+
 ### `-w`/`--output-format`: output format
 
 `--output-format json` emits documentation in the experimental

From fe52572a4aa5e81bb9c7bc56306271cd3045477c Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Tue, 30 Jul 2024 16:27:29 -0400
Subject: [PATCH 151/685] rewrite remap-path-prefix-dwarf to rmake

---
 .../src/external_deps/llvm.rs                 |  30 +++
 src/tools/run-make-support/src/lib.rs         |   5 +-
 .../tidy/src/allowed_run_make_makefiles.txt   |   1 -
 .../run-make/remap-path-prefix-dwarf/Makefile | 112 ----------
 .../run-make/remap-path-prefix-dwarf/rmake.rs | 202 ++++++++++++++++++
 5 files changed, 235 insertions(+), 115 deletions(-)
 delete mode 100644 tests/run-make/remap-path-prefix-dwarf/Makefile
 create mode 100644 tests/run-make/remap-path-prefix-dwarf/rmake.rs

diff --git a/src/tools/run-make-support/src/external_deps/llvm.rs b/src/tools/run-make-support/src/external_deps/llvm.rs
index dc651fdd8205a..7af79443affd6 100644
--- a/src/tools/run-make-support/src/external_deps/llvm.rs
+++ b/src/tools/run-make-support/src/external_deps/llvm.rs
@@ -48,6 +48,12 @@ pub fn llvm_bcanalyzer() -> LlvmBcanalyzer {
     LlvmBcanalyzer::new()
 }
 
+/// Construct a new `llvm-dwarfdump` invocation. This assumes that `llvm-dwarfdump` is available
+/// at `$LLVM_BIN_DIR/llvm-dwarfdump`.
+pub fn llvm_dwarfdump() -> LlvmDwarfdump {
+    LlvmDwarfdump::new()
+}
+
 /// A `llvm-readobj` invocation builder.
 #[derive(Debug)]
 #[must_use]
@@ -97,6 +103,13 @@ pub struct LlvmBcanalyzer {
     cmd: Command,
 }
 
+/// A `llvm-dwarfdump` invocation builder.
+#[derive(Debug)]
+#[must_use]
+pub struct LlvmDwarfdump {
+    cmd: Command,
+}
+
 crate::macros::impl_common_helpers!(LlvmReadobj);
 crate::macros::impl_common_helpers!(LlvmProfdata);
 crate::macros::impl_common_helpers!(LlvmFilecheck);
@@ -104,6 +117,7 @@ crate::macros::impl_common_helpers!(LlvmObjdump);
 crate::macros::impl_common_helpers!(LlvmAr);
 crate::macros::impl_common_helpers!(LlvmNm);
 crate::macros::impl_common_helpers!(LlvmBcanalyzer);
+crate::macros::impl_common_helpers!(LlvmDwarfdump);
 
 /// Generate the path to the bin directory of LLVM.
 #[must_use]
@@ -317,3 +331,19 @@ impl LlvmBcanalyzer {
         self
     }
 }
+
+impl LlvmDwarfdump {
+    /// Construct a new `llvm-dwarfdump` invocation. This assumes that `llvm-dwarfdump` is available
+    /// at `$LLVM_BIN_DIR/llvm-dwarfdump`.
+    pub fn new() -> Self {
+        let llvm_dwarfdump = llvm_bin_dir().join("llvm-dwarfdump");
+        let cmd = Command::new(llvm_dwarfdump);
+        Self { cmd }
+    }
+
+    /// Provide an input file.
+    pub fn input<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
+        self.cmd.arg(path.as_ref());
+        self
+    }
+}
diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
index a44dd00ad7986..4d0c1b0930ced 100644
--- a/src/tools/run-make-support/src/lib.rs
+++ b/src/tools/run-make-support/src/lib.rs
@@ -49,8 +49,9 @@ pub use c_build::{build_native_dynamic_lib, build_native_static_lib, build_nativ
 pub use clang::{clang, Clang};
 pub use htmldocck::htmldocck;
 pub use llvm::{
-    llvm_ar, llvm_bcanalyzer, llvm_filecheck, llvm_nm, llvm_objdump, llvm_profdata, llvm_readobj,
-    LlvmAr, LlvmBcanalyzer, LlvmFilecheck, LlvmNm, LlvmObjdump, LlvmProfdata, LlvmReadobj,
+    llvm_ar, llvm_bcanalyzer, llvm_dwarfdump, llvm_filecheck, llvm_nm, llvm_objdump, llvm_profdata,
+    llvm_readobj, LlvmAr, LlvmBcanalyzer, LlvmDwarfdump, LlvmFilecheck, LlvmNm, LlvmObjdump,
+    LlvmProfdata, LlvmReadobj,
 };
 pub use python::python_command;
 pub use rustc::{aux_build, bare_rustc, rustc, Rustc};
diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 14f0a9cd23d21..2d25de46f6e4a 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -16,7 +16,6 @@ run-make/macos-deployment-target/Makefile
 run-make/min-global-align/Makefile
 run-make/native-link-modifier-bundle/Makefile
 run-make/no-alloc-shim/Makefile
-run-make/remap-path-prefix-dwarf/Makefile
 run-make/reproducible-build/Makefile
 run-make/rlib-format-packed-bundled-libs/Makefile
 run-make/split-debuginfo/Makefile
diff --git a/tests/run-make/remap-path-prefix-dwarf/Makefile b/tests/run-make/remap-path-prefix-dwarf/Makefile
deleted file mode 100644
index 8905a00ea2878..0000000000000
--- a/tests/run-make/remap-path-prefix-dwarf/Makefile
+++ /dev/null
@@ -1,112 +0,0 @@
-# This test makes sure that --remap-path-prefix has the expected effects on paths in debuginfo.
-# It tests several cases, each of them has a detailed description attached to it.
-
-# ignore-windows
-
-include ../tools.mk
-
-SRC_DIR := $(abspath .)
-SRC_DIR_PARENT := $(abspath ..)
-
-ifeq ($(UNAME),Darwin)
-  DEBUGINFOOPTS := -Csplit-debuginfo=off
-else
-  DEBUGINFOOPTS :=
-endif
-
-all: \
-  abs_input_outside_working_dir \
-  rel_input_remap_working_dir \
-  rel_input_remap_working_dir_scope \
-  rel_input_remap_working_dir_parent \
-  rel_input_remap_working_dir_child \
-  rel_input_remap_working_dir_diagnostics \
-  abs_input_inside_working_dir \
-  abs_input_inside_working_dir_scope \
-  abs_input_outside_working_dir
-
-# The compiler is called with an *ABSOLUTE PATH* as input, and that absolute path *is* within
-# the working directory of the compiler. We are remapping the path that contains `src`.
-abs_input_inside_working_dir:
-	# We explicitly switch to a directory that *is* a prefix of the directory our
-	# source code is contained in.
-	cd $(SRC_DIR) && $(RUSTC) $(SRC_DIR)/src/quux.rs -o "$(TMPDIR)/abs_input_inside_working_dir.rlib" -Cdebuginfo=2 --remap-path-prefix $(SRC_DIR)=REMAPPED
-	# We expect the path to the main source file to be remapped.
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump $(TMPDIR)/abs_input_inside_working_dir.rlib | $(CGREP) "REMAPPED/src/quux.rs"
-	# No weird duplication of remapped components (see #78479)
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump $(TMPDIR)/abs_input_inside_working_dir.rlib | $(CGREP) -v "REMAPPED/REMAPPED"
-
-# The compiler is called with an *ABSOLUTE PATH* as input, and that absolute path *is* within
-# the working directory of the compiler. We are remapping the path that contains `src`.
-abs_input_inside_working_dir_scope:
-	# We explicitly switch to a directory that *is* a prefix of the directory our
-	# source code is contained in.
-	cd $(SRC_DIR) && $(RUSTC) $(SRC_DIR)/src/quux.rs -o "$(TMPDIR)/abs_input_inside_working_dir_scope.rlib" -Cdebuginfo=2 --remap-path-prefix $(SRC_DIR)=REMAPPED -Zremap-path-scope=object $(DEBUGINFOOPTS)
-	# We expect the path to the main source file to be remapped.
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump $(TMPDIR)/abs_input_inside_working_dir_scope.rlib | $(CGREP) "REMAPPED/src/quux.rs"
-	# No weird duplication of remapped components (see #78479)
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump $(TMPDIR)/abs_input_inside_working_dir_scope.rlib | $(CGREP) -v "REMAPPED/REMAPPED"
-
-# The compiler is called with an *ABSOLUTE PATH* as input, and that absolute path is *not* within
-# the working directory of the compiler. We are remapping both the path that contains `src` and
-# the working directory to the same thing. This setup corresponds to a workaround that is needed
-# when trying to remap everything to something that looks like a local path.
-# Relative paths are interpreted as relative to the compiler's working directory (e.g. in
-# debuginfo). If we also remap the working directory, the compiler strip it from other paths so
-# that the final outcome is the desired one again.
-abs_input_outside_working_dir:
-	# We explicitly switch to a directory that is *not* a prefix of the directory our
-	# source code is contained in.
-	cd $(TMPDIR) && $(RUSTC) $(SRC_DIR)/src/quux.rs -o "$(TMPDIR)/abs_input_outside_working_dir.rlib" -Cdebuginfo=2 --remap-path-prefix $(SRC_DIR)=REMAPPED --remap-path-prefix $(TMPDIR)=REMAPPED
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump $(TMPDIR)/abs_input_outside_working_dir.rlib | $(CGREP) "REMAPPED/src/quux.rs"
-	# No weird duplication of remapped components (see #78479)
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump $(TMPDIR)/abs_input_outside_working_dir.rlib | $(CGREP) -v "REMAPPED/REMAPPED"
-
-# The compiler is called with a *RELATIVE PATH* as input. We are remapping the working directory of
-# the compiler, which naturally is an implicit prefix of our relative input path. Debuginfo will
-# expand the relative path to an absolute path and we expect the working directory to be remapped
-# in that expansion.
-rel_input_remap_working_dir:
-	cd $(SRC_DIR) && $(RUSTC) src/quux.rs -o "$(TMPDIR)/rel_input_remap_working_dir.rlib" -Cdebuginfo=2 --remap-path-prefix "$(SRC_DIR)=REMAPPED"
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir.rlib" | $(CGREP) "REMAPPED/src/quux.rs"
-	# No weird duplication of remapped components (see #78479)
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir.rlib" | $(CGREP) -v "REMAPPED/REMAPPED"
-
-# The compiler is called with a *RELATIVE PATH* as input. We are remapping the working directory of
-# the compiler, which naturally is an implicit prefix of our relative input path. Debuginfo will
-# expand the relative path to an absolute path and we expect the working directory to be remapped
-# in that expansion.
-rel_input_remap_working_dir_scope:
-	cd $(SRC_DIR) && $(RUSTC) src/quux.rs -o "$(TMPDIR)/rel_input_remap_working_dir_scope.rlib" -Cdebuginfo=2 --remap-path-prefix "$(SRC_DIR)=REMAPPED" -Zremap-path-scope=object $(DEBUGINFOOPTS)
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir_scope.rlib" | $(CGREP) "REMAPPED/src/quux.rs"
-	# No weird duplication of remapped components (see #78479)
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir_scope.rlib" | $(CGREP) -v "REMAPPED/REMAPPED"
-
-rel_input_remap_working_dir_diagnostics:
-	cd $(SRC_DIR) && $(RUSTC) src/quux.rs -o "$(TMPDIR)/rel_input_remap_working_dir_scope.rlib" -Cdebuginfo=2 --remap-path-prefix "$(SRC_DIR)=REMAPPED" -Zremap-path-scope=diagnostics $(DEBUGINFOOPTS)
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir_scope.rlib" | $(CGREP) -v "REMAPPED/src/quux.rs"
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir_scope.rlib" | $(CGREP) -v "REMAPPED/REMAPPED"
-
-# The compiler is called with a *RELATIVE PATH* as input. We are remapping a *SUB-DIRECTORY* of the
-# compiler's working directory. This test makes sure that that directory is remapped even though it
-# won't actually show up in this form in the compiler's SourceMap and instead is only constructed
-# on demand during debuginfo generation.
-rel_input_remap_working_dir_child:
-	cd $(SRC_DIR) && $(RUSTC) src/quux.rs -o "$(TMPDIR)/rel_input_remap_working_dir_child.rlib" -Cdebuginfo=2 --remap-path-prefix "$(SRC_DIR)/src=REMAPPED"
-	# We expect `src/quux.rs` to have been remapped to `REMAPPED/quux.rs`.
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir_child.rlib" | $(CGREP) "REMAPPED/quux.rs"
-	# We don't want to find the path that we just remapped anywhere in the DWARF
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir_child.rlib" | $(CGREP) -v "$(SRC_DIR)/src"
-	# No weird duplication of remapped components (see #78479)
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir_child.rlib" | $(CGREP) -v "REMAPPED/REMAPPED"
-
-# The compiler is called with a *RELATIVE PATH* as input. We are remapping a *PARENT DIRECTORY* of
-# the compiler's working directory.
-rel_input_remap_working_dir_parent:
-	cd $(SRC_DIR) && $(RUSTC) src/quux.rs -o "$(TMPDIR)/rel_input_remap_working_dir_parent.rlib" -Cdebuginfo=2 --remap-path-prefix "$(SRC_DIR_PARENT)=REMAPPED"
-	# We expect `src/quux.rs` to have been remapped to `REMAPPED/remap-path-prefix-dwarf/src/quux.rs`.
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir_parent.rlib" | $(CGREP) "REMAPPED/remap-path-prefix-dwarf/src/quux.rs"
-	# We don't want to find the path that we just remapped anywhere in the DWARF
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir_parent.rlib" | $(CGREP) -v "$(SRC_DIR_PARENT)"
-	# No weird duplication of remapped components (see #78479)
-	"$(LLVM_BIN_DIR)"/llvm-dwarfdump "$(TMPDIR)/rel_input_remap_working_dir_parent.rlib" | $(CGREP) -v "REMAPPED/REMAPPED"
diff --git a/tests/run-make/remap-path-prefix-dwarf/rmake.rs b/tests/run-make/remap-path-prefix-dwarf/rmake.rs
new file mode 100644
index 0000000000000..ede1d61574257
--- /dev/null
+++ b/tests/run-make/remap-path-prefix-dwarf/rmake.rs
@@ -0,0 +1,202 @@
+// This test makes sure that --remap-path-prefix has the expected effects on paths in debuginfo.
+// We explicitly switch to a directory that *is* a prefix of the directory our
+// source code is contained in.
+// It tests several cases, each of them has a detailed description attached to it.
+// See https://github.com/rust-lang/rust/pull/96867
+
+//@ ignore-windows
+// Reason: the remap path prefix is not printed in the dwarf dump.
+
+use run_make_support::{cwd, is_darwin, llvm_dwarfdump, rust_lib_name, rustc};
+
+fn main() {
+    // The compiler is called with an *ABSOLUTE PATH* as input, and that absolute path *is* within
+    // the working directory of the compiler. We are remapping the path that contains `src`.
+    check_dwarf(DwarfTest {
+        lib_name: "abs_input_inside_working_dir",
+        input_path: PathType::Absolute,
+        scope: None,
+        remap_path_prefix: PrefixType::Regular(format!("{}=REMAPPED", cwd().display())),
+        dwarf_test: DwarfDump::ContainsSrcPath,
+    });
+    check_dwarf(DwarfTest {
+        lib_name: "abs_input_inside_working_dir_scope",
+        input_path: PathType::Absolute,
+        scope: Some(ScopeType::Object),
+        remap_path_prefix: PrefixType::Regular(format!("{}=REMAPPED", cwd().display())),
+        dwarf_test: DwarfDump::ContainsSrcPath,
+    });
+    // The compiler is called with an *ABSOLUTE PATH* as input, and that absolute path is *not*
+    // within the working directory of the compiler. We are remapping both the path that contains
+    // `src` and the working directory to the same thing. This setup corresponds to a workaround
+    // that is needed when trying to remap everything to something that looks like a local
+    // path. Relative paths are interpreted as relative to the compiler's working directory (e.g.
+    // in debuginfo). If we also remap the working directory, the compiler strip it from other
+    // paths so that the final outcome is the desired one again.
+    check_dwarf(DwarfTest {
+        lib_name: "abs_input_outside_working_dir",
+        input_path: PathType::Absolute,
+        scope: None,
+        remap_path_prefix: PrefixType::Dual((
+            format!("{}=REMAPPED", cwd().display()),
+            "rmake_out=REMAPPED".to_owned(),
+        )),
+        dwarf_test: DwarfDump::ContainsSrcPath,
+    });
+    // The compiler is called with a *RELATIVE PATH* as input. We are remapping the working
+    // directory of the compiler, which naturally is an implicit prefix of our relative input path.
+    // Debuginfo will expand the relative path to an absolute path and we expect the working
+    // directory to be remapped in that expansion.
+    check_dwarf(DwarfTest {
+        lib_name: "rel_input_remap_working_dir",
+        input_path: PathType::Relative,
+        scope: None,
+        remap_path_prefix: PrefixType::Regular(format!("{}=REMAPPED", cwd().display())),
+        dwarf_test: DwarfDump::ContainsSrcPath,
+    });
+    check_dwarf(DwarfTest {
+        lib_name: "rel_input_remap_working_dir_scope",
+        input_path: PathType::Relative,
+        scope: Some(ScopeType::Object),
+        remap_path_prefix: PrefixType::Regular(format!("{}=REMAPPED", cwd().display())),
+        dwarf_test: DwarfDump::ContainsSrcPath,
+    });
+    check_dwarf(DwarfTest {
+        lib_name: "rel_input_remap_working_dir_scope",
+        input_path: PathType::Relative,
+        scope: Some(ScopeType::Diagnostics),
+        remap_path_prefix: PrefixType::Regular(format!("{}=REMAPPED", cwd().display())),
+        dwarf_test: DwarfDump::AvoidSrcPath,
+    });
+    // The compiler is called with a *RELATIVE PATH* as input. We are remapping a *SUB-DIRECTORY*
+    // of the compiler's working directory. This test makes sure that that directory is remapped
+    // even though it won't actually show up in this form in the compiler's SourceMap and instead
+    // is only constructed on demand during debuginfo generation.
+    check_dwarf(DwarfTest {
+        lib_name: "rel_input_remap_working_dir_child",
+        input_path: PathType::Relative,
+        scope: None,
+        remap_path_prefix: PrefixType::Regular(format!("{}=REMAPPED", cwd().join("src").display())),
+        dwarf_test: DwarfDump::ChildTest,
+    });
+    // The compiler is called with a *RELATIVE PATH* as input. We are remapping a
+    // *PARENT DIRECTORY* of the compiler's working directory.
+    check_dwarf(DwarfTest {
+        lib_name: "rel_input_remap_working_dir_parent",
+        input_path: PathType::Relative,
+        scope: None,
+        remap_path_prefix: PrefixType::Regular(format!(
+            "{}=REMAPPED",
+            cwd().parent().unwrap().display()
+        )),
+        dwarf_test: DwarfDump::ParentTest,
+    });
+}
+
+#[track_caller]
+fn check_dwarf(test: DwarfTest) {
+    let mut rustc = rustc();
+    match test.input_path {
+        PathType::Absolute => rustc.input(cwd().join("src/quux.rs")),
+        PathType::Relative => rustc.input("src/quux.rs"),
+    };
+    rustc.output(rust_lib_name(test.lib_name));
+    rustc.arg("-Cdebuginfo=2");
+    if let Some(scope) = test.scope {
+        match scope {
+            ScopeType::Object => rustc.arg("-Zremap-path-scope=object"),
+            ScopeType::Diagnostics => rustc.arg("-Zremap-path-scope=diagnostics"),
+        };
+        if is_darwin() {
+            rustc.arg("-Csplit-debuginfo=off");
+        }
+    }
+    match test.remap_path_prefix {
+        PrefixType::Regular(prefix) => {
+            // We explicitly switch to a directory that *is* a prefix of the directory our
+            // source code is contained in.
+            rustc.arg("--remap-path-prefix");
+            rustc.arg(prefix);
+        }
+        PrefixType::Dual((prefix1, prefix2)) => {
+            // We explicitly switch to a directory that is *not* a prefix of the directory our
+            // source code is contained in.
+            rustc.arg("--remap-path-prefix");
+            rustc.arg(prefix1);
+            rustc.arg("--remap-path-prefix");
+            rustc.arg(prefix2);
+        }
+    }
+    rustc.run();
+    match test.dwarf_test {
+        DwarfDump::ContainsSrcPath => {
+            llvm_dwarfdump()
+                .input(rust_lib_name(test.lib_name))
+                .run()
+                // We expect the path to the main source file to be remapped.
+                .assert_stdout_contains("REMAPPED/src/quux.rs")
+                // No weird duplication of remapped components (see #78479)
+                .assert_stdout_not_contains("REMAPPED/REMAPPED");
+        }
+        DwarfDump::AvoidSrcPath => {
+            llvm_dwarfdump()
+                .input(rust_lib_name(test.lib_name))
+                .run()
+                .assert_stdout_not_contains("REMAPPED/src/quux.rs")
+                .assert_stdout_not_contains("REMAPPED/REMAPPED");
+        }
+        DwarfDump::ChildTest => {
+            llvm_dwarfdump()
+                .input(rust_lib_name(test.lib_name))
+                .run()
+                // We expect `src/quux.rs` to have been remapped to `REMAPPED/quux.rs`.
+                .assert_stdout_contains("REMAPPED/quux.rs")
+                // We don't want to find the path that we just remapped anywhere in the DWARF
+                .assert_stdout_not_contains(cwd().join("src").to_str().unwrap())
+                // No weird duplication of remapped components (see #78479)
+                .assert_stdout_not_contains("REMAPPED/REMAPPED");
+        }
+        DwarfDump::ParentTest => {
+            llvm_dwarfdump()
+                .input(rust_lib_name(test.lib_name))
+                .run()
+                // We expect `src/quux.rs` to have been remapped to
+                // `REMAPPED/remap-path-prefix-dwarf/src/quux.rs`.
+                .assert_stdout_contains("REMAPPED/rmake_out/src/quux.rs")
+                // We don't want to find the path that we just remapped anywhere in the DWARF
+                .assert_stdout_not_contains(cwd().parent().unwrap().to_str().unwrap())
+                // No weird duplication of remapped components (see #78479)
+                .assert_stdout_not_contains("REMAPPED/REMAPPED");
+        }
+    };
+}
+
+struct DwarfTest {
+    lib_name: &'static str,
+    input_path: PathType,
+    scope: Option<ScopeType>,
+    remap_path_prefix: PrefixType,
+    dwarf_test: DwarfDump,
+}
+
+enum PathType {
+    Absolute,
+    Relative,
+}
+
+enum ScopeType {
+    Object,
+    Diagnostics,
+}
+
+enum DwarfDump {
+    ContainsSrcPath,
+    AvoidSrcPath,
+    ChildTest,
+    ParentTest,
+}
+
+enum PrefixType {
+    Regular(String),
+    Dual((String, String)),
+}

From d7f1252ddf7ae02667ac9de295171596c7075640 Mon Sep 17 00:00:00 2001
From: Antoni Spaanderman <56turtle56@gmail.com>
Date: Mon, 12 Aug 2024 18:42:13 +0200
Subject: [PATCH 152/685] fix code blocks in doc comments inconsistently using
 3 or 4 spaces of indentation

---
 clippy_lints/src/doc/mod.rs                                 | 2 +-
 clippy_lints/src/methods/mod.rs                             | 6 +++---
 clippy_lints/src/utils/internal_lints/metadata_collector.rs | 6 ++++--
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index d7b3a7c74f3ce..762d5595e145e 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -309,7 +309,7 @@ declare_clippy_lint! {
     /// ### Known problems
     /// Inner doc comments can only appear before items, so there are certain cases where the suggestion
     /// made by this lint is not valid code. For example:
-    /// ```rs
+    /// ```rust
     /// fn foo() {}
     /// ///!
     /// fn bar() {}
diff --git a/clippy_lints/src/methods/mod.rs b/clippy_lints/src/methods/mod.rs
index 1d7b10fe8f045..d7126990edb1d 100644
--- a/clippy_lints/src/methods/mod.rs
+++ b/clippy_lints/src/methods/mod.rs
@@ -2702,10 +2702,10 @@ declare_clippy_lint! {
     ///             }
     ///         })
     /// }
-    ///  ```
+    /// ```
     ///
-    ///  After:
-    ///  ```rust
+    /// After:
+    /// ```rust
     /// use std::{fmt, num::ParseIntError};
     ///
     /// #[derive(Debug)]
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
index 57f45aa3e4851..c73ec262637f7 100644
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
@@ -687,10 +687,12 @@ fn cleanup_docs(docs_collection: &Vec<String>) -> String {
                     .trim()
                     .split(',')
                     // remove rustdoc directives
-                    .find(|&s| !matches!(s, "" | "ignore" | "no_run" | "should_panic"))
+                    .find(|&s| !matches!(s, "" | "ignore" | "no_run" | "should_panic" | "compile_fail"))
                     // if no language is present, fill in "rust"
                     .unwrap_or("rust");
-                let len_diff = line.len() - line.trim_start().len();
+                let len_diff = line
+                    .strip_prefix(' ')
+                    .map_or(0, |line| line.len() - line.trim_start().len());
                 if len_diff != 0 {
                     // We put back the indentation.
                     docs.push_str(&line[..len_diff]);

From a719514777e9c63dbb5b66b9d7cfc0fb6c0c27bd Mon Sep 17 00:00:00 2001
From: rustbot <47979223+rustbot@users.noreply.github.com>
Date: Mon, 12 Aug 2024 13:01:03 -0400
Subject: [PATCH 153/685] Update books

---
 src/doc/book            | 2 +-
 src/doc/edition-guide   | 2 +-
 src/doc/nomicon         | 2 +-
 src/doc/reference       | 2 +-
 src/doc/rust-by-example | 2 +-
 src/doc/rustc-dev-guide | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/doc/book b/src/doc/book
index 67fa536768013..04bc1396bb857 160000
--- a/src/doc/book
+++ b/src/doc/book
@@ -1 +1 @@
-Subproject commit 67fa536768013d9d5a13f3a06790521d511ef711
+Subproject commit 04bc1396bb857f35b5dda1d773c9571e1f253304
diff --git a/src/doc/edition-guide b/src/doc/edition-guide
index 5454de3d12b9c..aeeb287d41a03 160000
--- a/src/doc/edition-guide
+++ b/src/doc/edition-guide
@@ -1 +1 @@
-Subproject commit 5454de3d12b9ccc6375b629cf7ccda8264640aac
+Subproject commit aeeb287d41a0332c210da122bea8e0e91844ab3e
diff --git a/src/doc/nomicon b/src/doc/nomicon
index 0ebdacadbda8c..6ecf95c5f2bfa 160000
--- a/src/doc/nomicon
+++ b/src/doc/nomicon
@@ -1 +1 @@
-Subproject commit 0ebdacadbda8ce2cd8fbf93985e15af61a7ab895
+Subproject commit 6ecf95c5f2bfa0e6314dfe282bf775fd1405f7e9
diff --git a/src/doc/reference b/src/doc/reference
index 2e191814f163e..62cd0df95061b 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit 2e191814f163ee1e77e2d6094eee4dd78a289c5b
+Subproject commit 62cd0df95061ba0ac886333f5cd7f3012f149da1
diff --git a/src/doc/rust-by-example b/src/doc/rust-by-example
index 89aecb6951b77..8f94061936e49 160000
--- a/src/doc/rust-by-example
+++ b/src/doc/rust-by-example
@@ -1 +1 @@
-Subproject commit 89aecb6951b77bc746da73df8c9f2b2ceaad494a
+Subproject commit 8f94061936e492159f4f6c09c0f917a7521893ff
diff --git a/src/doc/rustc-dev-guide b/src/doc/rustc-dev-guide
index 0c4d55cb59fe4..43d83780db545 160000
--- a/src/doc/rustc-dev-guide
+++ b/src/doc/rustc-dev-guide
@@ -1 +1 @@
-Subproject commit 0c4d55cb59fe440d1a630e4e5774d043968edb3f
+Subproject commit 43d83780db545a1ed6d45773312fc578987e3968

From 1b6df71192db3e0d635754e3810def977e28092f Mon Sep 17 00:00:00 2001
From: Zachary S <zasample18+github@gmail.com>
Date: Fri, 9 Aug 2024 23:28:40 -0500
Subject: [PATCH 154/685] Explicitly specify type parameter on FromResidual
 impls in stdlib.

To work around coherence issue. Also adds regression test.
---
 library/core/src/ops/control_flow.rs          |  4 ++-
 library/core/src/option.rs                    |  4 ++-
 library/core/tests/ops.rs                     |  1 +
 library/core/tests/ops/from_residual.rs       | 26 +++++++++++++++++++
 tests/ui/try-trait/bad-interconversion.stderr |  4 +--
 tests/ui/try-trait/option-to-result.stderr    |  2 +-
 6 files changed, 36 insertions(+), 5 deletions(-)
 create mode 100644 library/core/tests/ops/from_residual.rs

diff --git a/library/core/src/ops/control_flow.rs b/library/core/src/ops/control_flow.rs
index a2709c66b06ad..ab73dc19fcc73 100644
--- a/library/core/src/ops/control_flow.rs
+++ b/library/core/src/ops/control_flow.rs
@@ -116,7 +116,9 @@ impl<B, C> ops::Try for ControlFlow<B, C> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "84277")]
-impl<B, C> ops::FromResidual for ControlFlow<B, C> {
+// Note: manually specifying the residual type instead of using the default to work around
+// https://github.com/rust-lang/rust/issues/99940
+impl<B, C> ops::FromResidual<ControlFlow<B, convert::Infallible>> for ControlFlow<B, C> {
     #[inline]
     fn from_residual(residual: ControlFlow<B, convert::Infallible>) -> Self {
         match residual {
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 6c89c81018038..9cec79c17ca73 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -2495,7 +2495,9 @@ impl<T> ops::Try for Option<T> {
 }
 
 #[unstable(feature = "try_trait_v2", issue = "84277")]
-impl<T> ops::FromResidual for Option<T> {
+// Note: manually specifying the residual type instead of using the default to work around
+// https://github.com/rust-lang/rust/issues/99940
+impl<T> ops::FromResidual<Option<convert::Infallible>> for Option<T> {
     #[inline]
     fn from_residual(residual: Option<convert::Infallible>) -> Self {
         match residual {
diff --git a/library/core/tests/ops.rs b/library/core/tests/ops.rs
index 2ee0abd399bb6..501e0f33fe4cc 100644
--- a/library/core/tests/ops.rs
+++ b/library/core/tests/ops.rs
@@ -1,4 +1,5 @@
 mod control_flow;
+mod from_residual;
 
 use core::ops::{
     Bound, Deref, DerefMut, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
diff --git a/library/core/tests/ops/from_residual.rs b/library/core/tests/ops/from_residual.rs
new file mode 100644
index 0000000000000..d5c86ccbcd317
--- /dev/null
+++ b/library/core/tests/ops/from_residual.rs
@@ -0,0 +1,26 @@
+//! Regression test that Option and ControlFlow can have downstream FromResidual impls.
+//! cc https://github.com/rust-lang/rust/issues/99940,
+//! This does NOT test that issue in general; Option and ControlFlow's FromResidual
+//! impls in core were changed to not be affected by that issue.
+
+use core::ops::{ControlFlow, FromResidual};
+
+struct Local;
+
+impl<T> FromResidual<Local> for Option<T> {
+    fn from_residual(_: Local) -> Option<T> {
+        unimplemented!()
+    }
+}
+
+impl<B, C> FromResidual<Local> for ControlFlow<B, C> {
+    fn from_residual(_: Local) -> ControlFlow<B, C> {
+        unimplemented!()
+    }
+}
+
+impl<T, E> FromResidual<Local> for Result<T, E> {
+    fn from_residual(_: Local) -> Result<T, E> {
+        unimplemented!()
+    }
+}
diff --git a/tests/ui/try-trait/bad-interconversion.stderr b/tests/ui/try-trait/bad-interconversion.stderr
index 642a93d64e2a5..9aab2cf6ab848 100644
--- a/tests/ui/try-trait/bad-interconversion.stderr
+++ b/tests/ui/try-trait/bad-interconversion.stderr
@@ -45,7 +45,7 @@ LL |     Some(Err("hello")?)
    |                      ^ use `.ok()?` if you want to discard the `Result<Infallible, &str>` error information
    |
    = help: the trait `FromResidual<Result<Infallible, &str>>` is not implemented for `Option<u16>`
-   = help: the trait `FromResidual` is implemented for `Option<T>`
+   = help: the trait `FromResidual<Option<Infallible>>` is implemented for `Option<T>`
 
 error[E0277]: the `?` operator can only be used on `Option`s in a function that returns `Option`
   --> $DIR/bad-interconversion.rs:27:33
@@ -56,7 +56,7 @@ LL |     Some(ControlFlow::Break(123)?)
    |                                 ^ this `?` produces `ControlFlow<{integer}, Infallible>`, which is incompatible with `Option<u64>`
    |
    = help: the trait `FromResidual<ControlFlow<{integer}, Infallible>>` is not implemented for `Option<u64>`
-   = help: the trait `FromResidual` is implemented for `Option<T>`
+   = help: the trait `FromResidual<Option<Infallible>>` is implemented for `Option<T>`
 
 error[E0277]: the `?` operator can only be used on `ControlFlow`s in a function that returns `ControlFlow`
   --> $DIR/bad-interconversion.rs:32:39
diff --git a/tests/ui/try-trait/option-to-result.stderr b/tests/ui/try-trait/option-to-result.stderr
index 8055b2a0b0452..1a5a925f92fce 100644
--- a/tests/ui/try-trait/option-to-result.stderr
+++ b/tests/ui/try-trait/option-to-result.stderr
@@ -20,7 +20,7 @@ LL |     a?;
    |      ^ use `.ok()?` if you want to discard the `Result<Infallible, i32>` error information
    |
    = help: the trait `FromResidual<Result<Infallible, i32>>` is not implemented for `Option<i32>`
-   = help: the trait `FromResidual` is implemented for `Option<T>`
+   = help: the trait `FromResidual<Option<Infallible>>` is implemented for `Option<T>`
 
 error: aborting due to 2 previous errors
 

From b2e7ae1f65fd5e1579692a9a7a8c95fb95aa1b04 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 7 Aug 2024 15:08:43 +0000
Subject: [PATCH 155/685] Detect multiple crate versions on method not found

When a type comes indirectly from one crate version but the imported trait comes from a separate crate version, the called method won't be found. We now show additional context:

```
error[E0599]: no method named `foo` found for struct `dep_2_reexport::Type` in the current scope
 --> multiple-dep-versions.rs:8:10
  |
8 |     Type.foo();
  |          ^^^ method not found in `Type`
  |
note: you have multiple different versions of crate `dependency` in your dependency graph
 --> multiple-dep-versions.rs:4:32
  |
4 | use dependency::{do_something, Trait};
  |                                ^^^^^ `dependency` imported here doesn't correspond to the right crate version
  |
 ::: ~/rust/build/x86_64-unknown-linux-gnu/test/run-make/crate-loading/rmake_out/multiple-dep-versions-1.rs:4:1
  |
4 | pub trait Trait {
  | --------------- this is the trait that was imported
  |
 ::: ~/rust/build/x86_64-unknown-linux-gnu/test/run-make/crate-loading/rmake_out/multiple-dep-versions-2.rs:4:1
  |
4 | pub trait Trait {
  | --------------- this is the trait that is needed
5 |     fn foo(&self);
  |        --- the method is available for `dep_2_reexport::Type` here
```
---
 .../rustc_hir_typeck/src/method/suggest.rs    | 69 +++++++++++++++++--
 .../crate-loading/multiple-dep-versions-1.rs  | 10 ++-
 .../crate-loading/multiple-dep-versions-2.rs  | 10 ++-
 .../crate-loading/multiple-dep-versions-3.rs  |  5 ++
 .../crate-loading/multiple-dep-versions.rs    |  5 +-
 tests/run-make/crate-loading/rmake.rs         | 14 +++-
 6 files changed, 99 insertions(+), 14 deletions(-)
 create mode 100644 tests/run-make/crate-loading/multiple-dep-versions-3.rs

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 61287d98676b2..d4fcbcad7ae07 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -3448,6 +3448,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         trait_missing_method: bool,
     ) {
         let mut alt_rcvr_sugg = false;
+        let mut suggest = true;
         if let (SelfSource::MethodCall(rcvr), false) = (source, unsatisfied_bounds) {
             debug!(
                 "suggest_traits_to_import: span={:?}, item_name={:?}, rcvr_ty={:?}, rcvr={:?}",
@@ -3491,10 +3492,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         let did = Some(pick.item.container_id(self.tcx));
                         let skip = skippable.contains(&did);
                         if pick.autoderefs == 0 && !skip {
-                            err.span_label(
-                                pick.item.ident(self.tcx).span,
-                                format!("the method is available for `{rcvr_ty}` here"),
+                            suggest = self.detect_and_explain_multiple_crate_versions(
+                                err,
+                                &pick.item,
+                                rcvr.hir_id.owner,
+                                *rcvr_ty,
                             );
+                            if suggest {
+                                err.span_label(
+                                    pick.item.ident(self.tcx).span,
+                                    format!("the method is available for `{rcvr_ty}` here"),
+                                );
+                            }
                         }
                         break;
                     }
@@ -3675,7 +3684,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
             }
         }
-        if self.suggest_valid_traits(err, item_name, valid_out_of_scope_traits, true) {
+        if suggest && self.suggest_valid_traits(err, item_name, valid_out_of_scope_traits, true) {
             return;
         }
 
@@ -4040,6 +4049,58 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    fn detect_and_explain_multiple_crate_versions(
+        &self,
+        err: &mut Diag<'_>,
+        item: &ty::AssocItem,
+        owner: hir::OwnerId,
+        rcvr_ty: Ty<'_>,
+    ) -> bool {
+        let pick_name = self.tcx.crate_name(item.def_id.krate);
+        if let Some(map) = self.tcx.in_scope_traits_map(owner) {
+            for trait_candidate in map.to_sorted_stable_ord().into_iter().flat_map(|v| v.1.iter()) {
+                let name = self.tcx.crate_name(trait_candidate.def_id.krate);
+                if trait_candidate.def_id.krate != item.def_id.krate && name == pick_name {
+                    let msg = format!(
+                        "you have multiple different versions of crate `{name}` in your \
+                         dependency graph",
+                    );
+                    let tdid = self.tcx.parent(item.def_id);
+                    if self.tcx.item_name(trait_candidate.def_id) == self.tcx.item_name(tdid)
+                        && let Some(def_id) = trait_candidate.import_ids.get(0)
+                    {
+                        let span = self.tcx.def_span(*def_id);
+                        let mut multi_span: MultiSpan = span.into();
+                        multi_span.push_span_label(
+                            span,
+                            format!(
+                                "`{name}` imported here doesn't correspond to the right crate \
+                                 version",
+                            ),
+                        );
+                        multi_span.push_span_label(
+                            self.tcx.def_span(trait_candidate.def_id),
+                            format!("this is the trait that was imported"),
+                        );
+                        multi_span.push_span_label(
+                            self.tcx.def_span(tdid),
+                            format!("this is the trait that is needed"),
+                        );
+                        multi_span.push_span_label(
+                            item.ident(self.tcx).span,
+                            format!("the method is available for `{rcvr_ty}` here"),
+                        );
+                        err.span_note(multi_span, msg);
+                        return false;
+                    } else {
+                        err.note(msg);
+                    }
+                }
+            }
+        }
+        true
+    }
+
     /// issue #102320, for `unwrap_or` with closure as argument, suggest `unwrap_or_else`
     /// FIXME: currently not working for suggesting `map_or_else`, see #102408
     pub(crate) fn suggest_else_fn_with_closure(
diff --git a/tests/run-make/crate-loading/multiple-dep-versions-1.rs b/tests/run-make/crate-loading/multiple-dep-versions-1.rs
index 2d35163382916..94f30ca326fdb 100644
--- a/tests/run-make/crate-loading/multiple-dep-versions-1.rs
+++ b/tests/run-make/crate-loading/multiple-dep-versions-1.rs
@@ -1,6 +1,10 @@
 #![crate_name = "dependency"]
 #![crate_type = "rlib"]
-pub struct Type;
-pub trait Trait {}
-impl Trait for Type {}
+pub struct Type(pub i32);
+pub trait Trait {
+    fn foo(&self);
+}
+impl Trait for Type {
+    fn foo(&self) {}
+}
 pub fn do_something<X: Trait>(_: X) {}
diff --git a/tests/run-make/crate-loading/multiple-dep-versions-2.rs b/tests/run-make/crate-loading/multiple-dep-versions-2.rs
index a5df3dc61eda5..0a4626be5605b 100644
--- a/tests/run-make/crate-loading/multiple-dep-versions-2.rs
+++ b/tests/run-make/crate-loading/multiple-dep-versions-2.rs
@@ -1,6 +1,10 @@
 #![crate_name = "dependency"]
 #![crate_type = "rlib"]
-pub struct Type(pub i32);
-pub trait Trait {}
-impl Trait for Type {}
+pub struct Type;
+pub trait Trait {
+    fn foo(&self);
+}
+impl Trait for Type {
+    fn foo(&self) {}
+}
 pub fn do_something<X: Trait>(_: X) {}
diff --git a/tests/run-make/crate-loading/multiple-dep-versions-3.rs b/tests/run-make/crate-loading/multiple-dep-versions-3.rs
new file mode 100644
index 0000000000000..07d888e9f1034
--- /dev/null
+++ b/tests/run-make/crate-loading/multiple-dep-versions-3.rs
@@ -0,0 +1,5 @@
+#![crate_name = "foo"]
+#![crate_type = "rlib"]
+
+extern crate dependency;
+pub use dependency::Type;
diff --git a/tests/run-make/crate-loading/multiple-dep-versions.rs b/tests/run-make/crate-loading/multiple-dep-versions.rs
index 5a6cb03aaa4a7..113a6b76d7d82 100644
--- a/tests/run-make/crate-loading/multiple-dep-versions.rs
+++ b/tests/run-make/crate-loading/multiple-dep-versions.rs
@@ -1,8 +1,9 @@
 extern crate dep_2_reexport;
 extern crate dependency;
-use dep_2_reexport::do_something;
-use dependency::Type;
+use dep_2_reexport::Type;
+use dependency::{do_something, Trait};
 
 fn main() {
     do_something(Type);
+    Type.foo();
 }
diff --git a/tests/run-make/crate-loading/rmake.rs b/tests/run-make/crate-loading/rmake.rs
index d7abd5872c94a..5da706624aef7 100644
--- a/tests/run-make/crate-loading/rmake.rs
+++ b/tests/run-make/crate-loading/rmake.rs
@@ -7,11 +7,15 @@ use run_make_support::{rust_lib_name, rustc};
 fn main() {
     rustc().input("multiple-dep-versions-1.rs").run();
     rustc().input("multiple-dep-versions-2.rs").extra_filename("2").metadata("2").run();
+    rustc()
+        .input("multiple-dep-versions-3.rs")
+        .extern_("dependency", rust_lib_name("dependency2"))
+        .run();
 
     rustc()
         .input("multiple-dep-versions.rs")
         .extern_("dependency", rust_lib_name("dependency"))
-        .extern_("dep_2_reexport", rust_lib_name("dependency2"))
+        .extern_("dep_2_reexport", rust_lib_name("foo"))
         .run_fail()
         .assert_stderr_contains(
             "you have multiple different versions of crate `dependency` in your dependency graph",
@@ -22,5 +26,11 @@ fn main() {
         )
         .assert_stderr_contains("this type doesn't implement the required trait")
         .assert_stderr_contains("this type implements the required trait")
-        .assert_stderr_contains("this is the required trait");
+        .assert_stderr_contains("this is the required trait")
+        .assert_stderr_contains(
+            "`dependency` imported here doesn't correspond to the right crate version",
+        )
+        .assert_stderr_contains("this is the trait that was imported")
+        .assert_stderr_contains("this is the trait that is needed")
+        .assert_stderr_contains("the method is available for `dep_2_reexport::Type` here");
 }

From 5c427b4600708dce24066ade292f8d8b592b1cc5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 7 Aug 2024 16:18:06 +0000
Subject: [PATCH 156/685] reword message

---
 compiler/rustc_hir_typeck/src/method/suggest.rs               | 2 +-
 .../src/error_reporting/traits/fulfillment_errors.rs          | 4 ++--
 tests/run-make/crate-loading/rmake.rs                         | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index d4fcbcad7ae07..6afbde867398a 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -4062,7 +4062,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let name = self.tcx.crate_name(trait_candidate.def_id.krate);
                 if trait_candidate.def_id.krate != item.def_id.krate && name == pick_name {
                     let msg = format!(
-                        "you have multiple different versions of crate `{name}` in your \
+                        "there are multiple different versions of crate `{name}` in the \
                          dependency graph",
                     );
                     let tdid = self.tcx.parent(item.def_id);
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 95d4509c100a2..5b879cf67ce0d 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -1697,11 +1697,11 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             err.highlighted_span_help(
                 span,
                 vec![
-                    StringPart::normal("you have ".to_string()),
+                    StringPart::normal("there are ".to_string()),
                     StringPart::highlighted("multiple different versions".to_string()),
                     StringPart::normal(" of crate `".to_string()),
                     StringPart::highlighted(format!("{name}")),
-                    StringPart::normal("` in your dependency graph".to_string()),
+                    StringPart::normal("` the your dependency graph".to_string()),
                 ],
             );
             let candidates = if impl_candidates.is_empty() {
diff --git a/tests/run-make/crate-loading/rmake.rs b/tests/run-make/crate-loading/rmake.rs
index 5da706624aef7..1b9c13c1f6a10 100644
--- a/tests/run-make/crate-loading/rmake.rs
+++ b/tests/run-make/crate-loading/rmake.rs
@@ -18,7 +18,7 @@ fn main() {
         .extern_("dep_2_reexport", rust_lib_name("foo"))
         .run_fail()
         .assert_stderr_contains(
-            "you have multiple different versions of crate `dependency` in your dependency graph",
+            "there are multiple different versions of crate `dependency` in the dependency graph",
         )
         .assert_stderr_contains(
             "two types coming from two different versions of the same crate are different types \

From eeb72835d291a9e5fc08731ed0e26cc707ced720 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 7 Aug 2024 21:09:17 +0000
Subject: [PATCH 157/685] Account for fully-qualified path case of conflicting
 crate versions

When encountering the following, mention the precense of conflicting crates:

```
error[E0599]: no function or associated item named `get_decoded` found for struct `HpkeConfig` in the current scope
   --> src/main.rs:7:17
    |
7   |     HpkeConfig::get_decoded(&foo);
    |                 ^^^^^^^^^^^ function or associated item not found in `HpkeConfig`
    |
note: if you're trying to build a new `HpkeConfig`, consider using `HpkeConfig::new` which returns `HpkeConfig`
   --> ~/.cargo/registry/src/index.crates.io-6f17d22bba15001f/janus_messages-0.3.1/src/lib.rs:908:5
    |
908 | /     pub fn new(
909 | |         id: HpkeConfigId,
910 | |         kem_id: HpkeKemId,
911 | |         kdf_id: HpkeKdfId,
912 | |         aead_id: HpkeAeadId,
913 | |         public_key: HpkePublicKey,
914 | |     ) -> HpkeConfig {
    | |___________________^
note: there are multiple different versions of crate `prio` in the dependency graph
   --> src/main.rs:1:5
    |
1   | use prio::codec::Decode;
    |     ^^^^^^^^^^^^^^^^^^^ `prio` imported here doesn't correspond to the right crate version
    |
   ::: ~/.cargo/registry/src/index.crates.io-6f17d22bba15001f/prio-0.9.1/src/codec.rs:35:1
    |
35  | pub trait Decode: Sized {
    | ----------------------- this is the trait that was imported
    |
   ::: ~/.cargo/registry/src/index.crates.io-6f17d22bba15001f/prio-0.10.3/src/codec.rs:35:1
    |
35  | pub trait Decode: Sized {
    | ----------------------- this is the trait that is needed
...
43  |     fn get_decoded(bytes: &[u8]) -> Result<Self, CodecError> {
    |     -------------------------------------------------------- the method is available for `HpkeConfig` here
help: there is an associated function `decode` with a similar name
    |
7   |     HpkeConfig::decode(&foo);
    |                 ~~~~~~
```
---
 .../rustc_hir_typeck/src/method/suggest.rs    | 52 ++++++++++++++-----
 1 file changed, 40 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 6afbde867398a..4ab7e2ee17772 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -3494,7 +3494,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         if pick.autoderefs == 0 && !skip {
                             suggest = self.detect_and_explain_multiple_crate_versions(
                                 err,
-                                &pick.item,
+                                pick.item.def_id,
+                                pick.item.ident(self.tcx).span,
                                 rcvr.hir_id.owner,
                                 *rcvr_ty,
                             );
@@ -3684,6 +3685,30 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
             }
         }
+
+        if let SelfSource::QPath(ty) = source
+            && !valid_out_of_scope_traits.is_empty()
+            && let hir::TyKind::Path(path) = ty.kind
+            && let hir::QPath::Resolved(_, path) = path
+            && let Some(def_id) = path.res.opt_def_id()
+            && let Some(assoc) = self
+                .tcx
+                .associated_items(valid_out_of_scope_traits[0])
+                .filter_by_name_unhygienic(item_name.name)
+                .next()
+        {
+            // See if the `Type::function(val)` where `function` wasn't found corresponds to a
+            // `Trait` that is imported directly, but `Type` came from a different version of the
+            // same crate.
+            let rcvr_ty = self.tcx.type_of(def_id).instantiate_identity();
+            suggest = self.detect_and_explain_multiple_crate_versions(
+                err,
+                assoc.def_id,
+                self.tcx.def_span(assoc.def_id),
+                ty.hir_id.owner,
+                rcvr_ty,
+            );
+        }
         if suggest && self.suggest_valid_traits(err, item_name, valid_out_of_scope_traits, true) {
             return;
         }
@@ -4052,21 +4077,24 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn detect_and_explain_multiple_crate_versions(
         &self,
         err: &mut Diag<'_>,
-        item: &ty::AssocItem,
+        item_def_id: DefId,
+        item_span: Span,
         owner: hir::OwnerId,
         rcvr_ty: Ty<'_>,
     ) -> bool {
-        let pick_name = self.tcx.crate_name(item.def_id.krate);
+        let pick_name = self.tcx.crate_name(item_def_id.krate);
+        let trait_did = self.tcx.parent(item_def_id);
+        let trait_name = self.tcx.item_name(trait_did);
         if let Some(map) = self.tcx.in_scope_traits_map(owner) {
             for trait_candidate in map.to_sorted_stable_ord().into_iter().flat_map(|v| v.1.iter()) {
-                let name = self.tcx.crate_name(trait_candidate.def_id.krate);
-                if trait_candidate.def_id.krate != item.def_id.krate && name == pick_name {
+                let crate_name = self.tcx.crate_name(trait_candidate.def_id.krate);
+                if trait_candidate.def_id.krate != item_def_id.krate && crate_name == pick_name {
                     let msg = format!(
-                        "there are multiple different versions of crate `{name}` in the \
+                        "there are multiple different versions of crate `{crate_name}` in the \
                          dependency graph",
                     );
-                    let tdid = self.tcx.parent(item.def_id);
-                    if self.tcx.item_name(trait_candidate.def_id) == self.tcx.item_name(tdid)
+                    let candidate_name = self.tcx.item_name(trait_candidate.def_id);
+                    if candidate_name == trait_name
                         && let Some(def_id) = trait_candidate.import_ids.get(0)
                     {
                         let span = self.tcx.def_span(*def_id);
@@ -4074,8 +4102,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         multi_span.push_span_label(
                             span,
                             format!(
-                                "`{name}` imported here doesn't correspond to the right crate \
-                                 version",
+                                "`{crate_name}` imported here doesn't correspond to the right \
+                                 crate version",
                             ),
                         );
                         multi_span.push_span_label(
@@ -4083,11 +4111,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             format!("this is the trait that was imported"),
                         );
                         multi_span.push_span_label(
-                            self.tcx.def_span(tdid),
+                            self.tcx.def_span(trait_did),
                             format!("this is the trait that is needed"),
                         );
                         multi_span.push_span_label(
-                            item.ident(self.tcx).span,
+                            item_span,
                             format!("the method is available for `{rcvr_ty}` here"),
                         );
                         err.span_note(multi_span, msg);

From 4e985534e850822c6e1069b6bb2459b31ea5a886 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 7 Aug 2024 21:24:49 +0000
Subject: [PATCH 158/685] Ignore auto-deref for multiple crate version note

As per the case presented in #128569, we should be showing the extra info even if auto-deref is involved.
---
 .../rustc_hir_typeck/src/method/suggest.rs    | 31 ++++++++++---------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 4ab7e2ee17772..cf9f496ed56ff 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -3448,7 +3448,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         trait_missing_method: bool,
     ) {
         let mut alt_rcvr_sugg = false;
-        let mut suggest = true;
+        let mut trait_in_other_version_found = false;
         if let (SelfSource::MethodCall(rcvr), false) = (source, unsatisfied_bounds) {
             debug!(
                 "suggest_traits_to_import: span={:?}, item_name={:?}, rcvr_ty={:?}, rcvr={:?}",
@@ -3490,21 +3490,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         // self types and rely on the suggestion to `use` the trait from
                         // `suggest_valid_traits`.
                         let did = Some(pick.item.container_id(self.tcx));
-                        let skip = skippable.contains(&did);
-                        if pick.autoderefs == 0 && !skip {
-                            suggest = self.detect_and_explain_multiple_crate_versions(
+                        if skippable.contains(&did) {
+                            continue;
+                        }
+                        trait_in_other_version_found = self
+                            .detect_and_explain_multiple_crate_versions(
                                 err,
                                 pick.item.def_id,
                                 pick.item.ident(self.tcx).span,
                                 rcvr.hir_id.owner,
                                 *rcvr_ty,
                             );
-                            if suggest {
-                                err.span_label(
-                                    pick.item.ident(self.tcx).span,
-                                    format!("the method is available for `{rcvr_ty}` here"),
-                                );
-                            }
+                        if pick.autoderefs == 0 && !trait_in_other_version_found {
+                            err.span_label(
+                                pick.item.ident(self.tcx).span,
+                                format!("the method is available for `{rcvr_ty}` here"),
+                            );
                         }
                         break;
                     }
@@ -3701,7 +3702,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // `Trait` that is imported directly, but `Type` came from a different version of the
             // same crate.
             let rcvr_ty = self.tcx.type_of(def_id).instantiate_identity();
-            suggest = self.detect_and_explain_multiple_crate_versions(
+            trait_in_other_version_found = self.detect_and_explain_multiple_crate_versions(
                 err,
                 assoc.def_id,
                 self.tcx.def_span(assoc.def_id),
@@ -3709,7 +3710,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 rcvr_ty,
             );
         }
-        if suggest && self.suggest_valid_traits(err, item_name, valid_out_of_scope_traits, true) {
+        if !trait_in_other_version_found
+            && self.suggest_valid_traits(err, item_name, valid_out_of_scope_traits, true)
+        {
             return;
         }
 
@@ -4119,14 +4122,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             format!("the method is available for `{rcvr_ty}` here"),
                         );
                         err.span_note(multi_span, msg);
-                        return false;
                     } else {
                         err.note(msg);
                     }
+                    return true;
                 }
             }
         }
-        true
+        false
     }
 
     /// issue #102320, for `unwrap_or` with closure as argument, suggest `unwrap_or_else`

From 61058937e5a9d58ce1f9c5e0ac6beef22c54cadf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sat, 10 Aug 2024 00:32:10 +0000
Subject: [PATCH 159/685] Rework suggestion method

Make checking slightly cheaper (by restricting to the right item only).

Add tests.
---
 .../rustc_hir_typeck/src/method/suggest.rs    | 96 +++++++++----------
 .../crate-loading/multiple-dep-versions-1.rs  |  2 +
 .../crate-loading/multiple-dep-versions-2.rs  |  2 +
 .../crate-loading/multiple-dep-versions.rs    |  1 +
 tests/run-make/crate-loading/rmake.rs         | 84 ++++++++++++++--
 5 files changed, 126 insertions(+), 59 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index cf9f496ed56ff..31366a3076050 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -3497,8 +3497,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             .detect_and_explain_multiple_crate_versions(
                                 err,
                                 pick.item.def_id,
-                                pick.item.ident(self.tcx).span,
-                                rcvr.hir_id.owner,
+                                rcvr.hir_id,
                                 *rcvr_ty,
                             );
                         if pick.autoderefs == 0 && !trait_in_other_version_found {
@@ -3705,8 +3704,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             trait_in_other_version_found = self.detect_and_explain_multiple_crate_versions(
                 err,
                 assoc.def_id,
-                self.tcx.def_span(assoc.def_id),
-                ty.hir_id.owner,
+                ty.hir_id,
                 rcvr_ty,
             );
         }
@@ -4081,55 +4079,55 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         &self,
         err: &mut Diag<'_>,
         item_def_id: DefId,
-        item_span: Span,
-        owner: hir::OwnerId,
+        hir_id: hir::HirId,
         rcvr_ty: Ty<'_>,
     ) -> bool {
-        let pick_name = self.tcx.crate_name(item_def_id.krate);
-        let trait_did = self.tcx.parent(item_def_id);
-        let trait_name = self.tcx.item_name(trait_did);
-        if let Some(map) = self.tcx.in_scope_traits_map(owner) {
-            for trait_candidate in map.to_sorted_stable_ord().into_iter().flat_map(|v| v.1.iter()) {
-                let crate_name = self.tcx.crate_name(trait_candidate.def_id.krate);
-                if trait_candidate.def_id.krate != item_def_id.krate && crate_name == pick_name {
-                    let msg = format!(
-                        "there are multiple different versions of crate `{crate_name}` in the \
-                         dependency graph",
-                    );
-                    let candidate_name = self.tcx.item_name(trait_candidate.def_id);
-                    if candidate_name == trait_name
-                        && let Some(def_id) = trait_candidate.import_ids.get(0)
-                    {
-                        let span = self.tcx.def_span(*def_id);
-                        let mut multi_span: MultiSpan = span.into();
-                        multi_span.push_span_label(
-                            span,
-                            format!(
-                                "`{crate_name}` imported here doesn't correspond to the right \
-                                 crate version",
-                            ),
-                        );
-                        multi_span.push_span_label(
-                            self.tcx.def_span(trait_candidate.def_id),
-                            format!("this is the trait that was imported"),
-                        );
-                        multi_span.push_span_label(
-                            self.tcx.def_span(trait_did),
-                            format!("this is the trait that is needed"),
-                        );
-                        multi_span.push_span_label(
-                            item_span,
-                            format!("the method is available for `{rcvr_ty}` here"),
-                        );
-                        err.span_note(multi_span, msg);
-                    } else {
-                        err.note(msg);
-                    }
-                    return true;
-                }
+        let hir_id = self.tcx.parent_hir_id(hir_id);
+        let Some(traits) = self.tcx.in_scope_traits(hir_id) else { return false };
+        if traits.is_empty() {
+            return false;
+        }
+        let trait_def_id = self.tcx.parent(item_def_id);
+        let krate = self.tcx.crate_name(trait_def_id.krate);
+        let name = self.tcx.item_name(trait_def_id);
+        let candidates: Vec<_> = traits
+            .iter()
+            .filter(|c| {
+                c.def_id.krate != trait_def_id.krate
+                    && self.tcx.crate_name(c.def_id.krate) == krate
+                    && self.tcx.item_name(c.def_id) == name
+            })
+            .map(|c| (c.def_id, c.import_ids.get(0).cloned()))
+            .collect();
+        if candidates.is_empty() {
+            return false;
+        }
+        let item_span = self.tcx.def_span(item_def_id);
+        let msg = format!(
+            "there are multiple different versions of crate `{krate}` in the dependency graph",
+        );
+        let trait_span = self.tcx.def_span(trait_def_id);
+        let mut multi_span: MultiSpan = trait_span.into();
+        multi_span.push_span_label(trait_span, format!("this is the trait that is needed"));
+        multi_span
+            .push_span_label(item_span, format!("the method is available for `{rcvr_ty}` here"));
+        for (def_id, import_def_id) in candidates {
+            if let Some(import_def_id) = import_def_id {
+                multi_span.push_span_label(
+                    self.tcx.def_span(import_def_id),
+                    format!(
+                        "`{name}` imported here doesn't correspond to the right version of crate \
+                         `{krate}`",
+                    ),
+                );
             }
+            multi_span.push_span_label(
+                self.tcx.def_span(def_id),
+                format!("this is the trait that was imported"),
+            );
         }
-        false
+        err.span_note(multi_span, msg);
+        true
     }
 
     /// issue #102320, for `unwrap_or` with closure as argument, suggest `unwrap_or_else`
diff --git a/tests/run-make/crate-loading/multiple-dep-versions-1.rs b/tests/run-make/crate-loading/multiple-dep-versions-1.rs
index 94f30ca326fdb..d81462504dd57 100644
--- a/tests/run-make/crate-loading/multiple-dep-versions-1.rs
+++ b/tests/run-make/crate-loading/multiple-dep-versions-1.rs
@@ -3,8 +3,10 @@
 pub struct Type(pub i32);
 pub trait Trait {
     fn foo(&self);
+    fn bar();
 }
 impl Trait for Type {
     fn foo(&self) {}
+    fn bar() {}
 }
 pub fn do_something<X: Trait>(_: X) {}
diff --git a/tests/run-make/crate-loading/multiple-dep-versions-2.rs b/tests/run-make/crate-loading/multiple-dep-versions-2.rs
index 0a4626be5605b..0a566fe2c6051 100644
--- a/tests/run-make/crate-loading/multiple-dep-versions-2.rs
+++ b/tests/run-make/crate-loading/multiple-dep-versions-2.rs
@@ -3,8 +3,10 @@
 pub struct Type;
 pub trait Trait {
     fn foo(&self);
+    fn bar();
 }
 impl Trait for Type {
     fn foo(&self) {}
+    fn bar() {}
 }
 pub fn do_something<X: Trait>(_: X) {}
diff --git a/tests/run-make/crate-loading/multiple-dep-versions.rs b/tests/run-make/crate-loading/multiple-dep-versions.rs
index 113a6b76d7d82..8ef042bf41842 100644
--- a/tests/run-make/crate-loading/multiple-dep-versions.rs
+++ b/tests/run-make/crate-loading/multiple-dep-versions.rs
@@ -6,4 +6,5 @@ use dependency::{do_something, Trait};
 fn main() {
     do_something(Type);
     Type.foo();
+    Type::bar();
 }
diff --git a/tests/run-make/crate-loading/rmake.rs b/tests/run-make/crate-loading/rmake.rs
index 1b9c13c1f6a10..65cbc8b0b1b96 100644
--- a/tests/run-make/crate-loading/rmake.rs
+++ b/tests/run-make/crate-loading/rmake.rs
@@ -1,6 +1,7 @@
 //@ only-linux
 //@ ignore-wasm32
 //@ ignore-wasm64
+// ignore-tidy-linelength
 
 use run_make_support::{rust_lib_name, rustc};
 
@@ -18,19 +19,82 @@ fn main() {
         .extern_("dep_2_reexport", rust_lib_name("foo"))
         .run_fail()
         .assert_stderr_contains(
-            "there are multiple different versions of crate `dependency` in the dependency graph",
+            r#"error[E0277]: the trait bound `dep_2_reexport::Type: Trait` is not satisfied
+  --> multiple-dep-versions.rs:7:18
+   |
+7  |     do_something(Type);
+   |     ------------ ^^^^ the trait `Trait` is not implemented for `dep_2_reexport::Type`
+   |     |
+   |     required by a bound introduced by this call
+   |
+help: there are multiple different versions of crate `dependency` the your dependency graph
+  --> multiple-dep-versions.rs:1:1
+   |
+1  | extern crate dep_2_reexport;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one version of crate `dependency` is used here, as a dependency of crate `foo`
+2  | extern crate dependency;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^ one version of crate `dependency` is used here, as a direct dependency of the current crate"#,
         )
         .assert_stderr_contains(
-            "two types coming from two different versions of the same crate are different types \
-             even if they look the same",
+            r#"
+3  | pub struct Type(pub i32);
+   | ^^^^^^^^^^^^^^^ this type implements the required trait
+4  | pub trait Trait {
+   | --------------- this is the required trait"#,
         )
-        .assert_stderr_contains("this type doesn't implement the required trait")
-        .assert_stderr_contains("this type implements the required trait")
-        .assert_stderr_contains("this is the required trait")
         .assert_stderr_contains(
-            "`dependency` imported here doesn't correspond to the right crate version",
+            r#"
+3  | pub struct Type;
+   | ^^^^^^^^^^^^^^^ this type doesn't implement the required trait"#,
         )
-        .assert_stderr_contains("this is the trait that was imported")
-        .assert_stderr_contains("this is the trait that is needed")
-        .assert_stderr_contains("the method is available for `dep_2_reexport::Type` here");
+        .assert_stderr_contains(
+            r#"
+error[E0599]: no method named `foo` found for struct `dep_2_reexport::Type` in the current scope
+ --> multiple-dep-versions.rs:8:10
+  |
+8 |     Type.foo();
+  |          ^^^ method not found in `Type`
+  |
+note: there are multiple different versions of crate `dependency` in the dependency graph"#,
+        )
+        .assert_stderr_contains(
+            r#"
+4 | pub trait Trait {
+  | ^^^^^^^^^^^^^^^ this is the trait that is needed
+5 |     fn foo(&self);
+  |     -------------- the method is available for `dep_2_reexport::Type` here
+  |
+ ::: multiple-dep-versions.rs:4:32
+  |
+4 | use dependency::{do_something, Trait};
+  |                                ----- `Trait` imported here doesn't correspond to the right version of crate `dependency`"#,
+        )
+        .assert_stderr_contains(
+            r#"
+4 | pub trait Trait {
+  | --------------- this is the trait that was imported"#,
+        )
+        .assert_stderr_contains(
+            r#"
+error[E0599]: no function or associated item named `bar` found for struct `dep_2_reexport::Type` in the current scope
+ --> multiple-dep-versions.rs:9:11
+  |
+9 |     Type::bar();
+  |           ^^^ function or associated item not found in `Type`
+  |
+note: there are multiple different versions of crate `dependency` in the dependency graph"#,
+        )
+        .assert_stderr_contains(
+            r#"
+4 | pub trait Trait {
+  | ^^^^^^^^^^^^^^^ this is the trait that is needed
+5 |     fn foo(&self);
+6 |     fn bar();
+  |     --------- the method is available for `dep_2_reexport::Type` here
+  |
+ ::: multiple-dep-versions.rs:4:32
+  |
+4 | use dependency::{do_something, Trait};
+  |                                ----- `Trait` imported here doesn't correspond to the right version of crate `dependency`"#,
+        );
 }

From 110b19b2b6a9896d4d73b8bd8b735fa9c2503d1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Mon, 12 Aug 2024 19:45:20 +0000
Subject: [PATCH 160/685] Properly differentiate between methods and assoc fns

---
 compiler/rustc_hir_typeck/src/method/suggest.rs | 3 ++-
 tests/run-make/crate-loading/rmake.rs           | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 31366a3076050..ab13b31439c04 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -4109,8 +4109,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let trait_span = self.tcx.def_span(trait_def_id);
         let mut multi_span: MultiSpan = trait_span.into();
         multi_span.push_span_label(trait_span, format!("this is the trait that is needed"));
+        let descr = self.tcx.associated_item(item_def_id).descr();
         multi_span
-            .push_span_label(item_span, format!("the method is available for `{rcvr_ty}` here"));
+            .push_span_label(item_span, format!("the {descr} is available for `{rcvr_ty}` here"));
         for (def_id, import_def_id) in candidates {
             if let Some(import_def_id) = import_def_id {
                 multi_span.push_span_label(
diff --git a/tests/run-make/crate-loading/rmake.rs b/tests/run-make/crate-loading/rmake.rs
index 65cbc8b0b1b96..13585edf6ccbe 100644
--- a/tests/run-make/crate-loading/rmake.rs
+++ b/tests/run-make/crate-loading/rmake.rs
@@ -90,7 +90,7 @@ note: there are multiple different versions of crate `dependency` in the depende
   | ^^^^^^^^^^^^^^^ this is the trait that is needed
 5 |     fn foo(&self);
 6 |     fn bar();
-  |     --------- the method is available for `dep_2_reexport::Type` here
+  |     --------- the associated function is available for `dep_2_reexport::Type` here
   |
  ::: multiple-dep-versions.rs:4:32
   |

From 182cd5f2785ae77f3a05cf75ee301ed8850c8d0a Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 5 Aug 2024 14:08:04 +0000
Subject: [PATCH 161/685] Replace the metadata collector with tests

---
 .cargo/config.toml                            |    6 +-
 .github/workflows/clippy_bors.yml             |    5 -
 Cargo.toml                                    |    4 +-
 book/src/development/adding_lints.md          |    2 +-
 book/src/lint_configuration.md                |    4 +-
 clippy_dev/src/update_lints.rs                |    2 +-
 clippy_lints/src/declared_lints.rs            |    4 +-
 clippy_lints/src/lib.rs                       |   48 +-
 clippy_lints/src/utils/internal_lints.rs      |    1 -
 .../internal_lints/metadata_collector.rs      | 1080 -----------------
 declare_clippy_lint/src/lib.rs                |   25 +-
 tests/compile-test.rs                         |  382 ++++--
 tests/config-metadata.rs                      |   76 ++
 util/gh-pages/index.html                      |    6 +-
 util/gh-pages/script.js                       |    9 +-
 15 files changed, 448 insertions(+), 1206 deletions(-)
 delete mode 100644 clippy_lints/src/utils/internal_lints/metadata_collector.rs
 create mode 100644 tests/config-metadata.rs

diff --git a/.cargo/config.toml b/.cargo/config.toml
index ce07290d1e1e5..d9c635df5dc79 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,10 +1,10 @@
 [alias]
+bless = "test --config env.RUSTC_BLESS='1'"
 uitest = "test --test compile-test"
-uibless = "test --test compile-test -- -- --bless"
-bless = "test -- -- --bless"
+uibless = "bless --test compile-test"
 dev = "run --package clippy_dev --bin clippy_dev --manifest-path clippy_dev/Cargo.toml --"
 lintcheck = "run --package lintcheck --bin lintcheck --manifest-path lintcheck/Cargo.toml  -- "
-collect-metadata = "test --test dogfood --features internal -- collect_metadata"
+collect-metadata = "test --test compile-test --config env.COLLECT_METADATA='1'"
 
 [build]
 # -Zbinary-dep-depinfo allows us to track which rlib files to use for compiling UI tests
diff --git a/.github/workflows/clippy_bors.yml b/.github/workflows/clippy_bors.yml
index 10e18e84c89fd..2aa13313fa518 100644
--- a/.github/workflows/clippy_bors.yml
+++ b/.github/workflows/clippy_bors.yml
@@ -136,11 +136,6 @@ jobs:
     - name: Test metadata collection
       run: cargo collect-metadata
 
-    - name: Test lint_configuration.md is up-to-date
-      run: |
-        echo "run \`cargo collect-metadata\` if this fails"
-        git update-index --refresh
-
   integration_build:
     needs: changelog
     runs-on: ubuntu-latest
diff --git a/Cargo.toml b/Cargo.toml
index 78409c7a09e29..b48b881097f47 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,8 +30,11 @@ color-print = "0.3.4"
 anstream = "0.6.0"
 
 [dev-dependencies]
+cargo_metadata = "0.18.1"
 ui_test = "0.25"
 regex = "1.5.5"
+serde = { version = "1.0.145", features = ["derive"] }
+serde_json = "1.0.122"
 toml = "0.7.3"
 walkdir = "2.3"
 filetime = "0.2.9"
@@ -41,7 +44,6 @@ itertools = "0.12"
 clippy_utils = { path = "clippy_utils" }
 if_chain = "1.0"
 quote = "1.0.25"
-serde = { version = "1.0.145", features = ["derive"] }
 syn = { version = "2.0", features = ["full"] }
 futures = "0.3"
 parking_lot = "0.12"
diff --git a/book/src/development/adding_lints.md b/book/src/development/adding_lints.md
index a71d94daca74c..963e02e5c1616 100644
--- a/book/src/development/adding_lints.md
+++ b/book/src/development/adding_lints.md
@@ -739,7 +739,7 @@ for some users. Adding a configuration is done in the following steps:
 
 5. Update [Lint Configuration](../lint_configuration.md)
 
-   Run `cargo collect-metadata` to generate documentation changes for the book.
+   Run `cargo bless --test config-metadata` to generate documentation changes for the book.
 
 [`clippy_config::conf`]: https://github.com/rust-lang/rust-clippy/blob/master/clippy_config/src/conf.rs
 [`clippy_lints` lib file]: https://github.com/rust-lang/rust-clippy/blob/master/clippy_lints/src/lib.rs
diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index e3d550b146629..4f23afe2e118a 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -1,5 +1,5 @@
 <!--
-This file is generated by `cargo collect-metadata`.
+This file is generated by `cargo bless --test config-metadata`.
 Please use that command to update the file and do not edit it by hand.
 -->
 
@@ -949,5 +949,3 @@ Whether to also emit warnings for unsafe blocks with metavariable expansions in
 ---
 **Affected lints:**
 * [`macro_metavars_in_unsafe`](https://rust-lang.github.io/rust-clippy/master/index.html#macro_metavars_in_unsafe)
-
-
diff --git a/clippy_dev/src/update_lints.rs b/clippy_dev/src/update_lints.rs
index 15578d69c3a9d..8dbda1c634c28 100644
--- a/clippy_dev/src/update_lints.rs
+++ b/clippy_dev/src/update_lints.rs
@@ -604,7 +604,7 @@ fn gen_declared_lints<'a>(
     details.sort_unstable();
 
     let mut output = GENERATED_FILE_COMMENT.to_string();
-    output.push_str("pub(crate) static LINTS: &[&crate::LintInfo] = &[\n");
+    output.push_str("pub static LINTS: &[&crate::LintInfo] = &[\n");
 
     for (is_public, module_name, lint_name) in details {
         if !is_public {
diff --git a/clippy_lints/src/declared_lints.rs b/clippy_lints/src/declared_lints.rs
index 3fb083dd83310..8754a4dff87b1 100644
--- a/clippy_lints/src/declared_lints.rs
+++ b/clippy_lints/src/declared_lints.rs
@@ -2,7 +2,7 @@
 // Use that command to update this file and do not edit by hand.
 // Manual edits will be overwritten.
 
-pub(crate) static LINTS: &[&crate::LintInfo] = &[
+pub static LINTS: &[&crate::LintInfo] = &[
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::almost_standard_lint_formulation::ALMOST_STANDARD_LINT_FORMULATION_INFO,
     #[cfg(feature = "internal")]
@@ -22,8 +22,6 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::lint_without_lint_pass::MISSING_CLIPPY_VERSION_ATTRIBUTE_INFO,
     #[cfg(feature = "internal")]
-    crate::utils::internal_lints::metadata_collector::METADATA_COLLECTOR_INFO,
-    #[cfg(feature = "internal")]
     crate::utils::internal_lints::msrv_attr_impl::MISSING_MSRV_ATTR_IMPL_INFO,
     #[cfg(feature = "internal")]
     crate::utils::internal_lints::outer_expn_data_pass::OUTER_EXPN_EXPN_DATA_INFO,
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
index ce13a9afef5b0..2ac06b360bea4 100644
--- a/clippy_lints/src/lib.rs
+++ b/clippy_lints/src/lib.rs
@@ -66,8 +66,8 @@ extern crate declare_clippy_lint;
 #[cfg_attr(feature = "internal", allow(clippy::missing_clippy_version_attribute))]
 mod utils;
 
-mod declared_lints;
-mod deprecated_lints;
+pub mod declared_lints;
+pub mod deprecated_lints;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
 mod absolute_paths;
@@ -440,7 +440,7 @@ impl RegistrationGroups {
     }
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 pub(crate) enum LintCategory {
     Cargo,
     Complexity,
@@ -479,11 +479,39 @@ impl LintCategory {
     }
 }
 
-pub(crate) struct LintInfo {
+pub struct LintInfo {
     /// Double reference to maintain pointer equality
-    lint: &'static &'static Lint,
+    pub lint: &'static &'static Lint,
     category: LintCategory,
-    explanation: &'static str,
+    pub explanation: &'static str,
+    /// e.g. `clippy_lints/src/absolute_paths.rs#43`
+    pub location: &'static str,
+    pub version: Option<&'static str>,
+}
+
+impl LintInfo {
+    /// Returns the lint name in lowercase without the `clippy::` prefix
+    #[allow(clippy::missing_panics_doc)]
+    pub fn name_lower(&self) -> String {
+        self.lint.name.strip_prefix("clippy::").unwrap().to_ascii_lowercase()
+    }
+
+    /// Returns the name of the lint's category in lowercase (`style`, `pedantic`)
+    pub fn category_str(&self) -> &'static str {
+        match self.category {
+            Cargo => "cargo",
+            Complexity => "complexity",
+            Correctness => "correctness",
+            Nursery => "nursery",
+            Pedantic => "pedantic",
+            Perf => "perf",
+            Restriction => "restriction",
+            Style => "style",
+            Suspicious => "suspicious",
+            #[cfg(feature = "internal")]
+            Internal => "internal",
+        }
+    }
 }
 
 pub fn explain(name: &str) -> i32 {
@@ -538,14 +566,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         store.register_removed(name, reason);
     }
 
-    #[cfg(feature = "internal")]
-    {
-        if std::env::var("ENABLE_METADATA_COLLECTION").eq(&Ok("1".to_string())) {
-            store.register_late_pass(|_| Box::new(utils::internal_lints::metadata_collector::MetadataCollector::new()));
-            return;
-        }
-    }
-
     let format_args_storage = FormatArgsStorage::default();
     let format_args = format_args_storage.clone();
     store.register_early_pass(move || {
diff --git a/clippy_lints/src/utils/internal_lints.rs b/clippy_lints/src/utils/internal_lints.rs
index 1d294c2944b2c..f662c7651f6bb 100644
--- a/clippy_lints/src/utils/internal_lints.rs
+++ b/clippy_lints/src/utils/internal_lints.rs
@@ -3,7 +3,6 @@ pub mod collapsible_calls;
 pub mod interning_defined_symbol;
 pub mod invalid_paths;
 pub mod lint_without_lint_pass;
-pub mod metadata_collector;
 pub mod msrv_attr_impl;
 pub mod outer_expn_data_pass;
 pub mod produce_ice;
diff --git a/clippy_lints/src/utils/internal_lints/metadata_collector.rs b/clippy_lints/src/utils/internal_lints/metadata_collector.rs
deleted file mode 100644
index c73ec262637f7..0000000000000
--- a/clippy_lints/src/utils/internal_lints/metadata_collector.rs
+++ /dev/null
@@ -1,1080 +0,0 @@
-//! This lint is used to collect metadata about clippy lints. This metadata is exported as a json
-//! file and then used to generate the [clippy lint list](https://rust-lang.github.io/rust-clippy/master/index.html)
-//!
-//! This module and therefore the entire lint is guarded by a feature flag called `internal`
-//!
-//! The module transforms all lint names to ascii lowercase to ensure that we don't have mismatches
-//! during any comparison or mapping. (Please take care of this, it's not fun to spend time on such
-//! a simple mistake)
-
-use crate::utils::internal_lints::lint_without_lint_pass::{extract_clippy_version_value, is_lint_ref_type};
-use clippy_config::{get_configuration_metadata, ClippyConfiguration};
-
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::ty::{match_type, walk_ptrs_ty_depth};
-use clippy_utils::{last_path_segment, match_function_call, match_path, paths};
-use itertools::Itertools;
-use rustc_ast as ast;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::def::DefKind;
-use rustc_hir::intravisit::Visitor;
-use rustc_hir::{self as hir, intravisit, Closure, ExprKind, Item, ItemKind, Mutability, QPath};
-use rustc_lint::{unerased_lint_store, CheckLintNameResult, LateContext, LateLintPass, LintContext, LintId};
-use rustc_middle::hir::nested_filter;
-use rustc_session::impl_lint_pass;
-use rustc_span::symbol::Ident;
-use rustc_span::{sym, Loc, Span, Symbol};
-use serde::ser::SerializeStruct;
-use serde::{Serialize, Serializer};
-use std::collections::{BTreeSet, BinaryHeap};
-use std::fmt::Write as _;
-use std::fs::{self, File};
-use std::io::prelude::*;
-use std::path::{Path, PathBuf};
-use std::process::Command;
-use std::{env, fmt};
-
-/// This is the json output file of the lint collector.
-const JSON_OUTPUT_FILE: &str = "../util/gh-pages/lints.json";
-/// This is the markdown output file of the lint collector.
-const MARKDOWN_OUTPUT_FILE: &str = "../book/src/lint_configuration.md";
-/// These groups will be ignored by the lint group matcher. This is useful for collections like
-/// `clippy::all`
-const IGNORED_LINT_GROUPS: [&str; 1] = ["clippy::all"];
-/// Lints within this group will be excluded from the collection. These groups
-/// have to be defined without the `clippy::` prefix.
-const EXCLUDED_LINT_GROUPS: [&str; 1] = ["internal"];
-/// Collected deprecated lint will be assigned to this group in the JSON output
-const DEPRECATED_LINT_GROUP_STR: &str = "deprecated";
-/// This is the lint level for deprecated lints that will be displayed in the lint list
-const DEPRECATED_LINT_LEVEL: &str = "none";
-/// This array holds Clippy's lint groups with their corresponding default lint level. The
-/// lint level for deprecated lints is set in `DEPRECATED_LINT_LEVEL`.
-const DEFAULT_LINT_LEVELS: &[(&str, &str)] = &[
-    ("correctness", "deny"),
-    ("suspicious", "warn"),
-    ("restriction", "allow"),
-    ("style", "warn"),
-    ("pedantic", "allow"),
-    ("complexity", "warn"),
-    ("perf", "warn"),
-    ("cargo", "allow"),
-    ("nursery", "allow"),
-];
-/// This prefix is in front of the lint groups in the lint store. The prefix will be trimmed
-/// to only keep the actual lint group in the output.
-const CLIPPY_LINT_GROUP_PREFIX: &str = "clippy::";
-const LINT_EMISSION_FUNCTIONS: [&[&str]; 7] = [
-    &["clippy_utils", "diagnostics", "span_lint"],
-    &["clippy_utils", "diagnostics", "span_lint_and_help"],
-    &["clippy_utils", "diagnostics", "span_lint_and_note"],
-    &["clippy_utils", "diagnostics", "span_lint_hir"],
-    &["clippy_utils", "diagnostics", "span_lint_and_sugg"],
-    &["clippy_utils", "diagnostics", "span_lint_and_then"],
-    &["clippy_utils", "diagnostics", "span_lint_hir_and_then"],
-];
-const SUGGESTION_DIAG_METHODS: [(&str, bool); 9] = [
-    ("span_suggestion", false),
-    ("span_suggestion_short", false),
-    ("span_suggestion_verbose", false),
-    ("span_suggestion_hidden", false),
-    ("tool_only_span_suggestion", false),
-    ("multipart_suggestion", true),
-    ("multipart_suggestions", true),
-    ("tool_only_multipart_suggestion", true),
-    ("span_suggestions", true),
-];
-
-/// The index of the applicability name of `paths::APPLICABILITY_VALUES`
-const APPLICABILITY_NAME_INDEX: usize = 2;
-/// This applicability will be set for unresolved applicability values.
-const APPLICABILITY_UNRESOLVED_STR: &str = "Unresolved";
-/// The version that will be displayed if none has been defined
-const VERSION_DEFAULT_STR: &str = "Unknown";
-
-const CHANGELOG_PATH: &str = "../CHANGELOG.md";
-
-declare_clippy_lint! {
-    /// ### What it does
-    /// Collects metadata about clippy lints for the website.
-    ///
-    /// This lint will be used to report problems of syntax parsing. You should hopefully never
-    /// see this but never say never I guess ^^
-    ///
-    /// ### Why is this bad?
-    /// This is not a bad thing but definitely a hacky way to do it. See
-    /// issue [#4310](https://github.com/rust-lang/rust-clippy/issues/4310) for a discussion
-    /// about the implementation.
-    ///
-    /// ### Known problems
-    /// Hopefully none. It would be pretty uncool to have a problem here :)
-    ///
-    /// ### Example output
-    /// ```json,ignore
-    /// {
-    ///     "id": "metadata_collector",
-    ///     "id_span": {
-    ///         "path": "clippy_lints/src/utils/internal_lints/metadata_collector.rs",
-    ///         "line": 1
-    ///     },
-    ///     "group": "clippy::internal",
-    ///     "docs": " ### What it does\nCollects metadata about clippy lints for the website. [...] "
-    /// }
-    /// ```
-    #[clippy::version = "1.56.0"]
-    pub METADATA_COLLECTOR,
-    internal,
-    "A busy bee collection metadata about lints"
-}
-
-impl_lint_pass!(MetadataCollector => [METADATA_COLLECTOR]);
-
-#[allow(clippy::module_name_repetitions)]
-#[derive(Debug, Clone)]
-pub struct MetadataCollector {
-    /// All collected lints
-    ///
-    /// We use a Heap here to have the lints added in alphabetic order in the export
-    lints: BinaryHeap<LintMetadata>,
-    applicability_info: FxHashMap<String, ApplicabilityInfo>,
-    config: Vec<ClippyConfiguration>,
-    clippy_project_root: PathBuf,
-}
-
-impl MetadataCollector {
-    pub fn new() -> Self {
-        Self {
-            lints: BinaryHeap::<LintMetadata>::default(),
-            applicability_info: FxHashMap::<String, ApplicabilityInfo>::default(),
-            config: get_configuration_metadata(),
-            clippy_project_root: env::current_dir()
-                .expect("failed to get current dir")
-                .ancestors()
-                .nth(1)
-                .expect("failed to get project root")
-                .to_path_buf(),
-        }
-    }
-
-    fn get_lint_configs(&self, lint_name: &str) -> Option<String> {
-        self.config
-            .iter()
-            .filter(|config| config.lints.iter().any(|&lint| lint == lint_name))
-            .map(ToString::to_string)
-            .reduce(|acc, x| acc + "\n\n" + &x)
-            .map(|configurations| {
-                format!(
-                    r#"
-### Configuration
-This lint has the following configuration variables:
-
-{configurations}
-"#
-                )
-            })
-    }
-
-    fn configs_to_markdown(&self, map_fn: fn(&ClippyConfiguration) -> String) -> String {
-        self.config
-            .iter()
-            .filter(|config| config.deprecation_reason.is_none())
-            .filter(|config| !config.lints.is_empty())
-            .map(map_fn)
-            .join("\n")
-    }
-
-    fn get_markdown_docs(&self) -> String {
-        format!(
-            r#"# Lint Configuration Options
-
-The following list shows each configuration option, along with a description, its default value, an example
-and lints affected.
-
----
-
-{}"#,
-            self.configs_to_markdown(ClippyConfiguration::to_markdown_paragraph),
-        )
-    }
-}
-
-impl Drop for MetadataCollector {
-    /// You might ask: How hacky is this?
-    /// My answer:     YES
-    fn drop(&mut self) {
-        // The metadata collector gets dropped twice, this makes sure that we only write
-        // when the list is full
-        if self.lints.is_empty() {
-            return;
-        }
-
-        let mut applicability_info = std::mem::take(&mut self.applicability_info);
-
-        // Add deprecated lints
-        self.lints.extend(
-            crate::deprecated_lints::DEPRECATED
-                .iter()
-                .zip(crate::deprecated_lints::DEPRECATED_VERSION)
-                .filter_map(|((lint, reason), version)| LintMetadata::new_deprecated(lint, reason, version)),
-        );
-        // Mapping the final data
-        let mut lints = std::mem::take(&mut self.lints).into_sorted_vec();
-        for x in &mut lints {
-            x.applicability = Some(applicability_info.remove(&x.id).unwrap_or_default());
-            replace_produces(&x.id, &mut x.docs, &self.clippy_project_root);
-        }
-
-        collect_renames(&mut lints);
-
-        // Outputting json
-        fs::write(JSON_OUTPUT_FILE, serde_json::to_string_pretty(&lints).unwrap()).unwrap();
-
-        // Outputting markdown
-        let mut file = File::create(MARKDOWN_OUTPUT_FILE).unwrap();
-        writeln!(
-            file,
-            "<!--
-This file is generated by `cargo collect-metadata`.
-Please use that command to update the file and do not edit it by hand.
--->
-
-{}",
-            self.get_markdown_docs(),
-        )
-        .unwrap();
-
-        // Write configuration links to CHANGELOG.md
-        let changelog = fs::read_to_string(CHANGELOG_PATH).unwrap();
-        let mut changelog_file = File::create(CHANGELOG_PATH).unwrap();
-        let position = changelog
-            .find("<!-- begin autogenerated links to configuration documentation -->")
-            .unwrap();
-        writeln!(
-            changelog_file,
-            "{}<!-- begin autogenerated links to configuration documentation -->\n{}\n<!-- end autogenerated links to configuration documentation -->",
-            &changelog[..position],
-            self.configs_to_markdown(ClippyConfiguration::to_markdown_link)
-        )
-        .unwrap();
-    }
-}
-
-#[derive(Debug, Clone, Serialize, PartialEq, Eq, PartialOrd, Ord)]
-struct LintMetadata {
-    id: String,
-    id_span: Option<SerializableSpan>,
-    group: String,
-    level: String,
-    docs: String,
-    version: String,
-    /// This field is only used in the output and will only be
-    /// mapped shortly before the actual output.
-    applicability: Option<ApplicabilityInfo>,
-    /// All the past names of lints which have been renamed.
-    #[serde(skip_serializing_if = "BTreeSet::is_empty")]
-    former_ids: BTreeSet<String>,
-}
-
-impl LintMetadata {
-    fn new(
-        id: String,
-        id_span: SerializableSpan,
-        group: String,
-        level: &'static str,
-        version: String,
-        docs: String,
-    ) -> Self {
-        Self {
-            id,
-            id_span: Some(id_span),
-            group,
-            level: level.to_string(),
-            version,
-            docs,
-            applicability: None,
-            former_ids: BTreeSet::new(),
-        }
-    }
-
-    fn new_deprecated(name: &str, reason: &str, version: &str) -> Option<Self> {
-        // The reason starts with a lowercase letter and end without a period.
-        // This needs to be fixed for the website.
-        let mut reason = reason.to_owned();
-        if let Some(reason) = reason.get_mut(0..1) {
-            reason.make_ascii_uppercase();
-        }
-        name.strip_prefix("clippy::").map(|name| Self {
-            id: name.into(),
-            id_span: None,
-            group: DEPRECATED_LINT_GROUP_STR.into(),
-            level: DEPRECATED_LINT_LEVEL.into(),
-            version: version.into(),
-            docs: format!(
-                "### What it does\n\n\
-                Nothing. This lint has been deprecated\n\n\
-                ### Deprecation reason\n\n{reason}.\n",
-            ),
-            applicability: None,
-            former_ids: BTreeSet::new(),
-        })
-    }
-}
-
-fn replace_produces(lint_name: &str, docs: &mut String, clippy_project_root: &Path) {
-    let mut doc_lines = docs.lines().map(ToString::to_string).collect::<Vec<_>>();
-    let mut lines = doc_lines.iter_mut();
-
-    'outer: loop {
-        // Find the start of the example
-
-        // ```rust
-        loop {
-            match lines.next() {
-                Some(line) if line.trim_start().starts_with("```rust") => {
-                    if line.contains("ignore") || line.contains("no_run") {
-                        // A {{produces}} marker may have been put on a ignored code block by mistake,
-                        // just seek to the end of the code block and continue checking.
-                        if lines.any(|line| line.trim_start().starts_with("```")) {
-                            continue;
-                        }
-
-                        panic!("lint `{lint_name}` has an unterminated code block")
-                    }
-
-                    break;
-                },
-                Some(line) if line.trim_start() == "{{produces}}" => {
-                    panic!("lint `{lint_name}` has marker {{{{produces}}}} with an ignored or missing code block")
-                },
-                Some(line) => {
-                    let line = line.trim();
-                    // These are the two most common markers of the corrections section
-                    if line.eq_ignore_ascii_case("Use instead:") || line.eq_ignore_ascii_case("Could be written as:") {
-                        break 'outer;
-                    }
-                },
-                None => break 'outer,
-            }
-        }
-
-        // Collect the example
-        let mut example = Vec::new();
-        loop {
-            match lines.next() {
-                Some(line) if line.trim_start() == "```" => break,
-                Some(line) => example.push(line),
-                None => panic!("lint `{lint_name}` has an unterminated code block"),
-            }
-        }
-
-        // Find the {{produces}} and attempt to generate the output
-        loop {
-            match lines.next() {
-                Some(line) if line.is_empty() => {},
-                Some(line) if line.trim() == "{{produces}}" => {
-                    let output = get_lint_output(lint_name, &example, clippy_project_root);
-                    line.replace_range(
-                        ..,
-                        &format!(
-                            "<details>\
-                            <summary>Produces</summary>\n\
-                            \n\
-                            ```text\n\
-                            {output}\n\
-                            ```\n\
-                        </details>"
-                        ),
-                    );
-
-                    break;
-                },
-                // No {{produces}}, we can move on to the next example
-                Some(_) => break,
-                None => break 'outer,
-            }
-        }
-    }
-
-    *docs = cleanup_docs(&doc_lines);
-}
-
-fn get_lint_output(lint_name: &str, example: &[&mut String], clippy_project_root: &Path) -> String {
-    let dir = tempfile::tempdir().unwrap_or_else(|e| panic!("failed to create temp dir: {e}"));
-    let file = dir.path().join("lint_example.rs");
-
-    let mut source = String::new();
-    let unhidden = example
-        .iter()
-        .map(|line| line.trim_start().strip_prefix("# ").unwrap_or(line));
-
-    // Get any attributes
-    let mut lines = unhidden.peekable();
-    while let Some(line) = lines.peek() {
-        if line.starts_with("#!") {
-            source.push_str(line);
-            source.push('\n');
-            lines.next();
-        } else {
-            break;
-        }
-    }
-
-    let needs_main = !example.iter().any(|line| line.contains("fn main"));
-    if needs_main {
-        source.push_str("fn main() {\n");
-    }
-
-    for line in lines {
-        source.push_str(line);
-        source.push('\n');
-    }
-
-    if needs_main {
-        source.push_str("}\n");
-    }
-
-    if let Err(e) = fs::write(&file, &source) {
-        panic!("failed to write to `{}`: {e}", file.as_path().to_string_lossy());
-    }
-
-    let prefixed_name = format!("{CLIPPY_LINT_GROUP_PREFIX}{lint_name}");
-
-    let mut cmd = Command::new(env::var("CARGO").unwrap_or("cargo".into()));
-
-    cmd.current_dir(clippy_project_root)
-        .env("CARGO_INCREMENTAL", "0")
-        .env("CLIPPY_ARGS", "")
-        .env("CLIPPY_DISABLE_DOCS_LINKS", "1")
-        // We need to disable this to enable all lints
-        .env("ENABLE_METADATA_COLLECTION", "0")
-        .args(["run", "--bin", "clippy-driver"])
-        .args(["--target-dir", "./clippy_lints/target"])
-        .args(["--", "--error-format=json"])
-        .args(["--edition", "2021"])
-        .arg("-Cdebuginfo=0")
-        .args(["-A", "clippy::all"])
-        .args(["-W", &prefixed_name])
-        .args(["-L", "./target/debug"])
-        .args(["-Z", "no-codegen"]);
-
-    let output = cmd
-        .arg(file.as_path())
-        .output()
-        .unwrap_or_else(|e| panic!("failed to run `{cmd:?}`: {e}"));
-
-    let tmp_file_path = file.to_string_lossy();
-    let stderr = std::str::from_utf8(&output.stderr).unwrap();
-    let msgs = stderr
-        .lines()
-        .filter(|line| line.starts_with('{'))
-        .map(|line| serde_json::from_str(line).unwrap())
-        .collect::<Vec<serde_json::Value>>();
-
-    let mut rendered = String::new();
-    let iter = msgs
-        .iter()
-        .filter(|msg| matches!(&msg["code"]["code"], serde_json::Value::String(s) if s == &prefixed_name));
-
-    for message in iter {
-        let rendered_part = message["rendered"].as_str().expect("rendered field should exist");
-        rendered.push_str(rendered_part);
-    }
-
-    if rendered.is_empty() {
-        let rendered: Vec<&str> = msgs.iter().filter_map(|msg| msg["rendered"].as_str()).collect();
-        let non_json: Vec<&str> = stderr.lines().filter(|line| !line.starts_with('{')).collect();
-        panic!(
-            "did not find lint `{lint_name}` in output of example, got:\n{}\n{}",
-            non_json.join("\n"),
-            rendered.join("\n")
-        );
-    }
-
-    // The reader doesn't need to see `/tmp/.tmpfiy2Qd/lint_example.rs` :)
-    rendered.trim_end().replace(&*tmp_file_path, "lint_example.rs")
-}
-
-#[derive(Debug, Clone, Serialize, PartialEq, Eq, PartialOrd, Ord)]
-struct SerializableSpan {
-    path: String,
-    line: usize,
-}
-
-impl fmt::Display for SerializableSpan {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}:{}", self.path.rsplit('/').next().unwrap_or_default(), self.line)
-    }
-}
-
-impl SerializableSpan {
-    fn from_item(cx: &LateContext<'_>, item: &Item<'_>) -> Self {
-        Self::from_span(cx, item.ident.span)
-    }
-
-    fn from_span(cx: &LateContext<'_>, span: Span) -> Self {
-        let loc: Loc = cx.sess().source_map().lookup_char_pos(span.lo());
-
-        Self {
-            path: format!("{}", loc.file.name.prefer_remapped_unconditionaly()),
-            line: loc.line,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, PartialOrd, Ord)]
-struct ApplicabilityInfo {
-    /// Indicates if any of the lint emissions uses multiple spans. This is related to
-    /// [rustfix#141](https://github.com/rust-lang/rustfix/issues/141) as such suggestions can
-    /// currently not be applied automatically.
-    is_multi_part_suggestion: bool,
-    applicability: Option<usize>,
-}
-
-impl Serialize for ApplicabilityInfo {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let mut s = serializer.serialize_struct("ApplicabilityInfo", 2)?;
-        s.serialize_field("is_multi_part_suggestion", &self.is_multi_part_suggestion)?;
-        if let Some(index) = self.applicability {
-            s.serialize_field(
-                "applicability",
-                &paths::APPLICABILITY_VALUES[index][APPLICABILITY_NAME_INDEX],
-            )?;
-        } else {
-            s.serialize_field("applicability", APPLICABILITY_UNRESOLVED_STR)?;
-        }
-        s.end()
-    }
-}
-
-// ==================================================================
-// Lint pass
-// ==================================================================
-impl<'hir> LateLintPass<'hir> for MetadataCollector {
-    /// Collecting lint declarations like:
-    /// ```rust, ignore
-    /// declare_clippy_lint! {
-    ///     /// ### What it does
-    ///     /// Something IDK.
-    ///     pub SOME_LINT,
-    ///     internal,
-    ///     "Who am I?"
-    /// }
-    /// ```
-    fn check_item(&mut self, cx: &LateContext<'hir>, item: &'hir Item<'_>) {
-        if let ItemKind::Static(ty, Mutability::Not, _) = item.kind {
-            // Normal lint
-            if is_lint_ref_type(cx, ty)
-                // item validation
-                // disallow check
-                && let lint_name = sym_to_string(item.ident.name).to_ascii_lowercase()
-                // metadata extraction
-                && let Some((group, level)) = get_lint_group_and_level_or_lint(cx, &lint_name, item)
-                && let Some(mut raw_docs) = extract_attr_docs_or_lint(cx, item)
-            {
-                if let Some(configuration_section) = self.get_lint_configs(&lint_name) {
-                    raw_docs.push_str(&configuration_section);
-                }
-                let version = get_lint_version(cx, item);
-
-                self.lints.push(LintMetadata::new(
-                    lint_name,
-                    SerializableSpan::from_item(cx, item),
-                    group,
-                    level,
-                    version,
-                    raw_docs,
-                ));
-            }
-        }
-    }
-
-    /// Collecting constant applicability from the actual lint emissions
-    ///
-    /// Example:
-    /// ```rust, ignore
-    /// span_lint_and_sugg(
-    ///     cx,
-    ///     SOME_LINT,
-    ///     item.span,
-    ///     "Le lint message",
-    ///     "Here comes help:",
-    ///     "#![allow(clippy::all)]",
-    ///     Applicability::MachineApplicable, // <-- Extracts this constant value
-    /// );
-    /// ```
-    fn check_expr(&mut self, cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>) {
-        if let Some(args) = match_lint_emission(cx, expr) {
-            let emission_info = extract_emission_info(cx, args);
-            if emission_info.is_empty() {
-                // See:
-                // - src/misc.rs:734:9
-                // - src/methods/mod.rs:3545:13
-                // - src/methods/mod.rs:3496:13
-                // We are basically unable to resolve the lint name itself.
-                return;
-            }
-
-            for (lint_name, applicability, is_multi_part) in emission_info {
-                let app_info = self.applicability_info.entry(lint_name).or_default();
-                app_info.applicability = applicability;
-                app_info.is_multi_part_suggestion = is_multi_part;
-            }
-        }
-    }
-}
-
-// ==================================================================
-// Lint definition extraction
-// ==================================================================
-fn sym_to_string(sym: Symbol) -> String {
-    sym.as_str().to_string()
-}
-
-fn extract_attr_docs_or_lint(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
-    extract_attr_docs(cx, item).or_else(|| {
-        lint_collection_error_item(cx, item, "could not collect the lint documentation");
-        None
-    })
-}
-
-/// This function collects all documentation that has been added to an item using
-/// `#[doc = r""]` attributes. Several attributes are aggravated using line breaks
-///
-/// ```ignore
-/// #[doc = r"Hello world!"]
-/// #[doc = r"=^.^="]
-/// struct SomeItem {}
-/// ```
-///
-/// Would result in `Hello world!\n=^.^=\n`
-fn extract_attr_docs(cx: &LateContext<'_>, item: &Item<'_>) -> Option<String> {
-    let attrs = cx.tcx.hir().attrs(item.hir_id());
-    let mut lines = attrs.iter().filter_map(ast::Attribute::doc_str);
-
-    if let Some(line) = lines.next() {
-        let raw_docs = lines.fold(String::from(line.as_str()) + "\n", |s, line| s + line.as_str() + "\n");
-        return Some(raw_docs);
-    }
-
-    None
-}
-
-/// This function may modify the doc comment to ensure that the string can be displayed using a
-/// markdown viewer in Clippy's lint list. The following modifications could be applied:
-/// * Removal of leading space after a new line. (Important to display tables)
-/// * Ensures that code blocks only contain language information
-fn cleanup_docs(docs_collection: &Vec<String>) -> String {
-    let mut in_code_block = false;
-    let mut is_code_block_rust = false;
-
-    let mut docs = String::new();
-    for line in docs_collection {
-        // Rustdoc hides code lines starting with `# ` and this removes them from Clippy's lint list :)
-        if is_code_block_rust && line.trim_start().starts_with("# ") {
-            continue;
-        }
-
-        // The line should be represented in the lint list, even if it's just an empty line
-        docs.push('\n');
-        if let Some(info) = line.trim_start().strip_prefix("```") {
-            in_code_block = !in_code_block;
-            is_code_block_rust = false;
-            if in_code_block {
-                let lang = info
-                    .trim()
-                    .split(',')
-                    // remove rustdoc directives
-                    .find(|&s| !matches!(s, "" | "ignore" | "no_run" | "should_panic" | "compile_fail"))
-                    // if no language is present, fill in "rust"
-                    .unwrap_or("rust");
-                let len_diff = line
-                    .strip_prefix(' ')
-                    .map_or(0, |line| line.len() - line.trim_start().len());
-                if len_diff != 0 {
-                    // We put back the indentation.
-                    docs.push_str(&line[..len_diff]);
-                }
-                docs.push_str("```");
-                docs.push_str(lang);
-
-                is_code_block_rust = lang == "rust";
-                continue;
-            }
-        }
-        // This removes the leading space that the macro translation introduces
-        if let Some(stripped_doc) = line.strip_prefix(' ') {
-            docs.push_str(stripped_doc);
-        } else if !line.is_empty() {
-            docs.push_str(line);
-        }
-    }
-
-    docs
-}
-
-fn get_lint_version(cx: &LateContext<'_>, item: &Item<'_>) -> String {
-    extract_clippy_version_value(cx, item).map_or_else(
-        || VERSION_DEFAULT_STR.to_string(),
-        |version| version.as_str().to_string(),
-    )
-}
-
-fn get_lint_group_and_level_or_lint(
-    cx: &LateContext<'_>,
-    lint_name: &str,
-    item: &Item<'_>,
-) -> Option<(String, &'static str)> {
-    let result = unerased_lint_store(cx.tcx.sess).check_lint_name(
-        lint_name,
-        Some(sym::clippy),
-        &std::iter::once(Ident::with_dummy_span(sym::clippy)).collect(),
-    );
-    if let CheckLintNameResult::Tool(lint_lst, None) = result {
-        if let Some(group) = get_lint_group(cx, lint_lst[0]) {
-            if EXCLUDED_LINT_GROUPS.contains(&group.as_str()) {
-                return None;
-            }
-
-            if let Some(level) = get_lint_level_from_group(&group) {
-                Some((group, level))
-            } else {
-                lint_collection_error_item(
-                    cx,
-                    item,
-                    &format!("Unable to determine lint level for found group `{group}`"),
-                );
-                None
-            }
-        } else {
-            lint_collection_error_item(cx, item, "Unable to determine lint group");
-            None
-        }
-    } else {
-        lint_collection_error_item(cx, item, "Unable to find lint in lint_store");
-        None
-    }
-}
-
-fn get_lint_group(cx: &LateContext<'_>, lint_id: LintId) -> Option<String> {
-    for (group_name, lints, _) in unerased_lint_store(cx.tcx.sess).get_lint_groups() {
-        if IGNORED_LINT_GROUPS.contains(&group_name) {
-            continue;
-        }
-
-        if lints.iter().any(|group_lint| *group_lint == lint_id) {
-            let group = group_name.strip_prefix(CLIPPY_LINT_GROUP_PREFIX).unwrap_or(group_name);
-            return Some((*group).to_string());
-        }
-    }
-
-    None
-}
-
-fn get_lint_level_from_group(lint_group: &str) -> Option<&'static str> {
-    DEFAULT_LINT_LEVELS
-        .iter()
-        .find_map(|(group_name, group_level)| (*group_name == lint_group).then_some(*group_level))
-}
-
-fn collect_renames(lints: &mut Vec<LintMetadata>) {
-    for lint in lints {
-        let mut collected = String::new();
-        let mut names = vec![lint.id.clone()];
-
-        loop {
-            if let Some(lint_name) = names.pop() {
-                for (k, v) in crate::deprecated_lints::RENAMED {
-                    if let Some(name) = v.strip_prefix(CLIPPY_LINT_GROUP_PREFIX)
-                        && name == lint_name
-                        && let Some(past_name) = k.strip_prefix(CLIPPY_LINT_GROUP_PREFIX)
-                    {
-                        lint.former_ids.insert(past_name.to_owned());
-                        writeln!(collected, "* `{past_name}`").unwrap();
-                        names.push(past_name.to_string());
-                    }
-                }
-
-                continue;
-            }
-
-            break;
-        }
-
-        if !collected.is_empty() {
-            write!(
-                &mut lint.docs,
-                r#"
-### Past names
-
-{collected}
-"#
-            )
-            .unwrap();
-        }
-    }
-}
-
-// ==================================================================
-// Lint emission
-// ==================================================================
-fn lint_collection_error_item(cx: &LateContext<'_>, item: &Item<'_>, message: &str) {
-    span_lint(
-        cx,
-        METADATA_COLLECTOR,
-        item.ident.span,
-        format!("metadata collection error for `{}`: {message}", item.ident.name),
-    );
-}
-
-// ==================================================================
-// Applicability
-// ==================================================================
-/// This function checks if a given expression is equal to a simple lint emission function call.
-/// It will return the function arguments if the emission matched any function.
-fn match_lint_emission<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'_>) -> Option<&'hir [hir::Expr<'hir>]> {
-    LINT_EMISSION_FUNCTIONS
-        .iter()
-        .find_map(|emission_fn| match_function_call(cx, expr, emission_fn))
-}
-
-fn take_higher_applicability(a: Option<usize>, b: Option<usize>) -> Option<usize> {
-    a.map_or(b, |a| a.max(b.unwrap_or_default()).into())
-}
-
-fn extract_emission_info<'hir>(
-    cx: &LateContext<'hir>,
-    args: &'hir [hir::Expr<'hir>],
-) -> Vec<(String, Option<usize>, bool)> {
-    let mut lints = Vec::new();
-    let mut applicability = None;
-    let mut multi_part = false;
-
-    for arg in args {
-        let (arg_ty, _) = walk_ptrs_ty_depth(cx.typeck_results().expr_ty(arg));
-
-        if match_type(cx, arg_ty, &paths::LINT) {
-            // If we found the lint arg, extract the lint name
-            let mut resolved_lints = resolve_lints(cx, arg);
-            lints.append(&mut resolved_lints);
-        } else if match_type(cx, arg_ty, &paths::APPLICABILITY) {
-            applicability = resolve_applicability(cx, arg);
-        } else if arg_ty.is_closure() {
-            multi_part |= check_is_multi_part(cx, arg);
-            applicability = applicability.or_else(|| resolve_applicability(cx, arg));
-        }
-    }
-
-    lints
-        .into_iter()
-        .map(|lint_name| (lint_name, applicability, multi_part))
-        .collect()
-}
-
-/// Resolves the possible lints that this expression could reference
-fn resolve_lints<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Vec<String> {
-    let mut resolver = LintResolver::new(cx);
-    resolver.visit_expr(expr);
-    resolver.lints
-}
-
-/// This function tries to resolve the linked applicability to the given expression.
-fn resolve_applicability<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<usize> {
-    let mut resolver = ApplicabilityResolver::new(cx);
-    resolver.visit_expr(expr);
-    resolver.complete()
-}
-
-fn check_is_multi_part<'hir>(cx: &LateContext<'hir>, closure_expr: &'hir hir::Expr<'hir>) -> bool {
-    if let ExprKind::Closure(&Closure { body, .. }) = closure_expr.kind {
-        let mut scanner = IsMultiSpanScanner::new(cx);
-        intravisit::walk_body(&mut scanner, cx.tcx.hir().body(body));
-        return scanner.is_multi_part();
-    } else if let Some(local) = get_parent_local(cx, closure_expr) {
-        if let Some(local_init) = local.init {
-            return check_is_multi_part(cx, local_init);
-        }
-    }
-
-    false
-}
-
-struct LintResolver<'a, 'hir> {
-    cx: &'a LateContext<'hir>,
-    lints: Vec<String>,
-}
-
-impl<'a, 'hir> LintResolver<'a, 'hir> {
-    fn new(cx: &'a LateContext<'hir>) -> Self {
-        Self {
-            cx,
-            lints: Vec::<String>::default(),
-        }
-    }
-}
-
-impl<'a, 'hir> Visitor<'hir> for LintResolver<'a, 'hir> {
-    type NestedFilter = nested_filter::All;
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-
-    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-        if let ExprKind::Path(qpath) = &expr.kind
-            && let QPath::Resolved(_, path) = qpath
-            && let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr))
-            && match_type(self.cx, expr_ty, &paths::LINT)
-        {
-            if let hir::def::Res::Def(DefKind::Static { .. }, _) = path.res {
-                let lint_name = last_path_segment(qpath).ident.name;
-                self.lints.push(sym_to_string(lint_name).to_ascii_lowercase());
-            } else if let Some(local) = get_parent_local(self.cx, expr) {
-                if let Some(local_init) = local.init {
-                    intravisit::walk_expr(self, local_init);
-                }
-            }
-        }
-
-        intravisit::walk_expr(self, expr);
-    }
-}
-
-/// This visitor finds the highest applicability value in the visited expressions
-struct ApplicabilityResolver<'a, 'hir> {
-    cx: &'a LateContext<'hir>,
-    /// This is the index of highest `Applicability` for `paths::APPLICABILITY_VALUES`
-    applicability_index: Option<usize>,
-}
-
-impl<'a, 'hir> ApplicabilityResolver<'a, 'hir> {
-    fn new(cx: &'a LateContext<'hir>) -> Self {
-        Self {
-            cx,
-            applicability_index: None,
-        }
-    }
-
-    fn add_new_index(&mut self, new_index: usize) {
-        self.applicability_index = take_higher_applicability(self.applicability_index, Some(new_index));
-    }
-
-    fn complete(self) -> Option<usize> {
-        self.applicability_index
-    }
-}
-
-impl<'a, 'hir> Visitor<'hir> for ApplicabilityResolver<'a, 'hir> {
-    type NestedFilter = nested_filter::All;
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-
-    fn visit_path(&mut self, path: &hir::Path<'hir>, _id: hir::HirId) {
-        for (index, enum_value) in paths::APPLICABILITY_VALUES.iter().enumerate() {
-            if match_path(path, enum_value) {
-                self.add_new_index(index);
-                return;
-            }
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-        let (expr_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(expr));
-
-        if match_type(self.cx, expr_ty, &paths::APPLICABILITY)
-            && let Some(local) = get_parent_local(self.cx, expr)
-            && let Some(local_init) = local.init
-        {
-            intravisit::walk_expr(self, local_init);
-        };
-
-        intravisit::walk_expr(self, expr);
-    }
-}
-
-/// This returns the parent local node if the expression is a reference one
-fn get_parent_local<'hir>(cx: &LateContext<'hir>, expr: &'hir hir::Expr<'hir>) -> Option<&'hir hir::LetStmt<'hir>> {
-    if let ExprKind::Path(QPath::Resolved(_, path)) = expr.kind {
-        if let hir::def::Res::Local(local_hir) = path.res {
-            return get_parent_local_hir_id(cx, local_hir);
-        }
-    }
-
-    None
-}
-
-fn get_parent_local_hir_id<'hir>(cx: &LateContext<'hir>, hir_id: hir::HirId) -> Option<&'hir hir::LetStmt<'hir>> {
-    match cx.tcx.parent_hir_node(hir_id) {
-        hir::Node::LetStmt(local) => Some(local),
-        hir::Node::Pat(pattern) => get_parent_local_hir_id(cx, pattern.hir_id),
-        _ => None,
-    }
-}
-
-/// This visitor finds the highest applicability value in the visited expressions
-struct IsMultiSpanScanner<'a, 'hir> {
-    cx: &'a LateContext<'hir>,
-    suggestion_count: usize,
-}
-
-impl<'a, 'hir> IsMultiSpanScanner<'a, 'hir> {
-    fn new(cx: &'a LateContext<'hir>) -> Self {
-        Self {
-            cx,
-            suggestion_count: 0,
-        }
-    }
-
-    /// Add a new single expression suggestion to the counter
-    fn add_single_span_suggestion(&mut self) {
-        self.suggestion_count += 1;
-    }
-
-    /// Signals that a suggestion with possible multiple spans was found
-    fn add_multi_part_suggestion(&mut self) {
-        self.suggestion_count += 2;
-    }
-
-    /// Checks if the suggestions include multiple spans
-    fn is_multi_part(&self) -> bool {
-        self.suggestion_count > 1
-    }
-}
-
-impl<'a, 'hir> Visitor<'hir> for IsMultiSpanScanner<'a, 'hir> {
-    type NestedFilter = nested_filter::All;
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-
-    fn visit_expr(&mut self, expr: &'hir hir::Expr<'hir>) {
-        // Early return if the lint is already multi span
-        if self.is_multi_part() {
-            return;
-        }
-
-        if let ExprKind::MethodCall(path, recv, _, _arg_span) = &expr.kind {
-            let (self_ty, _) = walk_ptrs_ty_depth(self.cx.typeck_results().expr_ty(recv));
-            if match_type(self.cx, self_ty, &paths::DIAG) {
-                let called_method = path.ident.name.as_str().to_string();
-                for (method_name, is_multi_part) in &SUGGESTION_DIAG_METHODS {
-                    if *method_name == called_method {
-                        if *is_multi_part {
-                            self.add_multi_part_suggestion();
-                        } else {
-                            self.add_single_span_suggestion();
-                        }
-                        break;
-                    }
-                }
-            }
-        }
-
-        intravisit::walk_expr(self, expr);
-    }
-}
diff --git a/declare_clippy_lint/src/lib.rs b/declare_clippy_lint/src/lib.rs
index ca070f6c250bf..fd366b6b26277 100644
--- a/declare_clippy_lint/src/lib.rs
+++ b/declare_clippy_lint/src/lib.rs
@@ -1,4 +1,4 @@
-#![feature(let_chains)]
+#![feature(let_chains, proc_macro_span)]
 // warn on lints, that are included in `rust-lang/rust`s bootstrap
 #![warn(rust_2018_idioms, unused_lifetimes)]
 
@@ -23,6 +23,7 @@ fn parse_attr<const LEN: usize>(path: [&'static str; LEN], attr: &Attribute) ->
 
 struct ClippyLint {
     attrs: Vec<Attribute>,
+    version: Option<LitStr>,
     explanation: String,
     name: Ident,
     category: Ident,
@@ -41,8 +42,14 @@ impl Parse for ClippyLint {
                 let value = lit.value();
                 let line = value.strip_prefix(' ').unwrap_or(&value);
 
-                if line.starts_with("```") {
-                    explanation += "```\n";
+                if let Some(lang) = line.strip_prefix("```") {
+                    let tag = lang.split_once(',').map_or(lang, |(left, _)| left);
+                    if !in_code && matches!(tag, "" | "rust" | "ignore" | "should_panic" | "no_run" | "compile_fail") {
+                        explanation += "```rust\n";
+                    } else {
+                        explanation += line;
+                        explanation.push('\n');
+                    }
                     in_code = !in_code;
                 } else if !(in_code && line.starts_with("# ")) {
                     explanation += line;
@@ -68,6 +75,7 @@ impl Parse for ClippyLint {
 
         Ok(Self {
             attrs,
+            version,
             explanation,
             name,
             category,
@@ -123,6 +131,7 @@ impl Parse for ClippyLint {
 pub fn declare_clippy_lint(input: TokenStream) -> TokenStream {
     let ClippyLint {
         attrs,
+        version,
         explanation,
         name,
         category,
@@ -146,6 +155,14 @@ pub fn declare_clippy_lint(input: TokenStream) -> TokenStream {
     (&mut category[0..1]).make_ascii_uppercase();
     let category_variant = format_ident!("{category}");
 
+    let name_span = name.span().unwrap();
+    let location = format!("{}#{}", name_span.source_file().path().display(), name_span.line());
+
+    let version = match version {
+        Some(version) => quote!(Some(#version)),
+        None => quote!(None),
+    };
+
     let output = quote! {
         rustc_session::declare_tool_lint! {
             #(#attrs)*
@@ -159,6 +176,8 @@ pub fn declare_clippy_lint(input: TokenStream) -> TokenStream {
             lint: &#name,
             category: crate::LintCategory::#category_variant,
             explanation: #explanation,
+            location: #location,
+            version: #version,
         };
     };
 
diff --git a/tests/compile-test.rs b/tests/compile-test.rs
index c7080e5dcdc9e..9754254cdd0df 100644
--- a/tests/compile-test.rs
+++ b/tests/compile-test.rs
@@ -1,22 +1,31 @@
+#![feature(rustc_private, let_chains)]
 #![warn(rust_2018_idioms, unused_lifetimes)]
 #![allow(unused_extern_crates)]
 
+use cargo_metadata::diagnostic::{Applicability, Diagnostic};
+use cargo_metadata::Message;
+use clippy_config::ClippyConfiguration;
+use clippy_lints::declared_lints::LINTS;
+use clippy_lints::deprecated_lints::{DEPRECATED, DEPRECATED_VERSION, RENAMED};
+use clippy_lints::LintInfo;
+use serde::{Deserialize, Serialize};
+use test_utils::IS_RUSTC_TEST_SUITE;
 use ui_test::custom_flags::rustfix::RustfixMode;
+use ui_test::custom_flags::Flag;
 use ui_test::spanned::Spanned;
+use ui_test::test_result::TestRun;
 use ui_test::{status_emitter, Args, CommandBuilder, Config, Match, OutputConflictHandling};
 
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 use std::env::{self, set_var, var_os};
 use std::ffi::{OsStr, OsString};
-use std::fs;
+use std::fmt::Write;
 use std::path::{Path, PathBuf};
-use std::sync::LazyLock;
-use test_utils::IS_RUSTC_TEST_SUITE;
+use std::sync::mpsc::{channel, Sender};
+use std::{fs, iter, thread};
 
 // Test dependencies may need an `extern crate` here to ensure that they show up
 // in the depinfo file (otherwise cargo thinks they are unused)
-extern crate clippy_lints;
-extern crate clippy_utils;
 extern crate futures;
 extern crate if_chain;
 extern crate itertools;
@@ -52,7 +61,7 @@ static TEST_DEPENDENCIES: &[&str] = &[
 /// dependencies must be added to Cargo.toml at the project root. Test
 /// dependencies that are not *directly* used by this test module require an
 /// `extern crate` declaration.
-static EXTERN_FLAGS: LazyLock<Vec<String>> = LazyLock::new(|| {
+fn extern_flags() -> Vec<String> {
     let current_exe_depinfo = {
         let mut path = env::current_exe().unwrap();
         path.set_extension("d");
@@ -100,70 +109,93 @@ static EXTERN_FLAGS: LazyLock<Vec<String>> = LazyLock::new(|| {
         .into_iter()
         .map(|(name, path)| format!("--extern={name}={path}"))
         .collect()
-});
+}
 
 // whether to run internal tests or not
 const RUN_INTERNAL_TESTS: bool = cfg!(feature = "internal");
 
-fn base_config(test_dir: &str) -> (Config, Args) {
-    let mut args = Args::test().unwrap();
-    args.bless |= var_os("RUSTC_BLESS").is_some_and(|v| v != "0");
-
-    let target_dir = PathBuf::from(var_os("CARGO_TARGET_DIR").unwrap_or_else(|| "target".into()));
-    let mut config = Config {
-        output_conflict_handling: OutputConflictHandling::Error,
-        filter_files: env::var("TESTNAME")
-            .map(|filters| filters.split(',').map(str::to_string).collect())
-            .unwrap_or_default(),
-        target: None,
-        bless_command: Some("cargo uibless".into()),
-        out_dir: target_dir.join("ui_test"),
-        ..Config::rustc(Path::new("tests").join(test_dir))
-    };
-    config.comment_defaults.base().exit_status = None.into();
-    config.comment_defaults.base().require_annotations = None.into();
-    config
-        .comment_defaults
-        .base()
-        .set_custom("rustfix", RustfixMode::Everything);
-    config.comment_defaults.base().diagnostic_code_prefix = Some(Spanned::dummy("clippy::".into())).into();
-    config.with_args(&args);
-    let current_exe_path = env::current_exe().unwrap();
-    let deps_path = current_exe_path.parent().unwrap();
-    let profile_path = deps_path.parent().unwrap();
-
-    config.program.args.extend(
-        [
-            "--emit=metadata",
-            "-Aunused",
-            "-Ainternal_features",
-            "-Zui-testing",
-            "-Zdeduplicate-diagnostics=no",
-            "-Dwarnings",
-            &format!("-Ldependency={}", deps_path.display()),
-        ]
-        .map(OsString::from),
-    );
-
-    config.program.args.extend(EXTERN_FLAGS.iter().map(OsString::from));
-    // Prevent rustc from creating `rustc-ice-*` files the console output is enough.
-    config.program.envs.push(("RUSTC_ICE".into(), Some("0".into())));
+struct TestContext {
+    args: Args,
+    extern_flags: Vec<String>,
+    diagnostic_collector: Option<DiagnosticCollector>,
+    collector_thread: Option<thread::JoinHandle<()>>,
+}
 
-    if let Some(host_libs) = option_env!("HOST_LIBS") {
-        let dep = format!("-Ldependency={}", Path::new(host_libs).join("deps").display());
-        config.program.args.push(dep.into());
+impl TestContext {
+    fn new() -> Self {
+        let mut args = Args::test().unwrap();
+        args.bless |= var_os("RUSTC_BLESS").is_some_and(|v| v != "0");
+        let (diagnostic_collector, collector_thread) = var_os("COLLECT_METADATA")
+            .is_some()
+            .then(DiagnosticCollector::spawn)
+            .unzip();
+        Self {
+            args,
+            extern_flags: extern_flags(),
+            diagnostic_collector,
+            collector_thread,
+        }
     }
 
-    config.program.program = profile_path.join(if cfg!(windows) {
-        "clippy-driver.exe"
-    } else {
-        "clippy-driver"
-    });
-    (config, args)
+    fn base_config(&self, test_dir: &str) -> Config {
+        let target_dir = PathBuf::from(var_os("CARGO_TARGET_DIR").unwrap_or_else(|| "target".into()));
+        let mut config = Config {
+            output_conflict_handling: OutputConflictHandling::Error,
+            filter_files: env::var("TESTNAME")
+                .map(|filters| filters.split(',').map(str::to_string).collect())
+                .unwrap_or_default(),
+            target: None,
+            bless_command: Some("cargo uibless".into()),
+            out_dir: target_dir.join("ui_test"),
+            ..Config::rustc(Path::new("tests").join(test_dir))
+        };
+        let defaults = config.comment_defaults.base();
+        defaults.exit_status = None.into();
+        defaults.require_annotations = None.into();
+        defaults.diagnostic_code_prefix = Some(Spanned::dummy("clippy::".into())).into();
+        defaults.set_custom("rustfix", RustfixMode::Everything);
+        if let Some(collector) = self.diagnostic_collector.clone() {
+            defaults.set_custom("diagnostic-collector", collector);
+        }
+        config.with_args(&self.args);
+        let current_exe_path = env::current_exe().unwrap();
+        let deps_path = current_exe_path.parent().unwrap();
+        let profile_path = deps_path.parent().unwrap();
+
+        config.program.args.extend(
+            [
+                "--emit=metadata",
+                "-Aunused",
+                "-Ainternal_features",
+                "-Zui-testing",
+                "-Zdeduplicate-diagnostics=no",
+                "-Dwarnings",
+                &format!("-Ldependency={}", deps_path.display()),
+            ]
+            .map(OsString::from),
+        );
+
+        config.program.args.extend(self.extern_flags.iter().map(OsString::from));
+        // Prevent rustc from creating `rustc-ice-*` files the console output is enough.
+        config.program.envs.push(("RUSTC_ICE".into(), Some("0".into())));
+
+        if let Some(host_libs) = option_env!("HOST_LIBS") {
+            let dep = format!("-Ldependency={}", Path::new(host_libs).join("deps").display());
+            config.program.args.push(dep.into());
+        }
+
+        config.program.program = profile_path.join(if cfg!(windows) {
+            "clippy-driver.exe"
+        } else {
+            "clippy-driver"
+        });
+
+        config
+    }
 }
 
-fn run_ui() {
-    let (mut config, args) = base_config("ui");
+fn run_ui(cx: &TestContext) {
+    let mut config = cx.base_config("ui");
     config
         .program
         .envs
@@ -173,30 +205,29 @@ fn run_ui() {
         vec![config],
         ui_test::default_file_filter,
         ui_test::default_per_file_config,
-        status_emitter::Text::from(args.format),
+        status_emitter::Text::from(cx.args.format),
     )
     .unwrap();
 }
 
-fn run_internal_tests() {
-    // only run internal tests with the internal-tests feature
+fn run_internal_tests(cx: &TestContext) {
     if !RUN_INTERNAL_TESTS {
         return;
     }
-    let (mut config, args) = base_config("ui-internal");
+    let mut config = cx.base_config("ui-internal");
     config.bless_command = Some("cargo uitest --features internal -- -- --bless".into());
 
     ui_test::run_tests_generic(
         vec![config],
         ui_test::default_file_filter,
         ui_test::default_per_file_config,
-        status_emitter::Text::from(args.format),
+        status_emitter::Text::from(cx.args.format),
     )
     .unwrap();
 }
 
-fn run_ui_toml() {
-    let (mut config, args) = base_config("ui-toml");
+fn run_ui_toml(cx: &TestContext) {
+    let mut config = cx.base_config("ui-toml");
 
     config
         .comment_defaults
@@ -214,19 +245,19 @@ fn run_ui_toml() {
                 .envs
                 .push(("CLIPPY_CONF_DIR".into(), Some(path.parent().unwrap().into())));
         },
-        status_emitter::Text::from(args.format),
+        status_emitter::Text::from(cx.args.format),
     )
     .unwrap();
 }
 
 // Allow `Default::default` as `OptWithSpan` is not nameable
 #[allow(clippy::default_trait_access)]
-fn run_ui_cargo() {
+fn run_ui_cargo(cx: &TestContext) {
     if IS_RUSTC_TEST_SUITE {
         return;
     }
 
-    let (mut config, args) = base_config("ui-cargo");
+    let mut config = cx.base_config("ui-cargo");
     config.program.input_file_flag = CommandBuilder::cargo().input_file_flag;
     config.program.out_dir_flag = CommandBuilder::cargo().out_dir_flag;
     config.program.args = vec!["clippy".into(), "--color".into(), "never".into(), "--quiet".into()];
@@ -261,23 +292,25 @@ fn run_ui_cargo() {
                 .then(|| ui_test::default_any_file_filter(path, config) && !ignored_32bit(path))
         },
         |_config, _file_contents| {},
-        status_emitter::Text::from(args.format),
+        status_emitter::Text::from(cx.args.format),
     )
     .unwrap();
 }
 
 fn main() {
     set_var("CLIPPY_DISABLE_DOCS_LINKS", "true");
+
+    let cx = TestContext::new();
+
     // The SPEEDTEST_* env variables can be used to check Clippy's performance on your PR. It runs the
     // affected test 1000 times and gets the average.
     if let Ok(speedtest) = std::env::var("SPEEDTEST") {
         println!("----------- STARTING SPEEDTEST -----------");
         let f = match speedtest.as_str() {
-            "ui" => run_ui as fn(),
-            "cargo" => run_ui_cargo as fn(),
-            "toml" => run_ui_toml as fn(),
-            "internal" => run_internal_tests as fn(),
-            "ui-cargo-toml-metadata" => ui_cargo_toml_metadata as fn(),
+            "ui" => run_ui,
+            "cargo" => run_ui_cargo,
+            "toml" => run_ui_toml,
+            "internal" => run_internal_tests,
 
             _ => panic!("unknown speedtest: {speedtest} || accepted speedtests are: [ui, cargo, toml, internal]"),
         };
@@ -294,7 +327,7 @@ fn main() {
         let mut sum = 0;
         for _ in 0..iterations {
             let start = std::time::Instant::now();
-            f();
+            f(&cx);
             sum += start.elapsed().as_millis();
         }
         println!(
@@ -303,11 +336,17 @@ fn main() {
             sum / u128::from(iterations)
         );
     } else {
-        run_ui();
-        run_ui_toml();
-        run_ui_cargo();
-        run_internal_tests();
+        run_ui(&cx);
+        run_ui_toml(&cx);
+        run_ui_cargo(&cx);
+        run_internal_tests(&cx);
+        drop(cx.diagnostic_collector);
+
         ui_cargo_toml_metadata();
+
+        if let Some(thread) = cx.collector_thread {
+            thread.join().unwrap();
+        }
     }
 }
 
@@ -346,3 +385,180 @@ fn ui_cargo_toml_metadata() {
         );
     }
 }
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum DiagnosticOrMessage {
+    Diagnostic(Diagnostic),
+    Message(Message),
+}
+
+/// Collects applicabilities from the diagnostics produced for each UI test, producing the
+/// `util/gh-pages/lints.json` file used by <https://rust-lang.github.io/rust-clippy/>
+#[derive(Debug, Clone)]
+struct DiagnosticCollector {
+    sender: Sender<Vec<u8>>,
+}
+
+impl DiagnosticCollector {
+    #[allow(clippy::assertions_on_constants)]
+    fn spawn() -> (Self, thread::JoinHandle<()>) {
+        assert!(!IS_RUSTC_TEST_SUITE && !RUN_INTERNAL_TESTS);
+
+        let (sender, receiver) = channel::<Vec<u8>>();
+
+        let handle = thread::spawn(|| {
+            let mut applicabilities = HashMap::new();
+
+            for stderr in receiver {
+                for line in stderr.split(|&byte| byte == b'\n') {
+                    let diag = match serde_json::from_slice(line) {
+                        Ok(DiagnosticOrMessage::Diagnostic(diag)) => diag,
+                        Ok(DiagnosticOrMessage::Message(Message::CompilerMessage(message))) => message.message,
+                        _ => continue,
+                    };
+
+                    if let Some(lint) = diag.code.as_ref().and_then(|code| code.code.strip_prefix("clippy::")) {
+                        let applicability = applicabilities
+                            .entry(lint.to_string())
+                            .or_insert(Applicability::Unspecified);
+                        let diag_applicability = diag
+                            .children
+                            .iter()
+                            .flat_map(|child| &child.spans)
+                            .filter_map(|span| span.suggestion_applicability.clone())
+                            .max_by_key(applicability_ord);
+                        if let Some(diag_applicability) = diag_applicability
+                            && applicability_ord(&diag_applicability) > applicability_ord(applicability)
+                        {
+                            *applicability = diag_applicability;
+                        }
+                    }
+                }
+            }
+
+            let configs = clippy_config::get_configuration_metadata();
+            let mut metadata: Vec<LintMetadata> = LINTS
+                .iter()
+                .map(|lint| LintMetadata::new(lint, &applicabilities, &configs))
+                .chain(
+                    iter::zip(DEPRECATED, DEPRECATED_VERSION)
+                        .map(|((lint, reason), version)| LintMetadata::new_deprecated(lint, reason, version)),
+                )
+                .collect();
+            metadata.sort_unstable_by(|a, b| a.id.cmp(&b.id));
+
+            let json = serde_json::to_string_pretty(&metadata).unwrap();
+            fs::write("util/gh-pages/lints.json", json).unwrap();
+        });
+
+        (Self { sender }, handle)
+    }
+}
+
+fn applicability_ord(applicability: &Applicability) -> u8 {
+    match applicability {
+        Applicability::MachineApplicable => 4,
+        Applicability::HasPlaceholders => 3,
+        Applicability::MaybeIncorrect => 2,
+        Applicability::Unspecified => 1,
+        _ => unimplemented!(),
+    }
+}
+
+impl Flag for DiagnosticCollector {
+    fn post_test_action(
+        &self,
+        _config: &ui_test::per_test_config::TestConfig<'_>,
+        _cmd: &mut std::process::Command,
+        output: &std::process::Output,
+        _build_manager: &ui_test::build_manager::BuildManager<'_>,
+    ) -> Result<Vec<TestRun>, ui_test::Errored> {
+        if !output.stderr.is_empty() {
+            self.sender.send(output.stderr.clone()).unwrap();
+        }
+        Ok(Vec::new())
+    }
+
+    fn clone_inner(&self) -> Box<dyn Flag> {
+        Box::new(self.clone())
+    }
+
+    fn must_be_unique(&self) -> bool {
+        true
+    }
+}
+
+#[derive(Debug, Serialize)]
+struct LintMetadata {
+    id: String,
+    id_location: Option<&'static str>,
+    group: &'static str,
+    level: &'static str,
+    docs: String,
+    version: &'static str,
+    applicability: Applicability,
+}
+
+impl LintMetadata {
+    fn new(lint: &LintInfo, applicabilities: &HashMap<String, Applicability>, configs: &[ClippyConfiguration]) -> Self {
+        let name = lint.name_lower();
+        let applicability = applicabilities
+            .get(&name)
+            .cloned()
+            .unwrap_or(Applicability::Unspecified);
+        let past_names = RENAMED
+            .iter()
+            .filter(|(_, new_name)| new_name.strip_prefix("clippy::") == Some(&name))
+            .map(|(old_name, _)| old_name.strip_prefix("clippy::").unwrap())
+            .collect::<Vec<_>>();
+        let mut docs = lint.explanation.to_string();
+        if !past_names.is_empty() {
+            docs.push_str("\n### Past names\n\n");
+            for past_name in past_names {
+                writeln!(&mut docs, " * {past_name}").unwrap();
+            }
+        }
+        let configs: Vec<_> = configs
+            .iter()
+            .filter(|conf| conf.lints.contains(&name.as_str()))
+            .collect();
+        if !configs.is_empty() {
+            docs.push_str("\n### Configuration\n\n");
+            for config in configs {
+                writeln!(&mut docs, "{config}").unwrap();
+            }
+        }
+        Self {
+            id: name,
+            id_location: Some(lint.location),
+            group: lint.category_str(),
+            level: lint.lint.default_level.as_str(),
+            docs,
+            version: lint.version.unwrap(),
+            applicability,
+        }
+    }
+
+    fn new_deprecated(name: &str, reason: &str, version: &'static str) -> Self {
+        // The reason starts with a lowercase letter and ends without a period.
+        // This needs to be fixed for the website.
+        let mut reason = reason.to_owned();
+        if let Some(reason) = reason.get_mut(0..1) {
+            reason.make_ascii_uppercase();
+        }
+        Self {
+            id: name.strip_prefix("clippy::").unwrap().into(),
+            id_location: None,
+            group: "deprecated",
+            level: "none",
+            version,
+            docs: format!(
+                "### What it does\n\n\
+                Nothing. This lint has been deprecated\n\n\
+                ### Deprecation reason\n\n{reason}.\n",
+            ),
+            applicability: Applicability::Unspecified,
+        }
+    }
+}
diff --git a/tests/config-metadata.rs b/tests/config-metadata.rs
new file mode 100644
index 0000000000000..c0b048270601a
--- /dev/null
+++ b/tests/config-metadata.rs
@@ -0,0 +1,76 @@
+use clippy_config::{get_configuration_metadata, ClippyConfiguration};
+use itertools::Itertools;
+use regex::Regex;
+use std::borrow::Cow;
+use std::{env, fs};
+
+fn metadata() -> impl Iterator<Item = ClippyConfiguration> {
+    get_configuration_metadata()
+        .into_iter()
+        .filter(|config| config.deprecation_reason.is_none())
+        .filter(|config| !config.lints.is_empty())
+}
+
+#[test]
+fn book() {
+    let path = "book/src/lint_configuration.md";
+    let current = fs::read_to_string(path).unwrap();
+
+    let configs = metadata().map(|conf| conf.to_markdown_paragraph()).join("\n");
+    let expected = format!(
+        r#"<!--
+This file is generated by `cargo bless --test config-metadata`.
+Please use that command to update the file and do not edit it by hand.
+-->
+
+# Lint Configuration Options
+
+The following list shows each configuration option, along with a description, its default value, an example
+and lints affected.
+
+---
+
+{}
+"#,
+        configs.trim(),
+    );
+
+    if current != expected {
+        if env::var_os("RUSTC_BLESS").is_some_and(|v| v != "0") {
+            fs::write(path, expected).unwrap();
+        } else {
+            panic!("`{path}` is out of date, run `cargo bless --test config-metadata` to update it");
+        }
+    }
+}
+
+#[test]
+fn changelog() {
+    let path = "CHANGELOG.md";
+    let current = fs::read_to_string(path).unwrap();
+
+    let configs = metadata().map(|conf| conf.to_markdown_link()).join("\n");
+
+    let re = Regex::new(
+        "(?s)\
+        (<!-- begin autogenerated links to configuration documentation -->)\
+        .*\
+        (<!-- end autogenerated links to configuration documentation -->)\
+        ",
+    )
+    .unwrap();
+    let expected = re.replace(&current, format!("$1\n{configs}\n$2"));
+
+    assert!(
+        matches!(expected, Cow::Owned(_)),
+        "failed to find configuration section in `{path}`"
+    );
+
+    if current != expected {
+        if env::var_os("RUSTC_BLESS").is_some_and(|v| v != "0") {
+            fs::write(path, expected.as_bytes()).unwrap();
+        } else {
+            panic!("`{path}` is out of date, run `cargo bless --test config-metadata` to update it");
+        }
+    }
+}
diff --git a/util/gh-pages/index.html b/util/gh-pages/index.html
index dd58fa2282c64..f3d7e504fdf80 100644
--- a/util/gh-pages/index.html
+++ b/util/gh-pages/index.html
@@ -239,7 +239,7 @@ <h2 class="panel-title">
                         <!-- Applicability -->
                         <div class="lint-additional-info-item">
                             <span> Applicability: </span>
-                            <span class="label label-default label-applicability">{{lint.applicability.applicability}}</span>
+                            <span class="label label-default label-applicability">{{lint.applicability}}</span>
                             <a href="https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint_defs/enum.Applicability.html#variants">(?)</a>
                         </div>
                         <!-- Clippy version -->
@@ -252,8 +252,8 @@ <h2 class="panel-title">
                             <a href="https://github.com/rust-lang/rust-clippy/issues?q=is%3Aissue+{{lint.id}}">Related Issues</a>
                         </div>
                         <!-- Jump to source -->
-                        <div class="lint-additional-info-item" ng-if="lint.id_span">
-                            <a href="https://github.com/rust-lang/rust-clippy/blob/{{docVersion}}/clippy_lints/{{lint.id_span.path}}#L{{lint.id_span.line}}">View Source</a>
+                        <div class="lint-additional-info-item" ng-if="lint.id_location">
+                            <a href="https://github.com/rust-lang/rust-clippy/blob/{{docVersion}}/{{lint.id_location}}">View Source</a>
                         </div>
                     </div>
                 </div>
diff --git a/util/gh-pages/script.js b/util/gh-pages/script.js
index d54b5e851c7c0..1a5330bc0e571 100644
--- a/util/gh-pages/script.js
+++ b/util/gh-pages/script.js
@@ -96,13 +96,13 @@
                 cargo: true,
                 complexity: true,
                 correctness: true,
-                deprecated: false,
                 nursery: true,
                 pedantic: true,
                 perf: true,
                 restriction: true,
                 style: true,
                 suspicious: true,
+                deprecated: false,
             }
 
             $scope.groups = {
@@ -126,11 +126,10 @@
             );
 
             const APPLICABILITIES_FILTER_DEFAULT = {
-                Unspecified: true,
-                Unresolved: true,
                 MachineApplicable: true,
                 MaybeIncorrect: true,
-                HasPlaceholders: true
+                HasPlaceholders: true,
+                Unspecified: true,
             };
 
             $scope.applicabilities = {
@@ -425,7 +424,7 @@
             }
 
             $scope.byApplicabilities = function (lint) {
-                return $scope.applicabilities[lint.applicability.applicability];
+                return $scope.applicabilities[lint.applicability];
             };
 
             // Show details for one lint

From a22ce2d00578bfdfbb079d8bacf626c2789d4b5a Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Mon, 12 Aug 2024 16:25:14 +0000
Subject: [PATCH 162/685] Remove `HashSet`s from `Conf`

---
 book/src/lint_configuration.md                |  4 ++--
 clippy_config/src/conf.rs                     | 23 +++++++++----------
 clippy_config/src/lib.rs                      |  1 -
 clippy_lints/src/cargo/mod.rs                 |  6 ++---
 clippy_lints/src/doc/mod.rs                   |  6 ++---
 clippy_lints/src/min_ident_chars.rs           |  4 ++--
 .../src/operators/arithmetic_side_effects.rs  |  2 +-
 clippy_lints/src/wildcard_imports.rs          |  6 ++---
 8 files changed, 25 insertions(+), 27 deletions(-)

diff --git a/book/src/lint_configuration.md b/book/src/lint_configuration.md
index 4f23afe2e118a..78348797588a6 100644
--- a/book/src/lint_configuration.md
+++ b/book/src/lint_configuration.md
@@ -199,7 +199,7 @@ Allowed names below the minimum allowed characters. The value `".."` can be used
 the list to indicate, that the configured values should be appended to the default
 configuration of Clippy. By default, any configuration will replace the default value.
 
-**Default Value:** `["j", "z", "i", "y", "n", "x", "w"]`
+**Default Value:** `["i", "j", "x", "y", "z", "w", "n"]`
 
 ---
 **Affected lints:**
@@ -455,7 +455,7 @@ default configuration of Clippy. By default, any configuration will replace the
 * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
 * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
 
-**Default Value:** `["TiB", "CoreGraphics", "CoffeeScript", "TeX", "Direct2D", "PiB", "DirectX", "NetBSD", "OAuth", "NaN", "OpenType", "WebGL2", "WebTransport", "JavaScript", "OpenSSL", "OpenSSH", "EiB", "PureScript", "OpenAL", "MiB", "WebAssembly", "MinGW", "CoreFoundation", "WebGPU", "ClojureScript", "CamelCase", "OpenDNS", "NaNs", "OpenMP", "GitLab", "KiB", "sRGB", "CoreText", "macOS", "TypeScript", "GiB", "OpenExr", "YCbCr", "OpenTelemetry", "OpenBSD", "FreeBSD", "GPLv2", "PostScript", "WebP", "LaTeX", "TensorFlow", "AccessKit", "TrueType", "OpenStreetMap", "OpenGL", "DevOps", "OCaml", "WebRTC", "WebGL", "BibLaTeX", "GitHub", "GraphQL", "iOS", "Direct3D", "BibTeX", "DirectWrite", "GPLv3", "IPv6", "WebSocket", "IPv4", "ECMAScript"]`
+**Default Value:** `["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "AccessKit", "CoreFoundation", "CoreGraphics", "CoreText", "DevOps", "Direct2D", "Direct3D", "DirectWrite", "DirectX", "ECMAScript", "GPLv2", "GPLv3", "GitHub", "GitLab", "IPv4", "IPv6", "ClojureScript", "CoffeeScript", "JavaScript", "PostScript", "PureScript", "TypeScript", "WebAssembly", "NaN", "NaNs", "OAuth", "GraphQL", "OCaml", "OpenAL", "OpenDNS", "OpenGL", "OpenMP", "OpenSSH", "OpenSSL", "OpenStreetMap", "OpenTelemetry", "OpenType", "WebGL", "WebGL2", "WebGPU", "WebRTC", "WebSocket", "WebTransport", "WebP", "OpenExr", "YCbCr", "sRGB", "TensorFlow", "TrueType", "iOS", "macOS", "FreeBSD", "NetBSD", "OpenBSD", "TeX", "LaTeX", "BibTeX", "BibLaTeX", "MinGW", "CamelCase"]`
 
 ---
 **Affected lints:**
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
index 4c2a8255d6b65..a6f1b958bfb17 100644
--- a/clippy_config/src/conf.rs
+++ b/clippy_config/src/conf.rs
@@ -1,7 +1,6 @@
 use crate::msrvs::Msrv;
 use crate::types::{DisallowedPath, MacroMatcher, MatchLintBehaviour, PubUnderscoreFieldsBehaviour, Rename};
 use crate::ClippyConfiguration;
-use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_session::Session;
 use rustc_span::edit_distance::edit_distance;
@@ -218,7 +217,7 @@ macro_rules! define_Conf {
 define_Conf! {
     /// Which crates to allow absolute paths from
     #[lints(absolute_paths)]
-    absolute_paths_allowed_crates: FxHashSet<String> = FxHashSet::default(),
+    absolute_paths_allowed_crates: Vec<String> = Vec::new(),
     /// The maximum number of segments a path can have before being linted, anything above this will
     /// be linted.
     #[lints(absolute_paths)]
@@ -280,12 +279,12 @@ define_Conf! {
     allowed_dotfiles: Vec<String> = Vec::default(),
     /// A list of crate names to allow duplicates of
     #[lints(multiple_crate_versions)]
-    allowed_duplicate_crates: FxHashSet<String> = FxHashSet::default(),
+    allowed_duplicate_crates: Vec<String> = Vec::new(),
     /// Allowed names below the minimum allowed characters. The value `".."` can be used as part of
     /// the list to indicate, that the configured values should be appended to the default
     /// configuration of Clippy. By default, any configuration will replace the default value.
     #[lints(min_ident_chars)]
-    allowed_idents_below_min_chars: FxHashSet<String> =
+    allowed_idents_below_min_chars: Vec<String> =
         DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string).collect(),
     /// List of prefixes to allow when determining whether an item's name ends with the module's name.
     /// If the rest of an item's name is an allowed prefix (e.g. item `ToFoo` or `to_foo` in module `foo`),
@@ -323,7 +322,7 @@ define_Conf! {
     /// 2. Paths with any segment that containing the word 'prelude'
     /// are already allowed by default.
     #[lints(wildcard_imports)]
-    allowed_wildcard_imports: FxHashSet<String> = FxHashSet::default(),
+    allowed_wildcard_imports: Vec<String> = Vec::new(),
     /// Suppress checking of the passed type names in all types of operations.
     ///
     /// If a specific operation is desired, consider using `arithmetic_side_effects_allowed_binary` or `arithmetic_side_effects_allowed_unary` instead.
@@ -355,7 +354,7 @@ define_Conf! {
     /// arithmetic-side-effects-allowed-binary = [["SomeType" , "f32"], ["AnotherType", "*"]]
     /// ```
     #[lints(arithmetic_side_effects)]
-    arithmetic_side_effects_allowed_binary: Vec<[String; 2]> = <_>::default(),
+    arithmetic_side_effects_allowed_binary: Vec<(String, String)> = <_>::default(),
     /// Suppress checking of the passed type names in unary operations like "negation" (`-`).
     ///
     /// #### Example
@@ -431,7 +430,7 @@ define_Conf! {
     /// * `doc-valid-idents = ["ClipPy"]` would replace the default list with `["ClipPy"]`.
     /// * `doc-valid-idents = ["ClipPy", ".."]` would append `ClipPy` to the default list.
     #[lints(doc_markdown)]
-    doc_valid_idents: FxHashSet<String> = DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect(),
+    doc_valid_idents: Vec<String> = DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string).collect(),
     /// Whether to apply the raw pointer heuristic to determine if a type is `Send`.
     #[lints(non_send_fields_in_send_ty)]
     enable_raw_pointer_heuristic_for_send: bool = true,
@@ -706,12 +705,12 @@ fn deserialize(file: &SourceFile) -> TryConf {
                 DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS,
             );
             // TODO: THIS SHOULD BE TESTED, this comment will be gone soon
-            if conf.conf.allowed_idents_below_min_chars.contains("..") {
+            if conf.conf.allowed_idents_below_min_chars.iter().any(|e| e == "..") {
                 conf.conf
                     .allowed_idents_below_min_chars
                     .extend(DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS.iter().map(ToString::to_string));
             }
-            if conf.conf.doc_valid_idents.contains("..") {
+            if conf.conf.doc_valid_idents.iter().any(|e| e == "..") {
                 conf.conf
                     .doc_valid_idents
                     .extend(DEFAULT_DOC_VALID_IDENTS.iter().map(ToString::to_string));
@@ -890,14 +889,14 @@ fn calculate_dimensions(fields: &[&str]) -> (usize, Vec<usize>) {
 
 #[cfg(test)]
 mod tests {
-    use rustc_data_structures::fx::{FxHashMap, FxHashSet};
     use serde::de::IgnoredAny;
+    use std::collections::{HashMap, HashSet};
     use std::fs;
     use walkdir::WalkDir;
 
     #[test]
     fn configs_are_tested() {
-        let mut names: FxHashSet<String> = crate::get_configuration_metadata()
+        let mut names: HashSet<String> = crate::get_configuration_metadata()
             .into_iter()
             .map(|meta| meta.name.replace('_', "-"))
             .collect();
@@ -910,7 +909,7 @@ mod tests {
         for entry in toml_files {
             let file = fs::read_to_string(entry.path()).unwrap();
             #[allow(clippy::zero_sized_map_values)]
-            if let Ok(map) = toml::from_str::<FxHashMap<String, IgnoredAny>>(&file) {
+            if let Ok(map) = toml::from_str::<HashMap<String, IgnoredAny>>(&file) {
                 for name in map.keys() {
                     names.remove(name.as_str());
                 }
diff --git a/clippy_config/src/lib.rs b/clippy_config/src/lib.rs
index 3afe599c7b6e4..ac838cc81d2f0 100644
--- a/clippy_config/src/lib.rs
+++ b/clippy_config/src/lib.rs
@@ -15,7 +15,6 @@
 
 extern crate rustc_ast;
 extern crate rustc_attr;
-extern crate rustc_data_structures;
 #[allow(unused_extern_crates)]
 extern crate rustc_driver;
 extern crate rustc_errors;
diff --git a/clippy_lints/src/cargo/mod.rs b/clippy_lints/src/cargo/mod.rs
index 312ad4c299007..96a2b1614646e 100644
--- a/clippy_lints/src/cargo/mod.rs
+++ b/clippy_lints/src/cargo/mod.rs
@@ -205,7 +205,7 @@ declare_clippy_lint! {
 }
 
 pub struct Cargo {
-    allowed_duplicate_crates: &'static FxHashSet<String>,
+    allowed_duplicate_crates: FxHashSet<String>,
     ignore_publish: bool,
 }
 
@@ -221,7 +221,7 @@ impl_lint_pass!(Cargo => [
 impl Cargo {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            allowed_duplicate_crates: &conf.allowed_duplicate_crates,
+            allowed_duplicate_crates: conf.allowed_duplicate_crates.iter().cloned().collect(),
             ignore_publish: conf.cargo_ignore_publish,
         }
     }
@@ -263,7 +263,7 @@ impl LateLintPass<'_> for Cargo {
         {
             match MetadataCommand::new().exec() {
                 Ok(metadata) => {
-                    multiple_crate_versions::check(cx, &metadata, self.allowed_duplicate_crates);
+                    multiple_crate_versions::check(cx, &metadata, &self.allowed_duplicate_crates);
                 },
                 Err(e) => {
                     for lint in WITH_DEPS_LINTS {
diff --git a/clippy_lints/src/doc/mod.rs b/clippy_lints/src/doc/mod.rs
index 762d5595e145e..daea0d18e4060 100644
--- a/clippy_lints/src/doc/mod.rs
+++ b/clippy_lints/src/doc/mod.rs
@@ -423,14 +423,14 @@ declare_clippy_lint! {
 }
 
 pub struct Documentation {
-    valid_idents: &'static FxHashSet<String>,
+    valid_idents: FxHashSet<String>,
     check_private_items: bool,
 }
 
 impl Documentation {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            valid_idents: &conf.doc_valid_idents,
+            valid_idents: conf.doc_valid_idents.iter().cloned().collect(),
             check_private_items: conf.check_private_items,
         }
     }
@@ -452,7 +452,7 @@ impl_lint_pass!(Documentation => [
 
 impl<'tcx> LateLintPass<'tcx> for Documentation {
     fn check_attributes(&mut self, cx: &LateContext<'tcx>, attrs: &'tcx [Attribute]) {
-        let Some(headers) = check_attrs(cx, self.valid_idents, attrs) else {
+        let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else {
             return;
         };
 
diff --git a/clippy_lints/src/min_ident_chars.rs b/clippy_lints/src/min_ident_chars.rs
index 53fa444e93c40..c83e5198c2748 100644
--- a/clippy_lints/src/min_ident_chars.rs
+++ b/clippy_lints/src/min_ident_chars.rs
@@ -41,14 +41,14 @@ declare_clippy_lint! {
 impl_lint_pass!(MinIdentChars => [MIN_IDENT_CHARS]);
 
 pub struct MinIdentChars {
-    allowed_idents_below_min_chars: &'static FxHashSet<String>,
+    allowed_idents_below_min_chars: FxHashSet<String>,
     min_ident_chars_threshold: u64,
 }
 
 impl MinIdentChars {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            allowed_idents_below_min_chars: &conf.allowed_idents_below_min_chars,
+            allowed_idents_below_min_chars: conf.allowed_idents_below_min_chars.iter().cloned().collect(),
             min_ident_chars_threshold: conf.min_ident_chars_threshold,
         }
     }
diff --git a/clippy_lints/src/operators/arithmetic_side_effects.rs b/clippy_lints/src/operators/arithmetic_side_effects.rs
index bc71a4790b9d4..8b9f899d82d3f 100644
--- a/clippy_lints/src/operators/arithmetic_side_effects.rs
+++ b/clippy_lints/src/operators/arithmetic_side_effects.rs
@@ -35,7 +35,7 @@ impl ArithmeticSideEffects {
             ("f64", FxHashSet::from_iter(["f64"])),
             ("std::string::String", FxHashSet::from_iter(["str"])),
         ]);
-        for [lhs, rhs] in &conf.arithmetic_side_effects_allowed_binary {
+        for (lhs, rhs) in &conf.arithmetic_side_effects_allowed_binary {
             allowed_binary.entry(lhs).or_default().insert(rhs);
         }
         for s in &conf.arithmetic_side_effects_allowed {
diff --git a/clippy_lints/src/wildcard_imports.rs b/clippy_lints/src/wildcard_imports.rs
index c4d64ee4609ee..7d9e58ad2f8d5 100644
--- a/clippy_lints/src/wildcard_imports.rs
+++ b/clippy_lints/src/wildcard_imports.rs
@@ -100,14 +100,14 @@ declare_clippy_lint! {
 
 pub struct WildcardImports {
     warn_on_all: bool,
-    allowed_segments: &'static FxHashSet<String>,
+    allowed_segments: FxHashSet<String>,
 }
 
 impl WildcardImports {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
             warn_on_all: conf.warn_on_all_wildcard_imports,
-            allowed_segments: &conf.allowed_wildcard_imports,
+            allowed_segments: conf.allowed_wildcard_imports.iter().cloned().collect(),
         }
     }
 }
@@ -181,7 +181,7 @@ impl WildcardImports {
     fn check_exceptions(&self, cx: &LateContext<'_>, item: &Item<'_>, segments: &[PathSegment<'_>]) -> bool {
         item.span.from_expansion()
             || is_prelude_import(segments)
-            || is_allowed_via_config(segments, self.allowed_segments)
+            || is_allowed_via_config(segments, &self.allowed_segments)
             || (is_super_only_import(segments) && is_in_test(cx.tcx, item.hir_id()))
     }
 }

From 5534cb0a4a3907db50956f7664ab2e5c3b2bc00a Mon Sep 17 00:00:00 2001
From: Ding Xiang Fei <dingxiangfei2009@protonmail.ch>
Date: Sat, 10 Aug 2024 21:11:07 +0800
Subject: [PATCH 163/685] derive(SmartPointer): register helper attributes

---
 compiler/rustc_feature/src/builtin_attrs.rs   |  6 ---
 library/core/src/marker.rs                    |  2 +-
 .../deriving/auxiliary/another-proc-macro.rs  | 45 +++++++++++++++++++
 .../ui/deriving/built-in-proc-macro-scope.rs  | 25 +++++++++++
 .../deriving/built-in-proc-macro-scope.stdout | 43 ++++++++++++++++++
 .../deriving/proc-macro-attribute-mixing.rs   | 20 +++++++++
 .../proc-macro-attribute-mixing.stdout        | 30 +++++++++++++
 .../feature-gate-derive-smart-pointer.rs      |  1 -
 .../feature-gate-derive-smart-pointer.stderr  | 12 +----
 9 files changed, 165 insertions(+), 19 deletions(-)
 create mode 100644 tests/ui/deriving/auxiliary/another-proc-macro.rs
 create mode 100644 tests/ui/deriving/built-in-proc-macro-scope.rs
 create mode 100644 tests/ui/deriving/built-in-proc-macro-scope.stdout
 create mode 100644 tests/ui/deriving/proc-macro-attribute-mixing.rs
 create mode 100644 tests/ui/deriving/proc-macro-attribute-mixing.stdout

diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 72ea55d5999a2..bb0e989bd812a 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -578,12 +578,6 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         EncodeCrossCrate::No, coroutines, experimental!(coroutines)
     ),
 
-    // `#[pointee]` attribute to designate the pointee type in SmartPointer derive-macro
-    gated!(
-        pointee, Normal, template!(Word), ErrorFollowing,
-        EncodeCrossCrate::No, derive_smart_pointer, experimental!(pointee)
-    ),
-
     // RFC 3543
     // `#[patchable_function_entry(prefix_nops = m, entry_nops = n)]`
     gated!(
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 6a83ec2eb1e0e..374fa086aecb7 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -1060,7 +1060,7 @@ pub trait FnPtr: Copy + Clone {
 }
 
 /// Derive macro generating impls of traits related to smart pointers.
-#[rustc_builtin_macro]
+#[rustc_builtin_macro(SmartPointer, attributes(pointee))]
 #[allow_internal_unstable(dispatch_from_dyn, coerce_unsized, unsize)]
 #[unstable(feature = "derive_smart_pointer", issue = "123430")]
 pub macro SmartPointer($item:item) {
diff --git a/tests/ui/deriving/auxiliary/another-proc-macro.rs b/tests/ui/deriving/auxiliary/another-proc-macro.rs
new file mode 100644
index 0000000000000..a05175c9de926
--- /dev/null
+++ b/tests/ui/deriving/auxiliary/another-proc-macro.rs
@@ -0,0 +1,45 @@
+//@ force-host
+//@ no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+#![feature(proc_macro_quote)]
+
+extern crate proc_macro;
+
+use proc_macro::{quote, TokenStream};
+
+#[proc_macro_derive(AnotherMacro, attributes(pointee))]
+pub fn derive(_input: TokenStream) -> TokenStream {
+    quote! {
+        const _: () = {
+            const ANOTHER_MACRO_DERIVED: () = ();
+        };
+    }
+    .into()
+}
+
+#[proc_macro_attribute]
+pub fn pointee(
+    _attr: proc_macro::TokenStream,
+    _item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    quote! {
+        const _: () = {
+            const POINTEE_MACRO_ATTR_DERIVED: () = ();
+        };
+    }
+    .into()
+}
+
+#[proc_macro_attribute]
+pub fn default(
+    _attr: proc_macro::TokenStream,
+    _item: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    quote! {
+        const _: () = {
+            const DEFAULT_MACRO_ATTR_DERIVED: () = ();
+        };
+    }
+    .into()
+}
diff --git a/tests/ui/deriving/built-in-proc-macro-scope.rs b/tests/ui/deriving/built-in-proc-macro-scope.rs
new file mode 100644
index 0000000000000..41c95f63b135e
--- /dev/null
+++ b/tests/ui/deriving/built-in-proc-macro-scope.rs
@@ -0,0 +1,25 @@
+//@ check-pass
+//@ aux-build: another-proc-macro.rs
+//@ compile-flags: -Zunpretty=expanded
+
+#![feature(derive_smart_pointer)]
+
+#[macro_use]
+extern crate another_proc_macro;
+
+use another_proc_macro::{pointee, AnotherMacro};
+
+#[derive(core::marker::SmartPointer)]
+#[repr(transparent)]
+pub struct Ptr<'a, #[pointee] T: ?Sized> {
+    data: &'a mut T,
+}
+
+#[pointee]
+fn f() {}
+
+#[derive(AnotherMacro)]
+#[pointee]
+struct MyStruct;
+
+fn main() {}
diff --git a/tests/ui/deriving/built-in-proc-macro-scope.stdout b/tests/ui/deriving/built-in-proc-macro-scope.stdout
new file mode 100644
index 0000000000000..c649b7a9a574c
--- /dev/null
+++ b/tests/ui/deriving/built-in-proc-macro-scope.stdout
@@ -0,0 +1,43 @@
+#![feature(prelude_import)]
+#![no_std]
+//@ check-pass
+//@ aux-build: another-proc-macro.rs
+//@ compile-flags: -Zunpretty=expanded
+
+#![feature(derive_smart_pointer)]
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+#[macro_use]
+extern crate std;
+
+#[macro_use]
+extern crate another_proc_macro;
+
+use another_proc_macro::{pointee, AnotherMacro};
+
+#[repr(transparent)]
+pub struct Ptr<'a, #[pointee] T: ?Sized> {
+    data: &'a mut T,
+}
+#[automatically_derived]
+impl<'a, T: ?Sized + ::core::marker::Unsize<__S>, __S: ?Sized>
+    ::core::ops::DispatchFromDyn<Ptr<'a, __S>> for Ptr<'a, T> {
+}
+#[automatically_derived]
+impl<'a, T: ?Sized + ::core::marker::Unsize<__S>, __S: ?Sized>
+    ::core::ops::CoerceUnsized<Ptr<'a, __S>> for Ptr<'a, T> {
+}
+
+
+
+const _: () =
+    {
+        const POINTEE_MACRO_ATTR_DERIVED: () = ();
+    };
+#[pointee]
+struct MyStruct;
+const _: () =
+    {
+        const ANOTHER_MACRO_DERIVED: () = ();
+    };
+fn main() {}
diff --git a/tests/ui/deriving/proc-macro-attribute-mixing.rs b/tests/ui/deriving/proc-macro-attribute-mixing.rs
new file mode 100644
index 0000000000000..489665ebeb520
--- /dev/null
+++ b/tests/ui/deriving/proc-macro-attribute-mixing.rs
@@ -0,0 +1,20 @@
+// This test certify that we can mix attribute macros from Rust and external proc-macros.
+// For instance, `#[derive(Default)]` uses `#[default]` and `#[derive(SmartPointer)]` uses
+// `#[pointee]`.
+// The scoping rule should allow the use of the said two attributes when external proc-macros
+// are in scope.
+
+//@ check-pass
+//@ aux-build: another-proc-macro.rs
+//@ compile-flags: -Zunpretty=expanded
+
+#![feature(derive_smart_pointer)]
+
+#[macro_use]
+extern crate another_proc_macro;
+
+#[pointee]
+fn f() {}
+
+#[default]
+fn g() {}
diff --git a/tests/ui/deriving/proc-macro-attribute-mixing.stdout b/tests/ui/deriving/proc-macro-attribute-mixing.stdout
new file mode 100644
index 0000000000000..f314f6efbe2b9
--- /dev/null
+++ b/tests/ui/deriving/proc-macro-attribute-mixing.stdout
@@ -0,0 +1,30 @@
+#![feature(prelude_import)]
+#![no_std]
+// This test certify that we can mix attribute macros from Rust and external proc-macros.
+// For instance, `#[derive(Default)]` uses `#[default]` and `#[derive(SmartPointer)]` uses
+// `#[pointee]`.
+// The scoping rule should allow the use of the said two attributes when external proc-macros
+// are in scope.
+
+//@ check-pass
+//@ aux-build: another-proc-macro.rs
+//@ compile-flags: -Zunpretty=expanded
+
+#![feature(derive_smart_pointer)]
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+#[macro_use]
+extern crate std;
+
+#[macro_use]
+extern crate another_proc_macro;
+
+
+const _: () =
+    {
+        const POINTEE_MACRO_ATTR_DERIVED: () = ();
+    };
+const _: () =
+    {
+        const DEFAULT_MACRO_ATTR_DERIVED: () = ();
+    };
diff --git a/tests/ui/feature-gates/feature-gate-derive-smart-pointer.rs b/tests/ui/feature-gates/feature-gate-derive-smart-pointer.rs
index 3257a9ca624ba..7b4764ee768ab 100644
--- a/tests/ui/feature-gates/feature-gate-derive-smart-pointer.rs
+++ b/tests/ui/feature-gates/feature-gate-derive-smart-pointer.rs
@@ -3,7 +3,6 @@ use std::marker::SmartPointer; //~ ERROR use of unstable library feature 'derive
 #[derive(SmartPointer)] //~ ERROR use of unstable library feature 'derive_smart_pointer'
 #[repr(transparent)]
 struct MyPointer<'a, #[pointee] T: ?Sized> {
-    //~^ ERROR the `#[pointee]` attribute is an experimental feature
     ptr: &'a T,
 }
 
diff --git a/tests/ui/feature-gates/feature-gate-derive-smart-pointer.stderr b/tests/ui/feature-gates/feature-gate-derive-smart-pointer.stderr
index 19501939dc5be..ea4d1271b7c87 100644
--- a/tests/ui/feature-gates/feature-gate-derive-smart-pointer.stderr
+++ b/tests/ui/feature-gates/feature-gate-derive-smart-pointer.stderr
@@ -8,16 +8,6 @@ LL | #[derive(SmartPointer)]
    = help: add `#![feature(derive_smart_pointer)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: the `#[pointee]` attribute is an experimental feature
-  --> $DIR/feature-gate-derive-smart-pointer.rs:5:22
-   |
-LL | struct MyPointer<'a, #[pointee] T: ?Sized> {
-   |                      ^^^^^^^^^^
-   |
-   = note: see issue #123430 <https://github.com/rust-lang/rust/issues/123430> for more information
-   = help: add `#![feature(derive_smart_pointer)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
 error[E0658]: use of unstable library feature 'derive_smart_pointer'
   --> $DIR/feature-gate-derive-smart-pointer.rs:1:5
    |
@@ -28,6 +18,6 @@ LL | use std::marker::SmartPointer;
    = help: add `#![feature(derive_smart_pointer)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0658`.

From c4333026a008741e5edba4bca1aae77aecba8d78 Mon Sep 17 00:00:00 2001
From: burlinchen <chenbeiliuhuo@gmail.com>
Date: Tue, 13 Aug 2024 08:40:08 +0800
Subject: [PATCH 164/685] chore(lib): fmt core::fmt::Formatter's write_fmt
 method

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

diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index 8143ff4addcdd..6078a71cb69fd 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -1630,7 +1630,7 @@ impl<'a> Formatter<'a> {
     ///
     /// This method should generally not be invoked manually, but rather through
     /// the [`write!`] macro itself.
-    /// 
+    ///
     /// Writes some formatted information into this instance.
     ///
     /// # Examples

From 1c5e3c90cf2d6133210d801fc6b7ef0bcb115212 Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Mon, 12 Aug 2024 19:20:00 -0700
Subject: [PATCH 165/685] Rework MIR inlining debuginfo so function parameters
 show up in debuggers.

Line numbers of multiply-inlined functions were fixed in #114643 by using a
single DISubprogram. That, however, triggered assertions because parameters
weren't deduplicated. The "solution" to that in #115417 was to insert a
DILexicalScope below the DISubprogram and parent all of the parameters to that
scope. That fixed the assertion, but debuggers (including gdb and lldb) don't
recognize variables that are not parented to the subprogram itself as parameters,
even if they are emitted with DW_TAG_formal_parameter.

Consider the program:

use std::env;

fn square(n: i32) -> i32 {
    n * n
}

fn square_no_inline(n: i32) -> i32 {
    n * n
}

fn main() {
    let x = square(env::vars().count() as i32);
    let y = square_no_inline(env::vars().count() as i32);
    println!("{x} == {y}");
}

When making a release build with debug=2 and rustc 1.82.0-nightly (8b3870784 2024-08-07)

(gdb) r
Starting program: /ephemeral/tmp/target/release/tmp
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Breakpoint 1, tmp::square () at src/main.rs:5
5	    n * n
(gdb) info args
No arguments.
(gdb) info locals
n = 31
(gdb) c
Continuing.

Breakpoint 2, tmp::square_no_inline (n=31) at src/main.rs:10
10	    n * n
(gdb) info args
n = 31
(gdb) info locals
No locals.

This issue is particularly annoying because it removes arguments from stack traces.

The DWARF for the inlined function looks like this:

< 2><0x00002132 GOFF=0x00002132>      DW_TAG_subprogram
                                        DW_AT_linkage_name          _ZN3tmp6square17hc507052ff3d2a488E
                                        DW_AT_name                  square
                                        DW_AT_decl_file             0x0000000f /ephemeral/tmp/src/main.rs
                                        DW_AT_decl_line             0x00000004
                                        DW_AT_type                  0x00001a56<.debug_info+0x00001a56>
                                        DW_AT_inline                DW_INL_inlined
< 3><0x00002142 GOFF=0x00002142>        DW_TAG_lexical_block
< 4><0x00002143 GOFF=0x00002143>          DW_TAG_formal_parameter
                                            DW_AT_name                  n
                                            DW_AT_decl_file             0x0000000f /ephemeral/tmp/src/main.rs
                                            DW_AT_decl_line             0x00000004
                                            DW_AT_type                  0x00001a56<.debug_info+0x00001a56>
< 4><0x0000214e GOFF=0x0000214e>          DW_TAG_null
< 3><0x0000214f GOFF=0x0000214f>        DW_TAG_null

That DW_TAG_lexical_block inhibits every debugger I've tested from recognizing
'n' as a parameter.

This patch removes the additional lexical scope. Parameters can be easily
deduplicated by a tuple of their scope and the argument index, at the trivial
cost of taking a Hash + Eq bound on DIScope.
---
 .../src/debuginfo/create_scope_map.rs         | 22 +++++++++----------
 .../rustc_codegen_ssa/src/mir/debuginfo.rs    | 15 ++++++++++++-
 compiler/rustc_codegen_ssa/src/mir/mod.rs     |  2 +-
 .../rustc_codegen_ssa/src/traits/backend.rs   |  3 ++-
 .../debuginfo-inline-callsite-location.rs     |  9 ++++----
 .../inline-function-args-debug-info.rs        |  1 +
 6 files changed, 32 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs b/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs
index efe616838bfe4..0a02c230cfcf8 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs
@@ -88,7 +88,7 @@ fn make_mir_scope<'ll, 'tcx>(
     let loc = cx.lookup_debug_loc(scope_data.span.lo());
     let file_metadata = file_metadata(cx, &loc.file);
 
-    let parent_dbg_scope = match scope_data.inlined {
+    let dbg_scope = match scope_data.inlined {
         Some((callee, _)) => {
             // FIXME(eddyb) this would be `self.monomorphize(&callee)`
             // if this is moved to `rustc_codegen_ssa::mir::debuginfo`.
@@ -102,17 +102,15 @@ fn make_mir_scope<'ll, 'tcx>(
                 cx.dbg_scope_fn(callee, callee_fn_abi, None)
             })
         }
-        None => parent_scope.dbg_scope,
-    };
-
-    let dbg_scope = unsafe {
-        llvm::LLVMRustDIBuilderCreateLexicalBlock(
-            DIB(cx),
-            parent_dbg_scope,
-            file_metadata,
-            loc.line,
-            loc.col,
-        )
+        None => unsafe {
+            llvm::LLVMRustDIBuilderCreateLexicalBlock(
+                DIB(cx),
+                parent_scope.dbg_scope,
+                file_metadata,
+                loc.line,
+                loc.col,
+            )
+        },
     };
 
     let inlined_at = scope_data.inlined.map(|(_, callsite_span)| {
diff --git a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
index 0e495973a01d9..75692540c0345 100644
--- a/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/debuginfo.rs
@@ -1,3 +1,4 @@
+use std::collections::hash_map::Entry;
 use std::ops::Range;
 
 use rustc_data_structures::fx::FxHashMap;
@@ -447,6 +448,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         }
 
         let mut per_local = IndexVec::from_elem(vec![], &self.mir.local_decls);
+        let mut params_seen: FxHashMap<_, Bx::DIVariable> = Default::default();
         for var in &self.mir.var_debug_info {
             let dbg_scope_and_span = if full_debug_info {
                 self.adjusted_span_and_dbg_scope(var.source_info)
@@ -491,7 +493,18 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     VariableKind::LocalVariable
                 };
 
-                self.cx.create_dbg_var(var.name, var_ty, dbg_scope, var_kind, span)
+                if let VariableKind::ArgumentVariable(arg_index) = var_kind {
+                    match params_seen.entry((dbg_scope, arg_index)) {
+                        Entry::Occupied(o) => o.get().clone(),
+                        Entry::Vacant(v) => v
+                            .insert(
+                                self.cx.create_dbg_var(var.name, var_ty, dbg_scope, var_kind, span),
+                            )
+                            .clone(),
+                    }
+                } else {
+                    self.cx.create_dbg_var(var.name, var_ty, dbg_scope, var_kind, span)
+                }
             });
 
             let fragment = if let Some(ref fragment) = var.composite {
diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
index 4ce07269cd2c1..de94d87bcea7a 100644
--- a/compiler/rustc_codegen_ssa/src/mir/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -106,7 +106,7 @@ pub struct FunctionCx<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> {
     locals: locals::Locals<'tcx, Bx::Value>,
 
     /// All `VarDebugInfo` from the MIR body, partitioned by `Local`.
-    /// This is `None` if no var`#[non_exhaustive]`iable debuginfo/names are needed.
+    /// This is `None` if no variable debuginfo/names are needed.
     per_local_var_debug_info:
         Option<IndexVec<mir::Local, Vec<PerLocalVarDebugInfo<'tcx, Bx::DIVariable>>>>,
 
diff --git a/compiler/rustc_codegen_ssa/src/traits/backend.rs b/compiler/rustc_codegen_ssa/src/traits/backend.rs
index 81e96413a9f34..c5e2d55be833d 100644
--- a/compiler/rustc_codegen_ssa/src/traits/backend.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/backend.rs
@@ -1,4 +1,5 @@
 use std::any::Any;
+use std::hash::Hash;
 
 use rustc_ast::expand::allocator::AllocatorKind;
 use rustc_data_structures::fx::FxIndexMap;
@@ -30,7 +31,7 @@ pub trait BackendTypes {
 
     // FIXME(eddyb) find a common convention for all of the debuginfo-related
     // names (choose between `Dbg`, `Debug`, `DebugInfo`, `DI` etc.).
-    type DIScope: Copy;
+    type DIScope: Copy + Hash + PartialEq + Eq;
     type DILocation: Copy;
     type DIVariable: Copy;
 }
diff --git a/tests/codegen/debuginfo-inline-callsite-location.rs b/tests/codegen/debuginfo-inline-callsite-location.rs
index aee07b4eb8c68..c31788d82db32 100644
--- a/tests/codegen/debuginfo-inline-callsite-location.rs
+++ b/tests/codegen/debuginfo-inline-callsite-location.rs
@@ -9,13 +9,12 @@
 // CHECK:       tail call void @{{[A-Za-z0-9_]+4core6option13unwrap_failed}}
 // CHECK-SAME:  !dbg ![[#second_dbg:]]
 
-// CHECK-DAG:   ![[#func_dbg:]] = distinct !DISubprogram(name: "unwrap<i32>"
-// CHECK-DAG:   ![[#first_scope:]] = distinct !DILexicalBlock(scope: ![[#func_dbg]],
-// CHECK:       ![[#second_scope:]] = distinct !DILexicalBlock(scope: ![[#func_dbg]],
+// CHECK-DAG:   ![[#func_scope:]] = distinct !DISubprogram(name: "unwrap<i32>"
+// CHECK-DAG:   ![[#]] = !DILocalVariable(name: "self",{{( arg: 1,)?}} scope: ![[#func_scope]]
 // CHECK:       ![[#first_dbg]] = !DILocation(line: [[#]]
-// CHECK-SAME:  scope: ![[#first_scope]], inlinedAt: ![[#]])
+// CHECK-SAME:  scope: ![[#func_scope]], inlinedAt: ![[#]])
 // CHECK:       ![[#second_dbg]] = !DILocation(line: [[#]]
-// CHECK-SAME:  scope: ![[#second_scope]], inlinedAt: ![[#]])
+// CHECK-SAME:  scope: ![[#func_scope]], inlinedAt: ![[#]])
 
 #![crate_type = "lib"]
 
diff --git a/tests/codegen/inline-function-args-debug-info.rs b/tests/codegen/inline-function-args-debug-info.rs
index 7263374b22e11..53a179160dc38 100644
--- a/tests/codegen/inline-function-args-debug-info.rs
+++ b/tests/codegen/inline-function-args-debug-info.rs
@@ -15,6 +15,7 @@ pub fn outer_function(x: usize, y: usize) -> usize {
 fn inner_function(aaaa: usize, bbbb: usize) -> usize {
     // CHECK: !DILocalVariable(name: "aaaa", arg: 1
     // CHECK-SAME: line: 15
+    // CHECK-NOT: !DILexicalBlock(
     // CHECK: !DILocalVariable(name: "bbbb", arg: 2
     // CHECK-SAME: line: 15
     aaaa + bbbb

From 1e445f48d4d0880d4c158c3ae96be8f0d9ad2e02 Mon Sep 17 00:00:00 2001
From: Henry Sloan <henryksloan@gmail.com>
Date: Mon, 12 Aug 2024 18:48:03 -0700
Subject: [PATCH 166/685] Add must_use attribute to Coroutine trait

---
 library/core/src/ops/coroutine.rs | 1 +
 tests/ui/coroutine/issue-58888.rs | 5 +++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/library/core/src/ops/coroutine.rs b/library/core/src/ops/coroutine.rs
index 13df888d24c5c..c7d596d74c383 100644
--- a/library/core/src/ops/coroutine.rs
+++ b/library/core/src/ops/coroutine.rs
@@ -69,6 +69,7 @@ pub enum CoroutineState<Y, R> {
 #[lang = "coroutine"]
 #[unstable(feature = "coroutine_trait", issue = "43122")]
 #[fundamental]
+#[must_use = "coroutines are lazy and do nothing unless resumed"]
 pub trait Coroutine<R = ()> {
     /// The type of value this coroutine yields.
     ///
diff --git a/tests/ui/coroutine/issue-58888.rs b/tests/ui/coroutine/issue-58888.rs
index 6266f97ce8c46..e4fada0cd432e 100644
--- a/tests/ui/coroutine/issue-58888.rs
+++ b/tests/ui/coroutine/issue-58888.rs
@@ -13,7 +13,8 @@ impl Database {
     }
 
     fn check_connection(&self) -> impl Coroutine<Yield = (), Return = ()> + '_ {
-        #[coroutine] move || {
+        #[coroutine]
+        move || {
             let iter = self.get_connection();
             for i in iter {
                 yield i
@@ -23,5 +24,5 @@ impl Database {
 }
 
 fn main() {
-    Database.check_connection();
+    let _ = Database.check_connection();
 }

From c4aa7a71a9cf16a242530fc1c3aedffb8567cba3 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 13 Aug 2024 12:55:58 +1000
Subject: [PATCH 167/685] Port `run-make/libtest-json` to rmake

---
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 tests/run-make/libtest-json/Makefile          | 20 ------------
 .../run-make/libtest-json/output-default.json |  2 +-
 .../libtest-json/output-stdout-success.json   |  2 +-
 tests/run-make/libtest-json/rmake.rs          | 31 +++++++++++++++++++
 5 files changed, 33 insertions(+), 23 deletions(-)
 delete mode 100644 tests/run-make/libtest-json/Makefile
 create mode 100644 tests/run-make/libtest-json/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 14f0a9cd23d21..96ab097b3885e 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -9,7 +9,6 @@ run-make/incr-add-rust-src-component/Makefile
 run-make/issue-84395-lto-embed-bitcode/Makefile
 run-make/jobserver-error/Makefile
 run-make/libs-through-symlinks/Makefile
-run-make/libtest-json/Makefile
 run-make/libtest-junit/Makefile
 run-make/libtest-thread-limit/Makefile
 run-make/macos-deployment-target/Makefile
diff --git a/tests/run-make/libtest-json/Makefile b/tests/run-make/libtest-json/Makefile
deleted file mode 100644
index c8bc7b5dd4a4c..0000000000000
--- a/tests/run-make/libtest-json/Makefile
+++ /dev/null
@@ -1,20 +0,0 @@
-# ignore-cross-compile
-# needs-unwind
-include ../tools.mk
-
-# Test expected libtest's JSON output
-
-OUTPUT_FILE_DEFAULT := $(TMPDIR)/libtest-json-output-default.json
-OUTPUT_FILE_STDOUT_SUCCESS := $(TMPDIR)/libtest-json-output-stdout-success.json
-
-all: f.rs validate_json.py output-default.json output-stdout-success.json
-	$(RUSTC) --test f.rs
-	RUST_BACKTRACE=0 $(call RUN,f) -Z unstable-options --test-threads=1 --format=json > $(OUTPUT_FILE_DEFAULT) || true
-	RUST_BACKTRACE=0 $(call RUN,f) -Z unstable-options --test-threads=1 --format=json --show-output > $(OUTPUT_FILE_STDOUT_SUCCESS) || true
-
-	cat $(OUTPUT_FILE_DEFAULT) | "$(PYTHON)" validate_json.py
-	cat $(OUTPUT_FILE_STDOUT_SUCCESS) | "$(PYTHON)" validate_json.py
-
-	# Normalize the actual output and compare to expected output file
-	cat $(OUTPUT_FILE_DEFAULT) | sed 's/"exec_time": [0-9.]*/"exec_time": $$TIME/' | diff output-default.json -
-	cat $(OUTPUT_FILE_STDOUT_SUCCESS) | sed 's/"exec_time": [0-9.]*/"exec_time": $$TIME/' | diff output-stdout-success.json -
diff --git a/tests/run-make/libtest-json/output-default.json b/tests/run-make/libtest-json/output-default.json
index 01710f59e5d74..a2293a032d012 100644
--- a/tests/run-make/libtest-json/output-default.json
+++ b/tests/run-make/libtest-json/output-default.json
@@ -7,4 +7,4 @@
 { "type": "test", "name": "c", "event": "ok" }
 { "type": "test", "event": "started", "name": "d" }
 { "type": "test", "name": "d", "event": "ignored", "message": "msg" }
-{ "type": "suite", "event": "failed", "passed": 2, "failed": 1, "ignored": 1, "measured": 0, "filtered_out": 0, "exec_time": $TIME }
+{ "type": "suite", "event": "failed", "passed": 2, "failed": 1, "ignored": 1, "measured": 0, "filtered_out": 0, "exec_time": "$EXEC_TIME" }
diff --git a/tests/run-make/libtest-json/output-stdout-success.json b/tests/run-make/libtest-json/output-stdout-success.json
index 878eb6c7c260d..cf92f01f63aca 100644
--- a/tests/run-make/libtest-json/output-stdout-success.json
+++ b/tests/run-make/libtest-json/output-stdout-success.json
@@ -7,4 +7,4 @@
 { "type": "test", "name": "c", "event": "ok", "stdout": "thread 'c' panicked at f.rs:15:5:\nassertion failed: false\n" }
 { "type": "test", "event": "started", "name": "d" }
 { "type": "test", "name": "d", "event": "ignored", "message": "msg" }
-{ "type": "suite", "event": "failed", "passed": 2, "failed": 1, "ignored": 1, "measured": 0, "filtered_out": 0, "exec_time": $TIME }
+{ "type": "suite", "event": "failed", "passed": 2, "failed": 1, "ignored": 1, "measured": 0, "filtered_out": 0, "exec_time": "$EXEC_TIME" }
diff --git a/tests/run-make/libtest-json/rmake.rs b/tests/run-make/libtest-json/rmake.rs
new file mode 100644
index 0000000000000..acbd88dc46cb9
--- /dev/null
+++ b/tests/run-make/libtest-json/rmake.rs
@@ -0,0 +1,31 @@
+// Check libtest's JSON output against snapshots.
+
+//@ ignore-cross-compile
+//@ needs-unwind (test file contains #[should_panic] test)
+
+use run_make_support::{cmd, diff, python_command, rustc};
+
+fn main() {
+    rustc().arg("--test").input("f.rs").run();
+
+    run_tests(&[], "output-default.json");
+    run_tests(&["--show-output"], "output-stdout-success.json");
+}
+
+#[track_caller]
+fn run_tests(extra_args: &[&str], expected_file: &str) {
+    let cmd_out = cmd("./f")
+        .env("RUST_BACKTRACE", "0")
+        .args(&["-Zunstable-options", "--test-threads=1", "--format=json"])
+        .args(extra_args)
+        .run_fail();
+    let test_stdout = &cmd_out.stdout_utf8();
+
+    python_command().arg("validate_json.py").stdin(test_stdout).run();
+
+    diff()
+        .expected_file(expected_file)
+        .actual_text("stdout", test_stdout)
+        .normalize(r#"(?<prefix>"exec_time": )[0-9.]+"#, r#"${prefix}"$$EXEC_TIME""#)
+        .run();
+}

From fc733a668afe9a16a23a6d249c6d253a08f36ebf Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 13 Aug 2024 13:02:26 +1000
Subject: [PATCH 168/685] Port `run-make/libtest-junit` to rmake

---
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 tests/run-make/libtest-junit/Makefile         | 20 ------------
 tests/run-make/libtest-junit/rmake.rs         | 31 +++++++++++++++++++
 3 files changed, 31 insertions(+), 21 deletions(-)
 delete mode 100644 tests/run-make/libtest-junit/Makefile
 create mode 100644 tests/run-make/libtest-junit/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 96ab097b3885e..e9dcc70dff538 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -9,7 +9,6 @@ run-make/incr-add-rust-src-component/Makefile
 run-make/issue-84395-lto-embed-bitcode/Makefile
 run-make/jobserver-error/Makefile
 run-make/libs-through-symlinks/Makefile
-run-make/libtest-junit/Makefile
 run-make/libtest-thread-limit/Makefile
 run-make/macos-deployment-target/Makefile
 run-make/min-global-align/Makefile
diff --git a/tests/run-make/libtest-junit/Makefile b/tests/run-make/libtest-junit/Makefile
deleted file mode 100644
index 26e56242dd239..0000000000000
--- a/tests/run-make/libtest-junit/Makefile
+++ /dev/null
@@ -1,20 +0,0 @@
-# ignore-cross-compile
-# needs-unwind contains should_panic test
-include ../tools.mk
-
-# Test expected libtest's junit output
-
-OUTPUT_FILE_DEFAULT := $(TMPDIR)/libtest-junit-output-default.xml
-OUTPUT_FILE_STDOUT_SUCCESS := $(TMPDIR)/libtest-junit-output-stdout-success.xml
-
-all: f.rs validate_junit.py output-default.xml output-stdout-success.xml
-	$(RUSTC) --test f.rs
-	RUST_BACKTRACE=0 $(call RUN,f) -Z unstable-options --test-threads=1 --format=junit > $(OUTPUT_FILE_DEFAULT) || true
-	RUST_BACKTRACE=0 $(call RUN,f) -Z unstable-options --test-threads=1 --format=junit --show-output > $(OUTPUT_FILE_STDOUT_SUCCESS) || true
-
-	cat $(OUTPUT_FILE_DEFAULT) | "$(PYTHON)" validate_junit.py
-	cat $(OUTPUT_FILE_STDOUT_SUCCESS) | "$(PYTHON)" validate_junit.py
-
-	# Normalize the actual output and compare to expected output file
-	cat $(OUTPUT_FILE_DEFAULT) | sed 's/time="[0-9.]*"/time="$$TIME"/g' | diff output-default.xml -
-	cat $(OUTPUT_FILE_STDOUT_SUCCESS) | sed 's/time="[0-9.]*"/time="$$TIME"/g' | diff output-stdout-success.xml -
diff --git a/tests/run-make/libtest-junit/rmake.rs b/tests/run-make/libtest-junit/rmake.rs
new file mode 100644
index 0000000000000..d631313ed9210
--- /dev/null
+++ b/tests/run-make/libtest-junit/rmake.rs
@@ -0,0 +1,31 @@
+// Check libtest's JUnit (XML) output against snapshots.
+
+//@ ignore-cross-compile
+//@ needs-unwind (test file contains #[should_panic] test)
+
+use run_make_support::{cmd, diff, python_command, rustc};
+
+fn main() {
+    rustc().arg("--test").input("f.rs").run();
+
+    run_tests(&[], "output-default.xml");
+    run_tests(&["--show-output"], "output-stdout-success.xml");
+}
+
+#[track_caller]
+fn run_tests(extra_args: &[&str], expected_file: &str) {
+    let cmd_out = cmd("./f")
+        .env("RUST_BACKTRACE", "0")
+        .args(&["-Zunstable-options", "--test-threads=1", "--format=junit"])
+        .args(extra_args)
+        .run_fail();
+    let test_stdout = &cmd_out.stdout_utf8();
+
+    python_command().arg("validate_junit.py").stdin(test_stdout).run();
+
+    diff()
+        .expected_file(expected_file)
+        .actual_text("stdout", test_stdout)
+        .normalize(r#"\btime="[0-9.]+""#, r#"time="$$TIME""#)
+        .run();
+}

From cebae30f7229007ecad8dfa47222d889541d7902 Mon Sep 17 00:00:00 2001
From: WANG Rui <wangrui@loongson.cn>
Date: Tue, 13 Aug 2024 11:41:37 +0800
Subject: [PATCH 169/685] Update `crosstool-ng` for loongarch64

The current cross-compilation toolchain for the LoongArch64 target
consists of GCC 13.2.0, Binutils 2.40, and Glibc 2.36. However, Binutils
2.40 has known issues that in broken binaries without any error reports:

- https://github.com/rust-lang/rust/issues/121289
- https://github.com/cross-rs/cross/issues/1538

This patch upgrades the cross-compilation toolchain for the LoongArch64 target
to resolve these issues.

- GCC: 13.2.0 -> 14.2.0
- Binutils: 2.40 -> 2.42

The new binaries remain compatible with the existing GCC 13.2.0/Glibc 2.36
distribution, and no issues have been identified.
---
 src/ci/docker/README.md                                   | 8 ++++----
 .../docker/host-x86_64/dist-loongarch64-linux/Dockerfile  | 4 ++--
 src/ci/docker/scripts/crosstool-ng-git.sh                 | 2 +-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/ci/docker/README.md b/src/ci/docker/README.md
index 985e3b37422d7..876787c30e537 100644
--- a/src/ci/docker/README.md
+++ b/src/ci/docker/README.md
@@ -266,9 +266,9 @@ For targets: `loongarch64-unknown-linux-gnu`
 - Target options > Bitness = 64-bit
 - Operating System > Target OS = linux
 - Operating System > Linux kernel version = 5.19.16
-- Binary utilities > Version of binutils = 2.40
+- Binary utilities > Version of binutils = 2.42
 - C-library > glibc version = 2.36
-- C compiler > gcc version = 13.2.0
+- C compiler > gcc version = 14.2.0
 - C compiler > C++ = ENABLE -- to cross compile LLVM
 
 ### `loongarch64-linux-musl.defconfig`
@@ -282,9 +282,9 @@ For targets: `loongarch64-unknown-linux-musl`
 - Target options > Bitness = 64-bit
 - Operating System > Target OS = linux
 - Operating System > Linux kernel version = 5.19.16
-- Binary utilities > Version of binutils = 2.41
+- Binary utilities > Version of binutils = 2.42
 - C-library > musl version = 1.2.5
-- C compiler > gcc version = 13.2.0
+- C compiler > gcc version = 14.2.0
 - C compiler > C++ = ENABLE -- to cross compile LLVM
 
 ### `mips-linux-gnu.defconfig`
diff --git a/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile
index d395665166365..865a9e32fa92b 100644
--- a/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-loongarch64-linux/Dockerfile
@@ -3,8 +3,8 @@ FROM ubuntu:22.04
 COPY scripts/cross-apt-packages.sh /scripts/
 RUN sh /scripts/cross-apt-packages.sh
 
-COPY scripts/crosstool-ng.sh /scripts/
-RUN sh /scripts/crosstool-ng.sh
+COPY scripts/crosstool-ng-git.sh /scripts/
+RUN sh /scripts/crosstool-ng-git.sh
 
 COPY scripts/rustbuild-setup.sh /scripts/
 RUN sh /scripts/rustbuild-setup.sh
diff --git a/src/ci/docker/scripts/crosstool-ng-git.sh b/src/ci/docker/scripts/crosstool-ng-git.sh
index 2a10e262df8cf..e86810ae6133e 100644
--- a/src/ci/docker/scripts/crosstool-ng-git.sh
+++ b/src/ci/docker/scripts/crosstool-ng-git.sh
@@ -2,7 +2,7 @@
 set -ex
 
 URL=https://github.com/crosstool-ng/crosstool-ng
-REV=c64500d94be92ed1bcdfdef911048a14e216a5e1
+REV=ed12fa68402f58e171a6f79500f73f4781fdc9e5
 
 mkdir crosstool-ng
 cd crosstool-ng

From ac88b330b875e8058589b1804ac5d95fcd40905d Mon Sep 17 00:00:00 2001
From: Mikhail Zabaluev <mikhail.zabaluev@gmail.com>
Date: Tue, 13 Aug 2024 08:21:16 +0300
Subject: [PATCH 170/685] Revert to original loop for const pow exponents

Give LLVM the for original, optimizable loop in pow and wrapped_pow
functions in the case when the exponent is statically known.
---
 library/core/src/num/int_macros.rs  | 135 ++++++++++++----------------
 library/core/src/num/uint_macros.rs | 135 ++++++++++++----------------
 2 files changed, 110 insertions(+), 160 deletions(-)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index be0e6a2a03b70..d8ef36f21ac63 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -2174,54 +2174,41 @@ macro_rules! int_impl {
         #[inline]
         #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn wrapping_pow(self, mut exp: u32) -> Self {
+            if exp == 0 {
+                return 1;
+            }
             let mut base = self;
+            let mut acc: Self = 1;
 
             if intrinsics::is_val_statically_known(exp) {
-                // Unroll multiplications for small exponent values.
-                // This gives the optimizer a way to efficiently inline call sites
-                // for the most common use cases with constant exponents.
-                // Currently, LLVM is unable to unroll the loop below.
-                match exp {
-                    0 => return 1,
-                    1 => return base,
-                    2 => return base.wrapping_mul(base),
-                    3 => {
-                        let squared = base.wrapping_mul(base);
-                        return squared.wrapping_mul(base);
-                    }
-                    4 => {
-                        let squared = base.wrapping_mul(base);
-                        return squared.wrapping_mul(squared);
+                while exp > 1 {
+                    if (exp & 1) == 1 {
+                        acc = acc.wrapping_mul(base);
                     }
-                    5 => {
-                        let squared = base.wrapping_mul(base);
-                        return squared.wrapping_mul(squared).wrapping_mul(base);
-                    }
-                    6 => {
-                        let cubed = base.wrapping_mul(base).wrapping_mul(base);
-                        return cubed.wrapping_mul(cubed);
-                    }
-                    _ => {}
+                    exp /= 2;
+                    base = base.wrapping_mul(base);
                 }
-            } else {
-                if exp == 0 {
-                    return 1;
-                }
-            }
-            debug_assert!(exp != 0);
 
-            let mut acc: Self = 1;
-
-            loop {
-                if (exp & 1) == 1 {
-                    acc = acc.wrapping_mul(base);
-                    // since exp!=0, finally the exp must be 1.
-                    if exp == 1 {
-                        return acc;
+                // since exp!=0, finally the exp must be 1.
+                // Deal with the final bit of the exponent separately, since
+                // squaring the base afterwards is not necessary.
+                acc.wrapping_mul(base)
+            } else {
+                // This is faster than the above when the exponent is not known
+                // at compile time. We can't use the same code for the constant
+                // exponent case because LLVM is currently unable to unroll
+                // this loop.
+                loop {
+                    if (exp & 1) == 1 {
+                        acc = acc.wrapping_mul(base);
+                        // since exp!=0, finally the exp must be 1.
+                        if exp == 1 {
+                            return acc;
+                        }
                     }
+                    exp /= 2;
+                    base = base.wrapping_mul(base);
                 }
-                exp /= 2;
-                base = base.wrapping_mul(base);
             }
         }
 
@@ -2753,54 +2740,42 @@ macro_rules! int_impl {
         #[rustc_inherit_overflow_checks]
         #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn pow(self, mut exp: u32) -> Self {
+            if exp == 0 {
+                return 1;
+            }
             let mut base = self;
+            let mut acc = 1;
 
             if intrinsics::is_val_statically_known(exp) {
-                // Unroll multiplications for small exponent values.
-                // This gives the optimizer a way to efficiently inline call sites
-                // for the most common use cases with constant exponents.
-                // Currently, LLVM is unable to unroll the loop below.
-                match exp {
-                    0 => return 1,
-                    1 => return base,
-                    2 => return base * base,
-                    3 => {
-                        let squared = base * base;
-                        return squared * base;
-                    }
-                    4 => {
-                        let squared = base * base;
-                        return squared * squared;
+                while exp > 1 {
+                    if (exp & 1) == 1 {
+                        acc = acc * base;
                     }
-                    5 => {
-                        let squared = base * base;
-                        return squared * squared * base;
-                    }
-                    6 => {
-                        let cubed = base * base * base;
-                        return cubed * cubed;
-                    }
-                    _ => {}
+                    exp /= 2;
+                    base = base * base;
                 }
-            } else {
-                if exp == 0 {
-                    return 1;
-                }
-            }
-            debug_assert!(exp != 0);
 
-            let mut acc = 1;
-
-            loop {
-                if (exp & 1) == 1 {
-                    acc = acc * base;
-                    // since exp!=0, finally the exp must be 1.
-                    if exp == 1 {
-                        return acc;
+                // since exp!=0, finally the exp must be 1.
+                // Deal with the final bit of the exponent separately, since
+                // squaring the base afterwards is not necessary and may cause a
+                // needless overflow.
+                acc * base
+            } else {
+                // This is faster than the above when the exponent is not known
+                // at compile time. We can't use the same code for the constant
+                // exponent case because LLVM is currently unable to unroll
+                // this loop.
+                loop {
+                    if (exp & 1) == 1 {
+                        acc = acc * base;
+                        // since exp!=0, finally the exp must be 1.
+                        if exp == 1 {
+                            return acc;
+                        }
                     }
+                    exp /= 2;
+                    base = base * base;
                 }
-                exp /= 2;
-                base = base * base;
             }
         }
 
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 24352593fca3d..5b3ef78d39a3d 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -2050,54 +2050,41 @@ macro_rules! uint_impl {
         #[inline]
         #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn wrapping_pow(self, mut exp: u32) -> Self {
+            if exp == 0 {
+                return 1;
+            }
             let mut base = self;
+            let mut acc: Self = 1;
 
             if intrinsics::is_val_statically_known(exp) {
-                // Unroll multiplications for small exponent values.
-                // This gives the optimizer a way to efficiently inline call sites
-                // for the most common use cases with constant exponents.
-                // Currently, LLVM is unable to unroll the loop below.
-                match exp {
-                    0 => return 1,
-                    1 => return base,
-                    2 => return base.wrapping_mul(base),
-                    3 => {
-                        let squared = base.wrapping_mul(base);
-                        return squared.wrapping_mul(base);
-                    }
-                    4 => {
-                        let squared = base.wrapping_mul(base);
-                        return squared.wrapping_mul(squared);
+                while exp > 1 {
+                    if (exp & 1) == 1 {
+                        acc = acc.wrapping_mul(base);
                     }
-                    5 => {
-                        let squared = base.wrapping_mul(base);
-                        return squared.wrapping_mul(squared).wrapping_mul(base);
-                    }
-                    6 => {
-                        let cubed = base.wrapping_mul(base).wrapping_mul(base);
-                        return cubed.wrapping_mul(cubed);
-                    }
-                    _ => {}
+                    exp /= 2;
+                    base = base.wrapping_mul(base);
                 }
-            } else {
-                if exp == 0 {
-                    return 1;
-                }
-            }
-            debug_assert!(exp != 0);
 
-            let mut acc: Self = 1;
-
-            loop {
-                if (exp & 1) == 1 {
-                    acc = acc.wrapping_mul(base);
-                    // since exp!=0, finally the exp must be 1.
-                    if exp == 1 {
-                        return acc;
+                // since exp!=0, finally the exp must be 1.
+                // Deal with the final bit of the exponent separately, since
+                // squaring the base afterwards is not necessary.
+                acc.wrapping_mul(base)
+            } else {
+                // This is faster than the above when the exponent is not known
+                // at compile time. We can't use the same code for the constant
+                // exponent case because LLVM is currently unable to unroll
+                // this loop.
+                loop {
+                    if (exp & 1) == 1 {
+                        acc = acc.wrapping_mul(base);
+                        // since exp!=0, finally the exp must be 1.
+                        if exp == 1 {
+                            return acc;
+                        }
                     }
+                    exp /= 2;
+                    base = base.wrapping_mul(base);
                 }
-                exp /= 2;
-                base = base.wrapping_mul(base);
             }
         }
 
@@ -2578,54 +2565,42 @@ macro_rules! uint_impl {
         #[rustc_inherit_overflow_checks]
         #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn pow(self, mut exp: u32) -> Self {
+            if exp == 0 {
+                return 1;
+            }
             let mut base = self;
+            let mut acc = 1;
 
             if intrinsics::is_val_statically_known(exp) {
-                // Unroll multiplications for small exponent values.
-                // This gives the optimizer a way to efficiently inline call sites
-                // for the most common use cases with constant exponents.
-                // Currently, LLVM is unable to unroll the loop below.
-                match exp {
-                    0 => return 1,
-                    1 => return base,
-                    2 => return base * base,
-                    3 => {
-                        let squared = base * base;
-                        return squared * base;
-                    }
-                    4 => {
-                        let squared = base * base;
-                        return squared * squared;
+                while exp > 1 {
+                    if (exp & 1) == 1 {
+                        acc = acc * base;
                     }
-                    5 => {
-                        let squared = base * base;
-                        return squared * squared * base;
-                    }
-                    6 => {
-                        let cubed = base * base * base;
-                        return cubed * cubed;
-                    }
-                    _ => {}
+                    exp /= 2;
+                    base = base * base;
                 }
-            } else {
-                if exp == 0 {
-                    return 1;
-                }
-            }
-            debug_assert!(exp != 0);
 
-            let mut acc = 1;
-
-            loop {
-                if (exp & 1) == 1 {
-                    acc = acc * base;
-                    // since exp!=0, finally the exp must be 1.
-                    if exp == 1 {
-                        return acc;
+                // since exp!=0, finally the exp must be 1.
+                // Deal with the final bit of the exponent separately, since
+                // squaring the base afterwards is not necessary and may cause a
+                // needless overflow.
+                acc * base
+            } else {
+                // This is faster than the above when the exponent is not known
+                // at compile time. We can't use the same code for the constant
+                // exponent case because LLVM is currently unable to unroll
+                // this loop.
+                loop {
+                    if (exp & 1) == 1 {
+                        acc = acc * base;
+                        // since exp!=0, finally the exp must be 1.
+                        if exp == 1 {
+                            return acc;
+                        }
                     }
+                    exp /= 2;
+                    base = base * base;
                 }
-                exp /= 2;
-                base = base * base;
             }
         }
 

From 194baa820d36926cfa9128211bbd61866d49d501 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 6 Aug 2024 12:25:37 +0200
Subject: [PATCH 171/685] simd_shuffle intrinsic: allow argument to be passed
 as vector (not just as array)

---
 .../src/intrinsics/simd.rs                    | 10 +++++++
 .../rustc_codegen_gcc/src/intrinsic/simd.rs   | 19 ++++++++-----
 compiler/rustc_codegen_llvm/src/intrinsic.rs  | 19 ++++++++-----
 library/core/src/intrinsics/simd.rs           |  2 +-
 tests/ui/simd/shuffle.rs                      | 27 +++++++++++++++++--
 5 files changed, 60 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
index ca910dccb0d06..604a88393fd95 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
@@ -191,6 +191,14 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
                     })
                     .try_into()
                     .unwrap(),
+                _ if idx_ty.is_simd()
+                    && matches!(
+                        idx_ty.simd_size_and_type(fx.tcx).1.kind(),
+                        ty::Uint(ty::UintTy::U32)
+                    ) =>
+                {
+                    idx_ty.simd_size_and_type(fx.tcx).0.try_into().unwrap()
+                }
                 _ => {
                     fx.tcx.dcx().span_err(
                         span,
@@ -213,6 +221,8 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
 
             let total_len = lane_count * 2;
 
+            // FIXME: this is a terrible abstraction-breaking hack.
+            // Find a way to reuse `immediate_const_vector` from `codegen_ssa` instead.
             let indexes = {
                 use rustc_middle::mir::interpret::*;
                 let idx_const = match &idx.node {
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
index 8da1df3be1534..96a833ccaf2b6 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
@@ -353,19 +353,24 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
     }
 
     if name == sym::simd_shuffle {
-        // Make sure this is actually an array, since typeck only checks the length-suffixed
+        // Make sure this is actually an array or SIMD vector, since typeck only checks the length-suffixed
         // version of this intrinsic.
-        let n: u64 = match *args[2].layout.ty.kind() {
+        let idx_ty = args[2].layout.ty;
+        let n: u64 = match idx_ty.kind() {
             ty::Array(ty, len) if matches!(*ty.kind(), ty::Uint(ty::UintTy::U32)) => {
                 len.try_eval_target_usize(bx.cx.tcx, ty::ParamEnv::reveal_all()).unwrap_or_else(
                     || span_bug!(span, "could not evaluate shuffle index array length"),
                 )
             }
-            _ => return_error!(InvalidMonomorphization::SimdShuffle {
-                span,
-                name,
-                ty: args[2].layout.ty
-            }),
+            _ if idx_ty.is_simd()
+                && matches!(
+                    idx_ty.simd_size_and_type(bx.cx.tcx).1.kind(),
+                    ty::Uint(ty::UintTy::U32)
+                ) =>
+            {
+                idx_ty.simd_size_and_type(bx.cx.tcx).0
+            }
+            _ => return_error!(InvalidMonomorphization::SimdShuffle { span, name, ty: idx_ty }),
         };
         require_simd!(ret_ty, InvalidMonomorphization::SimdReturn { span, name, ty: ret_ty });
 
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index f5558723d11bf..5d32ef0d9d65f 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -1279,19 +1279,24 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
     }
 
     if name == sym::simd_shuffle {
-        // Make sure this is actually an array, since typeck only checks the length-suffixed
+        // Make sure this is actually an array or SIMD vector, since typeck only checks the length-suffixed
         // version of this intrinsic.
-        let n: u64 = match args[2].layout.ty.kind() {
+        let idx_ty = args[2].layout.ty;
+        let n: u64 = match idx_ty.kind() {
             ty::Array(ty, len) if matches!(ty.kind(), ty::Uint(ty::UintTy::U32)) => {
                 len.try_eval_target_usize(bx.cx.tcx, ty::ParamEnv::reveal_all()).unwrap_or_else(
                     || span_bug!(span, "could not evaluate shuffle index array length"),
                 )
             }
-            _ => return_error!(InvalidMonomorphization::SimdShuffle {
-                span,
-                name,
-                ty: args[2].layout.ty
-            }),
+            _ if idx_ty.is_simd()
+                && matches!(
+                    idx_ty.simd_size_and_type(bx.cx.tcx).1.kind(),
+                    ty::Uint(ty::UintTy::U32)
+                ) =>
+            {
+                idx_ty.simd_size_and_type(bx.cx.tcx).0
+            }
+            _ => return_error!(InvalidMonomorphization::SimdShuffle { span, name, ty: idx_ty }),
         };
 
         let (out_len, out_ty) = require_simd!(ret_ty, SimdReturn);
diff --git a/library/core/src/intrinsics/simd.rs b/library/core/src/intrinsics/simd.rs
index 221724d7b4ae9..5982819809937 100644
--- a/library/core/src/intrinsics/simd.rs
+++ b/library/core/src/intrinsics/simd.rs
@@ -232,7 +232,7 @@ extern "rust-intrinsic" {
     ///
     /// `T` must be a vector.
     ///
-    /// `U` must be a **const** array of `i32`s. This means it must either refer to a named
+    /// `U` must be a **const** array or vector of `u32`s. This means it must either refer to a named
     /// const or be given as an inline const expression (`const { ... }`).
     ///
     /// `V` must be a vector with the same element type as `T` and the same length as `U`.
diff --git a/tests/ui/simd/shuffle.rs b/tests/ui/simd/shuffle.rs
index 09926d95557cd..dc0d688284e3c 100644
--- a/tests/ui/simd/shuffle.rs
+++ b/tests/ui/simd/shuffle.rs
@@ -6,15 +6,20 @@
 #![allow(incomplete_features)]
 #![feature(adt_const_params)]
 
+use std::marker::ConstParamTy;
+
 extern "rust-intrinsic" {
     fn simd_shuffle<T, I, U>(a: T, b: T, i: I) -> U;
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, ConstParamTy, PartialEq, Eq)]
 #[repr(simd)]
 struct Simd<T, const N: usize>([T; N]);
 
-pub unsafe fn __shuffle_vector16<const IDX: [u32; 16], T, U>(x: T, y: T) -> U {
+unsafe fn __shuffle_vector16<const IDX: [u32; 16], T, U>(x: T, y: T) -> U {
+    simd_shuffle(x, y, IDX)
+}
+unsafe fn __shuffle_vector16_v2<const IDX: Simd<u32, 16>, T, U>(x: T, y: T) -> U {
     simd_shuffle(x, y, IDX)
 }
 
@@ -30,6 +35,17 @@ fn main() {
         let y: Simd<u8, 2> = simd_shuffle(a, b, I2);
         assert_eq!(y.0, [1, 5]);
     }
+    // Test that we can also use a SIMD vector instead of a normal array for the shuffle.
+    const I1_SIMD: Simd<u32, 4> = Simd([0, 2, 4, 6]);
+    const I2_SIMD: Simd<u32, 2> = Simd([1, 5]);
+    unsafe {
+        let x: Simd<u8, 4> = simd_shuffle(a, b, I1_SIMD);
+        assert_eq!(x.0, [0, 2, 4, 6]);
+
+        let y: Simd<u8, 2> = simd_shuffle(a, b, I2_SIMD);
+        assert_eq!(y.0, [1, 5]);
+    }
+
     // Test that an indirection (via an unnamed constant)
     // through a const generic parameter also works.
     // See https://github.com/rust-lang/rust/issues/113500 for details.
@@ -42,4 +58,11 @@ fn main() {
             Simd<u8, 16>,
         >(a, b);
     }
+    unsafe {
+        __shuffle_vector16_v2::<
+            { Simd([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]) },
+            Simd<u8, 16>,
+            Simd<u8, 16>,
+        >(a, b);
+    }
 }

From daedbd4d7abb9132638cb420acc549d198c46c48 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 6 Aug 2024 17:08:50 +0200
Subject: [PATCH 172/685] make the GCC backend compatible with vector shuffle
 indices

---
 compiler/rustc_codegen_gcc/src/builder.rs | 44 +++++++++++++++--------
 1 file changed, 30 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_codegen_gcc/src/builder.rs b/compiler/rustc_codegen_gcc/src/builder.rs
index 47b378cc1cd82..6ba678e2e7c65 100644
--- a/compiler/rustc_codegen_gcc/src/builder.rs
+++ b/compiler/rustc_codegen_gcc/src/builder.rs
@@ -1923,15 +1923,11 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         v2: RValue<'gcc>,
         mask: RValue<'gcc>,
     ) -> RValue<'gcc> {
-        let struct_type = mask.get_type().is_struct().expect("mask should be of struct type");
-
         // TODO(antoyo): use a recursive unqualified() here.
         let vector_type = v1.get_type().unqualified().dyncast_vector().expect("vector type");
         let element_type = vector_type.get_element_type();
         let vec_num_units = vector_type.get_num_units();
 
-        let mask_num_units = struct_type.get_field_count();
-        let mut vector_elements = vec![];
         let mask_element_type = if element_type.is_integral() {
             element_type
         } else {
@@ -1942,19 +1938,39 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
             #[cfg(not(feature = "master"))]
             self.int_type
         };
-        for i in 0..mask_num_units {
-            let field = struct_type.get_field(i as i32);
-            vector_elements.push(self.context.new_cast(
-                self.location,
-                mask.access_field(self.location, field).to_rvalue(),
-                mask_element_type,
-            ));
-        }
+
+        let mut mask_elements = if let Some(vector_type) = mask.get_type().dyncast_vector() {
+            let mask_num_units = vector_type.get_num_units();
+            let mut mask_elements = vec![];
+            for i in 0..mask_num_units {
+                let index = self.context.new_rvalue_from_long(self.cx.type_u32(), i as _);
+                mask_elements.push(self.context.new_cast(
+                    self.location,
+                    self.extract_element(mask, index).to_rvalue(),
+                    mask_element_type,
+                ));
+            }
+            mask_elements
+        } else {
+            let struct_type = mask.get_type().is_struct().expect("mask should be of struct type");
+            let mask_num_units = struct_type.get_field_count();
+            let mut mask_elements = vec![];
+            for i in 0..mask_num_units {
+                let field = struct_type.get_field(i as i32);
+                mask_elements.push(self.context.new_cast(
+                    self.location,
+                    mask.access_field(self.location, field).to_rvalue(),
+                    mask_element_type,
+                ));
+            }
+            mask_elements
+        };
+        let mask_num_units = mask_elements.len();
 
         // NOTE: the mask needs to be the same length as the input vectors, so add the missing
         // elements in the mask if needed.
         for _ in mask_num_units..vec_num_units {
-            vector_elements.push(self.context.new_rvalue_zero(mask_element_type));
+            mask_elements.push(self.context.new_rvalue_zero(mask_element_type));
         }
 
         let result_type = self.context.new_vector_type(element_type, mask_num_units as u64);
@@ -1998,7 +2014,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
 
         let new_mask_num_units = std::cmp::max(mask_num_units, vec_num_units);
         let mask_type = self.context.new_vector_type(mask_element_type, new_mask_num_units as u64);
-        let mask = self.context.new_rvalue_from_vector(self.location, mask_type, &vector_elements);
+        let mask = self.context.new_rvalue_from_vector(self.location, mask_type, &mask_elements);
         let result = self.context.new_rvalue_vector_perm(self.location, v1, v2, mask);
 
         if vec_num_units != mask_num_units {

From 399ef23d2bf2b1619d360a87de9b83edf9d99762 Mon Sep 17 00:00:00 2001
From: Tobias Bucher <tobiasbucher5991@gmail.com>
Date: Wed, 17 Jul 2024 13:45:31 +0200
Subject: [PATCH 173/685] Allow to customize `// TODO:` comment for deprecated
 safe autofix

Relevant for the deprecation of `CommandExt::before_exit` in #125970.
---
 compiler/rustc_feature/src/builtin_attrs.rs   |  4 ++--
 compiler/rustc_mir_build/messages.ftl         |  2 +-
 .../rustc_mir_build/src/check_unsafety.rs     | 22 +++++++++++++++++--
 compiler/rustc_mir_build/src/errors.rs        |  6 ++---
 compiler/rustc_span/src/symbol.rs             |  1 +
 library/std/src/env.rs                        | 16 ++++++++++++--
 .../ui/rust-2024/unsafe-env-suggestion.stderr |  4 ++--
 7 files changed, 42 insertions(+), 13 deletions(-)

diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 72ea55d5999a2..1b4c18e96fc74 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -643,8 +643,8 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         through unstable paths"
     ),
     rustc_attr!(
-        rustc_deprecated_safe_2024, Normal, template!(Word), WarnFollowing,
-        EncodeCrossCrate::Yes,
+        rustc_deprecated_safe_2024, Normal, template!(List: r#"todo = "...""#),
+        ErrorFollowing, EncodeCrossCrate::Yes,
         "rustc_deprecated_safe_2024 is supposed to be used in libstd only",
     ),
 
diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index dda4debecec67..91c4de7963665 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -30,7 +30,7 @@ mir_build_call_to_deprecated_safe_fn_requires_unsafe =
     call to deprecated safe function `{$function}` is unsafe and requires unsafe block
     .note = consult the function's documentation for information on how to avoid undefined behavior
     .label = call to unsafe function
-    .suggestion = you can wrap the call in an `unsafe` block if you can guarantee the code is only ever called from single-threaded code
+    .suggestion = you can wrap the call in an `unsafe` block if you can guarantee its unsafe preconditions
 
 mir_build_call_to_fn_with_requires_unsafe =
     call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe block
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index 54a4204da71e8..f856555a95c21 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -96,9 +96,27 @@ impl<'tcx> UnsafetyVisitor<'_, 'tcx> {
             // from an edition before 2024.
             &UnsafeOpKind::CallToUnsafeFunction(Some(id))
                 if !span.at_least_rust_2024()
-                    && self.tcx.has_attr(id, sym::rustc_deprecated_safe_2024) =>
+                    && let Some(attr) = self.tcx.get_attr(id, sym::rustc_deprecated_safe_2024) =>
             {
+                let suggestion = attr
+                    .meta_item_list()
+                    .unwrap_or_default()
+                    .into_iter()
+                    .find(|item| item.has_name(sym::todo))
+                    .map(|item| {
+                        item.value_str().expect(
+                            "`#[rustc_deprecated_safe_2024(todo)]` must have a string value",
+                        )
+                    });
+
                 let sm = self.tcx.sess.source_map();
+                let suggestion = suggestion
+                    .and_then(|suggestion| {
+                        sm.indentation_before(span)
+                            .map(|indent| format!("{}// TODO: {}\n", indent, suggestion)) // ignore-tidy-todo
+                    })
+                    .unwrap_or_default();
+
                 self.tcx.emit_node_span_lint(
                     DEPRECATED_SAFE_2024,
                     self.hir_context,
@@ -107,7 +125,7 @@ impl<'tcx> UnsafetyVisitor<'_, 'tcx> {
                         span,
                         function: with_no_trimmed_paths!(self.tcx.def_path_str(id)),
                         sub: CallToDeprecatedSafeFnRequiresUnsafeSub {
-                            indent: sm.indentation_before(span).unwrap_or_default(),
+                            start_of_line_suggestion: suggestion,
                             start_of_line: sm.span_extend_to_line(span).shrink_to_lo(),
                             left: span.shrink_to_lo(),
                             right: span.shrink_to_hi(),
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index 42eca71ca3f30..8c45f949e4350 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -35,10 +35,8 @@ pub(crate) struct CallToDeprecatedSafeFnRequiresUnsafe {
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(mir_build_suggestion, applicability = "machine-applicable")]
 pub(crate) struct CallToDeprecatedSafeFnRequiresUnsafeSub {
-    pub(crate) indent: String,
-    #[suggestion_part(
-        code = "{indent}// TODO: Audit that the environment access only happens in single-threaded code.\n" // ignore-tidy-todo
-    )]
+    pub(crate) start_of_line_suggestion: String,
+    #[suggestion_part(code = "{start_of_line_suggestion}")]
     pub(crate) start_of_line: Span,
     #[suggestion_part(code = "unsafe {{ ")]
     pub(crate) left: Span,
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 9cb729ec48588..95810a9a8379a 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1897,6 +1897,7 @@ symbols! {
         to_string,
         to_string_method,
         to_vec,
+        todo,
         todo_macro,
         tool_attributes,
         tool_lints,
diff --git a/library/std/src/env.rs b/library/std/src/env.rs
index 50ae83090c7e1..631d86dbe6e00 100644
--- a/library/std/src/env.rs
+++ b/library/std/src/env.rs
@@ -355,7 +355,13 @@ impl Error for VarError {
 /// }
 /// assert_eq!(env::var(key), Ok("VALUE".to_string()));
 /// ```
-#[rustc_deprecated_safe_2024]
+#[cfg_attr(bootstrap, rustc_deprecated_safe_2024)]
+#[cfg_attr(
+    not(bootstrap),
+    rustc_deprecated_safe_2024(
+        todo = "Audit that the environment access only happens in single-threaded code."
+    )
+)]
 #[stable(feature = "env", since = "1.0.0")]
 pub unsafe fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(key: K, value: V) {
     let (key, value) = (key.as_ref(), value.as_ref());
@@ -419,7 +425,13 @@ pub unsafe fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(key: K, value: V) {
 /// }
 /// assert!(env::var(key).is_err());
 /// ```
-#[rustc_deprecated_safe_2024]
+#[cfg_attr(bootstrap, rustc_deprecated_safe_2024)]
+#[cfg_attr(
+    not(bootstrap),
+    rustc_deprecated_safe_2024(
+        todo = "Audit that the environment access only happens in single-threaded code."
+    )
+)]
 #[stable(feature = "env", since = "1.0.0")]
 pub unsafe fn remove_var<K: AsRef<OsStr>>(key: K) {
     let key = key.as_ref();
diff --git a/tests/ui/rust-2024/unsafe-env-suggestion.stderr b/tests/ui/rust-2024/unsafe-env-suggestion.stderr
index 3aa10a3bed682..5c90c08e2ddfb 100644
--- a/tests/ui/rust-2024/unsafe-env-suggestion.stderr
+++ b/tests/ui/rust-2024/unsafe-env-suggestion.stderr
@@ -11,7 +11,7 @@ note: the lint level is defined here
    |
 LL | #![deny(deprecated_safe_2024)]
    |         ^^^^^^^^^^^^^^^^^^^^
-help: you can wrap the call in an `unsafe` block if you can guarantee the code is only ever called from single-threaded code
+help: you can wrap the call in an `unsafe` block if you can guarantee its unsafe preconditions
    |
 LL +     // TODO: Audit that the environment access only happens in single-threaded code.
 LL ~     unsafe { env::set_var("FOO", "BAR") };
@@ -25,7 +25,7 @@ LL |     env::remove_var("FOO");
    |
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2024!
    = note: for more information, see issue #27970 <https://github.com/rust-lang/rust/issues/27970>
-help: you can wrap the call in an `unsafe` block if you can guarantee the code is only ever called from single-threaded code
+help: you can wrap the call in an `unsafe` block if you can guarantee its unsafe preconditions
    |
 LL +     // TODO: Audit that the environment access only happens in single-threaded code.
 LL ~     unsafe { env::remove_var("FOO") };

From 811d7dd11302e86d1678f7d61586d51e54c47e27 Mon Sep 17 00:00:00 2001
From: Tobias Bucher <tobiasbucher5991@gmail.com>
Date: Mon, 29 Jul 2024 13:31:59 +0200
Subject: [PATCH 174/685] `#[deprecated_safe_2024]`: Also use the `// TODO:`
 hint in the compiler error

This doesn't work for translated compiler error messages.
---
 compiler/rustc_feature/src/builtin_attrs.rs     |  2 +-
 compiler/rustc_mir_build/messages.ftl           |  2 +-
 compiler/rustc_mir_build/src/check_unsafety.rs  | 14 ++++++++++----
 compiler/rustc_mir_build/src/errors.rs          |  1 +
 compiler/rustc_span/src/symbol.rs               |  2 +-
 library/std/src/env.rs                          |  4 ++--
 tests/ui/rust-2024/unsafe-env-suggestion.stderr |  4 ++--
 7 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index 1b4c18e96fc74..d593f05c8c6db 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -643,7 +643,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         through unstable paths"
     ),
     rustc_attr!(
-        rustc_deprecated_safe_2024, Normal, template!(List: r#"todo = "...""#),
+        rustc_deprecated_safe_2024, Normal, template!(List: r#"audit_that = "...""#),
         ErrorFollowing, EncodeCrossCrate::Yes,
         "rustc_deprecated_safe_2024 is supposed to be used in libstd only",
     ),
diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index 91c4de7963665..7baf0256dd890 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -30,7 +30,7 @@ mir_build_call_to_deprecated_safe_fn_requires_unsafe =
     call to deprecated safe function `{$function}` is unsafe and requires unsafe block
     .note = consult the function's documentation for information on how to avoid undefined behavior
     .label = call to unsafe function
-    .suggestion = you can wrap the call in an `unsafe` block if you can guarantee its unsafe preconditions
+    .suggestion = you can wrap the call in an `unsafe` block if you can guarantee {$guarantee}
 
 mir_build_call_to_fn_with_requires_unsafe =
     call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe block
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index f856555a95c21..9b85ad0ad0891 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -102,18 +102,23 @@ impl<'tcx> UnsafetyVisitor<'_, 'tcx> {
                     .meta_item_list()
                     .unwrap_or_default()
                     .into_iter()
-                    .find(|item| item.has_name(sym::todo))
+                    .find(|item| item.has_name(sym::audit_that))
                     .map(|item| {
                         item.value_str().expect(
-                            "`#[rustc_deprecated_safe_2024(todo)]` must have a string value",
+                            "`#[rustc_deprecated_safe_2024(audit_that)]` must have a string value",
                         )
                     });
 
                 let sm = self.tcx.sess.source_map();
+                let guarantee = suggestion
+                    .as_ref()
+                    .map(|suggestion| format!("that {}", suggestion))
+                    .unwrap_or_else(|| String::from("its unsafe preconditions"));
                 let suggestion = suggestion
                     .and_then(|suggestion| {
-                        sm.indentation_before(span)
-                            .map(|indent| format!("{}// TODO: {}\n", indent, suggestion)) // ignore-tidy-todo
+                        sm.indentation_before(span).map(|indent| {
+                            format!("{}// TODO: Audit that {}.\n", indent, suggestion) // ignore-tidy-todo
+                        })
                     })
                     .unwrap_or_default();
 
@@ -124,6 +129,7 @@ impl<'tcx> UnsafetyVisitor<'_, 'tcx> {
                     CallToDeprecatedSafeFnRequiresUnsafe {
                         span,
                         function: with_no_trimmed_paths!(self.tcx.def_path_str(id)),
+                        guarantee,
                         sub: CallToDeprecatedSafeFnRequiresUnsafeSub {
                             start_of_line_suggestion: suggestion,
                             start_of_line: sm.span_extend_to_line(span).shrink_to_lo(),
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index 8c45f949e4350..34577f102d1c5 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -28,6 +28,7 @@ pub(crate) struct CallToDeprecatedSafeFnRequiresUnsafe {
     #[label]
     pub(crate) span: Span,
     pub(crate) function: String,
+    pub(crate) guarantee: String,
     #[subdiagnostic]
     pub(crate) sub: CallToDeprecatedSafeFnRequiresUnsafeSub,
 }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 95810a9a8379a..a2e94492f8c23 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -472,6 +472,7 @@ symbols! {
         attr,
         attr_literals,
         attributes,
+        audit_that,
         augmented_assignments,
         auto_traits,
         automatically_derived,
@@ -1897,7 +1898,6 @@ symbols! {
         to_string,
         to_string_method,
         to_vec,
-        todo,
         todo_macro,
         tool_attributes,
         tool_lints,
diff --git a/library/std/src/env.rs b/library/std/src/env.rs
index 631d86dbe6e00..80890e61471c6 100644
--- a/library/std/src/env.rs
+++ b/library/std/src/env.rs
@@ -359,7 +359,7 @@ impl Error for VarError {
 #[cfg_attr(
     not(bootstrap),
     rustc_deprecated_safe_2024(
-        todo = "Audit that the environment access only happens in single-threaded code."
+        audit_that = "the environment access only happens in single-threaded code"
     )
 )]
 #[stable(feature = "env", since = "1.0.0")]
@@ -429,7 +429,7 @@ pub unsafe fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(key: K, value: V) {
 #[cfg_attr(
     not(bootstrap),
     rustc_deprecated_safe_2024(
-        todo = "Audit that the environment access only happens in single-threaded code."
+        audit_that = "the environment access only happens in single-threaded code"
     )
 )]
 #[stable(feature = "env", since = "1.0.0")]
diff --git a/tests/ui/rust-2024/unsafe-env-suggestion.stderr b/tests/ui/rust-2024/unsafe-env-suggestion.stderr
index 5c90c08e2ddfb..1506741f6bc9b 100644
--- a/tests/ui/rust-2024/unsafe-env-suggestion.stderr
+++ b/tests/ui/rust-2024/unsafe-env-suggestion.stderr
@@ -11,7 +11,7 @@ note: the lint level is defined here
    |
 LL | #![deny(deprecated_safe_2024)]
    |         ^^^^^^^^^^^^^^^^^^^^
-help: you can wrap the call in an `unsafe` block if you can guarantee its unsafe preconditions
+help: you can wrap the call in an `unsafe` block if you can guarantee that the environment access only happens in single-threaded code
    |
 LL +     // TODO: Audit that the environment access only happens in single-threaded code.
 LL ~     unsafe { env::set_var("FOO", "BAR") };
@@ -25,7 +25,7 @@ LL |     env::remove_var("FOO");
    |
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2024!
    = note: for more information, see issue #27970 <https://github.com/rust-lang/rust/issues/27970>
-help: you can wrap the call in an `unsafe` block if you can guarantee its unsafe preconditions
+help: you can wrap the call in an `unsafe` block if you can guarantee that the environment access only happens in single-threaded code
    |
 LL +     // TODO: Audit that the environment access only happens in single-threaded code.
 LL ~     unsafe { env::remove_var("FOO") };

From 2a000c8d7073ad1b857c8028a5bbaa21eb12ced5 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 13 Aug 2024 20:23:48 +1000
Subject: [PATCH 175/685] Don't panic on unknown JSON-like output lines

This function is called for both compiler and non-compiler output, so if the
line isn't recognized as JSON from the compiler then just print it as-is.
---
 src/tools/compiletest/src/json.rs | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/tools/compiletest/src/json.rs b/src/tools/compiletest/src/json.rs
index 76b83f02b149a..70c05925b50fc 100644
--- a/src/tools/compiletest/src/json.rs
+++ b/src/tools/compiletest/src/json.rs
@@ -127,11 +127,10 @@ pub fn extract_rendered(output: &str) -> String {
                     // Ignore the notification.
                     None
                 } else {
-                    print!(
-                        "failed to decode compiler output as json: line: {}\noutput: {}",
-                        line, output
-                    );
-                    panic!()
+                    // This function is called for both compiler and non-compiler output,
+                    // so if the line isn't recognized as JSON from the compiler then
+                    // just print it as-is.
+                    Some(format!("{line}\n"))
                 }
             } else {
                 // preserve non-JSON lines, such as ICEs

From 355f264d32cf449e00adeeaccfb17a1e2f3fdd18 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 13 Aug 2024 20:24:53 +1000
Subject: [PATCH 176/685] Remove a confusing comment

The JSON messages parsed by this file are from the _compiler_, not from
libtest.
---
 src/tools/compiletest/src/json.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/tools/compiletest/src/json.rs b/src/tools/compiletest/src/json.rs
index 70c05925b50fc..0da93dcafa20b 100644
--- a/src/tools/compiletest/src/json.rs
+++ b/src/tools/compiletest/src/json.rs
@@ -1,5 +1,4 @@
 //! These structs are a subset of the ones found in `rustc_errors::json`.
-//! They are only used for deserialization of JSON output provided by libtest.
 
 use std::path::{Path, PathBuf};
 use std::str::FromStr;

From aba675fe7597e2aabf53d1d93d52f57aedc97dd6 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Tue, 13 Aug 2024 13:48:23 +0300
Subject: [PATCH 177/685] copy `builder-config` file into ci-rustc sysroot

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/download.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index 4d1aea3cd956a..a88b4a33856cf 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -273,11 +273,12 @@ impl Config {
 
         let mut tar = tar::Archive::new(decompressor);
 
+        let is_ci_rustc = dst.ends_with("ci-rustc");
+
         // `compile::Sysroot` needs to know the contents of the `rustc-dev` tarball to avoid adding
         // it to the sysroot unless it was explicitly requested. But parsing the 100 MB tarball is slow.
         // Cache the entries when we extract it so we only have to read it once.
-        let mut recorded_entries =
-            if dst.ends_with("ci-rustc") { recorded_entries(dst, pattern) } else { None };
+        let mut recorded_entries = if is_ci_rustc { recorded_entries(dst, pattern) } else { None };
 
         for member in t!(tar.entries()) {
             let mut member = t!(member);
@@ -287,10 +288,12 @@ impl Config {
                 continue;
             }
             let mut short_path = t!(original_path.strip_prefix(directory_prefix));
-            if !short_path.starts_with(pattern) {
+            let is_builder_config = short_path.to_str() == Some("builder-config");
+
+            if !short_path.starts_with(pattern) && (is_ci_rustc && !is_builder_config) {
                 continue;
             }
-            short_path = t!(short_path.strip_prefix(pattern));
+            short_path = short_path.strip_prefix(pattern).unwrap_or(short_path);
             let dst_path = dst.join(short_path);
             self.verbose(|| {
                 println!("extracting {} to {}", original_path.display(), dst.display())

From 5fee8408758ea1dfc33712065386d8a4c5213cd5 Mon Sep 17 00:00:00 2001
From: Antoni Spaanderman <56turtle56@gmail.com>
Date: Tue, 13 Aug 2024 13:13:02 +0200
Subject: [PATCH 178/685] fix indentation in docs

---
 clippy_lints/src/attrs/mod.rs     | 4 ++--
 clippy_lints/src/operators/mod.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/clippy_lints/src/attrs/mod.rs b/clippy_lints/src/attrs/mod.rs
index 8f430ae601a85..5d99001e5aa3f 100644
--- a/clippy_lints/src/attrs/mod.rs
+++ b/clippy_lints/src/attrs/mod.rs
@@ -310,8 +310,8 @@ declare_clippy_lint! {
     /// ```rust,ignore
     /// #[allow(unused_mut)]
     /// fn foo() -> usize {
-    ///    let mut a = Vec::new();
-    ///    a.len()
+    ///     let mut a = Vec::new();
+    ///     a.len()
     /// }
     /// ```
     /// Use instead:
diff --git a/clippy_lints/src/operators/mod.rs b/clippy_lints/src/operators/mod.rs
index 9baecff801f21..9e8a821c3f4e8 100644
--- a/clippy_lints/src/operators/mod.rs
+++ b/clippy_lints/src/operators/mod.rs
@@ -80,7 +80,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// // `n` can be any number, including `i32::MAX`.
     /// fn foo(n: i32) -> i32 {
-    ///   n + 1
+    ///     n + 1
     /// }
     /// ```
     ///

From 819fa6f1806c4432c98137e97e3b251ccf047ae8 Mon Sep 17 00:00:00 2001
From: Antoni Spaanderman <56turtle56@gmail.com>
Date: Tue, 13 Aug 2024 13:13:31 +0200
Subject: [PATCH 179/685] fix source location github link

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

diff --git a/declare_clippy_lint/src/lib.rs b/declare_clippy_lint/src/lib.rs
index fd366b6b26277..6aa24329b0659 100644
--- a/declare_clippy_lint/src/lib.rs
+++ b/declare_clippy_lint/src/lib.rs
@@ -156,7 +156,7 @@ pub fn declare_clippy_lint(input: TokenStream) -> TokenStream {
     let category_variant = format_ident!("{category}");
 
     let name_span = name.span().unwrap();
-    let location = format!("{}#{}", name_span.source_file().path().display(), name_span.line());
+    let location = format!("{}#L{}", name_span.source_file().path().display(), name_span.line());
 
     let version = match version {
         Some(version) => quote!(Some(#version)),

From 10cb5aa9349fe99e3c208346eccc09d5ce90b8ba Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 13 Aug 2024 13:51:08 +0200
Subject: [PATCH 180/685] borrow_tracker: update comments regarding protectors

---
 src/tools/miri/src/borrow_tracker/mod.rs                 | 1 -
 .../miri/src/borrow_tracker/stacked_borrows/item.rs      | 9 ++++++---
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/tools/miri/src/borrow_tracker/mod.rs b/src/tools/miri/src/borrow_tracker/mod.rs
index ac4f6979a087b..b632c0d3a62f5 100644
--- a/src/tools/miri/src/borrow_tracker/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/mod.rs
@@ -96,7 +96,6 @@ pub struct GlobalStateInner {
     /// Next unused call ID (for protectors).
     next_call_id: CallId,
     /// All currently protected tags.
-    /// An item is protected if its tag is in this set, *and* it has the "protected" bit set.
     /// We add tags to this when they are created with a protector in `reborrow`, and
     /// we remove tags from this when the call which is protecting them returns, in
     /// `GlobalStateInner::end_call`. See `Stack::item_invalidated` for more details.
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/item.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/item.rs
index b9a52e4966cd7..13846710615eb 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/item.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/item.rs
@@ -7,9 +7,12 @@ use crate::borrow_tracker::BorTag;
 pub struct Item(u64);
 
 // An Item contains 3 bitfields:
-// * Bits 0-61 store a BorTag
-// * Bits 61-63 store a Permission
-// * Bit 64 stores a flag which indicates if we have a protector
+// * Bits 0-61 store a BorTag.
+// * Bits 61-63 store a Permission.
+// * Bit 64 stores a flag which indicates if we might have a protector.
+//   This is purely an optimization: if the bit is set, the tag *might* be
+//   in `protected_tags`, but if the bit is not set then the tag is definitely
+//   not in `protected_tags`.
 const TAG_MASK: u64 = u64::MAX >> 3;
 const PERM_MASK: u64 = 0x3 << 61;
 const PROTECTED_MASK: u64 = 0x1 << 63;

From 53e87d211ca314c5e3e664ef254bd20d134c9a00 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 13 Aug 2024 15:03:18 +0200
Subject: [PATCH 181/685] Remove duplicated rustdoc ui test

---
 .../generate-link-to-definition-opt2.rs                     | 6 ------
 .../generate-link-to-definition-opt2.stderr                 | 2 --
 2 files changed, 8 deletions(-)
 delete mode 100644 tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt2.rs
 delete mode 100644 tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt2.stderr

diff --git a/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt2.rs b/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt2.rs
deleted file mode 100644
index 718522059799e..0000000000000
--- a/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt2.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-// This test purpose is to check that the "--generate-link-to-definition"
-// option can only be used with HTML generation.
-
-//@ compile-flags: -Zunstable-options --generate-link-to-definition --show-coverage
-
-pub fn f() {}
diff --git a/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt2.stderr b/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt2.stderr
deleted file mode 100644
index 4c8c607e7da23..0000000000000
--- a/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt2.stderr
+++ /dev/null
@@ -1,2 +0,0 @@
-error: --generate-link-to-definition option can only be used with HTML output format
-

From d2177d90b04e7af7d52279fe4664002f1e2a9c58 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 13 Aug 2024 15:07:26 +0200
Subject: [PATCH 182/685] Emit a warning instead of an error if
 `--generate-link-to-definition` is used with other output formats than HTML

---
 src/librustdoc/config.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index 9c7a9f8467f5a..d599fead2668a 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -733,9 +733,11 @@ impl Options {
         let html_no_source = matches.opt_present("html-no-source");
 
         if generate_link_to_definition && (show_coverage || output_format != OutputFormat::Html) {
-            dcx.fatal(
-                "--generate-link-to-definition option can only be used with HTML output format",
-            );
+            dcx.struct_warn(
+                "`--generate-link-to-definition` option can only be used with HTML output format",
+            )
+            .with_note("`--generate-link-to-definition` option will be ignored")
+            .emit();
         }
 
         let scrape_examples_options = ScrapeExamplesOptions::new(matches, dcx);

From afbab80681de5f5eb205d1ace743225baf27a9f0 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 13 Aug 2024 15:08:07 +0200
Subject: [PATCH 183/685] Update rustdoc-ui test for
 `--generate-link-to-definition` option

---
 .../generate-link-to-definition-opt.rs                        | 1 +
 .../generate-link-to-definition-opt.stderr                    | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt.rs b/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt.rs
index f11b94bb036c6..babdbd0a69216 100644
--- a/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt.rs
+++ b/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt.rs
@@ -2,5 +2,6 @@
 // option can only be used with HTML generation.
 
 //@ compile-flags: -Zunstable-options --generate-link-to-definition --output-format json
+//@ check-pass
 
 pub fn f() {}
diff --git a/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt.stderr b/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt.stderr
index 4c8c607e7da23..62b0e3ce408b7 100644
--- a/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt.stderr
+++ b/tests/rustdoc-ui/generate-link-to-definition/generate-link-to-definition-opt.stderr
@@ -1,2 +1,4 @@
-error: --generate-link-to-definition option can only be used with HTML output format
+warning: `--generate-link-to-definition` option can only be used with HTML output format
+   |
+   = note: `--generate-link-to-definition` option will be ignored
 

From b2f1fc16979f9a0c17863ffef3178206071eed83 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Tue, 13 Aug 2024 17:20:39 +0300
Subject: [PATCH 184/685] separate inner function (`get_toml`) of
 `Config::parse`

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/config/config.rs | 70 +++++++++++++------------
 1 file changed, 36 insertions(+), 34 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 35ee4a29c6822..91f73c2a48fb2 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -1191,37 +1191,39 @@ impl Config {
         }
     }
 
-    pub fn parse(flags: Flags) -> Config {
-        #[cfg(test)]
-        fn get_toml(_: &Path) -> TomlConfig {
-            TomlConfig::default()
-        }
+    #[cfg(test)]
+    fn get_toml(_: &Path) -> TomlConfig {
+        TomlConfig::default()
+    }
 
-        #[cfg(not(test))]
-        fn get_toml(file: &Path) -> TomlConfig {
-            let contents =
-                t!(fs::read_to_string(file), format!("config file {} not found", file.display()));
-            // Deserialize to Value and then TomlConfig to prevent the Deserialize impl of
-            // TomlConfig and sub types to be monomorphized 5x by toml.
-            toml::from_str(&contents)
-                .and_then(|table: toml::Value| TomlConfig::deserialize(table))
-                .unwrap_or_else(|err| {
-                    if let Ok(Some(changes)) = toml::from_str(&contents)
-                        .and_then(|table: toml::Value| ChangeIdWrapper::deserialize(table)).map(|change_id| change_id.inner.map(crate::find_recent_config_change_ids))
-                    {
-                        if !changes.is_empty() {
-                            println!(
-                                "WARNING: There have been changes to x.py since you last updated:\n{}",
-                                crate::human_readable_changes(&changes)
-                            );
-                        }
+    #[cfg(not(test))]
+    fn get_toml(file: &Path) -> TomlConfig {
+        let contents =
+            t!(fs::read_to_string(file), format!("config file {} not found", file.display()));
+        // Deserialize to Value and then TomlConfig to prevent the Deserialize impl of
+        // TomlConfig and sub types to be monomorphized 5x by toml.
+        toml::from_str(&contents)
+            .and_then(|table: toml::Value| TomlConfig::deserialize(table))
+            .unwrap_or_else(|err| {
+                if let Ok(Some(changes)) = toml::from_str(&contents)
+                    .and_then(|table: toml::Value| ChangeIdWrapper::deserialize(table))
+                    .map(|change_id| change_id.inner.map(crate::find_recent_config_change_ids))
+                {
+                    if !changes.is_empty() {
+                        println!(
+                            "WARNING: There have been changes to x.py since you last updated:\n{}",
+                            crate::human_readable_changes(&changes)
+                        );
                     }
+                }
 
-                    eprintln!("failed to parse TOML configuration '{}': {err}", file.display());
-                    exit!(2);
-                })
-        }
-        Self::parse_inner(flags, get_toml)
+                eprintln!("failed to parse TOML configuration '{}': {err}", file.display());
+                exit!(2);
+            })
+    }
+
+    pub fn parse(flags: Flags) -> Config {
+        Self::parse_inner(flags, Self::get_toml)
     }
 
     pub(crate) fn parse_inner(mut flags: Flags, get_toml: impl Fn(&Path) -> TomlConfig) -> Config {
@@ -2656,10 +2658,10 @@ fn check_incompatible_options_for_ci_rustc(rust: &Rust) -> Result<(), String> {
     macro_rules! err {
         ($name:expr) => {
             if $name.is_some() {
-                return Err(format!(
-                    "ERROR: Setting `rust.{}` is incompatible with `rust.download-rustc`.",
+                    return Err(format!(
+                        "ERROR: Setting `rust.{}` is incompatible with `rust.download-rustc`.",
                     stringify!($name).replace("_", "-")
-                ));
+                    ));
             }
         };
     }
@@ -2667,10 +2669,10 @@ fn check_incompatible_options_for_ci_rustc(rust: &Rust) -> Result<(), String> {
     macro_rules! warn {
         ($name:expr) => {
             if $name.is_some() {
-                println!(
-                    "WARNING: `rust.{}` has no effect with `rust.download-rustc`.",
+                    println!(
+                        "WARNING: `rust.{}` has no effect with `rust.download-rustc`.",
                     stringify!($name).replace("_", "-")
-                );
+                    );
             }
         };
     }

From 0518e8c7fd8c7e890b7a3f603944136374596639 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Tue, 13 Aug 2024 17:22:13 +0300
Subject: [PATCH 185/685] detect incompatible CI rustc options more precisely

Previously, the logic here was simply checking whether the option was set in `config.toml`.
This approach was not manageable in our CI runners as we set so many options in config.toml.
In reality, those values are not incompatible since they are usually the same value used to generate
the CI rustc. Now, the new logic compares the configuration values with the values used to generate
the CI rustc, so we get more precise results and make the process more manageable.

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/config/config.rs | 117 ++++++++++++++----------
 1 file changed, 69 insertions(+), 48 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 91f73c2a48fb2..2f28d1d2cbe5b 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -117,7 +117,7 @@ impl Display for DebuginfoLevel {
 /// 2) MSVC
 /// - Self-contained: `-Clinker=<path to rust-lld>`
 /// - External: `-Clinker=lld`
-#[derive(Default, Copy, Clone)]
+#[derive(Copy, Clone, Default, PartialEq)]
 pub enum LldMode {
     /// Do not use LLD
     #[default]
@@ -1581,24 +1581,6 @@ impl Config {
         let mut is_user_configured_rust_channel = false;
 
         if let Some(rust) = toml.rust {
-            if let Some(commit) = config.download_ci_rustc_commit(rust.download_rustc.clone()) {
-                // Primarily used by CI runners to avoid handling download-rustc incompatible
-                // options one by one on shell scripts.
-                let disable_ci_rustc_if_incompatible =
-                    env::var_os("DISABLE_CI_RUSTC_IF_INCOMPATIBLE")
-                        .is_some_and(|s| s == "1" || s == "true");
-
-                if let Err(e) = check_incompatible_options_for_ci_rustc(&rust) {
-                    if disable_ci_rustc_if_incompatible {
-                        config.download_rustc_commit = None;
-                    } else {
-                        panic!("{}", e);
-                    }
-                } else {
-                    config.download_rustc_commit = Some(commit);
-                }
-            }
-
             let Rust {
                 optimize: optimize_toml,
                 debug: debug_toml,
@@ -1646,7 +1628,7 @@ impl Config {
                 new_symbol_mangling,
                 profile_generate,
                 profile_use,
-                download_rustc: _,
+                download_rustc,
                 lto,
                 validate_mir_opts,
                 frame_pointers,
@@ -1658,6 +1640,8 @@ impl Config {
             is_user_configured_rust_channel = channel.is_some();
             set(&mut config.channel, channel.clone());
 
+            config.download_rustc_commit = config.download_ci_rustc_commit(download_rustc);
+
             debug = debug_toml;
             debug_assertions = debug_assertions_toml;
             debug_assertions_std = debug_assertions_std_toml;
@@ -2335,6 +2319,29 @@ impl Config {
                 None => None,
                 Some(commit) => {
                     self.download_ci_rustc(commit);
+
+                    let builder_config_path =
+                        self.out.join(self.build.triple).join("ci-rustc/builder-config");
+                    let ci_config_toml = Self::get_toml(&builder_config_path);
+                    let current_config_toml = Self::get_toml(self.config.as_ref().unwrap());
+
+                    // Check the config compatibility
+                    let res = check_incompatible_options_for_ci_rustc(
+                        current_config_toml,
+                        ci_config_toml,
+                    );
+
+                    let disable_ci_rustc_if_incompatible =
+                        env::var_os("DISABLE_CI_RUSTC_IF_INCOMPATIBLE")
+                            .is_some_and(|s| s == "1" || s == "true");
+
+                    if disable_ci_rustc_if_incompatible && res.is_err() {
+                        println!("WARNING: download-rustc is disabled with `DISABLE_CI_RUSTC_IF_INCOMPATIBLE` env.");
+                        return None;
+                    }
+
+                    res.unwrap();
+
                     Some(commit.clone())
                 }
             })
@@ -2652,31 +2659,44 @@ impl Config {
     }
 }
 
-/// Checks the CI rustc incompatible options by destructuring the `Rust` instance
-/// and makes sure that no rust options from config.toml are missed.
-fn check_incompatible_options_for_ci_rustc(rust: &Rust) -> Result<(), String> {
+/// Compares the current Rust options against those in the CI rustc builder and detects any incompatible options.
+/// It does this by destructuring the `Rust` instance to make sure every `Rust` field is covered and not missing.
+fn check_incompatible_options_for_ci_rustc(
+    current_config_toml: TomlConfig,
+    ci_config_toml: TomlConfig,
+) -> Result<(), String> {
     macro_rules! err {
-        ($name:expr) => {
-            if $name.is_some() {
+        ($current:expr, $expected:expr) => {
+            if let Some(current) = $current {
+                if Some(current) != $expected {
                     return Err(format!(
                         "ERROR: Setting `rust.{}` is incompatible with `rust.download-rustc`.",
-                    stringify!($name).replace("_", "-")
+                        stringify!($expected).replace("_", "-")
                     ));
-            }
+                };
+            };
         };
     }
 
     macro_rules! warn {
-        ($name:expr) => {
-            if $name.is_some() {
+        ($current:expr, $expected:expr) => {
+            if let Some(current) = $current {
+                if Some(current) != $expected {
                     println!(
                         "WARNING: `rust.{}` has no effect with `rust.download-rustc`.",
-                    stringify!($name).replace("_", "-")
+                        stringify!($expected).replace("_", "-")
                     );
-            }
+                };
+            };
         };
     }
 
+    let (Some(current_rust_config), Some(ci_rust_config)) =
+        (current_config_toml.rust, ci_config_toml.rust)
+    else {
+        return Ok(());
+    };
+
     let Rust {
         // Following options are the CI rustc incompatible ones.
         optimize,
@@ -2734,7 +2754,7 @@ fn check_incompatible_options_for_ci_rustc(rust: &Rust) -> Result<(), String> {
         download_rustc: _,
         validate_mir_opts: _,
         frame_pointers: _,
-    } = rust;
+    } = ci_rust_config;
 
     // There are two kinds of checks for CI rustc incompatible options:
     //    1. Checking an option that may change the compiler behaviour/output.
@@ -2742,22 +2762,23 @@ fn check_incompatible_options_for_ci_rustc(rust: &Rust) -> Result<(), String> {
     //
     // If the option belongs to the first category, we call `err` macro for a hard error;
     // otherwise, we just print a warning with `warn` macro.
-    err!(optimize);
-    err!(debug_logging);
-    err!(debuginfo_level_rustc);
-    err!(default_linker);
-    err!(rpath);
-    err!(strip);
-    err!(stack_protector);
-    err!(lld_mode);
-    err!(llvm_tools);
-    err!(llvm_bitcode_linker);
-    err!(jemalloc);
-    err!(lto);
-
-    warn!(channel);
-    warn!(description);
-    warn!(incremental);
+
+    err!(current_rust_config.optimize, optimize);
+    err!(current_rust_config.debug_logging, debug_logging);
+    err!(current_rust_config.debuginfo_level_rustc, debuginfo_level_rustc);
+    err!(current_rust_config.rpath, rpath);
+    err!(current_rust_config.strip, strip);
+    err!(current_rust_config.lld_mode, lld_mode);
+    err!(current_rust_config.llvm_tools, llvm_tools);
+    err!(current_rust_config.llvm_bitcode_linker, llvm_bitcode_linker);
+    err!(current_rust_config.jemalloc, jemalloc);
+    err!(current_rust_config.default_linker, default_linker);
+    err!(current_rust_config.stack_protector, stack_protector);
+    err!(current_rust_config.lto, lto);
+
+    warn!(current_rust_config.channel, channel);
+    warn!(current_rust_config.description, description);
+    warn!(current_rust_config.incremental, incremental);
 
     Ok(())
 }

From 0aa17a4c4de2daaf44e38e40f3ac8c2b4275d6bd Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 24 Jul 2024 17:07:22 +0200
Subject: [PATCH 186/685] implement a performant and fuzzed solver cache

---
 .../src/solve/search_graph.rs                 |  52 +-
 .../src/search_graph/global_cache.rs          |  72 +-
 .../rustc_type_ir/src/search_graph/mod.rs     | 913 +++++++++++++-----
 .../src/search_graph/validate.rs              |  63 --
 4 files changed, 741 insertions(+), 359 deletions(-)
 delete mode 100644 compiler/rustc_type_ir/src/search_graph/validate.rs

diff --git a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
index 0994d0e3b3d88..81c89fad8e8a0 100644
--- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
@@ -2,12 +2,12 @@ use std::convert::Infallible;
 use std::marker::PhantomData;
 
 use rustc_type_ir::inherent::*;
-use rustc_type_ir::search_graph::{self, CycleKind, UsageKind};
+use rustc_type_ir::search_graph::{self, PathKind};
 use rustc_type_ir::solve::{CanonicalInput, Certainty, QueryResult};
 use rustc_type_ir::Interner;
 
 use super::inspect::ProofTreeBuilder;
-use super::FIXPOINT_STEP_LIMIT;
+use super::{has_no_inference_or_external_constraints, FIXPOINT_STEP_LIMIT};
 use crate::delegate::SolverDelegate;
 
 /// This type is never constructed. We only use it to implement `search_graph::Delegate`
@@ -23,10 +23,11 @@ where
 {
     type Cx = D::Interner;
 
+    const ENABLE_PROVISIONAL_CACHE: bool = true;
     type ValidationScope = Infallible;
     fn enter_validation_scope(
         _cx: Self::Cx,
-        _input: <Self::Cx as search_graph::Cx>::Input,
+        _input: CanonicalInput<I>,
     ) -> Option<Self::ValidationScope> {
         None
     }
@@ -38,39 +39,32 @@ where
         inspect.is_noop()
     }
 
+    const DIVIDE_AVAILABLE_DEPTH_ON_OVERFLOW: usize = 4;
     fn recursion_limit(cx: I) -> usize {
         cx.recursion_limit()
     }
 
     fn initial_provisional_result(
         cx: I,
-        kind: CycleKind,
+        kind: PathKind,
         input: CanonicalInput<I>,
     ) -> QueryResult<I> {
         match kind {
-            CycleKind::Coinductive => response_no_constraints(cx, input, Certainty::Yes),
-            CycleKind::Inductive => response_no_constraints(cx, input, Certainty::overflow(false)),
+            PathKind::Coinductive => response_no_constraints(cx, input, Certainty::Yes),
+            PathKind::Inductive => response_no_constraints(cx, input, Certainty::overflow(false)),
         }
     }
 
-    fn reached_fixpoint(
-        cx: I,
-        kind: UsageKind,
+    fn is_initial_provisional_result(
+        cx: Self::Cx,
+        kind: PathKind,
         input: CanonicalInput<I>,
-        provisional_result: Option<QueryResult<I>>,
         result: QueryResult<I>,
     ) -> bool {
-        if let Some(r) = provisional_result {
-            r == result
-        } else {
-            match kind {
-                UsageKind::Single(CycleKind::Coinductive) => {
-                    response_no_constraints(cx, input, Certainty::Yes) == result
-                }
-                UsageKind::Single(CycleKind::Inductive) => {
-                    response_no_constraints(cx, input, Certainty::overflow(false)) == result
-                }
-                UsageKind::Mixed => false,
+        match kind {
+            PathKind::Coinductive => response_no_constraints(cx, input, Certainty::Yes) == result,
+            PathKind::Inductive => {
+                response_no_constraints(cx, input, Certainty::overflow(false)) == result
             }
         }
     }
@@ -88,6 +82,22 @@ where
         response_no_constraints(cx, input, Certainty::overflow(false))
     }
 
+    fn is_ambiguous_result(result: QueryResult<I>) -> bool {
+        result.is_ok_and(|response| {
+            has_no_inference_or_external_constraints(response)
+                && matches!(response.value.certainty, Certainty::Maybe(_))
+        })
+    }
+
+    fn propagate_ambiguity(
+        cx: I,
+        for_input: CanonicalInput<I>,
+        from_result: QueryResult<I>,
+    ) -> QueryResult<I> {
+        let certainty = from_result.unwrap().value.certainty;
+        response_no_constraints(cx, for_input, certainty)
+    }
+
     fn step_is_coinductive(cx: I, input: CanonicalInput<I>) -> bool {
         input.value.goal.predicate.is_coinductive(cx)
     }
diff --git a/compiler/rustc_type_ir/src/search_graph/global_cache.rs b/compiler/rustc_type_ir/src/search_graph/global_cache.rs
index d63a8d16bea73..47f7cefac6ad1 100644
--- a/compiler/rustc_type_ir/src/search_graph/global_cache.rs
+++ b/compiler/rustc_type_ir/src/search_graph/global_cache.rs
@@ -1,12 +1,17 @@
 use derive_where::derive_where;
-use rustc_index::IndexVec;
 
-use super::{AvailableDepth, Cx, StackDepth, StackEntry};
-use crate::data_structures::{HashMap, HashSet};
+use super::{AvailableDepth, Cx, NestedGoals};
+use crate::data_structures::HashMap;
 
 struct Success<X: Cx> {
-    result: X::Tracked<X::Result>,
     additional_depth: usize,
+    nested_goals: NestedGoals<X>,
+    result: X::Tracked<X::Result>,
+}
+
+struct WithOverflow<X: Cx> {
+    nested_goals: NestedGoals<X>,
+    result: X::Tracked<X::Result>,
 }
 
 /// The cache entry for a given input.
@@ -17,12 +22,7 @@ struct Success<X: Cx> {
 #[derive_where(Default; X: Cx)]
 struct CacheEntry<X: Cx> {
     success: Option<Success<X>>,
-    /// We have to be careful when caching roots of cycles.
-    ///
-    /// See the doc comment of `StackEntry::cycle_participants` for more
-    /// details.
-    nested_goals: HashSet<X::Input>,
-    with_overflow: HashMap<usize, X::Tracked<X::Result>>,
+    with_overflow: HashMap<usize, WithOverflow<X>>,
 }
 
 #[derive_where(Debug; X: Cx)]
@@ -30,10 +30,7 @@ pub(super) struct CacheData<'a, X: Cx> {
     pub(super) result: X::Result,
     pub(super) additional_depth: usize,
     pub(super) encountered_overflow: bool,
-    // FIXME: This is currently unused, but impacts the design
-    // by requiring a closure for `Cx::with_global_cache`.
-    #[allow(dead_code)]
-    pub(super) nested_goals: &'a HashSet<X::Input>,
+    pub(super) nested_goals: &'a NestedGoals<X>,
 }
 #[derive_where(Default; X: Cx)]
 pub struct GlobalCache<X: Cx> {
@@ -52,15 +49,17 @@ impl<X: Cx> GlobalCache<X> {
 
         additional_depth: usize,
         encountered_overflow: bool,
-        nested_goals: &HashSet<X::Input>,
+        nested_goals: NestedGoals<X>,
     ) {
         let result = cx.mk_tracked(result, dep_node);
         let entry = self.map.entry(input).or_default();
-        entry.nested_goals.extend(nested_goals);
         if encountered_overflow {
-            entry.with_overflow.insert(additional_depth, result);
+            let with_overflow = WithOverflow { nested_goals, result };
+            let prev = entry.with_overflow.insert(additional_depth, with_overflow);
+            assert!(prev.is_none());
         } else {
-            entry.success = Some(Success { result, additional_depth });
+            let prev = entry.success.replace(Success { additional_depth, nested_goals, result });
+            assert!(prev.is_none());
         }
     }
 
@@ -72,30 +71,37 @@ impl<X: Cx> GlobalCache<X> {
         &'a self,
         cx: X,
         input: X::Input,
-        stack: &IndexVec<StackDepth, StackEntry<X>>,
         available_depth: AvailableDepth,
+        mut candidate_is_applicable: impl FnMut(&NestedGoals<X>) -> bool,
     ) -> Option<CacheData<'a, X>> {
         let entry = self.map.get(&input)?;
-        if stack.iter().any(|e| entry.nested_goals.contains(&e.input)) {
-            return None;
+        if let Some(Success { additional_depth, ref nested_goals, ref result }) = entry.success {
+            if available_depth.cache_entry_is_applicable(additional_depth)
+                && candidate_is_applicable(nested_goals)
+            {
+                return Some(CacheData {
+                    result: cx.get_tracked(&result),
+                    additional_depth,
+                    encountered_overflow: false,
+                    nested_goals,
+                });
+            }
         }
 
-        if let Some(ref success) = entry.success {
-            if available_depth.cache_entry_is_applicable(success.additional_depth) {
+        let additional_depth = available_depth.0;
+        if let Some(WithOverflow { nested_goals, result }) =
+            entry.with_overflow.get(&additional_depth)
+        {
+            if candidate_is_applicable(nested_goals) {
                 return Some(CacheData {
-                    result: cx.get_tracked(&success.result),
-                    additional_depth: success.additional_depth,
-                    encountered_overflow: false,
-                    nested_goals: &entry.nested_goals,
+                    result: cx.get_tracked(result),
+                    additional_depth,
+                    encountered_overflow: true,
+                    nested_goals,
                 });
             }
         }
 
-        entry.with_overflow.get(&available_depth.0).map(|e| CacheData {
-            result: cx.get_tracked(e),
-            additional_depth: available_depth.0,
-            encountered_overflow: true,
-            nested_goals: &entry.nested_goals,
-        })
+        None
     }
 }
diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index a1aa63c2e7d75..d47c9e725f350 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -1,19 +1,32 @@
+/// The search graph is responsible for caching and cycle detection in the trait
+/// solver. Making sure that caching doesn't result in soundness bugs or unstable
+/// query results is very challenging and makes this one of the most-involved
+/// self-contained components of the compiler.
+///
+/// We added fuzzing support to test its correctness. The fuzzers used to verify
+/// the current implementation can be found in https://github.com/lcnr/search_graph_fuzz.
+///
+/// This is just a quick overview of the general design, please check out the relevant
+/// [rustc-dev-guide chapter](https://rustc-dev-guide.rust-lang.org/solve/caching.html) for
+/// more details. Caching is split between a global cache and the per-cycle `provisional_cache`.
+/// The global cache has to be completely unobservable, while the per-cycle cache may impact
+/// behavior as long as the resulting behavior is still correct.
+use std::cmp::Ordering;
+use std::collections::BTreeSet;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::marker::PhantomData;
-use std::mem;
 
 use derive_where::derive_where;
 use rustc_index::{Idx, IndexVec};
 use tracing::debug;
 
-use crate::data_structures::{HashMap, HashSet};
+use crate::data_structures::HashMap;
 use crate::solve::SolverMode;
 
 mod global_cache;
 use global_cache::CacheData;
 pub use global_cache::GlobalCache;
-mod validate;
 
 /// The search graph does not simply use `Interner` directly
 /// to enable its fuzzing without having to stub the rest of
@@ -44,6 +57,9 @@ pub trait Cx: Copy {
 
 pub trait Delegate {
     type Cx: Cx;
+    /// Whether to use the provisional cache. Set to `false` by a fuzzer when
+    /// validating the search graph.
+    const ENABLE_PROVISIONAL_CACHE: bool;
     type ValidationScope;
     /// Returning `Some` disables the global cache for the current goal.
     ///
@@ -62,18 +78,18 @@ pub trait Delegate {
     type ProofTreeBuilder;
     fn inspect_is_noop(inspect: &mut Self::ProofTreeBuilder) -> bool;
 
+    const DIVIDE_AVAILABLE_DEPTH_ON_OVERFLOW: usize;
     fn recursion_limit(cx: Self::Cx) -> usize;
 
     fn initial_provisional_result(
         cx: Self::Cx,
-        kind: CycleKind,
+        kind: PathKind,
         input: <Self::Cx as Cx>::Input,
     ) -> <Self::Cx as Cx>::Result;
-    fn reached_fixpoint(
+    fn is_initial_provisional_result(
         cx: Self::Cx,
-        kind: UsageKind,
+        kind: PathKind,
         input: <Self::Cx as Cx>::Input,
-        provisional_result: Option<<Self::Cx as Cx>::Result>,
         result: <Self::Cx as Cx>::Result,
     ) -> bool;
     fn on_stack_overflow(
@@ -86,6 +102,13 @@ pub trait Delegate {
         input: <Self::Cx as Cx>::Input,
     ) -> <Self::Cx as Cx>::Result;
 
+    fn is_ambiguous_result(result: <Self::Cx as Cx>::Result) -> bool;
+    fn propagate_ambiguity(
+        cx: Self::Cx,
+        for_input: <Self::Cx as Cx>::Input,
+        from_result: <Self::Cx as Cx>::Result,
+    ) -> <Self::Cx as Cx>::Result;
+
     fn step_is_coinductive(cx: Self::Cx, input: <Self::Cx as Cx>::Input) -> bool;
 }
 
@@ -93,14 +116,14 @@ pub trait Delegate {
 /// result. In the case we return an initial provisional result depending
 /// on the kind of cycle.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum CycleKind {
+pub enum PathKind {
     Coinductive,
     Inductive,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum UsageKind {
-    Single(CycleKind),
+    Single(PathKind),
     Mixed,
 }
 impl UsageKind {
@@ -116,11 +139,9 @@ impl UsageKind {
             }
         }
     }
-}
-
-enum StepResult<X: Cx> {
-    Done(StackEntry<X>, X::Result),
-    HasChanged,
+    fn and_merge(&mut self, other: Self) {
+        *self = self.merge(other);
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -142,7 +163,7 @@ impl AvailableDepth {
             }
 
             Some(if last.encountered_overflow {
-                AvailableDepth(last.available_depth.0 / 2)
+                AvailableDepth(last.available_depth.0 / D::DIVIDE_AVAILABLE_DEPTH_ON_OVERFLOW)
             } else {
                 AvailableDepth(last.available_depth.0 - 1)
             })
@@ -158,94 +179,181 @@ impl AvailableDepth {
     }
 }
 
+/// All cycle heads a given goal depends on, ordered by their stack depth.
+///
+/// We therefore pop the cycle heads from highest to lowest.
+#[derive(Clone, Debug, PartialEq, Eq, Default)]
+struct CycleHeads {
+    heads: BTreeSet<StackDepth>,
+}
+
+impl CycleHeads {
+    fn is_empty(&self) -> bool {
+        self.heads.is_empty()
+    }
+
+    fn highest_cycle_head(&self) -> StackDepth {
+        *self.heads.last().unwrap()
+    }
+
+    fn opt_highest_cycle_head(&self) -> Option<StackDepth> {
+        self.heads.last().copied()
+    }
+
+    fn opt_lowest_cycle_head(&self) -> Option<StackDepth> {
+        self.heads.first().copied()
+    }
+
+    fn remove_highest_cycle_head(&mut self) {
+        let last = self.heads.pop_last();
+        debug_assert_ne!(last, None);
+    }
+
+    fn insert(&mut self, head: StackDepth) {
+        self.heads.insert(head);
+    }
+
+    fn merge(&mut self, heads: &CycleHeads) {
+        for &head in heads.heads.iter() {
+            self.insert(head);
+        }
+    }
+
+    /// Update the cycle heads of a goal at depth `this` given the cycle heads
+    /// of a nested goal. This merges the heads after filtering the parent goal
+    /// itself.
+    fn extend_from_child(&mut self, this: StackDepth, child: &CycleHeads) {
+        for &head in child.heads.iter() {
+            match head.cmp(&this) {
+                Ordering::Less => {}
+                Ordering::Equal => continue,
+                Ordering::Greater => unreachable!(),
+            }
+
+            self.insert(head);
+        }
+    }
+}
+
+/// The nested goals of each stack entry and the path from the
+/// stack entry to that nested goal.
+///
+/// We only start tracking nested goals once we've either encountered
+/// overflow or a solver cycle. This is a performance optimization to
+/// avoid tracking nested goals on the happy path.
+///
+/// We use nested goals for two reasons:
+/// - when rebasing provisional cache entries
+/// - when checking whether we have to ignore a global cache entry as reevaluating
+///   it would encounter a cycle or use a provisional cache entry.
+///
+/// We need to disable the global cache if using it would hide a cycle, as
+/// cycles can impact behavior. The cycle ABA may have different final
+/// results from a the cycle BAB depending on the cycle root.
+#[derive_where(Debug, Default; X: Cx)]
+struct NestedGoals<X: Cx> {
+    nested_goals: HashMap<X::Input, UsageKind>,
+}
+impl<X: Cx> NestedGoals<X> {
+    fn is_empty(&self) -> bool {
+        self.nested_goals.is_empty()
+    }
+
+    fn insert(&mut self, input: X::Input, path_from_entry: UsageKind) {
+        self.nested_goals.entry(input).or_insert(path_from_entry).and_merge(path_from_entry);
+    }
+
+    fn merge(&mut self, nested_goals: &NestedGoals<X>) {
+        #[allow(rustc::potential_query_instability)]
+        for (input, path_from_entry) in nested_goals.iter() {
+            self.insert(input, path_from_entry);
+        }
+    }
+
+    /// Adds the nested goals of a nested goal, given that the path `step_kind` from this goal
+    /// to the parent goal.
+    ///
+    /// If the path from this goal to the nested goal is inductive, the paths from this goal
+    /// to all nested goals of that nested goal are also inductive. Otherwise the paths are
+    /// the same as for the child.
+    fn extend_from_child(&mut self, step_kind: PathKind, nested_goals: &NestedGoals<X>) {
+        #[allow(rustc::potential_query_instability)]
+        for (input, path_from_entry) in nested_goals.iter() {
+            let path_from_entry = match step_kind {
+                PathKind::Coinductive => path_from_entry,
+                PathKind::Inductive => UsageKind::Single(PathKind::Inductive),
+            };
+            self.insert(input, path_from_entry);
+        }
+    }
+
+    #[rustc_lint_query_instability]
+    #[allow(rustc::potential_query_instability)]
+    fn iter(&self) -> impl Iterator<Item = (X::Input, UsageKind)> + '_ {
+        self.nested_goals.iter().map(|(i, p)| (*i, *p))
+    }
+
+    fn get(&self, input: X::Input) -> Option<UsageKind> {
+        self.nested_goals.get(&input).copied()
+    }
+
+    fn contains(&self, input: X::Input) -> bool {
+        self.nested_goals.contains_key(&input)
+    }
+}
+
 rustc_index::newtype_index! {
     #[orderable]
     #[gate_rustc_only]
     pub struct StackDepth {}
 }
 
+/// Stack entries of the evaluation stack. Its fields tend to be lazily
+/// when popping a child goal or completely immutable.
 #[derive_where(Debug; X: Cx)]
 struct StackEntry<X: Cx> {
     input: X::Input,
 
+    /// The available depth of a given goal, immutable.
     available_depth: AvailableDepth,
 
     /// The maximum depth reached by this stack entry, only up-to date
     /// for the top of the stack and lazily updated for the rest.
     reached_depth: StackDepth,
 
-    /// Whether this entry is a non-root cycle participant.
-    ///
-    /// We must not move the result of non-root cycle participants to the
-    /// global cache. We store the highest stack depth of a head of a cycle
-    /// this goal is involved in. This necessary to soundly cache its
-    /// provisional result.
-    non_root_cycle_participant: Option<StackDepth>,
+    /// All cycle heads this goal depends on. Lazily updated and only
+    /// up-to date for the top of the stack.
+    heads: CycleHeads,
 
+    /// Whether evaluating this goal encountered overflow. Lazily updated.
     encountered_overflow: bool,
 
+    /// Whether this goal has been used as the root of a cycle. This gets
+    /// eagerly updated when encountering a cycle.
     has_been_used: Option<UsageKind>,
 
-    /// We put only the root goal of a coinductive cycle into the global cache.
-    ///
-    /// If we were to use that result when later trying to prove another cycle
-    /// participant, we can end up with unstable query results.
-    ///
-    /// See tests/ui/next-solver/coinduction/incompleteness-unstable-result.rs for
-    /// an example of where this is needed.
-    ///
-    /// There can  be multiple roots on the same stack, so we need to track
-    /// cycle participants per root:
-    /// ```plain
-    /// A :- B
-    /// B :- A, C
-    /// C :- D
-    /// D :- C
-    /// ```
-    nested_goals: HashSet<X::Input>,
+    /// The nested goals of this goal, see the doc comment of the type.
+    nested_goals: NestedGoals<X>,
+
     /// Starts out as `None` and gets set when rerunning this
     /// goal in case we encounter a cycle.
     provisional_result: Option<X::Result>,
 }
 
-/// The provisional result for a goal which is not on the stack.
-#[derive(Debug)]
-struct DetachedEntry<X: Cx> {
-    /// The head of the smallest non-trivial cycle involving this entry.
-    ///
-    /// Given the following rules, when proving `A` the head for
-    /// the provisional entry of `C` would be `B`.
-    /// ```plain
-    /// A :- B
-    /// B :- C
-    /// C :- A + B + C
-    /// ```
-    head: StackDepth,
-    result: X::Result,
-}
-
-/// Stores the provisional result of already computed results for goals which
-/// depend on other goals still on the stack.
-///
-/// The provisional result may depend on whether the stack above it is inductive
-/// or coinductive. Because of this, we store separate provisional results for
-/// each case. If an provisional entry is not applicable, it may be the case
-/// that we already have provisional result while computing a goal. In this case
-/// we prefer the provisional result to potentially avoid fixpoint iterations.
-/// See tests/ui/traits/next-solver/cycles/mixed-cycles-2.rs for an example.
-///
-/// The provisional cache can theoretically result in changes to the observable behavior,
-/// see tests/ui/traits/next-solver/cycles/provisional-cache-impacts-behavior.rs.
-#[derive_where(Default; X: Cx)]
+/// A provisional result of an already computed goals which depends on other
+/// goals still on the stack.
+#[derive_where(Debug; X: Cx)]
 struct ProvisionalCacheEntry<X: Cx> {
-    with_inductive_stack: Option<DetachedEntry<X>>,
-    with_coinductive_stack: Option<DetachedEntry<X>>,
-}
-
-impl<X: Cx> ProvisionalCacheEntry<X> {
-    fn is_empty(&self) -> bool {
-        self.with_inductive_stack.is_none() && self.with_coinductive_stack.is_none()
-    }
+    /// Whether evaluating the goal encountered overflow. This is used to
+    /// disable the cache entry except if the last goal on the stack is
+    /// already involved in this cycle.
+    encountered_overflow: bool,
+    /// All cycle heads this cache entry depends on.
+    heads: CycleHeads,
+    /// The path from the highest cycle head to this goal.
+    path_from_head: PathKind,
+    nested_goals: NestedGoals<X>,
+    result: X::Result,
 }
 
 pub struct SearchGraph<D: Delegate<Cx = X>, X: Cx = <D as Delegate>::Cx> {
@@ -254,7 +362,11 @@ pub struct SearchGraph<D: Delegate<Cx = X>, X: Cx = <D as Delegate>::Cx> {
     ///
     /// An element is *deeper* in the stack if its index is *lower*.
     stack: IndexVec<StackDepth, StackEntry<X>>,
-    provisional_cache: HashMap<X::Input, ProvisionalCacheEntry<X>>,
+    /// The provisional cache contains entries for already computed goals which
+    /// still depend on goals higher-up in the stack. We don't move them to the
+    /// global cache and track them locally instead. A provisional cache entry
+    /// is only valid until the result of one of its cycle heads changes.
+    provisional_cache: HashMap<X::Input, Vec<ProvisionalCacheEntry<X>>>,
 
     _marker: PhantomData<D>,
 }
@@ -273,67 +385,66 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         self.mode
     }
 
-    fn update_parent_goal(&mut self, reached_depth: StackDepth, encountered_overflow: bool) {
-        if let Some(parent) = self.stack.raw.last_mut() {
+    /// Lazily update the stack entry for the parent goal.
+    /// This behavior is shared between actually evaluating goals
+    /// and using existing global cache entries to make sure they
+    /// have the same impact on the remaining evaluation.
+    fn update_parent_goal(
+        cx: X,
+        stack: &mut IndexVec<StackDepth, StackEntry<X>>,
+        reached_depth: StackDepth,
+        heads: &CycleHeads,
+        encountered_overflow: bool,
+        nested_goals: &NestedGoals<X>,
+    ) {
+        if let Some(parent_index) = stack.last_index() {
+            let parent = &mut stack[parent_index];
             parent.reached_depth = parent.reached_depth.max(reached_depth);
             parent.encountered_overflow |= encountered_overflow;
+
+            parent.heads.extend_from_child(parent_index, heads);
+            let step_kind = Self::step_kind(cx, parent.input);
+            parent.nested_goals.extend_from_child(step_kind, nested_goals);
+            // Once we've got goals which encountered overflow or a cycle,
+            // we track all goals whose behavior may depend depend on these
+            // goals as this change may cause them to now depend on additional
+            // goals, resulting in new cycles. See the dev-guide for examples.
+            if !nested_goals.is_empty() {
+                parent.nested_goals.insert(parent.input, UsageKind::Single(PathKind::Coinductive))
+            }
         }
     }
 
     pub fn is_empty(&self) -> bool {
-        self.stack.is_empty()
+        if self.stack.is_empty() {
+            debug_assert!(self.provisional_cache.is_empty());
+            true
+        } else {
+            false
+        }
     }
 
-    fn stack_coinductive_from(
-        cx: X,
-        stack: &IndexVec<StackDepth, StackEntry<X>>,
-        head: StackDepth,
-    ) -> bool {
-        stack.raw[head.index()..].iter().all(|entry| D::step_is_coinductive(cx, entry.input))
-    }
-
-    // When encountering a solver cycle, the result of the current goal
-    // depends on goals lower on the stack.
-    //
-    // We have to therefore be careful when caching goals. Only the final result
-    // of the cycle root, i.e. the lowest goal on the stack involved in this cycle,
-    // is moved to the global cache while all others are stored in a provisional cache.
-    //
-    // We update both the head of this cycle to rerun its evaluation until
-    // we reach a fixpoint and all other cycle participants to make sure that
-    // their result does not get moved to the global cache.
-    fn tag_cycle_participants(stack: &mut IndexVec<StackDepth, StackEntry<X>>, head: StackDepth) {
-        // The current root of these cycles. Note that this may not be the final
-        // root in case a later goal depends on a goal higher up the stack.
-        let mut current_root = head;
-        while let Some(parent) = stack[current_root].non_root_cycle_participant {
-            current_root = parent;
-            debug_assert!(stack[current_root].has_been_used.is_some());
-        }
+    /// The number of goals currently in the search graph. This should only be
+    /// used for debugging purposes.
+    pub fn debug_current_depth(&self) -> usize {
+        self.stack.len()
+    }
 
-        let (stack, cycle_participants) = stack.raw.split_at_mut(head.index() + 1);
-        let current_cycle_root = &mut stack[current_root.as_usize()];
-        for entry in cycle_participants {
-            entry.non_root_cycle_participant = entry.non_root_cycle_participant.max(Some(head));
-            current_cycle_root.nested_goals.insert(entry.input);
-            current_cycle_root.nested_goals.extend(mem::take(&mut entry.nested_goals));
-        }
+    fn step_kind(cx: X, input: X::Input) -> PathKind {
+        if D::step_is_coinductive(cx, input) { PathKind::Coinductive } else { PathKind::Inductive }
     }
 
-    fn clear_dependent_provisional_results(
-        provisional_cache: &mut HashMap<X::Input, ProvisionalCacheEntry<X>>,
+    /// Whether the path from `head` to the current stack entry is inductive or coinductive.
+    fn stack_path_kind(
+        cx: X,
+        stack: &IndexVec<StackDepth, StackEntry<X>>,
         head: StackDepth,
-    ) {
-        #[allow(rustc::potential_query_instability)]
-        provisional_cache.retain(|_, entry| {
-            if entry.with_coinductive_stack.as_ref().is_some_and(|p| p.head == head) {
-                entry.with_coinductive_stack.take();
-            }
-            if entry.with_inductive_stack.as_ref().is_some_and(|p| p.head == head) {
-                entry.with_inductive_stack.take();
-            }
-            !entry.is_empty()
-        });
+    ) -> PathKind {
+        if stack.raw[head.index()..].iter().all(|entry| D::step_is_coinductive(cx, entry.input)) {
+            PathKind::Coinductive
+        } else {
+            PathKind::Inductive
+        }
     }
 
     /// Probably the most involved method of the whole solver.
@@ -345,20 +456,27 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         cx: X,
         input: X::Input,
         inspect: &mut D::ProofTreeBuilder,
-        mut prove_goal: impl FnMut(&mut Self, &mut D::ProofTreeBuilder) -> X::Result,
+        mut evaluate_goal: impl FnMut(&mut Self, &mut D::ProofTreeBuilder) -> X::Result,
     ) -> X::Result {
-        self.check_invariants();
-        // Check for overflow.
         let Some(available_depth) = AvailableDepth::allowed_depth_for_nested::<D>(cx, &self.stack)
         else {
-            if let Some(last) = self.stack.raw.last_mut() {
-                last.encountered_overflow = true;
-            }
-
-            debug!("encountered stack overflow");
-            return D::on_stack_overflow(cx, inspect, input);
+            return self.handle_overflow(cx, input, inspect);
         };
 
+        // We check the provisional cache before checking the global cache. This simplifies
+        // the implementation as we can avoid worrying about cases where both the global and
+        // provisional cache may apply, e.g. consider the following example
+        //
+        // - xxBA overflow
+        // - A
+        //     - BA cycle
+        //     - CB :x:
+        if let Some(result) = self.lookup_provisional_cache(cx, input) {
+            return result;
+        }
+
+        // Lookup the global cache unless we're building proof trees or are currently
+        // fuzzing.
         let validate_cache = if !D::inspect_is_noop(inspect) {
             None
         } else if let Some(scope) = D::enter_validation_scope(cx, input) {
@@ -375,20 +493,22 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             None
         };
 
-        if let Some(result) = self.lookup_provisional_cache(cx, input) {
-            return result;
-        }
-
+        // Detect cycles on the stack. We do this after the global cache lookup to
+        // avoid iterating over the stack in case a goal has already been computed.
+        // This may not have an actual performance impact and we could reorder them
+        // as it may reduce the number of `nested_goals` we need to track.
         if let Some(result) = self.check_cycle_on_stack(cx, input) {
+            debug_assert!(validate_cache.is_none(), "global cache and cycle on stack");
             return result;
         }
 
+        // Unfortunate, it looks like we actually have to compute this goalrar.
         let depth = self.stack.next_index();
         let entry = StackEntry {
             input,
             available_depth,
             reached_depth: depth,
-            non_root_cycle_participant: None,
+            heads: Default::default(),
             encountered_overflow: false,
             has_been_used: None,
             nested_goals: Default::default(),
@@ -403,37 +523,23 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         // must not be added to the global cache. Notably, this is the case for
         // trait solver cycles participants.
         let ((final_entry, result), dep_node) = cx.with_cached_task(|| {
-            for _ in 0..D::FIXPOINT_STEP_LIMIT {
-                match self.fixpoint_step_in_task(cx, input, inspect, &mut prove_goal) {
-                    StepResult::Done(final_entry, result) => return (final_entry, result),
-                    StepResult::HasChanged => {}
-                }
-            }
-
-            debug!("canonical cycle overflow");
-            let current_entry = self.stack.pop().unwrap();
-            debug_assert!(current_entry.has_been_used.is_none());
-            let result = D::on_fixpoint_overflow(cx, input);
-            (current_entry, result)
+            self.evaluate_goal_in_task(cx, input, inspect, &mut evaluate_goal)
         });
 
-        self.update_parent_goal(final_entry.reached_depth, final_entry.encountered_overflow);
-
-        // We're now done with this goal. In case this goal is involved in a larger cycle
-        // do not remove it from the provisional cache and update its provisional result.
-        // We only add the root of cycles to the global cache.
-        if let Some(head) = final_entry.non_root_cycle_participant {
-            debug_assert!(validate_cache.is_none());
-            let coinductive_stack = Self::stack_coinductive_from(cx, &self.stack, head);
+        // We've finished computing the goal and have popped it from the stack,
+        // lazily update its parent goal.
+        Self::update_parent_goal(
+            cx,
+            &mut self.stack,
+            final_entry.reached_depth,
+            &final_entry.heads,
+            final_entry.encountered_overflow,
+            &final_entry.nested_goals,
+        );
 
-            let entry = self.provisional_cache.entry(input).or_default();
-            if coinductive_stack {
-                entry.with_coinductive_stack = Some(DetachedEntry { head, result });
-            } else {
-                entry.with_inductive_stack = Some(DetachedEntry { head, result });
-            }
-        } else {
-            self.provisional_cache.remove(&input);
+        // We're now done with this goal. We only add the root of cycles to the global cache.
+        // In case this goal is involved in a larger cycle add it to the provisional cache.
+        if final_entry.heads.is_empty() {
             if let Some((_scope, expected)) = validate_cache {
                 // Do not try to move a goal into the cache again if we're testing
                 // the global cache.
@@ -441,11 +547,278 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             } else if D::inspect_is_noop(inspect) {
                 self.insert_global_cache(cx, input, final_entry, result, dep_node)
             }
+        } else if D::ENABLE_PROVISIONAL_CACHE {
+            debug_assert!(validate_cache.is_none());
+            let entry = self.provisional_cache.entry(input).or_default();
+            let StackEntry { heads, nested_goals, encountered_overflow, .. } = final_entry;
+            let path_from_head = Self::stack_path_kind(cx, &self.stack, heads.highest_cycle_head());
+            entry.push(ProvisionalCacheEntry {
+                encountered_overflow,
+                heads,
+                path_from_head,
+                nested_goals,
+                result,
+            });
+        } else {
+            debug_assert!(validate_cache.is_none());
         }
 
         result
     }
 
+    fn handle_overflow(
+        &mut self,
+        cx: X,
+        input: X::Input,
+        inspect: &mut D::ProofTreeBuilder,
+    ) -> X::Result {
+        if let Some(last) = self.stack.raw.last_mut() {
+            last.encountered_overflow = true;
+            // If computing a goal `B` depends on another goal `A` and
+            // `A` has a nested goal which overflows, then computing `B`
+            // at the same depth, but with `A` already on the stack,
+            // would encounter a solver cycle instead, potentially
+            // changing the result.
+            //
+            // We must therefore not use the global cache entry for `B` in that case.
+            // See tests/ui/traits/next-solver/cycles/hidden-by-overflow.rs
+            last.nested_goals.insert(last.input, UsageKind::Single(PathKind::Coinductive));
+        }
+
+        debug!("encountered stack overflow");
+        D::on_stack_overflow(cx, inspect, input)
+    }
+
+    /// When reevaluating a goal with a changed provisional result, all provisional cache entry
+    /// which depend on this goal get invalidated.
+    fn clear_dependent_provisional_results(&mut self) {
+        let head = self.stack.next_index();
+        #[allow(rustc::potential_query_instability)]
+        self.provisional_cache.retain(|_, entries| {
+            entries.retain(|entry| entry.heads.highest_cycle_head() != head);
+            !entries.is_empty()
+        });
+    }
+
+    /// A necessary optimization to handle complex solver cycles. A provisional cache entry
+    /// relies on a set of cycle heads and the path towards these heads. When popping a cycle
+    /// head from the stack after we've finished computing it, we can't be sure that the
+    /// provisional cache entry is still applicable. We need to keep the cache entries to
+    /// prevent hangs.
+    ///
+    /// What we therefore do is check whether the cycle kind of all cycles the goal of a
+    /// provisional cache entry is involved in would stay the same when computing the
+    /// goal without its cycle head on the stack. For more details, see the relevant
+    /// [rustc-dev-guide chapter](https://rustc-dev-guide.rust-lang.org/solve/caching.html).
+    ///
+    /// This can be thought of rotating the sub-tree of this provisional result and changing
+    /// its entry point while making sure that all paths through this sub-tree stay the same.
+    ///
+    ///
+    /// In case the popped cycle head failed to reach a fixpoint anything which depends on
+    /// its provisional result is invalid. Actually discarding provisional cache entries in
+    /// this case would cause hangs, so we instead change the result of dependant provisional
+    /// cache entries to also be ambiguous. This causes some undesirable ambiguity for nested
+    /// goals whose result doesn't actually depend on this cycle head, but that's acceptable
+    /// to me.
+    fn rebase_provisional_cache_entries(
+        &mut self,
+        cx: X,
+        stack_entry: &StackEntry<X>,
+        mut mutate_result: impl FnMut(X::Input, X::Result) -> X::Result,
+    ) {
+        let head = self.stack.next_index();
+        #[allow(rustc::potential_query_instability)]
+        self.provisional_cache.retain(|&input, entries| {
+            entries.retain_mut(|entry| {
+                let ProvisionalCacheEntry {
+                    encountered_overflow: _,
+                    heads,
+                    path_from_head,
+                    nested_goals,
+                    result,
+                } = entry;
+                if heads.highest_cycle_head() != head {
+                    return true;
+                }
+
+                // We don't try rebasing if the path from the current head
+                // to the cache entry is not coinductive or if the path from
+                // the cache entry to the current head is not coinductive.
+                //
+                // Both of these constraints could be weakened, but by only
+                // accepting coinductive paths we don't have to worry about
+                // changing the cycle kind of the remaining cycles. We can
+                // extend this in the future once there's a known issue
+                // caused by it.
+                if *path_from_head != PathKind::Coinductive
+                    || nested_goals.get(stack_entry.input).unwrap()
+                        != UsageKind::Single(PathKind::Coinductive)
+                {
+                    return false;
+                }
+
+                // Merge the cycle heads of the provisional cache entry and the
+                // popped head. If the popped cycle head was a root, discard all
+                // provisional cache entries which depend on it.
+                heads.remove_highest_cycle_head();
+                heads.merge(&stack_entry.heads);
+                let Some(head) = heads.opt_highest_cycle_head() else {
+                    return false;
+                };
+
+                // As we've made sure that the path from the new highest cycle
+                // head to the uses of the popped cycle head are fully coinductive,
+                // we can be sure that the paths to all nested goals of the popped
+                // cycle head remain the same. We can simply merge them.
+                nested_goals.merge(&stack_entry.nested_goals);
+                // We now care about the path from the next highest cycle head to the
+                // provisional cache entry.
+                *path_from_head = Self::stack_path_kind(cx, &self.stack, head);
+                // Mutate the result of the provisional cache entry in case we did
+                // not reach a fixpoint.
+                *result = mutate_result(input, *result);
+                true
+            });
+            !entries.is_empty()
+        });
+    }
+
+    fn lookup_provisional_cache(&mut self, cx: X, input: X::Input) -> Option<X::Result> {
+        if !D::ENABLE_PROVISIONAL_CACHE {
+            return None;
+        }
+
+        let entries = self.provisional_cache.get(&input)?;
+        for &ProvisionalCacheEntry {
+            encountered_overflow,
+            ref heads,
+            path_from_head,
+            ref nested_goals,
+            result,
+        } in entries
+        {
+            let head = heads.highest_cycle_head();
+            if encountered_overflow {
+                // This check is overly strict and very subtle. We need to make sure that if
+                // a global cache entry depends on some goal without adding it to its
+                // `nested_goals`, that goal must never have an applicable provisional
+                // cache entry to avoid incorrectly applying the cache entry.
+                //
+                // As we'd have to otherwise track literally all nested goals, we only
+                // apply provisional cache entries which encountered overflow once the
+                // current goal is already part of the same cycle. This check could be
+                // improved but seems to be good enough for now.
+                let last = self.stack.raw.last().unwrap();
+                if !last.heads.opt_lowest_cycle_head().is_some_and(|lowest| lowest <= head) {
+                    continue;
+                }
+            }
+
+            // A provisional cache entry is only valid if the current path from its
+            // highest cycle head to the goal is the same.
+            if path_from_head == Self::stack_path_kind(cx, &self.stack, head) {
+                // While we don't have to track the full depth of the provisional cache entry,
+                // we do have to increment the required depth by one as we'd have already failed
+                // with overflow otherwise
+                let next_index = self.stack.next_index();
+                let last = &mut self.stack.raw.last_mut().unwrap();
+                let path_from_entry = Self::step_kind(cx, last.input);
+                last.nested_goals.insert(input, UsageKind::Single(path_from_entry));
+
+                Self::update_parent_goal(
+                    cx,
+                    &mut self.stack,
+                    next_index,
+                    heads,
+                    false,
+                    nested_goals,
+                );
+                debug_assert!(self.stack[head].has_been_used.is_some());
+                debug!(?head, ?path_from_head, "provisional cache hit");
+                return Some(result);
+            }
+        }
+
+        None
+    }
+
+    /// Even if there is a global cache entry for a given goal, we need to make sure
+    /// evaluating this entry would not have ended up depending on either a goal
+    /// already on the stack or a provisional cache entry.
+    fn candidate_is_applicable(
+        cx: X,
+        stack: &IndexVec<StackDepth, StackEntry<X>>,
+        provisional_cache: &HashMap<X::Input, Vec<ProvisionalCacheEntry<X>>>,
+        nested_goals: &NestedGoals<X>,
+    ) -> bool {
+        // If the global cache entry didn't depend on any nested goals, it always
+        // applies.
+        if nested_goals.is_empty() {
+            return true;
+        }
+
+        // If a nested goal of the global cache entry is on the stack, we would
+        // definitely encounter a cycle.
+        if stack.iter().any(|e| nested_goals.contains(e.input)) {
+            debug!("cache entry not applicable due to stack");
+            return false;
+        }
+
+        // The global cache entry is also invalid if there's a provisional cache entry
+        // would apply for any of its nested goals.
+        #[allow(rustc::potential_query_instability)]
+        for (input, path_from_global_entry) in nested_goals.iter() {
+            let Some(entries) = provisional_cache.get(&input) else {
+                continue;
+            };
+
+            debug!(?input, ?path_from_global_entry, ?entries, "candidate_is_applicable");
+            // A provisional cache entry is applicable if the path to
+            // its highest cycle head is equal to the expected path.
+            for &ProvisionalCacheEntry {
+                encountered_overflow,
+                ref heads,
+                path_from_head,
+                nested_goals: _,
+                result: _,
+            } in entries.iter()
+            {
+                // We don't have to worry about provisional cache entries which encountered
+                // overflow, see the relevant comment in `lookup_provisional_cache`.
+                if encountered_overflow {
+                    continue;
+                }
+
+                // A provisional cache entry only applies if the path from its highest head
+                // matches the path when encountering the goal.
+                let head = heads.highest_cycle_head();
+                let full_path = match Self::stack_path_kind(cx, stack, head) {
+                    PathKind::Coinductive => path_from_global_entry,
+                    PathKind::Inductive => UsageKind::Single(PathKind::Inductive),
+                };
+
+                match (full_path, path_from_head) {
+                    (UsageKind::Mixed, _)
+                    | (UsageKind::Single(PathKind::Coinductive), PathKind::Coinductive)
+                    | (UsageKind::Single(PathKind::Inductive), PathKind::Inductive) => {
+                        debug!(
+                            ?full_path,
+                            ?path_from_head,
+                            "cache entry not applicable due to matching paths"
+                        );
+                        return false;
+                    }
+                    _ => debug!(?full_path, ?path_from_head, "paths don't match"),
+                }
+            }
+        }
+
+        true
+    }
+
+    /// Used when fuzzing the global cache. Accesses the global cache without
+    /// updating the state of the search graph.
     fn lookup_global_cache_untracked(
         &self,
         cx: X,
@@ -453,7 +826,16 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         available_depth: AvailableDepth,
     ) -> Option<X::Result> {
         cx.with_global_cache(self.mode, |cache| {
-            cache.get(cx, input, &self.stack, available_depth).map(|c| c.result)
+            cache
+                .get(cx, input, available_depth, |nested_goals| {
+                    Self::candidate_is_applicable(
+                        cx,
+                        &self.stack,
+                        &self.provisional_cache,
+                        nested_goals,
+                    )
+                })
+                .map(|c| c.result)
         })
     }
 
@@ -467,46 +849,37 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         available_depth: AvailableDepth,
     ) -> Option<X::Result> {
         cx.with_global_cache(self.mode, |cache| {
-            let CacheData {
-                result,
-                additional_depth,
-                encountered_overflow,
-                nested_goals: _, // FIXME: consider nested goals here.
-            } = cache.get(cx, input, &self.stack, available_depth)?;
+            let CacheData { result, additional_depth, encountered_overflow, nested_goals } = cache
+                .get(cx, input, available_depth, |nested_goals| {
+                    Self::candidate_is_applicable(
+                        cx,
+                        &self.stack,
+                        &self.provisional_cache,
+                        nested_goals,
+                    )
+                })?;
 
             // Update the reached depth of the current goal to make sure
             // its state is the same regardless of whether we've used the
             // global cache or not.
             let reached_depth = self.stack.next_index().plus(additional_depth);
-            self.update_parent_goal(reached_depth, encountered_overflow);
+            // We don't move cycle participants to the global cache, so the
+            // cycle heads are always empty.
+            let heads = Default::default();
+            Self::update_parent_goal(
+                cx,
+                &mut self.stack,
+                reached_depth,
+                &heads,
+                encountered_overflow,
+                nested_goals,
+            );
 
             debug!(?additional_depth, "global cache hit");
             Some(result)
         })
     }
 
-    fn lookup_provisional_cache(&mut self, cx: X, input: X::Input) -> Option<X::Result> {
-        let cache_entry = self.provisional_cache.get(&input)?;
-        let &DetachedEntry { head, result } = cache_entry
-            .with_coinductive_stack
-            .as_ref()
-            .filter(|p| Self::stack_coinductive_from(cx, &self.stack, p.head))
-            .or_else(|| {
-                cache_entry
-                    .with_inductive_stack
-                    .as_ref()
-                    .filter(|p| !Self::stack_coinductive_from(cx, &self.stack, p.head))
-            })?;
-
-        debug!("provisional cache hit");
-        // We have a nested goal which is already in the provisional cache, use
-        // its result. We do not provide any usage kind as that should have been
-        // already set correctly while computing the cache entry.
-        Self::tag_cycle_participants(&mut self.stack, head);
-        debug_assert!(self.stack[head].has_been_used.is_some());
-        Some(result)
-    }
-
     fn check_cycle_on_stack(&mut self, cx: X, input: X::Input) -> Option<X::Result> {
         let (head, _stack_entry) = self.stack.iter_enumerated().find(|(_, e)| e.input == input)?;
         debug!("encountered cycle with depth {head:?}");
@@ -516,20 +889,48 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         //
         // Finally we can return either the provisional response or the initial response
         // in case we're in the first fixpoint iteration for this goal.
-        let is_coinductive_cycle = Self::stack_coinductive_from(cx, &self.stack, head);
-        let cycle_kind =
-            if is_coinductive_cycle { CycleKind::Coinductive } else { CycleKind::Inductive };
-        let usage_kind = UsageKind::Single(cycle_kind);
+        let path_kind = Self::stack_path_kind(cx, &self.stack, head);
+        let usage_kind = UsageKind::Single(path_kind);
         self.stack[head].has_been_used =
             Some(self.stack[head].has_been_used.map_or(usage_kind, |prev| prev.merge(usage_kind)));
-        Self::tag_cycle_participants(&mut self.stack, head);
+
+        // Subtle: when encountering a cyclic goal, we still first checked for overflow,
+        // so we have to update the reached depth.
+        let next_index = self.stack.next_index();
+        let last_index = self.stack.last_index().unwrap();
+        let last = &mut self.stack[last_index];
+        last.reached_depth = last.reached_depth.max(next_index);
+
+        let path_from_entry = Self::step_kind(cx, last.input);
+        last.nested_goals.insert(input, UsageKind::Single(path_from_entry));
+        last.nested_goals.insert(last.input, UsageKind::Single(PathKind::Coinductive));
+        if last_index != head {
+            last.heads.insert(head);
+        }
 
         // Return the provisional result or, if we're in the first iteration,
         // start with no constraints.
         if let Some(result) = self.stack[head].provisional_result {
             Some(result)
         } else {
-            Some(D::initial_provisional_result(cx, cycle_kind, input))
+            Some(D::initial_provisional_result(cx, path_kind, input))
+        }
+    }
+
+    /// Whether we've reached a fixpoint when evaluating a cycle head.
+    fn reached_fixpoint(
+        &mut self,
+        cx: X,
+        stack_entry: &StackEntry<X>,
+        usage_kind: UsageKind,
+        result: X::Result,
+    ) -> bool {
+        if let Some(prev) = stack_entry.provisional_result {
+            prev == result
+        } else if let UsageKind::Single(kind) = usage_kind {
+            D::is_initial_provisional_result(cx, kind, stack_entry.input, result)
+        } else {
+            false
         }
     }
 
@@ -538,55 +939,83 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
     /// of this we continuously recompute the cycle until the result
     /// of the previous iteration is equal to the final result, at which
     /// point we are done.
-    fn fixpoint_step_in_task<F>(
+    fn evaluate_goal_in_task(
         &mut self,
         cx: X,
         input: X::Input,
         inspect: &mut D::ProofTreeBuilder,
-        prove_goal: &mut F,
-    ) -> StepResult<X>
-    where
-        F: FnMut(&mut Self, &mut D::ProofTreeBuilder) -> X::Result,
-    {
-        let result = prove_goal(self, inspect);
-        let stack_entry = self.stack.pop().unwrap();
-        debug_assert_eq!(stack_entry.input, input);
-
-        // If the current goal is not the root of a cycle, we are done.
-        let Some(usage_kind) = stack_entry.has_been_used else {
-            return StepResult::Done(stack_entry, result);
-        };
+        mut evaluate_goal: impl FnMut(&mut Self, &mut D::ProofTreeBuilder) -> X::Result,
+    ) -> (StackEntry<X>, X::Result) {
+        let mut i = 0;
+        loop {
+            let result = evaluate_goal(self, inspect);
+            let stack_entry = self.stack.pop().unwrap();
+            debug_assert_eq!(stack_entry.input, input);
+
+            // If the current goal is not the root of a cycle, we are done.
+            //
+            // There are no provisional cache entries which depend on this goal.
+            let Some(usage_kind) = stack_entry.has_been_used else {
+                return (stack_entry, result);
+            };
+
+            // If it is a cycle head, we have to keep trying to prove it until
+            // we reach a fixpoint. We need to do so for all cycle heads,
+            // not only for the root.
+            //
+            // See tests/ui/traits/next-solver/cycles/fixpoint-rerun-all-cycle-heads.rs
+            // for an example.
+            //
+            // Check whether we reached a fixpoint, either because the final result
+            // is equal to the provisional result of the previous iteration, or because
+            // this was only the root of either coinductive or inductive cycles, and the
+            // final result is equal to the initial response for that case.
+            if self.reached_fixpoint(cx, &stack_entry, usage_kind, result) {
+                self.rebase_provisional_cache_entries(cx, &stack_entry, |_, result| result);
+                return (stack_entry, result);
+            }
 
-        // If it is a cycle head, we have to keep trying to prove it until
-        // we reach a fixpoint. We need to do so for all cycle heads,
-        // not only for the root.
-        //
-        // See tests/ui/traits/next-solver/cycles/fixpoint-rerun-all-cycle-heads.rs
-        // for an example.
-
-        // Start by clearing all provisional cache entries which depend on this
-        // the current goal.
-        Self::clear_dependent_provisional_results(
-            &mut self.provisional_cache,
-            self.stack.next_index(),
-        );
+            // If computing this goal results in ambiguity with no constraints,
+            // we do not rerun it. It's incredibly difficult to get a different
+            // response in the next iteration in this case. These changes would
+            // likely either be caused by incompleteness or can change the maybe
+            // cause from ambiguity to overflow. Returning ambiguity always
+            // preserves soundness and completeness even if the goal is be known
+            // to succeed or fail.
+            //
+            // This prevents exponential blowup affecting multiple major crates.
+            // As we only get to this branch if we haven't yet reached a fixpoint,
+            // we also taint all provisional cache entries which depend on the
+            // current goal.
+            if D::is_ambiguous_result(result) {
+                self.rebase_provisional_cache_entries(cx, &stack_entry, |input, _| {
+                    D::propagate_ambiguity(cx, input, result)
+                });
+                return (stack_entry, result);
+            };
+
+            // If we've reached the fixpoint step limit, we bail with overflow and taint all
+            // provisional cache entries which depend on the current goal.
+            i += 1;
+            if i >= D::FIXPOINT_STEP_LIMIT {
+                debug!("canonical cycle overflow");
+                let result = D::on_fixpoint_overflow(cx, input);
+                self.rebase_provisional_cache_entries(cx, &stack_entry, |input, _| {
+                    D::on_fixpoint_overflow(cx, input)
+                });
+                return (stack_entry, result);
+            }
+
+            // Clear all provisional cache entries which depend on a previous provisional
+            // result of this goal and rerun.
+            self.clear_dependent_provisional_results();
 
-        // Check whether we reached a fixpoint, either because the final result
-        // is equal to the provisional result of the previous iteration, or because
-        // this was only the root of either coinductive or inductive cycles, and the
-        // final result is equal to the initial response for that case.
-        //
-        // If we did not reach a fixpoint, update the provisional result and reevaluate.
-        if D::reached_fixpoint(cx, usage_kind, input, stack_entry.provisional_result, result) {
-            StepResult::Done(stack_entry, result)
-        } else {
             debug!(?result, "fixpoint changed provisional results");
             self.stack.push(StackEntry {
                 has_been_used: None,
                 provisional_result: Some(result),
                 ..stack_entry
             });
-            StepResult::HasChanged
         }
     }
 
@@ -616,7 +1045,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                 dep_node,
                 additional_depth,
                 final_entry.encountered_overflow,
-                &final_entry.nested_goals,
+                final_entry.nested_goals,
             )
         })
     }
diff --git a/compiler/rustc_type_ir/src/search_graph/validate.rs b/compiler/rustc_type_ir/src/search_graph/validate.rs
deleted file mode 100644
index b4802811b0f57..0000000000000
--- a/compiler/rustc_type_ir/src/search_graph/validate.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use super::*;
-
-impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
-    #[allow(rustc::potential_query_instability)]
-    pub(super) fn check_invariants(&self) {
-        if !cfg!(debug_assertions) {
-            return;
-        }
-
-        let SearchGraph { mode: _, stack, provisional_cache, _marker } = self;
-        if stack.is_empty() {
-            assert!(provisional_cache.is_empty());
-        }
-
-        for (depth, entry) in stack.iter_enumerated() {
-            let StackEntry {
-                input,
-                available_depth: _,
-                reached_depth: _,
-                non_root_cycle_participant,
-                encountered_overflow: _,
-                has_been_used,
-                ref nested_goals,
-                provisional_result,
-            } = *entry;
-            if let Some(head) = non_root_cycle_participant {
-                assert!(head < depth);
-                assert!(nested_goals.is_empty());
-                assert_ne!(stack[head].has_been_used, None);
-
-                let mut current_root = head;
-                while let Some(parent) = stack[current_root].non_root_cycle_participant {
-                    current_root = parent;
-                }
-                assert!(stack[current_root].nested_goals.contains(&input));
-            }
-
-            if !nested_goals.is_empty() {
-                assert!(provisional_result.is_some() || has_been_used.is_some());
-                for entry in stack.iter().take(depth.as_usize()) {
-                    assert_eq!(nested_goals.get(&entry.input), None);
-                }
-            }
-        }
-
-        for (&_input, entry) in &self.provisional_cache {
-            let ProvisionalCacheEntry { with_coinductive_stack, with_inductive_stack } = entry;
-            assert!(with_coinductive_stack.is_some() || with_inductive_stack.is_some());
-            let check_detached = |detached_entry: &DetachedEntry<X>| {
-                let DetachedEntry { head, result: _ } = *detached_entry;
-                assert_ne!(stack[head].has_been_used, None);
-            };
-
-            if let Some(with_coinductive_stack) = with_coinductive_stack {
-                check_detached(with_coinductive_stack);
-            }
-
-            if let Some(with_inductive_stack) = with_inductive_stack {
-                check_detached(with_inductive_stack);
-            }
-        }
-    }
-}

From 87a4c325d2767e5e0baf0c2a4d0cc12bb78ca356 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <jakub.beranek@vsb.cz>
Date: Tue, 13 Aug 2024 18:08:30 +0200
Subject: [PATCH 187/685] Fix target triple in bootstrap

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

diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index 8131666fcb225..fd85650bc5620 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -519,7 +519,7 @@ impl Config {
         extra_components: &[&str],
         download_component: fn(&Config, String, &str, &str),
     ) {
-        let host = self.build;
+        let host = self.build.triple;
         let bin_root = self.out.join(host).join(sysroot);
         let rustc_stamp = bin_root.join(".rustc-stamp");
 

From 71d98a8620b89f1efa3f597622a34396fd4966f8 Mon Sep 17 00:00:00 2001
From: Colin Finck <mail@colinfinck.de>
Date: Fri, 9 Aug 2024 15:02:18 +0200
Subject: [PATCH 188/685] Ship MinGW-w64 runtime DLLs along with `rust-lld.exe`
 for `-pc-windows-gnu` targets

`rust-lld.exe` built for `x86_64-pc-windows-gnu` depends on `libgcc_s_seh-1.dll` and `libwinpthread-1.dll` from MinGW-w64.
Until now, they were not shipped alongside `rust-lld.exe`, and you could not run `rust-lld.exe` on most systems.

This problem didn't surface until now because:
* Most targets don't use `rust-lld` by default.
* Some people had these DLLs in their `PATH` from some other MinGW binary.
* `rustup` used to add `bin` to the `PATH`, which contains these DLLs for `rustc.exe`. But it no longer does that: https://github.com/rust-lang/rustup/commit/ce3c09a0cb126e2c65a3bb2a3bbf3f098b4c23a2

Fixes #125809
---
 src/bootstrap/src/core/build_steps/dist.rs | 37 ++++++++++++++--------
 1 file changed, 24 insertions(+), 13 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index 530eb9b446a43..0e4b0b4ac8391 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -268,34 +268,45 @@ fn make_win_dist(
     let target_libs = find_files(&target_libs, &lib_path);
 
     // Copy runtime dlls next to rustc.exe
-    let dist_bin_dir = rust_root.join("bin/");
-    fs::create_dir_all(&dist_bin_dir).expect("creating dist_bin_dir failed");
-    for src in rustc_dlls {
-        builder.copy_link_to_folder(&src, &dist_bin_dir);
+    let rust_bin_dir = rust_root.join("bin/");
+    fs::create_dir_all(&rust_bin_dir).expect("creating rust_bin_dir failed");
+    for src in &rustc_dlls {
+        builder.copy_link_to_folder(src, &rust_bin_dir);
+    }
+
+    if builder.config.lld_enabled {
+        // rust-lld.exe also needs runtime dlls
+        let rust_target_bin_dir = rust_root.join("lib/rustlib").join(target).join("bin");
+        fs::create_dir_all(&rust_target_bin_dir).expect("creating rust_target_bin_dir failed");
+        for src in &rustc_dlls {
+            builder.copy_link_to_folder(src, &rust_target_bin_dir);
+        }
     }
 
     //Copy platform tools to platform-specific bin directory
-    let target_bin_dir =
-        plat_root.join("lib").join("rustlib").join(target).join("bin").join("self-contained");
-    fs::create_dir_all(&target_bin_dir).expect("creating target_bin_dir failed");
+    let plat_target_bin_self_contained_dir =
+        plat_root.join("lib/rustlib").join(target).join("bin/self-contained");
+    fs::create_dir_all(&plat_target_bin_self_contained_dir)
+        .expect("creating plat_target_bin_self_contained_dir failed");
     for src in target_tools {
-        builder.copy_link_to_folder(&src, &target_bin_dir);
+        builder.copy_link_to_folder(&src, &plat_target_bin_self_contained_dir);
     }
 
     // Warn windows-gnu users that the bundled GCC cannot compile C files
     builder.create(
-        &target_bin_dir.join("GCC-WARNING.txt"),
+        &plat_target_bin_self_contained_dir.join("GCC-WARNING.txt"),
         "gcc.exe contained in this folder cannot be used for compiling C files - it is only \
          used as a linker. In order to be able to compile projects containing C code use \
          the GCC provided by MinGW or Cygwin.",
     );
 
     //Copy platform libs to platform-specific lib directory
-    let target_lib_dir =
-        plat_root.join("lib").join("rustlib").join(target).join("lib").join("self-contained");
-    fs::create_dir_all(&target_lib_dir).expect("creating target_lib_dir failed");
+    let plat_target_lib_self_contained_dir =
+        plat_root.join("lib/rustlib").join(target).join("lib/self-contained");
+    fs::create_dir_all(&plat_target_lib_self_contained_dir)
+        .expect("creating plat_target_lib_self_contained_dir failed");
     for src in target_libs {
-        builder.copy_link_to_folder(&src, &target_lib_dir);
+        builder.copy_link_to_folder(&src, &plat_target_lib_self_contained_dir);
     }
 }
 

From c6fb0f344e0c6edb34966b1d73c3c1d8c5afbe34 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Tue, 13 Aug 2024 09:33:12 -0700
Subject: [PATCH 189/685] diagnostics: use `DeepRejectCtxt` for check

This makes more things match, particularly applicable blankets.
---
 .../error_reporting/infer/note_and_explain.rs | 37 ++++++++++++++-----
 .../ptr-to-trait-obj-different-args.stderr    |  3 ++
 tests/ui/traits/upcast_soundness_bug.stderr   |  1 +
 3 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
index 0c140f93d94b2..eab4addf97072 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
@@ -4,6 +4,7 @@ use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
+use rustc_middle::ty::fast_reject::{DeepRejectCtxt, TreatParams};
 use rustc_middle::ty::print::{FmtPrinter, Printer};
 use rustc_middle::ty::{self, suggest_constraining_type_param, Ty};
 use rustc_span::def_id::DefId;
@@ -313,9 +314,15 @@ impl<T> Trait<T> for X {
                     (ty::Dynamic(t, _, ty::DynKind::Dyn), _)
                         if let Some(def_id) = t.principal_def_id() =>
                     {
-                        let has_non_blanket_impl =
-                            tcx.non_blanket_impls_for_ty(def_id, values.found).next().is_some();
-                        if has_non_blanket_impl {
+                        let mut has_matching_impl = false;
+                        tcx.for_each_relevant_impl(def_id, values.found, |did| {
+                            if DeepRejectCtxt::new(tcx, TreatParams::ForLookup)
+                                .types_may_unify(values.found, tcx.type_of(did).skip_binder())
+                            {
+                                has_matching_impl = true;
+                            }
+                        });
+                        if has_matching_impl {
                             let trait_name = tcx.item_name(def_id);
                             diag.help(format!(
                                 "`{}` implements `{trait_name}` so you could box the found value \
@@ -328,9 +335,15 @@ impl<T> Trait<T> for X {
                     (_, ty::Dynamic(t, _, ty::DynKind::Dyn))
                         if let Some(def_id) = t.principal_def_id() =>
                     {
-                        let has_non_blanket_impl =
-                            tcx.non_blanket_impls_for_ty(def_id, values.expected).next().is_some();
-                        if has_non_blanket_impl {
+                        let mut has_matching_impl = false;
+                        tcx.for_each_relevant_impl(def_id, values.expected, |did| {
+                            if DeepRejectCtxt::new(tcx, TreatParams::ForLookup)
+                                .types_may_unify(values.expected, tcx.type_of(did).skip_binder())
+                            {
+                                has_matching_impl = true;
+                            }
+                        });
+                        if has_matching_impl {
                             let trait_name = tcx.item_name(def_id);
                             diag.help(format!(
                                 "`{}` implements `{trait_name}` so you could change the expected \
@@ -342,9 +355,15 @@ impl<T> Trait<T> for X {
                     (ty::Dynamic(t, _, ty::DynKind::DynStar), _)
                         if let Some(def_id) = t.principal_def_id() =>
                     {
-                        let has_non_blanket_impl =
-                            tcx.non_blanket_impls_for_ty(def_id, values.found).next().is_some();
-                        if has_non_blanket_impl {
+                        let mut has_matching_impl = false;
+                        tcx.for_each_relevant_impl(def_id, values.found, |did| {
+                            if DeepRejectCtxt::new(tcx, TreatParams::ForLookup)
+                                .types_may_unify(values.found, tcx.type_of(did).skip_binder())
+                            {
+                                has_matching_impl = true;
+                            }
+                        });
+                        if has_matching_impl {
                             let trait_name = tcx.item_name(def_id);
                             diag.help(format!(
                                 "`{}` implements `{trait_name}`, `#[feature(dyn_star)]` is likely \
diff --git a/tests/ui/cast/ptr-to-trait-obj-different-args.stderr b/tests/ui/cast/ptr-to-trait-obj-different-args.stderr
index b04289ae74748..8e60ca42f0a52 100644
--- a/tests/ui/cast/ptr-to-trait-obj-different-args.stderr
+++ b/tests/ui/cast/ptr-to-trait-obj-different-args.stderr
@@ -14,6 +14,7 @@ LL |     let y: *const dyn Trait<Y> = x as _;
    |
    = note: expected trait object `dyn Trait<X>`
               found trait object `dyn Trait<Y>`
+   = help: `dyn Trait<Y>` implements `Trait` so you could box the found value and coerce it to the trait object `Box<dyn Trait>`, you will have to change the expected type as well
 
 error[E0308]: mismatched types
   --> $DIR/ptr-to-trait-obj-different-args.rs:27:34
@@ -25,6 +26,7 @@ LL |     let _: *const dyn Trait<T> = x as _;
    |
    = note: expected trait object `dyn Trait<X>`
               found trait object `dyn Trait<T>`
+   = help: `dyn Trait<T>` implements `Trait` so you could box the found value and coerce it to the trait object `Box<dyn Trait>`, you will have to change the expected type as well
 
 error[E0308]: mismatched types
   --> $DIR/ptr-to-trait-obj-different-args.rs:28:34
@@ -37,6 +39,7 @@ LL |     let _: *const dyn Trait<X> = t as _;
    |
    = note: expected trait object `dyn Trait<T>`
               found trait object `dyn Trait<X>`
+   = help: `dyn Trait<X>` implements `Trait` so you could box the found value and coerce it to the trait object `Box<dyn Trait>`, you will have to change the expected type as well
 
 error[E0308]: mismatched types
   --> $DIR/ptr-to-trait-obj-different-args.rs:36:5
diff --git a/tests/ui/traits/upcast_soundness_bug.stderr b/tests/ui/traits/upcast_soundness_bug.stderr
index 31f77b52b5fbf..5864abcdb41f5 100644
--- a/tests/ui/traits/upcast_soundness_bug.stderr
+++ b/tests/ui/traits/upcast_soundness_bug.stderr
@@ -6,6 +6,7 @@ LL |     let p = p as *const dyn Trait<u8, u16>; // <- this is bad!
    |
    = note: expected trait object `dyn Trait<u8, u8>`
               found trait object `dyn Trait<u8, u16>`
+   = help: `dyn Trait<u8, u16>` implements `Trait` so you could box the found value and coerce it to the trait object `Box<dyn Trait>`, you will have to change the expected type as well
 
 error: aborting due to 1 previous error
 

From 7db942b320aee0a0965184b979e278f98737ce64 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 13 Aug 2024 19:05:28 +0200
Subject: [PATCH 190/685] remove the concept of a Call ID

---
 src/tools/miri/README.md                      |  4 ----
 src/tools/miri/src/bin/miri.rs                | 11 ---------
 src/tools/miri/src/borrow_tracker/mod.rs      | 23 ++-----------------
 .../stacked_borrows/diagnostics.rs            | 20 ++--------------
 src/tools/miri/src/diagnostics.rs             |  3 ---
 src/tools/miri/src/eval.rs                    |  3 ---
 src/tools/miri/src/lib.rs                     |  4 +---
 src/tools/miri/src/machine.rs                 |  2 +-
 .../both_borrows/aliasing_mut1.stack.stderr   |  4 ++--
 .../both_borrows/aliasing_mut2.stack.stderr   |  4 ++--
 .../both_borrows/aliasing_mut4.stack.stderr   |  4 ++--
 .../box_noalias_violation.stack.stderr        |  4 ++--
 .../both_borrows/illegal_write6.stack.stderr  |  4 ++--
 ...invalidate_against_protector2.stack.stderr |  4 ++--
 ...invalidate_against_protector3.stack.stderr |  4 ++--
 .../newtype_pair_retagging.stack.stderr       |  4 ++--
 .../newtype_retagging.stack.stderr            |  4 ++--
 .../arg_inplace_mutate.stack.stderr           |  4 ++--
 .../arg_inplace_observe_during.stack.stderr   |  4 ++--
 .../return_pointer_aliasing_read.stack.stderr |  4 ++--
 ...return_pointer_aliasing_write.stack.stderr |  4 ++--
 ...nter_aliasing_write_tail_call.stack.stderr |  4 ++--
 .../deallocate_against_protector1.stderr      |  4 ++--
 .../drop_in_place_protector.stderr            |  4 ++--
 .../invalidate_against_protector1.stderr      |  4 ++--
 25 files changed, 40 insertions(+), 98 deletions(-)

diff --git a/src/tools/miri/README.md b/src/tools/miri/README.md
index a0bff386a71dd..5821adb96ce29 100644
--- a/src/tools/miri/README.md
+++ b/src/tools/miri/README.md
@@ -414,10 +414,6 @@ to Miri failing to detect cases of undefined behavior in a program.
   being allocated or freed.  This helps in debugging memory leaks and
   use after free bugs. Specifying this argument multiple times does not overwrite the previous
   values, instead it appends its values to the list. Listing an id multiple times has no effect.
-* `-Zmiri-track-call-id=<id1>,<id2>,...` shows a backtrace when the given call ids are
-  assigned to a stack frame.  This helps in debugging UB related to Stacked
-  Borrows "protectors". Specifying this argument multiple times does not overwrite the previous
-  values, instead it appends its values to the list. Listing an id multiple times has no effect.
 * `-Zmiri-track-pointer-tag=<tag1>,<tag2>,...` shows a backtrace when a given pointer tag
   is created and when (if ever) it is popped from a borrow stack (which is where the tag becomes invalid
   and any future use of it will error).  This helps you in finding out why UB is
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index e13e54c33094a..14f43f576d3a4 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -581,17 +581,6 @@ fn main() {
                     show_error!("-Zmiri-track-pointer-tag requires nonzero arguments");
                 }
             }
-        } else if let Some(param) = arg.strip_prefix("-Zmiri-track-call-id=") {
-            let ids: Vec<u64> = parse_comma_list(param).unwrap_or_else(|err| {
-                show_error!("-Zmiri-track-call-id requires a comma separated list of valid `u64` arguments: {err}")
-            });
-            for id in ids.into_iter().map(miri::CallId::new) {
-                if let Some(id) = id {
-                    miri_config.tracked_call_ids.insert(id);
-                } else {
-                    show_error!("-Zmiri-track-call-id requires a nonzero argument");
-                }
-            }
         } else if let Some(param) = arg.strip_prefix("-Zmiri-track-alloc-id=") {
             let ids = parse_comma_list::<NonZero<u64>>(param).unwrap_or_else(|err| {
                 show_error!("-Zmiri-track-alloc-id requires a comma separated list of valid non-zero `u64` arguments: {err}")
diff --git a/src/tools/miri/src/borrow_tracker/mod.rs b/src/tools/miri/src/borrow_tracker/mod.rs
index b632c0d3a62f5..7a3d76a9beb35 100644
--- a/src/tools/miri/src/borrow_tracker/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/mod.rs
@@ -12,8 +12,6 @@ use crate::*;
 pub mod stacked_borrows;
 pub mod tree_borrows;
 
-pub type CallId = NonZero<u64>;
-
 /// Tracking pointer provenance
 #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct BorTag(NonZero<u64>);
@@ -57,9 +55,6 @@ impl fmt::Debug for BorTag {
 /// Per-call-stack-frame data for borrow tracking
 #[derive(Debug)]
 pub struct FrameState {
-    /// The ID of the call this frame corresponds to.
-    call_id: CallId,
-
     /// If this frame is protecting any tags, they are listed here. We use this list to do
     /// incremental updates of the global list of protected tags stored in the
     /// `stacked_borrows::GlobalState` upon function return, and if we attempt to pop a protected
@@ -93,8 +88,6 @@ pub struct GlobalStateInner {
     /// The root tag is the one used for the initial pointer.
     /// We need this in a separate table to handle cyclic statics.
     root_ptr_tags: FxHashMap<AllocId, BorTag>,
-    /// Next unused call ID (for protectors).
-    next_call_id: CallId,
     /// All currently protected tags.
     /// We add tags to this when they are created with a protector in `reborrow`, and
     /// we remove tags from this when the call which is protecting them returns, in
@@ -102,8 +95,6 @@ pub struct GlobalStateInner {
     protected_tags: FxHashMap<BorTag, ProtectorKind>,
     /// The pointer ids to trace
     tracked_pointer_tags: FxHashSet<BorTag>,
-    /// The call ids to trace
-    tracked_call_ids: FxHashSet<CallId>,
     /// Whether to recurse into datatypes when searching for pointers to retag.
     retag_fields: RetagFields,
     /// Whether `core::ptr::Unique` gets special (`Box`-like) handling.
@@ -167,7 +158,6 @@ impl GlobalStateInner {
     pub fn new(
         borrow_tracker_method: BorrowTrackerMethod,
         tracked_pointer_tags: FxHashSet<BorTag>,
-        tracked_call_ids: FxHashSet<CallId>,
         retag_fields: RetagFields,
         unique_is_unique: bool,
     ) -> Self {
@@ -175,10 +165,8 @@ impl GlobalStateInner {
             borrow_tracker_method,
             next_ptr_tag: BorTag::one(),
             root_ptr_tags: FxHashMap::default(),
-            next_call_id: NonZero::new(1).unwrap(),
             protected_tags: FxHashMap::default(),
             tracked_pointer_tags,
-            tracked_call_ids,
             retag_fields,
             unique_is_unique,
         }
@@ -191,14 +179,8 @@ impl GlobalStateInner {
         id
     }
 
-    pub fn new_frame(&mut self, machine: &MiriMachine<'_>) -> FrameState {
-        let call_id = self.next_call_id;
-        trace!("new_frame: Assigning call ID {}", call_id);
-        if self.tracked_call_ids.contains(&call_id) {
-            machine.emit_diagnostic(NonHaltingDiagnostic::CreatedCallId(call_id));
-        }
-        self.next_call_id = NonZero::new(call_id.get() + 1).unwrap();
-        FrameState { call_id, protected_tags: SmallVec::new() }
+    pub fn new_frame(&mut self) -> FrameState {
+        FrameState { protected_tags: SmallVec::new() }
     }
 
     fn end_call(&mut self, frame: &machine::FrameExtra<'_>) {
@@ -251,7 +233,6 @@ impl BorrowTrackerMethod {
         RefCell::new(GlobalStateInner::new(
             self,
             config.tracked_pointer_tags.clone(),
-            config.tracked_call_ids.clone(),
             config.retag_fields,
             config.unique_is_unique,
         ))
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs
index 87d9057cb89dc..12eeaae0eff47 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/diagnostics.rs
@@ -429,30 +429,14 @@ impl<'history, 'ecx, 'tcx> DiagnosticCx<'history, 'ecx, 'tcx> {
             ProtectorKind::WeakProtector => "weakly protected",
             ProtectorKind::StrongProtector => "strongly protected",
         };
-        let item_tag = item.tag();
-        let call_id = self
-            .machine
-            .threads
-            .all_stacks()
-            .flat_map(|(_id, stack)| stack)
-            .map(|frame| {
-                frame.extra.borrow_tracker.as_ref().expect("we should have borrow tracking data")
-            })
-            .find(|frame| frame.protected_tags.iter().any(|(_, tag)| tag == &item_tag))
-            .map(|frame| frame.call_id)
-            .unwrap(); // FIXME: Surely we should find something, but a panic seems wrong here?
         match self.operation {
             Operation::Dealloc(_) =>
-                err_sb_ub(
-                    format!("deallocating while item {item:?} is {protected} by call {call_id:?}",),
-                    vec![],
-                    None,
-                ),
+                err_sb_ub(format!("deallocating while item {item:?} is {protected}",), vec![], None),
             Operation::Retag(RetagOp { orig_tag: tag, .. })
             | Operation::Access(AccessOp { tag, .. }) =>
                 err_sb_ub(
                     format!(
-                        "not granting access to tag {tag:?} because that would remove {item:?} which is {protected} because it is an argument of call {call_id:?}",
+                        "not granting access to tag {tag:?} because that would remove {item:?} which is {protected}",
                     ),
                     vec![],
                     tag.and_then(|tag| self.get_logs_relevant_to(tag, Some(item.tag()))),
diff --git a/src/tools/miri/src/diagnostics.rs b/src/tools/miri/src/diagnostics.rs
index 1bed55743d4af..92f344d13b72c 100644
--- a/src/tools/miri/src/diagnostics.rs
+++ b/src/tools/miri/src/diagnostics.rs
@@ -116,7 +116,6 @@ pub enum NonHaltingDiagnostic {
     CreatedPointerTag(NonZero<u64>, Option<String>, Option<(AllocId, AllocRange, ProvenanceExtra)>),
     /// This `Item` was popped from the borrow stack. The string explains the reason.
     PoppedPointerTag(Item, String),
-    CreatedCallId(CallId),
     CreatedAlloc(AllocId, Size, Align, MemoryKind),
     FreedAlloc(AllocId),
     AccessedAlloc(AllocId, AccessKind),
@@ -607,7 +606,6 @@ impl<'tcx> MiriMachine<'tcx> {
                 ("reborrow of reference to `extern type`".to_string(), DiagLevel::Warning),
             CreatedPointerTag(..)
             | PoppedPointerTag(..)
-            | CreatedCallId(..)
             | CreatedAlloc(..)
             | AccessedAlloc(..)
             | FreedAlloc(..)
@@ -625,7 +623,6 @@ impl<'tcx> MiriMachine<'tcx> {
                     "created tag {tag:?} with {perm} at {alloc_id:?}{range:?} derived from {orig_tag:?}"
                 ),
             PoppedPointerTag(item, cause) => format!("popped tracked tag for item {item:?}{cause}"),
-            CreatedCallId(id) => format!("function call with id {id}"),
             CreatedAlloc(AllocId(id), size, align, kind) =>
                 format!(
                     "created {kind} allocation of {size} bytes (alignment {align} bytes) with id {id}",
diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index d75202b0a3018..0850a8f24d96c 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -118,8 +118,6 @@ pub struct MiriConfig {
     pub seed: Option<u64>,
     /// The stacked borrows pointer ids to report about
     pub tracked_pointer_tags: FxHashSet<BorTag>,
-    /// The stacked borrows call IDs to report about
-    pub tracked_call_ids: FxHashSet<CallId>,
     /// The allocation ids to report about.
     pub tracked_alloc_ids: FxHashSet<AllocId>,
     /// For the tracked alloc ids, also report read/write accesses.
@@ -183,7 +181,6 @@ impl Default for MiriConfig {
             args: vec![],
             seed: None,
             tracked_pointer_tags: FxHashSet::default(),
-            tracked_call_ids: FxHashSet::default(),
             tracked_alloc_ids: FxHashSet::default(),
             track_alloc_accesses: false,
             data_race_detector: true,
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 2b3ae6df5de8a..0dfe9f0912156 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -123,9 +123,7 @@ pub use crate::borrow_tracker::stacked_borrows::{
     EvalContextExt as _, Item, Permission, Stack, Stacks,
 };
 pub use crate::borrow_tracker::tree_borrows::{EvalContextExt as _, Tree};
-pub use crate::borrow_tracker::{
-    BorTag, BorrowTrackerMethod, CallId, EvalContextExt as _, RetagFields,
-};
+pub use crate::borrow_tracker::{BorTag, BorrowTrackerMethod, EvalContextExt as _, RetagFields};
 pub use crate::clock::{Clock, Instant};
 pub use crate::concurrency::{
     cpu_affinity::MAX_CPUS,
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 94598e7d2e3cc..c670ff669a2df 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1368,7 +1368,7 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         let borrow_tracker = ecx.machine.borrow_tracker.as_ref();
 
         let extra = FrameExtra {
-            borrow_tracker: borrow_tracker.map(|bt| bt.borrow_mut().new_frame(&ecx.machine)),
+            borrow_tracker: borrow_tracker.map(|bt| bt.borrow_mut().new_frame()),
             catch_unwind: None,
             timing,
             is_user_relevant: ecx.machine.is_user_relevant(&frame),
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 fe1f7060f1efe..4f9e6222db266 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> $DIR/aliasing_mut1.rs:LL:CC
    |
 LL | pub fn safe(x: &mut i32, y: &mut i32) {
-   |                          ^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |                          ^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 c5bdfcb8fe48f..54679d177da0f 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected
   --> $DIR/aliasing_mut2.rs:LL:CC
    |
 LL | pub fn safe(x: &i32, y: &mut i32) {
-   |                      ^ not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected because it is an argument of call ID
+   |                      ^ not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 383eb086d1efb..b3e97c92f1a29 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected
   --> $DIR/aliasing_mut4.rs:LL:CC
    |
 LL | pub fn safe(x: &i32, y: &mut Cell<i32>) {
-   |                      ^ not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected because it is an argument of call ID
+   |                      ^ not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 6e87d3ce06b52..a9ea7a9e9c401 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is weakly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is weakly protected
   --> $DIR/box_noalias_violation.rs:LL:CC
    |
 LL |     *y
-   |     ^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is weakly protected because it is an argument of call ID
+   |     ^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is weakly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 159b6cc9a8ec1..b5484745c41db 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> $DIR/illegal_write6.rs:LL:CC
    |
 LL |     unsafe { *y = 2 };
-   |              ^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |              ^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 5d093aeae88f5..11edbc3270c96 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected
   --> $DIR/invalidate_against_protector2.rs:LL:CC
    |
 LL |     unsafe { *x = 0 };
-   |              ^^^^^^ not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected because it is an argument of call ID
+   |              ^^^^^^ not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 8426f56004bee..c6666ceac2b33 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected
   --> $DIR/invalidate_against_protector3.rs:LL:CC
    |
 LL |     unsafe { *x = 0 };
-   |              ^^^^^^ not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected because it is an argument of call ID
+   |              ^^^^^^ not granting access to tag <TAG> because that would remove [SharedReadOnly for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 c26c7f397b09f..9f545e5687e7f 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> RUSTLIB/alloc/src/boxed.rs:LL:CC
    |
 LL |         Box(unsafe { Unique::new_unchecked(raw) }, alloc)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 ae54da70fe2d8..a4111f6f5cc2f 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> RUSTLIB/alloc/src/boxed.rs:LL:CC
    |
 LL |         Box(unsafe { Unique::new_unchecked(raw) }, alloc)
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 e0d1bed6332f6..609426bb28916 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> $DIR/arg_inplace_mutate.rs:LL:CC
    |
 LL |     unsafe { ptr.write(S(0)) };
-   |              ^^^^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |              ^^^^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 09c9a777eca46..68b7c0307c846 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> $DIR/arg_inplace_observe_during.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
-   |              ^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |              ^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.stack.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.stack.stderr
index a8817fe639038..941470e92959e 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.stack.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> $DIR/return_pointer_aliasing_read.rs:LL:CC
    |
 LL |     unsafe { ptr.read() };
-   |              ^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |              ^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.stack.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.stack.stderr
index 09f9681ff8ebc..51cb270dd2ecb 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.stack.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> $DIR/return_pointer_aliasing_write.rs:LL:CC
    |
 LL |     unsafe { ptr.write(0) };
-   |              ^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |              ^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr
index b8d8a93ec8329..7e527a440d128 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.stack.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> $DIR/return_pointer_aliasing_write_tail_call.rs:LL:CC
    |
 LL |     unsafe { ptr.write(0) };
-   |              ^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |              ^^^^^^^^^^^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 2cc714f935a13..2a8d4f3aea0f8 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: deallocating while item [Unique for <TAG>] is strongly protected by call ID
+error: Undefined Behavior: deallocating while item [Unique for <TAG>] is strongly protected
   --> RUSTLIB/alloc/src/alloc.rs:LL:CC
    |
 LL |     unsafe { __rust_dealloc(ptr, layout.size(), layout.align()) }
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocating while item [Unique for <TAG>] is strongly protected by call ID
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocating while item [Unique for <TAG>] is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 627c790f843eb..5147bcd458c6f 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> $DIR/drop_in_place_protector.rs:LL:CC
    |
 LL |             let _val = *P;
-   |                        ^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |                        ^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information
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 22a0b42cfd8ba..96cdce5a778b4 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
@@ -1,8 +1,8 @@
-error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+error: Undefined Behavior: not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
   --> $DIR/invalidate_against_protector1.rs:LL:CC
    |
 LL |     let _val = unsafe { *x };
-   |                         ^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected because it is an argument of call ID
+   |                         ^^ not granting access to tag <TAG> because that would remove [Unique for <TAG>] which is strongly protected
    |
    = help: this indicates a potential bug in the program: it performed an invalid operation, but the Stacked Borrows rules it violated are still experimental
    = help: see https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md for further information

From 05fbfde17d34a0685877e7590cd30fcbaa27c0bd Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sat, 8 Jun 2024 13:46:02 +0200
Subject: [PATCH 191/685] Clean up rustdoc make_test function code

---
 src/librustdoc/doctest/make.rs | 42 +++++++++++++++++-----------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 74833c113623b..322881dcd9c5b 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -25,6 +25,7 @@ pub(crate) fn make_test(
     dont_insert_main: bool,
     opts: &GlobalTestOptions,
     edition: Edition,
+    // If `test_id` is `None`, it means we're generating code for a code example "run" link.
     test_id: Option<&str>,
 ) -> (String, usize, bool) {
     let (crate_attrs, everything_else, crates) = partition_source(s, edition);
@@ -65,21 +66,22 @@ pub(crate) fn make_test(
 
     // Don't inject `extern crate std` because it's already injected by the
     // compiler.
-    if !already_has_extern_crate && !opts.no_crate_inject && crate_name != Some("std") {
-        if let Some(crate_name) = crate_name {
-            // Don't inject `extern crate` if the crate is never used.
-            // NOTE: this is terribly inaccurate because it doesn't actually
-            // parse the source, but only has false positives, not false
-            // negatives.
-            if s.contains(crate_name) {
-                // rustdoc implicitly inserts an `extern crate` item for the own crate
-                // which may be unused, so we need to allow the lint.
-                prog.push_str("#[allow(unused_extern_crates)]\n");
-
-                prog.push_str(&format!("extern crate r#{crate_name};\n"));
-                line_offset += 1;
-            }
-        }
+    if !already_has_extern_crate &&
+        !opts.no_crate_inject &&
+        let Some(crate_name) = crate_name &&
+        crate_name != "std" &&
+        // Don't inject `extern crate` if the crate is never used.
+        // NOTE: this is terribly inaccurate because it doesn't actually
+        // parse the source, but only has false positives, not false
+        // negatives.
+        s.contains(crate_name)
+    {
+        // rustdoc implicitly inserts an `extern crate` item for the own crate
+        // which may be unused, so we need to allow the lint.
+        prog.push_str("#[allow(unused_extern_crates)]\n");
+
+        prog.push_str(&format!("extern crate r#{crate_name};\n"));
+        line_offset += 1;
     }
 
     // FIXME: This code cannot yet handle no_std test cases yet
@@ -234,22 +236,20 @@ fn check_for_main_and_extern_crate(
             (found_main, found_extern_crate, found_macro)
         })
     });
-    let (already_has_main, already_has_extern_crate, found_macro) = result?;
+    let (mut already_has_main, already_has_extern_crate, found_macro) = result?;
 
     // If a doctest's `fn main` is being masked by a wrapper macro, the parsing loop above won't
     // see it. In that case, run the old text-based scan to see if they at least have a main
     // function written inside a macro invocation. See
     // https://github.com/rust-lang/rust/issues/56898
-    let already_has_main = if found_macro && !already_has_main {
-        source
+    if found_macro && !already_has_main {
+        already_has_main = source
             .lines()
             .map(|line| {
                 let comment = line.find("//");
                 if let Some(comment_begins) = comment { &line[0..comment_begins] } else { line }
             })
-            .any(|code| code.contains("fn main"))
-    } else {
-        already_has_main
+            .any(|code| code.contains("fn main"));
     };
 
     Ok((already_has_main, already_has_extern_crate))

From 5e244370fe1a4d8facb8c02326d076c0e3b85def Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sat, 8 Jun 2024 16:31:53 +0200
Subject: [PATCH 192/685] Add `DocTest` type

---
 src/librustdoc/doctest.rs       |  12 +-
 src/librustdoc/doctest/make.rs  | 293 ++++++++++++++++++--------------
 src/librustdoc/doctest/tests.rs |  18 +-
 src/librustdoc/html/markdown.rs |   5 +-
 4 files changed, 190 insertions(+), 138 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 08d6a5a52b21a..f8f5744e4db43 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -10,7 +10,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 use std::{panic, str};
 
-pub(crate) use make::make_test;
+pub(crate) use make::DocTest;
 pub(crate) use markdown::test as test_markdown;
 use rustc_ast as ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -732,13 +732,12 @@ fn doctest_run_fn(
         unused_externs.lock().unwrap().push(uext);
     };
     let edition = scraped_test.edition(&rustdoc_options);
-    let (full_test_code, full_test_line_offset, supports_color) = make_test(
-        &scraped_test.text,
-        Some(&global_opts.crate_name),
+    let doctest = DocTest::new(&scraped_test.text, Some(&global_opts.crate_name), edition);
+    let (full_test_code, full_test_line_offset) = doctest.generate_unique_doctest(
         scraped_test.langstr.test_harness,
         &global_opts,
-        edition,
         Some(&test_opts.test_id),
+        Some(&global_opts.crate_name),
     );
     let runnable_test = RunnableDoctest {
         full_test_code,
@@ -747,7 +746,8 @@ fn doctest_run_fn(
         global_opts,
         scraped_test,
     };
-    let res = run_test(runnable_test, &rustdoc_options, supports_color, report_unused_externs);
+    let res =
+        run_test(runnable_test, &rustdoc_options, doctest.supports_color, report_unused_externs);
 
     if let Err(err) = res {
         match err {
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 322881dcd9c5b..3ba0f36ef7af1 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -13,139 +13,173 @@ use rustc_session::parse::ParseSess;
 use rustc_span::edition::Edition;
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::sym;
-use rustc_span::FileName;
+use rustc_span::{FileName, Span, DUMMY_SP};
 
 use super::GlobalTestOptions;
 
-/// Transforms a test into code that can be compiled into a Rust binary, and returns the number of
-/// lines before the test code begins as well as if the output stream supports colors or not.
-pub(crate) fn make_test(
-    s: &str,
-    crate_name: Option<&str>,
-    dont_insert_main: bool,
-    opts: &GlobalTestOptions,
-    edition: Edition,
-    // If `test_id` is `None`, it means we're generating code for a code example "run" link.
-    test_id: Option<&str>,
-) -> (String, usize, bool) {
-    let (crate_attrs, everything_else, crates) = partition_source(s, edition);
-    let everything_else = everything_else.trim();
-    let mut line_offset = 0;
-    let mut prog = String::new();
-    let mut supports_color = false;
-
-    if opts.attrs.is_empty() {
-        // If there aren't any attributes supplied by #![doc(test(attr(...)))], then allow some
-        // lints that are commonly triggered in doctests. The crate-level test attributes are
-        // commonly used to make tests fail in case they trigger warnings, so having this there in
-        // that case may cause some tests to pass when they shouldn't have.
-        prog.push_str("#![allow(unused)]\n");
-        line_offset += 1;
-    }
+pub(crate) struct DocTest {
+    pub(crate) test_code: String,
+    pub(crate) supports_color: bool,
+    pub(crate) already_has_extern_crate: bool,
+    pub(crate) main_fn_span: Option<Span>,
+    pub(crate) crate_attrs: String,
+    pub(crate) crates: String,
+    pub(crate) everything_else: String,
+}
 
-    // Next, any attributes that came from the crate root via #![doc(test(attr(...)))].
-    for attr in &opts.attrs {
-        prog.push_str(&format!("#![{attr}]\n"));
-        line_offset += 1;
+impl DocTest {
+    pub(crate) fn new(source: &str, crate_name: Option<&str>, edition: Edition) -> Self {
+        let (crate_attrs, everything_else, crates) = partition_source(source, edition);
+        let mut supports_color = false;
+
+        // Uses librustc_ast to parse the doctest and find if there's a main fn and the extern
+        // crate already is included.
+        let Ok((main_fn_span, already_has_extern_crate)) =
+            check_for_main_and_extern_crate(crate_name, source, edition, &mut supports_color)
+        else {
+            // If the parser panicked due to a fatal error, pass the test code through unchanged.
+            // The error will be reported during compilation.
+            return DocTest {
+                test_code: source.to_string(),
+                supports_color: false,
+                main_fn_span: None,
+                crate_attrs,
+                crates,
+                everything_else,
+                already_has_extern_crate: false,
+            };
+        };
+        Self {
+            test_code: source.to_string(),
+            supports_color,
+            main_fn_span,
+            crate_attrs,
+            crates,
+            everything_else,
+            already_has_extern_crate,
+        }
     }
 
-    // Now push any outer attributes from the example, assuming they
-    // are intended to be crate attributes.
-    prog.push_str(&crate_attrs);
-    prog.push_str(&crates);
-
-    // Uses librustc_ast to parse the doctest and find if there's a main fn and the extern
-    // crate already is included.
-    let Ok((already_has_main, already_has_extern_crate)) =
-        check_for_main_and_extern_crate(crate_name, s.to_owned(), edition, &mut supports_color)
-    else {
-        // If the parser panicked due to a fatal error, pass the test code through unchanged.
-        // The error will be reported during compilation.
-        return (s.to_owned(), 0, false);
-    };
-
-    // Don't inject `extern crate std` because it's already injected by the
-    // compiler.
-    if !already_has_extern_crate &&
-        !opts.no_crate_inject &&
-        let Some(crate_name) = crate_name &&
-        crate_name != "std" &&
-        // Don't inject `extern crate` if the crate is never used.
-        // NOTE: this is terribly inaccurate because it doesn't actually
-        // parse the source, but only has false positives, not false
-        // negatives.
-        s.contains(crate_name)
-    {
-        // rustdoc implicitly inserts an `extern crate` item for the own crate
-        // which may be unused, so we need to allow the lint.
-        prog.push_str("#[allow(unused_extern_crates)]\n");
+    /// Transforms a test into code that can be compiled into a Rust binary, and returns the number of
+    /// lines before the test code begins.
+    pub(crate) fn generate_unique_doctest(
+        &self,
+        dont_insert_main: bool,
+        opts: &GlobalTestOptions,
+        // If `test_id` is `None`, it means we're generating code for a code example "run" link.
+        test_id: Option<&str>,
+        crate_name: Option<&str>,
+    ) -> (String, usize) {
+        let mut line_offset = 0;
+        let mut prog = String::new();
+        let everything_else = self.everything_else.trim();
+        if opts.attrs.is_empty() {
+            // If there aren't any attributes supplied by #![doc(test(attr(...)))], then allow some
+            // lints that are commonly triggered in doctests. The crate-level test attributes are
+            // commonly used to make tests fail in case they trigger warnings, so having this there in
+            // that case may cause some tests to pass when they shouldn't have.
+            prog.push_str("#![allow(unused)]\n");
+            line_offset += 1;
+        }
 
-        prog.push_str(&format!("extern crate r#{crate_name};\n"));
-        line_offset += 1;
-    }
+        // Next, any attributes that came from the crate root via #![doc(test(attr(...)))].
+        for attr in &opts.attrs {
+            prog.push_str(&format!("#![{attr}]\n"));
+            line_offset += 1;
+        }
 
-    // FIXME: This code cannot yet handle no_std test cases yet
-    if dont_insert_main || already_has_main || prog.contains("![no_std]") {
-        prog.push_str(everything_else);
-    } else {
-        let returns_result = everything_else.trim_end().ends_with("(())");
-        // Give each doctest main function a unique name.
-        // This is for example needed for the tooling around `-C instrument-coverage`.
-        let inner_fn_name = if let Some(test_id) = test_id {
-            format!("_doctest_main_{test_id}")
-        } else {
-            "_inner".into()
-        };
-        let inner_attr = if test_id.is_some() { "#[allow(non_snake_case)] " } else { "" };
-        let (main_pre, main_post) = if returns_result {
-            (
-                format!(
-                    "fn main() {{ {inner_attr}fn {inner_fn_name}() -> Result<(), impl core::fmt::Debug> {{\n",
-                ),
-                format!("\n}} {inner_fn_name}().unwrap() }}"),
-            )
-        } else if test_id.is_some() {
-            (
-                format!("fn main() {{ {inner_attr}fn {inner_fn_name}() {{\n",),
-                format!("\n}} {inner_fn_name}() }}"),
-            )
-        } else {
-            ("fn main() {\n".into(), "\n}".into())
-        };
-        // Note on newlines: We insert a line/newline *before*, and *after*
-        // the doctest and adjust the `line_offset` accordingly.
-        // In the case of `-C instrument-coverage`, this means that the generated
-        // inner `main` function spans from the doctest opening codeblock to the
-        // closing one. For example
-        // /// ``` <- start of the inner main
-        // /// <- code under doctest
-        // /// ``` <- end of the inner main
-        line_offset += 1;
-
-        // add extra 4 spaces for each line to offset the code block
-        let content = if opts.insert_indent_space {
-            everything_else
-                .lines()
-                .map(|line| format!("    {}", line))
-                .collect::<Vec<String>>()
-                .join("\n")
+        // Now push any outer attributes from the example, assuming they
+        // are intended to be crate attributes.
+        prog.push_str(&self.crate_attrs);
+        prog.push_str(&self.crates);
+
+        // Don't inject `extern crate std` because it's already injected by the
+        // compiler.
+        if !self.already_has_extern_crate &&
+            !opts.no_crate_inject &&
+            let Some(crate_name) = crate_name &&
+            crate_name != "std" &&
+            // Don't inject `extern crate` if the crate is never used.
+            // NOTE: this is terribly inaccurate because it doesn't actually
+            // parse the source, but only has false positives, not false
+            // negatives.
+            self.test_code.contains(crate_name)
+        {
+            // rustdoc implicitly inserts an `extern crate` item for the own crate
+            // which may be unused, so we need to allow the lint.
+            prog.push_str("#[allow(unused_extern_crates)]\n");
+
+            prog.push_str(&format!("extern crate r#{crate_name};\n"));
+            line_offset += 1;
+        }
+
+        // FIXME: This code cannot yet handle no_std test cases yet
+        if dont_insert_main || self.main_fn_span.is_some() || prog.contains("![no_std]") {
+            prog.push_str(everything_else);
         } else {
-            everything_else.to_string()
-        };
-        prog.extend([&main_pre, content.as_str(), &main_post].iter().cloned());
-    }
+            let returns_result = everything_else.ends_with("(())");
+            // Give each doctest main function a unique name.
+            // This is for example needed for the tooling around `-C instrument-coverage`.
+            let inner_fn_name = if let Some(test_id) = test_id {
+                format!("_doctest_main_{test_id}")
+            } else {
+                "_inner".into()
+            };
+            let inner_attr = if test_id.is_some() { "#[allow(non_snake_case)] " } else { "" };
+            let (main_pre, main_post) = if returns_result {
+                (
+                    format!(
+                        "fn main() {{ {inner_attr}fn {inner_fn_name}() -> Result<(), impl core::fmt::Debug> {{\n",
+                    ),
+                    format!("\n}} {inner_fn_name}().unwrap() }}"),
+                )
+            } else if test_id.is_some() {
+                (
+                    format!("fn main() {{ {inner_attr}fn {inner_fn_name}() {{\n",),
+                    format!("\n}} {inner_fn_name}() }}"),
+                )
+            } else {
+                ("fn main() {\n".into(), "\n}".into())
+            };
+            // Note on newlines: We insert a line/newline *before*, and *after*
+            // the doctest and adjust the `line_offset` accordingly.
+            // In the case of `-C instrument-coverage`, this means that the generated
+            // inner `main` function spans from the doctest opening codeblock to the
+            // closing one. For example
+            // /// ``` <- start of the inner main
+            // /// <- code under doctest
+            // /// ``` <- end of the inner main
+            line_offset += 1;
+
+            prog.push_str(&main_pre);
+
+            // add extra 4 spaces for each line to offset the code block
+            if opts.insert_indent_space {
+                prog.push_str(
+                    &everything_else
+                        .lines()
+                        .map(|line| format!("    {}", line))
+                        .collect::<Vec<String>>()
+                        .join("\n"),
+                );
+            } else {
+                prog.push_str(everything_else);
+            };
+            prog.push_str(&main_post);
+        }
 
-    debug!("final doctest:\n{prog}");
+        debug!("final doctest:\n{prog}");
 
-    (prog, line_offset, supports_color)
+        (prog, line_offset)
+    }
 }
 
 fn check_for_main_and_extern_crate(
     crate_name: Option<&str>,
-    source: String,
+    source: &str,
     edition: Edition,
     supports_color: &mut bool,
-) -> Result<(bool, bool), FatalError> {
+) -> Result<(Option<Span>, bool), FatalError> {
     let result = rustc_driver::catch_fatal_errors(|| {
         rustc_span::create_session_if_not_set_then(edition, |_| {
             use rustc_errors::emitter::{Emitter, HumanEmitter};
@@ -153,7 +187,7 @@ fn check_for_main_and_extern_crate(
             use rustc_parse::parser::ForceCollect;
             use rustc_span::source_map::FilePathMapping;
 
-            let filename = FileName::anon_source_code(&source);
+            let filename = FileName::anon_source_code(source);
 
             // Any errors in parsing should also appear when the doctest is compiled for real, so just
             // send all the errors that librustc_ast emits directly into a `Sink` instead of stderr.
@@ -172,11 +206,11 @@ fn check_for_main_and_extern_crate(
             let dcx = DiagCtxt::new(Box::new(emitter)).disable_warnings();
             let psess = ParseSess::with_dcx(dcx, sm);
 
-            let mut found_main = false;
+            let mut found_main = None;
             let mut found_extern_crate = crate_name.is_none();
             let mut found_macro = false;
 
-            let mut parser = match new_parser_from_source_str(&psess, filename, source.clone()) {
+            let mut parser = match new_parser_from_source_str(&psess, filename, source.to_owned()) {
                 Ok(p) => p,
                 Err(errs) => {
                     errs.into_iter().for_each(|err| err.cancel());
@@ -187,11 +221,11 @@ fn check_for_main_and_extern_crate(
             loop {
                 match parser.parse_item(ForceCollect::No) {
                     Ok(Some(item)) => {
-                        if !found_main
+                        if found_main.is_none()
                             && let ast::ItemKind::Fn(..) = item.kind
                             && item.ident.name == sym::main
                         {
-                            found_main = true;
+                            found_main = Some(item.span);
                         }
 
                         if !found_extern_crate
@@ -211,7 +245,7 @@ fn check_for_main_and_extern_crate(
                             found_macro = true;
                         }
 
-                        if found_main && found_extern_crate {
+                        if found_main.is_some() && found_extern_crate {
                             break;
                         }
                     }
@@ -236,23 +270,26 @@ fn check_for_main_and_extern_crate(
             (found_main, found_extern_crate, found_macro)
         })
     });
-    let (mut already_has_main, already_has_extern_crate, found_macro) = result?;
+    let (mut main_fn_span, already_has_extern_crate, found_macro) = result?;
 
     // If a doctest's `fn main` is being masked by a wrapper macro, the parsing loop above won't
     // see it. In that case, run the old text-based scan to see if they at least have a main
     // function written inside a macro invocation. See
     // https://github.com/rust-lang/rust/issues/56898
-    if found_macro && !already_has_main {
-        already_has_main = source
+    if found_macro
+        && main_fn_span.is_none()
+        && source
             .lines()
             .map(|line| {
                 let comment = line.find("//");
                 if let Some(comment_begins) = comment { &line[0..comment_begins] } else { line }
             })
-            .any(|code| code.contains("fn main"));
-    };
+            .any(|code| code.contains("fn main"))
+    {
+        main_fn_span = Some(DUMMY_SP);
+    }
 
-    Ok((already_has_main, already_has_extern_crate))
+    Ok((main_fn_span, already_has_extern_crate))
 }
 
 fn check_if_attr_is_complete(source: &str, edition: Edition) -> bool {
diff --git a/src/librustdoc/doctest/tests.rs b/src/librustdoc/doctest/tests.rs
index 0f13ee404c682..fc631de7d2a3f 100644
--- a/src/librustdoc/doctest/tests.rs
+++ b/src/librustdoc/doctest/tests.rs
@@ -1,8 +1,22 @@
 use std::path::PathBuf;
 
-use rustc_span::edition::DEFAULT_EDITION;
+use super::{DocTest, GlobalTestOptions};
+use rustc_span::edition::{Edition, DEFAULT_EDITION};
 
-use super::{make_test, GlobalTestOptions};
+// FIXME: remove the last element of the returned tuple and simplify arguments of this helper.
+fn make_test(
+    test_code: &str,
+    crate_name: Option<&str>,
+    dont_insert_main: bool,
+    opts: &GlobalTestOptions,
+    edition: Edition,
+    test_id: Option<&str>,
+) -> (String, usize, ()) {
+    let doctest = DocTest::new(test_code, crate_name, edition);
+    let (code, line_offset) =
+        doctest.generate_unique_doctest(dont_insert_main, opts, test_id, crate_name);
+    (code, line_offset, ())
+}
 
 /// Default [`GlobalTestOptions`] for these unit tests.
 fn default_global_opts(crate_name: impl Into<String>) -> GlobalTestOptions {
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index c41db654112eb..90ff71396d75b 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -297,10 +297,11 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
                 attrs: vec![],
                 args_file: PathBuf::new(),
             };
-            let (test, _, _) = doctest::make_test(&test, krate, false, &opts, edition, None);
+            let doctest = doctest::DocTest::new(&test, krate, edition);
+            let (test, _) = doctest.generate_unique_doctest(false, &opts, None, krate);
             let channel = if test.contains("#![feature(") { "&amp;version=nightly" } else { "" };
 
-            let test_escaped = small_url_encode(test);
+            let test_escaped = small_url_encode(doctest.test_code);
             Some(format!(
                 "<a class=\"test-arrow\" \
                     target=\"_blank\" \

From 7d724824315cabc5269827b8a8718019c00b149f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sat, 8 Jun 2024 16:35:33 +0200
Subject: [PATCH 193/685] Simplify doctest tests

---
 src/librustdoc/doctest/tests.rs | 51 ++++++++++++++++-----------------
 1 file changed, 24 insertions(+), 27 deletions(-)

diff --git a/src/librustdoc/doctest/tests.rs b/src/librustdoc/doctest/tests.rs
index fc631de7d2a3f..77322b59b653c 100644
--- a/src/librustdoc/doctest/tests.rs
+++ b/src/librustdoc/doctest/tests.rs
@@ -1,21 +1,19 @@
 use std::path::PathBuf;
 
 use super::{DocTest, GlobalTestOptions};
-use rustc_span::edition::{Edition, DEFAULT_EDITION};
+use rustc_span::edition::DEFAULT_EDITION;
 
-// FIXME: remove the last element of the returned tuple and simplify arguments of this helper.
 fn make_test(
     test_code: &str,
     crate_name: Option<&str>,
     dont_insert_main: bool,
     opts: &GlobalTestOptions,
-    edition: Edition,
     test_id: Option<&str>,
-) -> (String, usize, ()) {
-    let doctest = DocTest::new(test_code, crate_name, edition);
+) -> (String, usize) {
+    let doctest = DocTest::new(test_code, crate_name, DEFAULT_EDITION);
     let (code, line_offset) =
         doctest.generate_unique_doctest(dont_insert_main, opts, test_id, crate_name);
-    (code, line_offset, ())
+    (code, line_offset)
 }
 
 /// Default [`GlobalTestOptions`] for these unit tests.
@@ -39,7 +37,7 @@ fn main() {
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, None, false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -54,7 +52,7 @@ fn main() {
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, Some("asdf"), false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -73,7 +71,7 @@ use asdf::qwop;
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, Some("asdf"), false, &opts, None);
     assert_eq!((output, len), (expected, 3));
 }
 
@@ -90,7 +88,7 @@ use asdf::qwop;
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, Some("asdf"), false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -108,7 +106,7 @@ use std::*;
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, Some("std"), false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, Some("std"), false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -127,7 +125,7 @@ use asdf::qwop;
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, Some("asdf"), false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -144,7 +142,7 @@ use asdf::qwop;
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, Some("asdf"), false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -164,7 +162,7 @@ use asdf::qwop;
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, Some("asdf"), false, &opts, None);
     assert_eq!((output, len), (expected, 3));
 
     // Adding more will also bump the returned line offset.
@@ -178,7 +176,7 @@ use asdf::qwop;
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, Some("asdf"), false, &opts, None);
     assert_eq!((output, len), (expected, 4));
 }
 
@@ -195,7 +193,7 @@ fn main() {
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, None, false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -211,7 +209,7 @@ fn main() {
     assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, None, false, &opts, None);
     assert_eq!((output, len), (expected, 1));
 }
 
@@ -227,7 +225,7 @@ fn main() {
 assert_eq!(2+2, 4);
 }"
     .to_string();
-    let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, None, false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -241,7 +239,7 @@ assert_eq!(2+2, 4);";
 //Ceci n'est pas une `fn main`
 assert_eq!(2+2, 4);"
         .to_string();
-    let (output, len, _) = make_test(input, None, true, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, None, true, &opts, None);
     assert_eq!((output, len), (expected, 1));
 }
 
@@ -259,7 +257,7 @@ assert_eq!(2+2, 4);
 }"
     .to_string();
 
-    let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, None, false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -279,7 +277,7 @@ assert_eq!(asdf::foo, 4);
 }"
     .to_string();
 
-    let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, Some("asdf"), false, &opts, None);
     assert_eq!((output, len), (expected, 3));
 }
 
@@ -297,7 +295,7 @@ test_wrapper! {
 }"
     .to_string();
 
-    let (output, len, _) = make_test(input, Some("my_crate"), false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, Some("my_crate"), false, &opts, None);
     assert_eq!((output, len), (expected, 1));
 }
 
@@ -317,7 +315,7 @@ io::stdin().read_line(&mut input)?;
 Ok::<(), io:Error>(())
 } _inner().unwrap() }"
         .to_string();
-    let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, None, false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -331,8 +329,7 @@ fn main() { #[allow(non_snake_case)] fn _doctest_main__some_unique_name() {
 assert_eq!(2+2, 4);
 } _doctest_main__some_unique_name() }"
         .to_string();
-    let (output, len, _) =
-        make_test(input, None, false, &opts, DEFAULT_EDITION, Some("_some_unique_name"));
+    let (output, len) = make_test(input, None, false, &opts, Some("_some_unique_name"));
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -351,7 +348,7 @@ fn main() {
     eprintln!(\"hello anan\");
 }"
     .to_string();
-    let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, None, false, &opts, None);
     assert_eq!((output, len), (expected, 2));
 }
 
@@ -371,6 +368,6 @@ fn main() {
     eprintln!(\"hello anan\");
 }"
     .to_string();
-    let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
+    let (output, len) = make_test(input, None, false, &opts, None);
     assert_eq!((output, len), (expected, 1));
 }

From 39f029a852418952716cbd28f8d0d922584198e2 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sat, 8 Jun 2024 17:32:51 +0200
Subject: [PATCH 194/685] Split doctests between standalone and mergeable ones

---
 src/librustdoc/doctest.rs          | 76 +++++++++++++++++++++---------
 src/librustdoc/doctest/make.rs     |  6 +--
 src/librustdoc/doctest/markdown.rs |  2 +-
 src/librustdoc/doctest/tests.rs    |  2 +-
 src/librustdoc/html/markdown.rs    |  4 +-
 5 files changed, 61 insertions(+), 29 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index f8f5744e4db43..65ddaedf26c5d 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -164,7 +164,8 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<()
     let args_path = temp_dir.path().join("rustdoc-cfgs");
     crate::wrap_return(dcx, generate_args_file(&args_path, &options))?;
 
-    let (tests, unused_extern_reports, compiling_test_count) =
+    // FIXME: use mergeable tests!
+    let (standalone_tests, unused_extern_reports, compiling_test_count) =
         interface::run_compiler(config, |compiler| {
             compiler.enter(|queries| {
                 let collector = queries.global_ctxt()?.enter(|tcx| {
@@ -192,11 +193,11 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<()
 
                 let unused_extern_reports = collector.unused_extern_reports.clone();
                 let compiling_test_count = collector.compiling_test_count.load(Ordering::SeqCst);
-                Ok((collector.tests, unused_extern_reports, compiling_test_count))
+                Ok((collector.standalone_tests, unused_extern_reports, compiling_test_count))
             })
         })?;
 
-    run_tests(test_args, nocapture, tests);
+    run_tests(test_args, nocapture, standalone_tests);
 
     // Collect and warn about unused externs, but only if we've gotten
     // reports for each doctest
@@ -617,7 +618,8 @@ pub(crate) trait DoctestVisitor {
 }
 
 struct CreateRunnableDoctests {
-    tests: Vec<test::TestDescAndFn>,
+    standalone_tests: Vec<test::TestDescAndFn>,
+    mergeable_tests: FxHashMap<Edition, Vec<(DocTest, ScrapedDoctest)>>,
 
     rustdoc_options: Arc<RustdocOptions>,
     opts: GlobalTestOptions,
@@ -629,7 +631,8 @@ struct CreateRunnableDoctests {
 impl CreateRunnableDoctests {
     fn new(rustdoc_options: RustdocOptions, opts: GlobalTestOptions) -> CreateRunnableDoctests {
         CreateRunnableDoctests {
-            tests: Vec::new(),
+            standalone_tests: Vec::new(),
+            mergeable_tests: FxHashMap::default(),
             rustdoc_options: Arc::new(rustdoc_options),
             opts,
             visited_tests: FxHashMap::default(),
@@ -647,16 +650,40 @@ impl CreateRunnableDoctests {
         format!("{} - {item_path}(line {line})", filename.prefer_remapped_unconditionaly())
     }
 
-    fn add_test(&mut self, test: ScrapedDoctest) {
-        let name = self.generate_name(&test.filename, test.line, &test.logical_path);
+    fn add_test(&mut self, scraped_test: ScrapedDoctest) {
+        let edition = scraped_test.edition(&self.rustdoc_options);
+        let doctest = DocTest::new(&scraped_test.text, Some(&self.opts.crate_name), edition);
+        let is_standalone = scraped_test.langstr.compile_fail
+            || scraped_test.langstr.test_harness
+            || self.rustdoc_options.nocapture
+            || self.rustdoc_options.test_args.iter().any(|arg| arg == "--show-output")
+            || doctest.crate_attrs.contains("#![no_std]");
+        if is_standalone {
+            let test_desc = self.generate_test_desc_and_fn(doctest, scraped_test);
+            self.standalone_tests.push(test_desc);
+        } else {
+            self.mergeable_tests.entry(edition).or_default().push((doctest, scraped_test));
+        }
+    }
+
+    fn generate_test_desc_and_fn(
+        &mut self,
+        test: DocTest,
+        scraped_test: ScrapedDoctest,
+    ) -> test::TestDescAndFn {
+        let name = self.generate_name(
+            &scraped_test.filename,
+            scraped_test.line,
+            &scraped_test.logical_path,
+        );
         let opts = self.opts.clone();
         let target_str = self.rustdoc_options.target.to_string();
         let unused_externs = self.unused_extern_reports.clone();
-        if !test.langstr.compile_fail {
+        if !scraped_test.langstr.compile_fail {
             self.compiling_test_count.fetch_add(1, Ordering::SeqCst);
         }
 
-        let path = match &test.filename {
+        let path = match &scraped_test.filename {
             FileName::Real(path) => {
                 if let Some(local_path) = path.local_path() {
                     local_path.to_path_buf()
@@ -669,7 +696,7 @@ impl CreateRunnableDoctests {
         };
 
         // For example `module/file.rs` would become `module_file_rs`
-        let file = test
+        let file = scraped_test
             .filename
             .prefer_local()
             .to_string_lossy()
@@ -679,12 +706,12 @@ impl CreateRunnableDoctests {
         let test_id = format!(
             "{file}_{line}_{number}",
             file = file,
-            line = test.line,
+            line = scraped_test.line,
             number = {
                 // Increases the current test number, if this file already
                 // exists or it creates a new entry with a test number of 0.
                 self.visited_tests
-                    .entry((file.clone(), test.line))
+                    .entry((file.clone(), scraped_test.line))
                     .and_modify(|v| *v += 1)
                     .or_insert(0)
             },
@@ -693,11 +720,11 @@ impl CreateRunnableDoctests {
         let rustdoc_options = self.rustdoc_options.clone();
         let rustdoc_test_options = IndividualTestOptions::new(&self.rustdoc_options, test_id, path);
 
-        debug!("creating test {name}: {}", test.text);
-        self.tests.push(test::TestDescAndFn {
+        debug!("creating test {name}: {}", scraped_test.text);
+        test::TestDescAndFn {
             desc: test::TestDesc {
                 name: test::DynTestName(name),
-                ignore: match test.langstr.ignore {
+                ignore: match scraped_test.langstr.ignore {
                     Ignore::All => true,
                     Ignore::None => false,
                     Ignore::Some(ref ignores) => ignores.iter().any(|s| target_str.contains(s)),
@@ -710,20 +737,28 @@ impl CreateRunnableDoctests {
                 end_col: 0,
                 // compiler failures are test failures
                 should_panic: test::ShouldPanic::No,
-                compile_fail: test.langstr.compile_fail,
-                no_run: test.no_run(&rustdoc_options),
+                compile_fail: scraped_test.langstr.compile_fail,
+                no_run: scraped_test.no_run(&rustdoc_options),
                 test_type: test::TestType::DocTest,
             },
             testfn: test::DynTestFn(Box::new(move || {
-                doctest_run_fn(rustdoc_test_options, opts, test, rustdoc_options, unused_externs)
+                doctest_run_fn(
+                    rustdoc_test_options,
+                    opts,
+                    test,
+                    scraped_test,
+                    rustdoc_options,
+                    unused_externs,
+                )
             })),
-        });
+        }
     }
 }
 
 fn doctest_run_fn(
     test_opts: IndividualTestOptions,
     global_opts: GlobalTestOptions,
+    doctest: DocTest,
     scraped_test: ScrapedDoctest,
     rustdoc_options: Arc<RustdocOptions>,
     unused_externs: Arc<Mutex<Vec<UnusedExterns>>>,
@@ -731,9 +766,8 @@ fn doctest_run_fn(
     let report_unused_externs = |uext| {
         unused_externs.lock().unwrap().push(uext);
     };
-    let edition = scraped_test.edition(&rustdoc_options);
-    let doctest = DocTest::new(&scraped_test.text, Some(&global_opts.crate_name), edition);
     let (full_test_code, full_test_line_offset) = doctest.generate_unique_doctest(
+        &scraped_test.text,
         scraped_test.langstr.test_harness,
         &global_opts,
         Some(&test_opts.test_id),
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 3ba0f36ef7af1..759a3e31b2391 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -18,7 +18,6 @@ use rustc_span::{FileName, Span, DUMMY_SP};
 use super::GlobalTestOptions;
 
 pub(crate) struct DocTest {
-    pub(crate) test_code: String,
     pub(crate) supports_color: bool,
     pub(crate) already_has_extern_crate: bool,
     pub(crate) main_fn_span: Option<Span>,
@@ -40,7 +39,6 @@ impl DocTest {
             // If the parser panicked due to a fatal error, pass the test code through unchanged.
             // The error will be reported during compilation.
             return DocTest {
-                test_code: source.to_string(),
                 supports_color: false,
                 main_fn_span: None,
                 crate_attrs,
@@ -50,7 +48,6 @@ impl DocTest {
             };
         };
         Self {
-            test_code: source.to_string(),
             supports_color,
             main_fn_span,
             crate_attrs,
@@ -64,6 +61,7 @@ impl DocTest {
     /// lines before the test code begins.
     pub(crate) fn generate_unique_doctest(
         &self,
+        test_code: &str,
         dont_insert_main: bool,
         opts: &GlobalTestOptions,
         // If `test_id` is `None`, it means we're generating code for a code example "run" link.
@@ -103,7 +101,7 @@ impl DocTest {
             // NOTE: this is terribly inaccurate because it doesn't actually
             // parse the source, but only has false positives, not false
             // negatives.
-            self.test_code.contains(crate_name)
+            test_code.contains(crate_name)
         {
             // rustdoc implicitly inserts an `extern crate` item for the own crate
             // which may be unused, so we need to allow the lint.
diff --git a/src/librustdoc/doctest/markdown.rs b/src/librustdoc/doctest/markdown.rs
index b8ab7adb36e8c..ff2adffe5c281 100644
--- a/src/librustdoc/doctest/markdown.rs
+++ b/src/librustdoc/doctest/markdown.rs
@@ -120,6 +120,6 @@ pub(crate) fn test(options: Options) -> Result<(), String> {
 
     let mut collector = CreateRunnableDoctests::new(options.clone(), opts);
     md_collector.tests.into_iter().for_each(|t| collector.add_test(t));
-    crate::doctest::run_tests(options.test_args, options.nocapture, collector.tests);
+    crate::doctest::run_tests(options.test_args, options.nocapture, collector.standalone_tests);
     Ok(())
 }
diff --git a/src/librustdoc/doctest/tests.rs b/src/librustdoc/doctest/tests.rs
index 77322b59b653c..7c1cdaf8236e2 100644
--- a/src/librustdoc/doctest/tests.rs
+++ b/src/librustdoc/doctest/tests.rs
@@ -12,7 +12,7 @@ fn make_test(
 ) -> (String, usize) {
     let doctest = DocTest::new(test_code, crate_name, DEFAULT_EDITION);
     let (code, line_offset) =
-        doctest.generate_unique_doctest(dont_insert_main, opts, test_id, crate_name);
+        doctest.generate_unique_doctest(test_code, dont_insert_main, opts, test_id, crate_name);
     (code, line_offset)
 }
 
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index 90ff71396d75b..c1f5f3d7e2392 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -298,10 +298,10 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
                 args_file: PathBuf::new(),
             };
             let doctest = doctest::DocTest::new(&test, krate, edition);
-            let (test, _) = doctest.generate_unique_doctest(false, &opts, None, krate);
+            let (test, _) = doctest.generate_unique_doctest(&test, false, &opts, None, krate);
             let channel = if test.contains("#![feature(") { "&amp;version=nightly" } else { "" };
 
-            let test_escaped = small_url_encode(doctest.test_code);
+            let test_escaped = small_url_encode(test);
             Some(format!(
                 "<a class=\"test-arrow\" \
                     target=\"_blank\" \

From 96051f20e2124bf5254dfbe8deeaf7a635170d85 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sat, 8 Jun 2024 22:55:52 +0200
Subject: [PATCH 195/685] Split standalone and mergeable doctests

---
 src/librustdoc/doctest.rs          | 363 ++++++++++++++++++-----------
 src/librustdoc/doctest/make.rs     |  19 +-
 src/librustdoc/doctest/markdown.rs |   8 +-
 src/librustdoc/doctest/runner.rs   | 188 +++++++++++++++
 src/librustdoc/doctest/rust.rs     |  12 +-
 src/librustdoc/html/markdown.rs    |   4 +-
 6 files changed, 440 insertions(+), 154 deletions(-)
 create mode 100644 src/librustdoc/doctest/runner.rs

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 65ddaedf26c5d..f00aef491f5c0 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -1,5 +1,6 @@
 mod make;
 mod markdown;
+mod runner;
 mod rust;
 
 use std::fs::File;
@@ -164,40 +165,54 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<()
     let args_path = temp_dir.path().join("rustdoc-cfgs");
     crate::wrap_return(dcx, generate_args_file(&args_path, &options))?;
 
-    // FIXME: use mergeable tests!
-    let (standalone_tests, unused_extern_reports, compiling_test_count) =
-        interface::run_compiler(config, |compiler| {
-            compiler.enter(|queries| {
-                let collector = queries.global_ctxt()?.enter(|tcx| {
-                    let crate_name = tcx.crate_name(LOCAL_CRATE).to_string();
-                    let crate_attrs = tcx.hir().attrs(CRATE_HIR_ID);
-                    let opts = scrape_test_config(crate_name, crate_attrs, args_path);
-                    let enable_per_target_ignores = options.enable_per_target_ignores;
-
-                    let mut collector = CreateRunnableDoctests::new(options, opts);
-                    let hir_collector = HirCollector::new(
-                        &compiler.sess,
-                        tcx.hir(),
-                        ErrorCodes::from(compiler.sess.opts.unstable_features.is_nightly_build()),
-                        enable_per_target_ignores,
-                        tcx,
-                    );
-                    let tests = hir_collector.collect_crate();
-                    tests.into_iter().for_each(|t| collector.add_test(t));
-
-                    collector
-                });
-                if compiler.sess.dcx().has_errors().is_some() {
-                    FatalError.raise();
-                }
+    let CreateRunnableDoctests {
+        standalone_tests,
+        mergeable_tests,
+        rustdoc_options,
+        opts,
+        unused_extern_reports,
+        compiling_test_count,
+        ..
+    } = interface::run_compiler(config, |compiler| {
+        compiler.enter(|queries| {
+            let collector = queries.global_ctxt()?.enter(|tcx| {
+                let crate_name = tcx.crate_name(LOCAL_CRATE).to_string();
+                let crate_attrs = tcx.hir().attrs(CRATE_HIR_ID);
+                let opts = scrape_test_config(crate_name, crate_attrs, args_path);
+                let enable_per_target_ignores = options.enable_per_target_ignores;
+
+                let mut collector = CreateRunnableDoctests::new(options, opts);
+                let hir_collector = HirCollector::new(
+                    &compiler.sess,
+                    tcx.hir(),
+                    ErrorCodes::from(compiler.sess.opts.unstable_features.is_nightly_build()),
+                    enable_per_target_ignores,
+                    tcx,
+                );
+                let tests = hir_collector.collect_crate();
+                tests.into_iter().for_each(|t| collector.add_test(t));
+
+                collector
+            });
+            if compiler.sess.dcx().has_errors().is_some() {
+                FatalError.raise();
+            }
 
-                let unused_extern_reports = collector.unused_extern_reports.clone();
-                let compiling_test_count = collector.compiling_test_count.load(Ordering::SeqCst);
-                Ok((collector.standalone_tests, unused_extern_reports, compiling_test_count))
-            })
-        })?;
+            Ok(collector)
+        })
+    })?;
+
+    run_tests(
+        test_args,
+        nocapture,
+        opts,
+        rustdoc_options,
+        &unused_extern_reports,
+        standalone_tests,
+        mergeable_tests,
+    );
 
-    run_tests(test_args, nocapture, standalone_tests);
+    let compiling_test_count = compiling_test_count.load(Ordering::SeqCst);
 
     // Collect and warn about unused externs, but only if we've gotten
     // reports for each doctest
@@ -243,14 +258,74 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<()
 pub(crate) fn run_tests(
     mut test_args: Vec<String>,
     nocapture: bool,
-    mut tests: Vec<test::TestDescAndFn>,
+    opts: GlobalTestOptions,
+    rustdoc_options: RustdocOptions,
+    unused_extern_reports: &Arc<Mutex<Vec<UnusedExterns>>>,
+    mut standalone_tests: Vec<test::TestDescAndFn>,
+    mut mergeable_tests: FxHashMap<Edition, Vec<(DocTest, ScrapedDoctest)>>,
 ) {
     test_args.insert(0, "rustdoctest".to_string());
     if nocapture {
         test_args.push("--nocapture".to_string());
     }
-    tests.sort_by(|a, b| a.desc.name.as_slice().cmp(&b.desc.name.as_slice()));
-    test::test_main(&test_args, tests, None);
+
+    let mut nb_errors = 0;
+
+    for (edition, mut doctests) in mergeable_tests {
+        if doctests.is_empty() {
+            continue;
+        }
+        doctests.sort_by(|(_, a), (_, b)| a.name.cmp(&b.name));
+        let outdir = Arc::clone(&doctests[0].outdir);
+
+        let mut tests_runner = runner::DocTestRunner::new();
+
+        let rustdoc_test_options = IndividualTestOptions::new(
+            &rustdoc_options,
+            format!("merged_doctest"),
+            PathBuf::from(r"doctest.rs"),
+        );
+
+        for (doctest, scraped_test) in &doctests {
+            tests_runner.add_test(doctest, scraped_test);
+        }
+        if let Ok(success) =
+            tests_runner.run_tests(rustdoc_test_options, edition, &opts, &test_args, &outdir)
+        {
+            if !success {
+                nb_errors += 1;
+            }
+            continue;
+        } else {
+            // We failed to compile all compatible tests as one so we push them into the
+            // `standalone_tests` doctests.
+            debug!("Failed to compile compatible doctests for edition {} all at once", edition);
+            for (doctest, scraped_test) in doctests {
+                doctest.generate_unique_doctest(
+                    &scraped_test.text,
+                    scraped_test.langstr.test_harness,
+                    &opts,
+                    Some(&opts.crate_name),
+                );
+                standalone_tests.push(generate_test_desc_and_fn(
+                    doctest,
+                    scraped_test,
+                    opts.clone(),
+                    rustdoc_test_options.clone(),
+                    unused_extern_reports.clone(),
+                ));
+            }
+        }
+    }
+
+    if !standalone_tests.is_empty() {
+        standalone_tests.sort_by(|a, b| a.desc.name.as_slice().cmp(&b.desc.name.as_slice()));
+        test::test_main(&test_args, standalone_tests, None);
+    }
+    if nb_errors != 0 {
+        // libtest::ERROR_EXIT_CODE is not public but it's the same value.
+        std::process::exit(101);
+    }
 }
 
 // Look for `#![doc(test(no_crate_inject))]`, used by crates in the std facade.
@@ -365,7 +440,10 @@ struct RunnableDoctest {
     full_test_line_offset: usize,
     test_opts: IndividualTestOptions,
     global_opts: GlobalTestOptions,
-    scraped_test: ScrapedDoctest,
+    langstr: LangString,
+    line: usize,
+    edition: Edition,
+    no_run: bool,
 }
 
 fn run_test(
@@ -374,8 +452,7 @@ fn run_test(
     supports_color: bool,
     report_unused_externs: impl Fn(UnusedExterns),
 ) -> Result<(), TestFailure> {
-    let scraped_test = &doctest.scraped_test;
-    let langstr = &scraped_test.langstr;
+    let langstr = &doctest.langstr;
     // Make sure we emit well-formed executable names for our target.
     let rust_out = add_exe_suffix("rust_out".to_owned(), &rustdoc_options.target);
     let output_file = doctest.test_opts.outdir.path().join(rust_out);
@@ -392,11 +469,11 @@ fn run_test(
         compiler.arg(format!("--sysroot={}", sysroot.display()));
     }
 
-    compiler.arg("--edition").arg(&scraped_test.edition(rustdoc_options).to_string());
+    compiler.arg("--edition").arg(&doctest.edition.to_string());
     compiler.env("UNSTABLE_RUSTDOC_TEST_PATH", &doctest.test_opts.path);
     compiler.env(
         "UNSTABLE_RUSTDOC_TEST_LINE",
-        format!("{}", scraped_test.line as isize - doctest.full_test_line_offset as isize),
+        format!("{}", doctest.line as isize - doctest.full_test_line_offset as isize),
     );
     compiler.arg("-o").arg(&output_file);
     if langstr.test_harness {
@@ -409,10 +486,7 @@ fn run_test(
         compiler.arg("-Z").arg("unstable-options");
     }
 
-    if scraped_test.no_run(rustdoc_options)
-        && !langstr.compile_fail
-        && rustdoc_options.persist_doctests.is_none()
-    {
+    if doctest.no_run && !langstr.compile_fail && rustdoc_options.persist_doctests.is_none() {
         // FIXME: why does this code check if it *shouldn't* persist doctests
         //        -- shouldn't it be the negation?
         compiler.arg("--emit=metadata");
@@ -493,8 +567,7 @@ fn run_test(
                 // We used to check if the output contained "error[{}]: " but since we added the
                 // colored output, we can't anymore because of the color escape characters before
                 // the ":".
-                let missing_codes: Vec<String> = scraped_test
-                    .langstr
+                let missing_codes: Vec<String> = langstr
                     .error_codes
                     .iter()
                     .filter(|err| !out.contains(&format!("error[{err}]")))
@@ -511,7 +584,7 @@ fn run_test(
         }
     }
 
-    if scraped_test.no_run(rustdoc_options) {
+    if doctest.no_run {
         return Ok(());
     }
 
@@ -600,9 +673,27 @@ struct ScrapedDoctest {
     logical_path: Vec<String>,
     langstr: LangString,
     text: String,
+    name: String,
 }
 
 impl ScrapedDoctest {
+    fn new(
+        filename: FileName,
+        line: usize,
+        logical_path: Vec<String>,
+        langstr: LangString,
+        text: String,
+    ) -> Self {
+        let mut item_path = logical_path.join("::");
+        item_path.retain(|c| c != ' ');
+        if !item_path.is_empty() {
+            item_path.push(' ');
+        }
+        let name =
+            format!("{} - {item_path}(line {line})", filename.prefer_remapped_unconditionaly());
+
+        Self { filename, line, logical_path, langstr, text, name }
+    }
     fn edition(&self, opts: &RustdocOptions) -> Edition {
         self.langstr.edition.unwrap_or(opts.edition)
     }
@@ -641,18 +732,32 @@ impl CreateRunnableDoctests {
         }
     }
 
-    fn generate_name(&self, filename: &FileName, line: usize, logical_path: &[String]) -> String {
-        let mut item_path = logical_path.join("::");
-        item_path.retain(|c| c != ' ');
-        if !item_path.is_empty() {
-            item_path.push(' ');
-        }
-        format!("{} - {item_path}(line {line})", filename.prefer_remapped_unconditionaly())
-    }
-
     fn add_test(&mut self, scraped_test: ScrapedDoctest) {
+        // For example `module/file.rs` would become `module_file_rs`
+        let file = scraped_test
+            .filename
+            .prefer_local()
+            .to_string_lossy()
+            .chars()
+            .map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })
+            .collect::<String>();
+        let test_id = format!(
+            "{file}_{line}_{number}",
+            file = file,
+            line = scraped_test.line,
+            number = {
+                // Increases the current test number, if this file already
+                // exists or it creates a new entry with a test number of 0.
+                self.visited_tests
+                    .entry((file.clone(), scraped_test.line))
+                    .and_modify(|v| *v += 1)
+                    .or_insert(0)
+            },
+        );
+
         let edition = scraped_test.edition(&self.rustdoc_options);
-        let doctest = DocTest::new(&scraped_test.text, Some(&self.opts.crate_name), edition);
+        let doctest =
+            DocTest::new(&scraped_test.text, Some(&self.opts.crate_name), edition, test_id);
         let is_standalone = scraped_test.langstr.compile_fail
             || scraped_test.langstr.test_harness
             || self.rustdoc_options.nocapture
@@ -671,87 +776,77 @@ impl CreateRunnableDoctests {
         test: DocTest,
         scraped_test: ScrapedDoctest,
     ) -> test::TestDescAndFn {
-        let name = self.generate_name(
-            &scraped_test.filename,
-            scraped_test.line,
-            &scraped_test.logical_path,
-        );
-        let opts = self.opts.clone();
-        let target_str = self.rustdoc_options.target.to_string();
-        let unused_externs = self.unused_extern_reports.clone();
         if !scraped_test.langstr.compile_fail {
             self.compiling_test_count.fetch_add(1, Ordering::SeqCst);
         }
 
-        let path = match &scraped_test.filename {
-            FileName::Real(path) => {
-                if let Some(local_path) = path.local_path() {
-                    local_path.to_path_buf()
-                } else {
-                    // Somehow we got the filename from the metadata of another crate, should never happen
-                    unreachable!("doctest from a different crate");
-                }
-            }
-            _ => PathBuf::from(r"doctest.rs"),
-        };
+        generate_test_desc_and_fn(
+            test,
+            scraped_test,
+            self.opts.clone(),
+            self.rustdoc_options.clone(),
+            self.unused_extern_reports.clone(),
+        )
+    }
+}
 
-        // For example `module/file.rs` would become `module_file_rs`
-        let file = scraped_test
-            .filename
-            .prefer_local()
-            .to_string_lossy()
-            .chars()
-            .map(|c| if c.is_ascii_alphanumeric() { c } else { '_' })
-            .collect::<String>();
-        let test_id = format!(
-            "{file}_{line}_{number}",
-            file = file,
-            line = scraped_test.line,
-            number = {
-                // Increases the current test number, if this file already
-                // exists or it creates a new entry with a test number of 0.
-                self.visited_tests
-                    .entry((file.clone(), scraped_test.line))
-                    .and_modify(|v| *v += 1)
-                    .or_insert(0)
-            },
-        );
+fn generate_test_desc_and_fn(
+    test: DocTest,
+    scraped_test: ScrapedDoctest,
+    opts: GlobalTestOptions,
+    rustdoc_options: IndividualTestOptions,
+    unused_externs: Arc<Mutex<Vec<UnusedExterns>>>,
+) -> test::TestDescAndFn {
+    let target_str = rustdoc_options.target.to_string();
 
-        let rustdoc_options = self.rustdoc_options.clone();
-        let rustdoc_test_options = IndividualTestOptions::new(&self.rustdoc_options, test_id, path);
-
-        debug!("creating test {name}: {}", scraped_test.text);
-        test::TestDescAndFn {
-            desc: test::TestDesc {
-                name: test::DynTestName(name),
-                ignore: match scraped_test.langstr.ignore {
-                    Ignore::All => true,
-                    Ignore::None => false,
-                    Ignore::Some(ref ignores) => ignores.iter().any(|s| target_str.contains(s)),
-                },
-                ignore_message: None,
-                source_file: "",
-                start_line: 0,
-                start_col: 0,
-                end_line: 0,
-                end_col: 0,
-                // compiler failures are test failures
-                should_panic: test::ShouldPanic::No,
-                compile_fail: scraped_test.langstr.compile_fail,
-                no_run: scraped_test.no_run(&rustdoc_options),
-                test_type: test::TestType::DocTest,
-            },
-            testfn: test::DynTestFn(Box::new(move || {
-                doctest_run_fn(
-                    rustdoc_test_options,
-                    opts,
-                    test,
-                    scraped_test,
-                    rustdoc_options,
-                    unused_externs,
-                )
-            })),
+    let path = match &scraped_test.filename {
+        FileName::Real(path) => {
+            if let Some(local_path) = path.local_path() {
+                local_path.to_path_buf()
+            } else {
+                // Somehow we got the filename from the metadata of another crate, should never happen
+                unreachable!("doctest from a different crate");
+            }
         }
+        _ => PathBuf::from(r"doctest.rs"),
+    };
+
+    let name = &test.name;
+    let rustdoc_test_options =
+        IndividualTestOptions::new(&rustdoc_options, test.test_id.clone(), path);
+    // let rustdoc_options_clone = rustdoc_options.clone();
+
+    debug!("creating test {name}: {}", scraped_test.text);
+    test::TestDescAndFn {
+        desc: test::TestDesc {
+            name: test::DynTestName(name),
+            ignore: match scraped_test.langstr.ignore {
+                Ignore::All => true,
+                Ignore::None => false,
+                Ignore::Some(ref ignores) => ignores.iter().any(|s| target_str.contains(s)),
+            },
+            ignore_message: None,
+            source_file: "",
+            start_line: 0,
+            start_col: 0,
+            end_line: 0,
+            end_col: 0,
+            // compiler failures are test failures
+            should_panic: test::ShouldPanic::No,
+            compile_fail: scraped_test.langstr.compile_fail,
+            no_run: scraped_test.no_run(&rustdoc_options),
+            test_type: test::TestType::DocTest,
+        },
+        testfn: test::DynTestFn(Box::new(move || {
+            doctest_run_fn(
+                rustdoc_test_options,
+                opts,
+                test,
+                scraped_test,
+                rustdoc_options,
+                unused_externs,
+            )
+        })),
     }
 }
 
@@ -770,7 +865,6 @@ fn doctest_run_fn(
         &scraped_test.text,
         scraped_test.langstr.test_harness,
         &global_opts,
-        Some(&test_opts.test_id),
         Some(&global_opts.crate_name),
     );
     let runnable_test = RunnableDoctest {
@@ -778,7 +872,10 @@ fn doctest_run_fn(
         full_test_line_offset,
         test_opts,
         global_opts,
-        scraped_test,
+        langstr: scraped_test.langstr.clone(),
+        line: scraped_test.line,
+        edition: scraped_test.edition(&rustdoc_options),
+        no_run: scraped_test.no_run(&rustdoc_options),
     };
     let res =
         run_test(runnable_test, &rustdoc_options, doctest.supports_color, report_unused_externs);
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 759a3e31b2391..c1d1e45ff042e 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -24,10 +24,17 @@ pub(crate) struct DocTest {
     pub(crate) crate_attrs: String,
     pub(crate) crates: String,
     pub(crate) everything_else: String,
+    pub(crate) test_id: Option<String>,
 }
 
 impl DocTest {
-    pub(crate) fn new(source: &str, crate_name: Option<&str>, edition: Edition) -> Self {
+    pub(crate) fn new(
+        source: &str,
+        crate_name: Option<&str>,
+        edition: Edition,
+        // If `test_id` is `None`, it means we're generating code for a code example "run" link.
+        test_id: Option<String>,
+    ) -> Self {
         let (crate_attrs, everything_else, crates) = partition_source(source, edition);
         let mut supports_color = false;
 
@@ -45,6 +52,7 @@ impl DocTest {
                 crates,
                 everything_else,
                 already_has_extern_crate: false,
+                test_id,
             };
         };
         Self {
@@ -54,6 +62,7 @@ impl DocTest {
             crates,
             everything_else,
             already_has_extern_crate,
+            test_id,
         }
     }
 
@@ -64,8 +73,6 @@ impl DocTest {
         test_code: &str,
         dont_insert_main: bool,
         opts: &GlobalTestOptions,
-        // If `test_id` is `None`, it means we're generating code for a code example "run" link.
-        test_id: Option<&str>,
         crate_name: Option<&str>,
     ) -> (String, usize) {
         let mut line_offset = 0;
@@ -118,12 +125,12 @@ impl DocTest {
             let returns_result = everything_else.ends_with("(())");
             // Give each doctest main function a unique name.
             // This is for example needed for the tooling around `-C instrument-coverage`.
-            let inner_fn_name = if let Some(test_id) = test_id {
+            let inner_fn_name = if let Some(ref test_id) = self.test_id {
                 format!("_doctest_main_{test_id}")
             } else {
                 "_inner".into()
             };
-            let inner_attr = if test_id.is_some() { "#[allow(non_snake_case)] " } else { "" };
+            let inner_attr = if self.test_id.is_some() { "#[allow(non_snake_case)] " } else { "" };
             let (main_pre, main_post) = if returns_result {
                 (
                     format!(
@@ -131,7 +138,7 @@ impl DocTest {
                     ),
                     format!("\n}} {inner_fn_name}().unwrap() }}"),
                 )
-            } else if test_id.is_some() {
+            } else if self.test_id.is_some() {
                 (
                     format!("fn main() {{ {inner_attr}fn {inner_fn_name}() {{\n",),
                     format!("\n}} {inner_fn_name}() }}"),
diff --git a/src/librustdoc/doctest/markdown.rs b/src/librustdoc/doctest/markdown.rs
index ff2adffe5c281..a5514857fff02 100644
--- a/src/librustdoc/doctest/markdown.rs
+++ b/src/librustdoc/doctest/markdown.rs
@@ -22,13 +22,7 @@ impl DoctestVisitor for MdCollector {
         let filename = self.filename.clone();
         // First line of Markdown is line 1.
         let line = 1 + rel_line.offset();
-        self.tests.push(ScrapedDoctest {
-            filename,
-            line,
-            logical_path: self.cur_path.clone(),
-            langstr: config,
-            text: test,
-        });
+        self.tests.push(ScrapedDoctest::new(filename, line, self.cur_path.clone(), config, test));
     }
 
     fn visit_header(&mut self, name: &str, level: u32) {
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
new file mode 100644
index 0000000000000..a672bb1bd9ba1
--- /dev/null
+++ b/src/librustdoc/doctest/runner.rs
@@ -0,0 +1,188 @@
+use rustc_data_structures::fx::FxHashSet;
+use rustc_span::edition::Edition;
+
+use std::fmt::Write;
+use std::sync::{Arc, Mutex};
+
+use crate::doctest::{
+    run_test, DirState, DocTest, GlobalTestOptions, IndividualTestOptions, RunnableDoctest,
+    RustdocOptions, ScrapedDoctest, TestFailure, UnusedExterns,
+};
+use crate::html::markdown::LangString;
+
+/// Convenient type to merge compatible doctests into one.
+pub(crate) struct DocTestRunner {
+    crate_attrs: FxHashSet<String>,
+    ids: String,
+    output: String,
+    supports_color: bool,
+    nb_tests: usize,
+    doctests: Vec<DocTest>,
+}
+
+impl DocTestRunner {
+    pub(crate) fn new() -> Self {
+        Self {
+            crate_attrs: FxHashSet::default(),
+            ids: String::new(),
+            output: String::new(),
+            supports_color: true,
+            nb_tests: 0,
+            doctests: Vec::with_capacity(10),
+        }
+    }
+
+    pub(crate) fn add_test(&mut self, doctest: &DocTest, scraped_test: &ScrapedDoctest) {
+        if !doctest.ignore {
+            for line in doctest.crate_attrs.split('\n') {
+                self.crate_attrs.insert(line.to_string());
+            }
+        }
+        if !self.ids.is_empty() {
+            self.ids.push(',');
+        }
+        self.ids.push_str(&format!(
+            "{}::TEST",
+            generate_mergeable_doctest(doctest, scraped_test, self.nb_tests, &mut self.output),
+        ));
+        self.supports_color &= doctest.supports_color;
+        self.nb_tests += 1;
+        self.doctests.push(doctest);
+    }
+
+    pub(crate) fn run_tests(
+        &mut self,
+        test_options: IndividualTestOptions,
+        edition: Edition,
+        opts: &GlobalTestOptions,
+        test_args: &[String],
+        outdir: &Arc<DirState>,
+        rustdoc_options: &RustdocOptions,
+        unused_externs: Arc<Mutex<Vec<UnusedExterns>>>,
+    ) -> Result<bool, ()> {
+        let mut code = "\
+#![allow(unused_extern_crates)]
+#![allow(internal_features)]
+#![feature(test)]
+#![feature(rustc_attrs)]
+#![feature(coverage_attribute)]\n"
+            .to_string();
+
+        for crate_attr in &self.crate_attrs {
+            code.push_str(crate_attr);
+            code.push('\n');
+        }
+
+        DocTest::push_attrs(&mut code, opts, &mut 0);
+        code.push_str("extern crate test;\n");
+
+        let test_args =
+            test_args.iter().map(|arg| format!("{arg:?}.to_string(),")).collect::<String>();
+        write!(
+            code,
+            "\
+{output}
+#[rustc_main]
+#[coverage(off)]
+fn main() {{
+test::test_main(&[{test_args}], vec![{ids}], None);
+}}",
+            output = self.output,
+            ids = self.ids,
+        )
+        .expect("failed to generate test code");
+        // let out_dir = build_test_dir(outdir, true, "");
+        let runnable_test = RunnableDoctest {
+            full_test_code: code,
+            full_test_line_offset: 0,
+            test_opts: test_options,
+            global_opts: opts.clone(),
+            langstr: LangString::default(),
+            line: 0,
+            edition,
+            no_run: false,
+        };
+        let ret = run_test(runnable_test, rustdoc_options, self.supports_color, unused_externs);
+        if let Err(TestFailure::CompileError) = ret { Err(()) } else { Ok(ret.is_ok()) }
+    }
+}
+
+/// Push new doctest content into `output`. Returns the test ID for this doctest.
+fn generate_mergeable_doctest(
+    doctest: &DocTest,
+    scraped_test: &ScrapedDoctest,
+    id: usize,
+    output: &mut String,
+) -> String {
+    let test_id = format!("__doctest_{id}");
+
+    if doctest.ignore {
+        // We generate nothing else.
+        writeln!(output, "mod {test_id} {{\n").unwrap();
+    } else {
+        writeln!(output, "mod {test_id} {{\n{}", doctest.crates).unwrap();
+        if doctest.main_fn_span.is_some() {
+            output.push_str(&doctest.everything_else);
+        } else {
+            let returns_result = if doctest.everything_else.trim_end().ends_with("(())") {
+                "-> Result<(), impl core::fmt::Debug>"
+            } else {
+                ""
+            };
+            write!(
+                output,
+                "\
+    fn main() {returns_result} {{
+        {}
+    }}",
+                doctest.everything_else
+            )
+            .unwrap();
+        }
+    }
+    writeln!(
+        output,
+        "
+#[rustc_test_marker = {test_name:?}]
+pub const TEST: test::TestDescAndFn = test::TestDescAndFn {{
+    desc: test::TestDesc {{
+        name: test::StaticTestName({test_name:?}),
+        ignore: {ignore},
+        ignore_message: None,
+        source_file: {file:?},
+        start_line: {line},
+        start_col: 0,
+        end_line: 0,
+        end_col: 0,
+        compile_fail: false,
+        no_run: {no_run},
+        should_panic: test::ShouldPanic::{should_panic},
+        test_type: test::TestType::UnitTest,
+    }},
+    testfn: test::StaticTestFn(
+        #[coverage(off)]
+        || test::assert_test_result({runner}),
+    )
+}};
+}}",
+        test_name = scraped_test.name,
+        ignore = scraped_test.langstr.ignore,
+        file = scraped_test.file,
+        line = scraped_test.line,
+        no_run = scraped_test.langstr.no_run,
+        should_panic = if !scraped_test.langstr.no_run && scraped_test.langstr.should_panic {
+            "Yes"
+        } else {
+            "No"
+        },
+        // Setting `no_run` to `true` in `TestDesc` still makes the test run, so we simply
+        // don't give it the function to run.
+        runner = if scraped_test.langstr.no_run || scraped_test.langstr.ignore {
+            "Ok::<(), String>(())"
+        } else {
+            "self::main()"
+        },
+    )
+    .unwrap();
+    test_id
+}
diff --git a/src/librustdoc/doctest/rust.rs b/src/librustdoc/doctest/rust.rs
index f179f3aa1c99b..17c29ba413a4a 100644
--- a/src/librustdoc/doctest/rust.rs
+++ b/src/librustdoc/doctest/rust.rs
@@ -51,13 +51,13 @@ impl RustCollector {
 impl DoctestVisitor for RustCollector {
     fn visit_test(&mut self, test: String, config: LangString, rel_line: MdRelLine) {
         let line = self.get_base_line() + rel_line.offset();
-        self.tests.push(ScrapedDoctest {
-            filename: self.get_filename(),
+        self.tests.push(ScrapedDoctest::new(
+            self.get_filename(),
             line,
-            logical_path: self.cur_path.clone(),
-            langstr: config,
-            text: test,
-        });
+            self.cur_path.clone(),
+            config,
+            test,
+        ));
     }
 
     fn visit_header(&mut self, _name: &str, _level: u32) {}
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index c1f5f3d7e2392..a268a2d704e54 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -297,8 +297,8 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
                 attrs: vec![],
                 args_file: PathBuf::new(),
             };
-            let doctest = doctest::DocTest::new(&test, krate, edition);
-            let (test, _) = doctest.generate_unique_doctest(&test, false, &opts, None, krate);
+            let doctest = doctest::DocTest::new(&test, krate, edition, None);
+            let (test, _) = doctest.generate_unique_doctest(&test, false, &opts, krate);
             let channel = if test.contains("#![feature(") { "&amp;version=nightly" } else { "" };
 
             let test_escaped = small_url_encode(test);

From 6ae35248358f1e9ac4e2535ceeb160dc1927a720 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 10 Jun 2024 15:31:19 +0200
Subject: [PATCH 196/685] Split doctests into two categories: mergeable ones
 and standalone ones

---
 src/librustdoc/doctest.rs          | 83 ++++++++++++++++--------------
 src/librustdoc/doctest/markdown.rs | 13 ++++-
 src/librustdoc/doctest/runner.rs   | 60 ++++++++++++++-------
 src/librustdoc/doctest/tests.rs    |  5 +-
 4 files changed, 99 insertions(+), 62 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index f00aef491f5c0..bfe5c9767b929 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -206,7 +206,7 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<()
         test_args,
         nocapture,
         opts,
-        rustdoc_options,
+        &rustdoc_options,
         &unused_extern_reports,
         standalone_tests,
         mergeable_tests,
@@ -259,10 +259,10 @@ pub(crate) fn run_tests(
     mut test_args: Vec<String>,
     nocapture: bool,
     opts: GlobalTestOptions,
-    rustdoc_options: RustdocOptions,
+    rustdoc_options: &Arc<RustdocOptions>,
     unused_extern_reports: &Arc<Mutex<Vec<UnusedExterns>>>,
     mut standalone_tests: Vec<test::TestDescAndFn>,
-    mut mergeable_tests: FxHashMap<Edition, Vec<(DocTest, ScrapedDoctest)>>,
+    mergeable_tests: FxHashMap<Edition, Vec<(DocTest, ScrapedDoctest)>>,
 ) {
     test_args.insert(0, "rustdoctest".to_string());
     if nocapture {
@@ -270,28 +270,32 @@ pub(crate) fn run_tests(
     }
 
     let mut nb_errors = 0;
+    let target_str = rustdoc_options.target.to_string();
 
     for (edition, mut doctests) in mergeable_tests {
         if doctests.is_empty() {
             continue;
         }
         doctests.sort_by(|(_, a), (_, b)| a.name.cmp(&b.name));
-        let outdir = Arc::clone(&doctests[0].outdir);
 
         let mut tests_runner = runner::DocTestRunner::new();
 
         let rustdoc_test_options = IndividualTestOptions::new(
             &rustdoc_options,
-            format!("merged_doctest"),
-            PathBuf::from(r"doctest.rs"),
+            &format!("merged_doctest_{edition}"),
+            PathBuf::from(format!("doctest_{edition}.rs")),
         );
 
         for (doctest, scraped_test) in &doctests {
-            tests_runner.add_test(doctest, scraped_test);
+            tests_runner.add_test(doctest, scraped_test, &target_str);
         }
-        if let Ok(success) =
-            tests_runner.run_tests(rustdoc_test_options, edition, &opts, &test_args, &outdir)
-        {
+        if let Ok(success) = tests_runner.run_tests(
+            rustdoc_test_options,
+            edition,
+            &opts,
+            &test_args,
+            rustdoc_options,
+        ) {
             if !success {
                 nb_errors += 1;
             }
@@ -311,7 +315,7 @@ pub(crate) fn run_tests(
                     doctest,
                     scraped_test,
                     opts.clone(),
-                    rustdoc_test_options.clone(),
+                    Arc::clone(&rustdoc_options),
                     unused_extern_reports.clone(),
                 ));
             }
@@ -406,7 +410,7 @@ impl DirState {
 // We could unify this struct the one in rustc but they have different
 // ownership semantics, so doing so would create wasteful allocations.
 #[derive(serde::Serialize, serde::Deserialize)]
-struct UnusedExterns {
+pub(crate) struct UnusedExterns {
     /// Lint level of the unused_crate_dependencies lint
     lint_level: String,
     /// List of unused externs by their names.
@@ -642,12 +646,11 @@ fn make_maybe_absolute_path(path: PathBuf) -> PathBuf {
 }
 struct IndividualTestOptions {
     outdir: DirState,
-    test_id: String,
     path: PathBuf,
 }
 
 impl IndividualTestOptions {
-    fn new(options: &RustdocOptions, test_id: String, test_path: PathBuf) -> Self {
+    fn new(options: &RustdocOptions, test_id: &str, test_path: PathBuf) -> Self {
         let outdir = if let Some(ref path) = options.persist_doctests {
             let mut path = path.clone();
             path.push(&test_id);
@@ -662,15 +665,14 @@ impl IndividualTestOptions {
             DirState::Temp(get_doctest_dir().expect("rustdoc needs a tempdir"))
         };
 
-        Self { outdir, test_id, path: test_path }
+        Self { outdir, path: test_path }
     }
 }
 
 /// A doctest scraped from the code, ready to be turned into a runnable test.
-struct ScrapedDoctest {
+pub(crate) struct ScrapedDoctest {
     filename: FileName,
     line: usize,
-    logical_path: Vec<String>,
     langstr: LangString,
     text: String,
     name: String,
@@ -692,7 +694,7 @@ impl ScrapedDoctest {
         let name =
             format!("{} - {item_path}(line {line})", filename.prefer_remapped_unconditionaly());
 
-        Self { filename, line, logical_path, langstr, text, name }
+        Self { filename, line, langstr, text, name }
     }
     fn edition(&self, opts: &RustdocOptions) -> Edition {
         self.langstr.edition.unwrap_or(opts.edition)
@@ -701,6 +703,19 @@ impl ScrapedDoctest {
     fn no_run(&self, opts: &RustdocOptions) -> bool {
         self.langstr.no_run || opts.no_run
     }
+    fn path(&self) -> PathBuf {
+        match &self.filename {
+            FileName::Real(path) => {
+                if let Some(local_path) = path.local_path() {
+                    local_path.to_path_buf()
+                } else {
+                    // Somehow we got the filename from the metadata of another crate, should never happen
+                    unreachable!("doctest from a different crate");
+                }
+            }
+            _ => PathBuf::from(r"doctest.rs"),
+        }
+    }
 }
 
 pub(crate) trait DoctestVisitor {
@@ -757,7 +772,7 @@ impl CreateRunnableDoctests {
 
         let edition = scraped_test.edition(&self.rustdoc_options);
         let doctest =
-            DocTest::new(&scraped_test.text, Some(&self.opts.crate_name), edition, test_id);
+            DocTest::new(&scraped_test.text, Some(&self.opts.crate_name), edition, Some(test_id));
         let is_standalone = scraped_test.langstr.compile_fail
             || scraped_test.langstr.test_harness
             || self.rustdoc_options.nocapture
@@ -784,7 +799,7 @@ impl CreateRunnableDoctests {
             test,
             scraped_test,
             self.opts.clone(),
-            self.rustdoc_options.clone(),
+            Arc::clone(&self.rustdoc_options),
             self.unused_extern_reports.clone(),
         )
     }
@@ -794,32 +809,20 @@ fn generate_test_desc_and_fn(
     test: DocTest,
     scraped_test: ScrapedDoctest,
     opts: GlobalTestOptions,
-    rustdoc_options: IndividualTestOptions,
+    rustdoc_options: Arc<RustdocOptions>,
     unused_externs: Arc<Mutex<Vec<UnusedExterns>>>,
 ) -> test::TestDescAndFn {
     let target_str = rustdoc_options.target.to_string();
+    let rustdoc_test_options = IndividualTestOptions::new(
+        &rustdoc_options,
+        test.test_id.as_deref().unwrap_or_else(|| "<doctest>"),
+        scraped_test.path(),
+    );
 
-    let path = match &scraped_test.filename {
-        FileName::Real(path) => {
-            if let Some(local_path) = path.local_path() {
-                local_path.to_path_buf()
-            } else {
-                // Somehow we got the filename from the metadata of another crate, should never happen
-                unreachable!("doctest from a different crate");
-            }
-        }
-        _ => PathBuf::from(r"doctest.rs"),
-    };
-
-    let name = &test.name;
-    let rustdoc_test_options =
-        IndividualTestOptions::new(&rustdoc_options, test.test_id.clone(), path);
-    // let rustdoc_options_clone = rustdoc_options.clone();
-
-    debug!("creating test {name}: {}", scraped_test.text);
+    debug!("creating test {}: {}", scraped_test.name, scraped_test.text);
     test::TestDescAndFn {
         desc: test::TestDesc {
-            name: test::DynTestName(name),
+            name: test::DynTestName(scraped_test.name.clone()),
             ignore: match scraped_test.langstr.ignore {
                 Ignore::All => true,
                 Ignore::None => false,
diff --git a/src/librustdoc/doctest/markdown.rs b/src/librustdoc/doctest/markdown.rs
index a5514857fff02..5f821634a82d2 100644
--- a/src/librustdoc/doctest/markdown.rs
+++ b/src/librustdoc/doctest/markdown.rs
@@ -1,6 +1,7 @@
 //! Doctest functionality used only for doctests in `.md` Markdown files.
 
 use std::fs::read_to_string;
+use std::sync::{Arc, Mutex};
 
 use rustc_span::FileName;
 use tempfile::tempdir;
@@ -114,6 +115,16 @@ pub(crate) fn test(options: Options) -> Result<(), String> {
 
     let mut collector = CreateRunnableDoctests::new(options.clone(), opts);
     md_collector.tests.into_iter().for_each(|t| collector.add_test(t));
-    crate::doctest::run_tests(options.test_args, options.nocapture, collector.standalone_tests);
+    let CreateRunnableDoctests { opts, rustdoc_options, standalone_tests, mergeable_tests, .. } =
+        collector;
+    crate::doctest::run_tests(
+        options.test_args,
+        options.nocapture,
+        opts,
+        &rustdoc_options,
+        &Arc::new(Mutex::new(Vec::new())),
+        standalone_tests,
+        mergeable_tests,
+    );
     Ok(())
 }
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index a672bb1bd9ba1..9bad83d4669dc 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -2,13 +2,12 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_span::edition::Edition;
 
 use std::fmt::Write;
-use std::sync::{Arc, Mutex};
 
 use crate::doctest::{
-    run_test, DirState, DocTest, GlobalTestOptions, IndividualTestOptions, RunnableDoctest,
-    RustdocOptions, ScrapedDoctest, TestFailure, UnusedExterns,
+    run_test, DocTest, GlobalTestOptions, IndividualTestOptions, RunnableDoctest, RustdocOptions,
+    ScrapedDoctest, TestFailure, UnusedExterns,
 };
-use crate::html::markdown::LangString;
+use crate::html::markdown::{Ignore, LangString};
 
 /// Convenient type to merge compatible doctests into one.
 pub(crate) struct DocTestRunner {
@@ -17,7 +16,6 @@ pub(crate) struct DocTestRunner {
     output: String,
     supports_color: bool,
     nb_tests: usize,
-    doctests: Vec<DocTest>,
 }
 
 impl DocTestRunner {
@@ -28,12 +26,21 @@ impl DocTestRunner {
             output: String::new(),
             supports_color: true,
             nb_tests: 0,
-            doctests: Vec::with_capacity(10),
         }
     }
 
-    pub(crate) fn add_test(&mut self, doctest: &DocTest, scraped_test: &ScrapedDoctest) {
-        if !doctest.ignore {
+    pub(crate) fn add_test(
+        &mut self,
+        doctest: &DocTest,
+        scraped_test: &ScrapedDoctest,
+        target_str: &str,
+    ) {
+        let ignore = match scraped_test.langstr.ignore {
+            Ignore::All => true,
+            Ignore::None => false,
+            Ignore::Some(ref ignores) => ignores.iter().any(|s| target_str.contains(s)),
+        };
+        if !ignore {
             for line in doctest.crate_attrs.split('\n') {
                 self.crate_attrs.insert(line.to_string());
             }
@@ -43,11 +50,16 @@ impl DocTestRunner {
         }
         self.ids.push_str(&format!(
             "{}::TEST",
-            generate_mergeable_doctest(doctest, scraped_test, self.nb_tests, &mut self.output),
+            generate_mergeable_doctest(
+                doctest,
+                scraped_test,
+                ignore,
+                self.nb_tests,
+                &mut self.output
+            ),
         ));
         self.supports_color &= doctest.supports_color;
         self.nb_tests += 1;
-        self.doctests.push(doctest);
     }
 
     pub(crate) fn run_tests(
@@ -56,9 +68,7 @@ impl DocTestRunner {
         edition: Edition,
         opts: &GlobalTestOptions,
         test_args: &[String],
-        outdir: &Arc<DirState>,
         rustdoc_options: &RustdocOptions,
-        unused_externs: Arc<Mutex<Vec<UnusedExterns>>>,
     ) -> Result<bool, ()> {
         let mut code = "\
 #![allow(unused_extern_crates)]
@@ -73,7 +83,19 @@ impl DocTestRunner {
             code.push('\n');
         }
 
-        DocTest::push_attrs(&mut code, opts, &mut 0);
+        if opts.attrs.is_empty() {
+            // If there aren't any attributes supplied by #![doc(test(attr(...)))], then allow some
+            // lints that are commonly triggered in doctests. The crate-level test attributes are
+            // commonly used to make tests fail in case they trigger warnings, so having this there in
+            // that case may cause some tests to pass when they shouldn't have.
+            code.push_str("#![allow(unused)]\n");
+        }
+
+        // Next, any attributes that came from the crate root via #![doc(test(attr(...)))].
+        for attr in &opts.attrs {
+            code.push_str(&format!("#![{attr}]\n"));
+        }
+
         code.push_str("extern crate test;\n");
 
         let test_args =
@@ -91,7 +113,6 @@ test::test_main(&[{test_args}], vec![{ids}], None);
             ids = self.ids,
         )
         .expect("failed to generate test code");
-        // let out_dir = build_test_dir(outdir, true, "");
         let runnable_test = RunnableDoctest {
             full_test_code: code,
             full_test_line_offset: 0,
@@ -102,7 +123,8 @@ test::test_main(&[{test_args}], vec![{ids}], None);
             edition,
             no_run: false,
         };
-        let ret = run_test(runnable_test, rustdoc_options, self.supports_color, unused_externs);
+        let ret =
+            run_test(runnable_test, rustdoc_options, self.supports_color, |_: UnusedExterns| {});
         if let Err(TestFailure::CompileError) = ret { Err(()) } else { Ok(ret.is_ok()) }
     }
 }
@@ -111,12 +133,13 @@ test::test_main(&[{test_args}], vec![{ids}], None);
 fn generate_mergeable_doctest(
     doctest: &DocTest,
     scraped_test: &ScrapedDoctest,
+    ignore: bool,
     id: usize,
     output: &mut String,
 ) -> String {
     let test_id = format!("__doctest_{id}");
 
-    if doctest.ignore {
+    if ignore {
         // We generate nothing else.
         writeln!(output, "mod {test_id} {{\n").unwrap();
     } else {
@@ -166,8 +189,7 @@ pub const TEST: test::TestDescAndFn = test::TestDescAndFn {{
 }};
 }}",
         test_name = scraped_test.name,
-        ignore = scraped_test.langstr.ignore,
-        file = scraped_test.file,
+        file = scraped_test.path(),
         line = scraped_test.line,
         no_run = scraped_test.langstr.no_run,
         should_panic = if !scraped_test.langstr.no_run && scraped_test.langstr.should_panic {
@@ -177,7 +199,7 @@ pub const TEST: test::TestDescAndFn = test::TestDescAndFn {{
         },
         // Setting `no_run` to `true` in `TestDesc` still makes the test run, so we simply
         // don't give it the function to run.
-        runner = if scraped_test.langstr.no_run || scraped_test.langstr.ignore {
+        runner = if ignore || scraped_test.langstr.no_run {
             "Ok::<(), String>(())"
         } else {
             "self::main()"
diff --git a/src/librustdoc/doctest/tests.rs b/src/librustdoc/doctest/tests.rs
index 7c1cdaf8236e2..533fc3a56eddd 100644
--- a/src/librustdoc/doctest/tests.rs
+++ b/src/librustdoc/doctest/tests.rs
@@ -10,9 +10,10 @@ fn make_test(
     opts: &GlobalTestOptions,
     test_id: Option<&str>,
 ) -> (String, usize) {
-    let doctest = DocTest::new(test_code, crate_name, DEFAULT_EDITION);
+    let doctest =
+        DocTest::new(test_code, crate_name, DEFAULT_EDITION, test_id.map(|s| s.to_string()));
     let (code, line_offset) =
-        doctest.generate_unique_doctest(test_code, dont_insert_main, opts, test_id, crate_name);
+        doctest.generate_unique_doctest(test_code, dont_insert_main, opts, crate_name);
     (code, line_offset)
 }
 

From 58cd70e062566eac07987fd1351599fb82c09098 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 10 Jun 2024 15:51:35 +0200
Subject: [PATCH 197/685] Only merge doctests starting 2024 edition

---
 src/librustdoc/doctest.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index bfe5c9767b929..aba2af35f7b98 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -732,10 +732,12 @@ struct CreateRunnableDoctests {
     visited_tests: FxHashMap<(String, usize), usize>,
     unused_extern_reports: Arc<Mutex<Vec<UnusedExterns>>>,
     compiling_test_count: AtomicUsize,
+    can_merge_doctests: bool,
 }
 
 impl CreateRunnableDoctests {
     fn new(rustdoc_options: RustdocOptions, opts: GlobalTestOptions) -> CreateRunnableDoctests {
+        let can_merge_doctests = rustdoc_options.edition >= Edition::Edition2024;
         CreateRunnableDoctests {
             standalone_tests: Vec::new(),
             mergeable_tests: FxHashMap::default(),
@@ -744,6 +746,7 @@ impl CreateRunnableDoctests {
             visited_tests: FxHashMap::default(),
             unused_extern_reports: Default::default(),
             compiling_test_count: AtomicUsize::new(0),
+            can_merge_doctests,
         }
     }
 
@@ -773,7 +776,8 @@ impl CreateRunnableDoctests {
         let edition = scraped_test.edition(&self.rustdoc_options);
         let doctest =
             DocTest::new(&scraped_test.text, Some(&self.opts.crate_name), edition, Some(test_id));
-        let is_standalone = scraped_test.langstr.compile_fail
+        let is_standalone = !self.can_merge_doctests
+            || scraped_test.langstr.compile_fail
             || scraped_test.langstr.test_harness
             || self.rustdoc_options.nocapture
             || self.rustdoc_options.test_args.iter().any(|arg| arg == "--show-output")

From 3147520d3475a816e21b6b352bfd8c2b38ab05f5 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 10 Jun 2024 15:40:17 +0200
Subject: [PATCH 198/685] Add new doc codeblock `standalone` attribute

---
 src/librustdoc/doctest.rs       | 1 +
 src/librustdoc/html/markdown.rs | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index aba2af35f7b98..250cfa0d4c59a 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -779,6 +779,7 @@ impl CreateRunnableDoctests {
         let is_standalone = !self.can_merge_doctests
             || scraped_test.langstr.compile_fail
             || scraped_test.langstr.test_harness
+            || scraped_test.langstr.standalone
             || self.rustdoc_options.nocapture
             || self.rustdoc_options.test_args.iter().any(|arg| arg == "--show-output")
             || doctest.crate_attrs.contains("#![no_std]");
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index a268a2d704e54..da6aa47fff262 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -869,6 +869,7 @@ pub(crate) struct LangString {
     pub(crate) rust: bool,
     pub(crate) test_harness: bool,
     pub(crate) compile_fail: bool,
+    pub(crate) standalone: bool,
     pub(crate) error_codes: Vec<String>,
     pub(crate) edition: Option<Edition>,
     pub(crate) added_classes: Vec<String>,
@@ -1191,6 +1192,7 @@ impl Default for LangString {
             rust: true,
             test_harness: false,
             compile_fail: false,
+            standalone: false,
             error_codes: Vec::new(),
             edition: None,
             added_classes: Vec::new(),
@@ -1260,6 +1262,10 @@ impl LangString {
                         seen_rust_tags = !seen_other_tags || seen_rust_tags;
                         data.no_run = true;
                     }
+                    LangStringToken::LangToken("standalone") => {
+                        data.standalone = true;
+                        seen_rust_tags = !seen_other_tags || seen_rust_tags;
+                    }
                     LangStringToken::LangToken(x) if x.starts_with("edition") => {
                         data.edition = x[7..].parse::<Edition>().ok();
                     }

From 23badff4fef474232f7ad02c3380035435f1a1cf Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 30 Apr 2024 17:45:09 +0200
Subject: [PATCH 199/685] Add documentation for the doctest `standalone`
 attribute

---
 .../documentation-tests.md                    | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/src/doc/rustdoc/src/write-documentation/documentation-tests.md b/src/doc/rustdoc/src/write-documentation/documentation-tests.md
index 9526f33359e4b..7ed2e9720fed5 100644
--- a/src/doc/rustdoc/src/write-documentation/documentation-tests.md
+++ b/src/doc/rustdoc/src/write-documentation/documentation-tests.md
@@ -376,6 +376,57 @@ that the code sample should be compiled using the respective edition of Rust.
 # fn foo() {}
 ```
 
+Starting in the 2024 edition[^edition-note], compatible doctests are merged as one before being
+run. We combine doctests for performance reasons: the slowest part of doctests is to compile them.
+Merging all of them into one file and compiling this new file, then running the doctests is much
+faster. Whether doctests are merged or not, they are run in their own process.
+
+An example of time spent when running doctests:
+
+[sysinfo crate](https://crates.io/crates/sysinfo):
+
+```text
+wall-time duration: 4.59s
+total compile time: 27.067s
+total runtime: 3.969s
+```
+
+Rust core library:
+
+```text
+wall-time duration: 102s
+total compile time: 775.204s
+total runtime: 15.487s
+```
+
+[^edition-note]: This is based on the edition of the whole crate, not the edition of the individual
+test case that may be specified in its code attribute.
+
+In some cases, doctests cannot be merged. For example, if you have:
+
+```rust
+//! ```
+//! let location = std::panic::Location::caller();
+//! assert_eq!(location.line(), 4);
+//! ```
+```
+
+The problem with this code is that, if you change any other doctests, it'll likely break when
+runing `rustdoc --test`, making it tricky to maintain.
+
+This is where the `standalone` attribute comes in: it tells `rustdoc` that a doctest
+should not be merged with the others. So the previous code should use it:
+
+```rust
+//! ```standalone
+//! let location = std::panic::Location::caller();
+//! assert_eq!(location.line(), 4);
+//! ```
+```
+
+In this case, it means that the line information will not change if you add/remove other
+doctests.
+
 ### Custom CSS classes for code blocks
 
 ```rust

From b7079c5c83419b92a99bb991940363ae01633a93 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 10 Jun 2024 16:29:50 +0200
Subject: [PATCH 200/685] Prevent merged doctests to break stdin if the
 generated file is too big

---
 src/librustdoc/doctest.rs        | 56 ++++++++++++++++++++++++--------
 src/librustdoc/doctest/runner.rs | 11 +++++--
 2 files changed, 50 insertions(+), 17 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 250cfa0d4c59a..3d0dc2378a5fd 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -289,7 +289,7 @@ pub(crate) fn run_tests(
         for (doctest, scraped_test) in &doctests {
             tests_runner.add_test(doctest, scraped_test, &target_str);
         }
-        if let Ok(success) = tests_runner.run_tests(
+        if let Ok(success) = tests_runner.run_merged_tests(
             rustdoc_test_options,
             edition,
             &opts,
@@ -454,6 +454,7 @@ fn run_test(
     doctest: RunnableDoctest,
     rustdoc_options: &RustdocOptions,
     supports_color: bool,
+    is_multiple_tests: bool,
     report_unused_externs: impl Fn(UnusedExterns),
 ) -> Result<(), TestFailure> {
     let langstr = &doctest.langstr;
@@ -474,11 +475,14 @@ fn run_test(
     }
 
     compiler.arg("--edition").arg(&doctest.edition.to_string());
-    compiler.env("UNSTABLE_RUSTDOC_TEST_PATH", &doctest.test_opts.path);
-    compiler.env(
-        "UNSTABLE_RUSTDOC_TEST_LINE",
-        format!("{}", doctest.line as isize - doctest.full_test_line_offset as isize),
-    );
+    if !is_multiple_tests {
+        // Setting these environment variables is unneeded if this is a merged doctest.
+        compiler.env("UNSTABLE_RUSTDOC_TEST_PATH", &doctest.test_opts.path);
+        compiler.env(
+            "UNSTABLE_RUSTDOC_TEST_LINE",
+            format!("{}", doctest.line as isize - doctest.full_test_line_offset as isize),
+        );
+    }
     compiler.arg("-o").arg(&output_file);
     if langstr.test_harness {
         compiler.arg("--test");
@@ -521,18 +525,37 @@ fn run_test(
         }
     }
 
-    compiler.arg("-");
-    compiler.stdin(Stdio::piped());
-    compiler.stderr(Stdio::piped());
+    // If this is a merged doctest, we need to write it into a file instead of using stdin
+    // because if the size of the merged doctests is too big, it'll simply break stdin.
+    if is_multiple_tests {
+        // It makes the compilation failure much faster if it is for a combined doctest.
+        compiler.arg("--error-format=short");
+        let input_file =
+            doctest.test_opts.outdir.path().join(&format!("doctest_{}.rs", doctest.edition));
+        if std::fs::write(&input_file, &doctest.full_test_code).is_err() {
+            // If we cannot write this file for any reason, we leave. All combined tests will be
+            // tested as standalone tests.
+            return Err(TestFailure::CompileError);
+        }
+        compiler.arg(input_file);
+        compiler.stderr(Stdio::null());
+    } else {
+        compiler.arg("-");
+        compiler.stdin(Stdio::piped());
+        compiler.stderr(Stdio::piped());
+    }
 
     debug!("compiler invocation for doctest: {compiler:?}");
 
     let mut child = compiler.spawn().expect("Failed to spawn rustc process");
-    {
+    let output = if is_multiple_tests {
+        let status = child.wait().expect("Failed to wait");
+        process::Output { status, stdout: Vec::new(), stderr: Vec::new() }
+    } else {
         let stdin = child.stdin.as_mut().expect("Failed to open stdin");
         stdin.write_all(doctest.full_test_code.as_bytes()).expect("could write out test sources");
-    }
-    let output = child.wait_with_output().expect("Failed to read stdout");
+        child.wait_with_output().expect("Failed to read stdout")
+    };
 
     struct Bomb<'a>(&'a str);
     impl Drop for Bomb<'_> {
@@ -885,8 +908,13 @@ fn doctest_run_fn(
         edition: scraped_test.edition(&rustdoc_options),
         no_run: scraped_test.no_run(&rustdoc_options),
     };
-    let res =
-        run_test(runnable_test, &rustdoc_options, doctest.supports_color, report_unused_externs);
+    let res = run_test(
+        runnable_test,
+        &rustdoc_options,
+        doctest.supports_color,
+        false,
+        report_unused_externs,
+    );
 
     if let Err(err) = res {
         match err {
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index 9bad83d4669dc..a3b461cdc06ae 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -62,7 +62,7 @@ impl DocTestRunner {
         self.nb_tests += 1;
     }
 
-    pub(crate) fn run_tests(
+    pub(crate) fn run_merged_tests(
         &mut self,
         test_options: IndividualTestOptions,
         edition: Edition,
@@ -123,8 +123,13 @@ test::test_main(&[{test_args}], vec![{ids}], None);
             edition,
             no_run: false,
         };
-        let ret =
-            run_test(runnable_test, rustdoc_options, self.supports_color, |_: UnusedExterns| {});
+        let ret = run_test(
+            runnable_test,
+            rustdoc_options,
+            self.supports_color,
+            true,
+            |_: UnusedExterns| {},
+        );
         if let Err(TestFailure::CompileError) = ret { Err(()) } else { Ok(ret.is_ok()) }
     }
 }

From a0ae8ac861d5e1096ff128833b17935e5ddef1e2 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 10 Jun 2024 17:37:10 +0200
Subject: [PATCH 201/685] If there is any AST error with a doctest, we make it
 a standalone test

To do so, AST error detection was improved in order to not filter out
too many doctests.
---
 src/librustdoc/doctest.rs      |   1 +
 src/librustdoc/doctest/make.rs | 270 ++++++++++++++++++++++-----------
 2 files changed, 183 insertions(+), 88 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 3d0dc2378a5fd..818ee16a4acf8 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -800,6 +800,7 @@ impl CreateRunnableDoctests {
         let doctest =
             DocTest::new(&scraped_test.text, Some(&self.opts.crate_name), edition, Some(test_id));
         let is_standalone = !self.can_merge_doctests
+            || doctest.failed_ast
             || scraped_test.langstr.compile_fail
             || scraped_test.langstr.test_harness
             || scraped_test.langstr.standalone
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index c1d1e45ff042e..492a9a6e38ded 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -25,6 +25,7 @@ pub(crate) struct DocTest {
     pub(crate) crates: String,
     pub(crate) everything_else: String,
     pub(crate) test_id: Option<String>,
+    pub(crate) failed_ast: bool,
 }
 
 impl DocTest {
@@ -40,8 +41,15 @@ impl DocTest {
 
         // Uses librustc_ast to parse the doctest and find if there's a main fn and the extern
         // crate already is included.
-        let Ok((main_fn_span, already_has_extern_crate)) =
-            check_for_main_and_extern_crate(crate_name, source, edition, &mut supports_color)
+        let Ok((main_fn_span, already_has_extern_crate, failed_ast)) =
+            check_for_main_and_extern_crate(
+                crate_name,
+                source,
+                &everything_else,
+                &crates,
+                edition,
+                &mut supports_color,
+            )
         else {
             // If the parser panicked due to a fatal error, pass the test code through unchanged.
             // The error will be reported during compilation.
@@ -53,6 +61,7 @@ impl DocTest {
                 everything_else,
                 already_has_extern_crate: false,
                 test_id,
+                failed_ast: true,
             };
         };
         Self {
@@ -63,6 +72,7 @@ impl DocTest {
             everything_else,
             already_has_extern_crate,
             test_id,
+            failed_ast,
         }
     }
 
@@ -179,103 +189,187 @@ impl DocTest {
     }
 }
 
-fn check_for_main_and_extern_crate(
-    crate_name: Option<&str>,
-    source: &str,
-    edition: Edition,
-    supports_color: &mut bool,
-) -> Result<(Option<Span>, bool), FatalError> {
-    let result = rustc_driver::catch_fatal_errors(|| {
-        rustc_span::create_session_if_not_set_then(edition, |_| {
-            use rustc_errors::emitter::{Emitter, HumanEmitter};
-            use rustc_errors::DiagCtxt;
-            use rustc_parse::parser::ForceCollect;
-            use rustc_span::source_map::FilePathMapping;
-
-            let filename = FileName::anon_source_code(source);
+#[derive(PartialEq, Eq, Debug)]
+enum ParsingResult {
+    Failed,
+    AstError,
+    Ok,
+}
 
-            // Any errors in parsing should also appear when the doctest is compiled for real, so just
-            // send all the errors that librustc_ast emits directly into a `Sink` instead of stderr.
-            let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
-            let fallback_bundle = rustc_errors::fallback_fluent_bundle(
-                rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec(),
-                false,
-            );
-            *supports_color =
-                HumanEmitter::new(stderr_destination(ColorConfig::Auto), fallback_bundle.clone())
-                    .supports_color();
+fn cancel_error_count(psess: &ParseSess) {
+    // Reset errors so that they won't be reported as compiler bugs when dropping the
+    // dcx. Any errors in the tests will be reported when the test file is compiled,
+    // Note that we still need to cancel the errors above otherwise `Diag` will panic on
+    // drop.
+    psess.dcx().reset_err_count();
+}
 
-            let emitter = HumanEmitter::new(Box::new(io::sink()), fallback_bundle);
+fn parse_source(
+    source: String,
+    found_main_span: &mut Option<Span>,
+    found_extern_crate: &mut bool,
+    found_macro: &mut bool,
+    crate_name: &Option<&str>,
+    supports_color: &mut bool,
+) -> ParsingResult {
+    use rustc_errors::emitter::{Emitter, HumanEmitter};
+    use rustc_errors::DiagCtxt;
+    use rustc_parse::parser::ForceCollect;
+    use rustc_span::source_map::FilePathMapping;
+
+    let filename = FileName::anon_source_code(&source);
+
+    // Any errors in parsing should also appear when the doctest is compiled for real, so just
+    // send all the errors that librustc_ast emits directly into a `Sink` instead of stderr.
+    let sm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
+    let fallback_bundle = rustc_errors::fallback_fluent_bundle(
+        rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec(),
+        false,
+    );
+    *supports_color =
+        HumanEmitter::new(stderr_destination(ColorConfig::Auto), fallback_bundle.clone())
+            .supports_color();
+
+    let emitter = HumanEmitter::new(Box::new(io::sink()), fallback_bundle);
+
+    // FIXME(misdreavus): pass `-Z treat-err-as-bug` to the doctest parser
+    let dcx = DiagCtxt::new(Box::new(emitter)).disable_warnings();
+    let psess = ParseSess::with_dcx(dcx, sm);
+
+    let mut parser = match new_parser_from_source_str(&psess, filename, source) {
+        Ok(p) => p,
+        Err(errs) => {
+            errs.into_iter().for_each(|err| err.cancel());
+            cancel_error_count(&psess);
+            return ParsingResult::Failed;
+        }
+    };
+    let mut parsing_result = ParsingResult::Ok;
+
+    // Recurse through functions body. It is necessary because the doctest source code is
+    // wrapped in a function to limit the number of AST errors. If we don't recurse into
+    // functions, we would thing all top-level items (so basically nothing).
+    fn check_item(
+        item: &ast::Item,
+        found_main_span: &mut Option<Span>,
+        found_extern_crate: &mut bool,
+        found_macro: &mut bool,
+        crate_name: &Option<&str>,
+    ) {
+        match item.kind {
+            ast::ItemKind::Fn(ref fn_item) if found_main_span.is_none() => {
+                if item.ident.name == sym::main {
+                    *found_main_span = Some(item.span);
+                }
+                if let Some(ref body) = fn_item.body {
+                    for stmt in &body.stmts {
+                        match stmt.kind {
+                            ast::StmtKind::Item(ref item) => check_item(
+                                item,
+                                found_main_span,
+                                found_extern_crate,
+                                found_macro,
+                                crate_name,
+                            ),
+                            ast::StmtKind::MacCall(..) => *found_macro = true,
+                            _ => {}
+                        }
+                    }
+                }
+            }
+            ast::ItemKind::ExternCrate(original) => {
+                if !*found_extern_crate && let Some(ref crate_name) = crate_name {
+                    *found_extern_crate = match original {
+                        Some(name) => name.as_str() == *crate_name,
+                        None => item.ident.as_str() == *crate_name,
+                    };
+                }
+            }
+            ast::ItemKind::MacCall(..) => *found_macro = true,
+            _ => {}
+        }
+    }
 
-            // FIXME(misdreavus): pass `-Z treat-err-as-bug` to the doctest parser
-            let dcx = DiagCtxt::new(Box::new(emitter)).disable_warnings();
-            let psess = ParseSess::with_dcx(dcx, sm);
+    loop {
+        match parser.parse_item(ForceCollect::No) {
+            Ok(Some(item)) => {
+                check_item(&item, found_main_span, found_extern_crate, found_macro, crate_name);
 
-            let mut found_main = None;
-            let mut found_extern_crate = crate_name.is_none();
-            let mut found_macro = false;
-
-            let mut parser = match new_parser_from_source_str(&psess, filename, source.to_owned()) {
-                Ok(p) => p,
-                Err(errs) => {
-                    errs.into_iter().for_each(|err| err.cancel());
-                    return (found_main, found_extern_crate, found_macro);
+                if found_main_span.is_some() && *found_extern_crate {
+                    break;
                 }
-            };
-
-            loop {
-                match parser.parse_item(ForceCollect::No) {
-                    Ok(Some(item)) => {
-                        if found_main.is_none()
-                            && let ast::ItemKind::Fn(..) = item.kind
-                            && item.ident.name == sym::main
-                        {
-                            found_main = Some(item.span);
-                        }
+            }
+            Ok(None) => break,
+            Err(e) => {
+                parsing_result = ParsingResult::AstError;
+                e.cancel();
+                break;
+            }
+        }
 
-                        if !found_extern_crate
-                            && let ast::ItemKind::ExternCrate(original) = item.kind
-                        {
-                            // This code will never be reached if `crate_name` is none because
-                            // `found_extern_crate` is initialized to `true` if it is none.
-                            let crate_name = crate_name.unwrap();
-
-                            match original {
-                                Some(name) => found_extern_crate = name.as_str() == crate_name,
-                                None => found_extern_crate = item.ident.as_str() == crate_name,
-                            }
-                        }
+        // The supplied slice is only used for diagnostics,
+        // which are swallowed here anyway.
+        parser.maybe_consume_incorrect_semicolon(None);
+    }
 
-                        if !found_macro && let ast::ItemKind::MacCall(..) = item.kind {
-                            found_macro = true;
-                        }
+    cancel_error_count(&psess);
+    parsing_result
+}
 
-                        if found_main.is_some() && found_extern_crate {
-                            break;
-                        }
-                    }
-                    Ok(None) => break,
-                    Err(e) => {
-                        e.cancel();
-                        break;
-                    }
-                }
+fn check_for_main_and_extern_crate(
+    crate_name: Option<&str>,
+    original_source_code: &str,
+    everything_else: &str,
+    crates: &str,
+    edition: Edition,
+    supports_color: &mut bool,
+) -> Result<(Option<Span>, bool, bool), FatalError> {
+    let result = rustc_driver::catch_fatal_errors(|| {
+        rustc_span::create_session_if_not_set_then(edition, |_| {
+            let mut found_main_span = None;
+            let mut found_extern_crate = crate_name.is_none();
+            let mut found_macro = false;
 
-                // The supplied item is only used for diagnostics,
-                // which are swallowed here anyway.
-                parser.maybe_consume_incorrect_semicolon(None);
+            let mut parsing_result = parse_source(
+                format!("{crates}{everything_else}"),
+                &mut found_main_span,
+                &mut found_extern_crate,
+                &mut found_macro,
+                &crate_name,
+                supports_color,
+            );
+            // No need to double-check this if the "merged doctests" feature isn't enabled (so
+            // before the 2024 edition).
+            if edition >= Edition::Edition2024 && parsing_result != ParsingResult::Ok {
+                // If we found an AST error, we want to ensure it's because of an expression being
+                // used outside of a function.
+                //
+                // To do so, we wrap in a function in order to make sure that the doctest AST is
+                // correct. For example, if your doctest is `foo::bar()`, if we don't wrap it in a
+                // block, it would emit an AST error, which would be problematic for us since we
+                // want to filter out such errors which aren't "real" errors.
+                //
+                // The end goal is to be able to merge as many doctests as possible as one for much
+                // faster doctests run time.
+                parsing_result = parse_source(
+                    format!("{crates}\nfn __doctest_wrap(){{{everything_else}\n}}"),
+                    &mut found_main_span,
+                    &mut found_extern_crate,
+                    &mut found_macro,
+                    &crate_name,
+                    supports_color,
+                );
             }
 
-            // Reset errors so that they won't be reported as compiler bugs when dropping the
-            // dcx. Any errors in the tests will be reported when the test file is compiled,
-            // Note that we still need to cancel the errors above otherwise `Diag` will panic on
-            // drop.
-            psess.dcx().reset_err_count();
-
-            (found_main, found_extern_crate, found_macro)
+            (found_main_span, found_extern_crate, found_macro, parsing_result)
         })
     });
-    let (mut main_fn_span, already_has_extern_crate, found_macro) = result?;
+    let (mut main_fn_span, already_has_extern_crate, found_macro, parsing_result) = match result {
+        Err(..) | Ok((_, _, _, ParsingResult::Failed)) => return Err(FatalError),
+        Ok((main_fn_span, already_has_extern_crate, found_macro, parsing_result)) => {
+            (main_fn_span, already_has_extern_crate, found_macro, parsing_result)
+        }
+    };
 
     // If a doctest's `fn main` is being masked by a wrapper macro, the parsing loop above won't
     // see it. In that case, run the old text-based scan to see if they at least have a main
@@ -283,7 +377,7 @@ fn check_for_main_and_extern_crate(
     // https://github.com/rust-lang/rust/issues/56898
     if found_macro
         && main_fn_span.is_none()
-        && source
+        && original_source_code
             .lines()
             .map(|line| {
                 let comment = line.find("//");
@@ -294,7 +388,7 @@ fn check_for_main_and_extern_crate(
         main_fn_span = Some(DUMMY_SP);
     }
 
-    Ok((main_fn_span, already_has_extern_crate))
+    Ok((main_fn_span, already_has_extern_crate, parsing_result != ParsingResult::Ok))
 }
 
 fn check_if_attr_is_complete(source: &str, edition: Edition) -> bool {

From 59a9e0986d061d095c813db1dc418ab55e9e7771 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 10 Jun 2024 18:03:40 +0200
Subject: [PATCH 202/685] Correctly handle the case where there is no doctests
 to run

---
 src/librustdoc/doctest.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 818ee16a4acf8..5586a23595def 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -270,6 +270,7 @@ pub(crate) fn run_tests(
     }
 
     let mut nb_errors = 0;
+    let mut ran_edition_tests = 0;
     let target_str = rustdoc_options.target.to_string();
 
     for (edition, mut doctests) in mergeable_tests {
@@ -296,6 +297,7 @@ pub(crate) fn run_tests(
             &test_args,
             rustdoc_options,
         ) {
+            ran_edition_tests += 1;
             if !success {
                 nb_errors += 1;
             }
@@ -322,7 +324,9 @@ pub(crate) fn run_tests(
         }
     }
 
-    if !standalone_tests.is_empty() {
+    // We need to call `test_main` even if there is no doctest to run to get the output
+    // `running 0 tests...`.
+    if ran_edition_tests == 0 || !standalone_tests.is_empty() {
         standalone_tests.sort_by(|a, b| a.desc.name.as_slice().cmp(&b.desc.name.as_slice()));
         test::test_main(&test_args, standalone_tests, None);
     }

From 7ec3cabe1776b1a3d0340b24a5a6901797836430 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 10 Jun 2024 18:29:33 +0200
Subject: [PATCH 203/685] Correctly handle doctests with invalid AST

---
 src/librustdoc/doctest.rs                     | 13 ++++---
 src/librustdoc/doctest/make.rs                | 19 ++++++++--
 src/librustdoc/doctest/tests.rs               |  2 +-
 src/librustdoc/html/markdown.rs               |  2 +-
 tests/rustdoc-ui/doctest/wrong-ast-2024.rs    | 20 +++++++++++
 .../rustdoc-ui/doctest/wrong-ast-2024.stdout  | 35 ++++++++++++++++++
 tests/rustdoc-ui/doctest/wrong-ast.rs         | 20 +++++++++++
 tests/rustdoc-ui/doctest/wrong-ast.stdout     | 36 +++++++++++++++++++
 8 files changed, 138 insertions(+), 9 deletions(-)
 create mode 100644 tests/rustdoc-ui/doctest/wrong-ast-2024.rs
 create mode 100644 tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
 create mode 100644 tests/rustdoc-ui/doctest/wrong-ast.rs
 create mode 100644 tests/rustdoc-ui/doctest/wrong-ast.stdout

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 5586a23595def..07bdccff278b8 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -635,7 +635,7 @@ fn run_test(
         cmd.current_dir(run_directory);
     }
 
-    let result = if rustdoc_options.nocapture {
+    let result = if is_multiple_tests || rustdoc_options.nocapture {
         cmd.status().map(|status| process::Output {
             status,
             stdout: Vec::new(),
@@ -801,10 +801,15 @@ impl CreateRunnableDoctests {
         );
 
         let edition = scraped_test.edition(&self.rustdoc_options);
-        let doctest =
-            DocTest::new(&scraped_test.text, Some(&self.opts.crate_name), edition, Some(test_id));
+        let doctest = DocTest::new(
+            &scraped_test.text,
+            Some(&self.opts.crate_name),
+            edition,
+            self.can_merge_doctests,
+            Some(test_id),
+        );
         let is_standalone = !self.can_merge_doctests
-            || doctest.failed_ast
+            || !doctest.can_be_merged
             || scraped_test.langstr.compile_fail
             || scraped_test.langstr.test_harness
             || scraped_test.langstr.standalone
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 492a9a6e38ded..c95dace1a81d4 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -26,6 +26,7 @@ pub(crate) struct DocTest {
     pub(crate) everything_else: String,
     pub(crate) test_id: Option<String>,
     pub(crate) failed_ast: bool,
+    pub(crate) can_be_merged: bool,
 }
 
 impl DocTest {
@@ -33,6 +34,7 @@ impl DocTest {
         source: &str,
         crate_name: Option<&str>,
         edition: Edition,
+        can_merge_doctests: bool,
         // If `test_id` is `None`, it means we're generating code for a code example "run" link.
         test_id: Option<String>,
     ) -> Self {
@@ -49,6 +51,7 @@ impl DocTest {
                 &crates,
                 edition,
                 &mut supports_color,
+                can_merge_doctests,
             )
         else {
             // If the parser panicked due to a fatal error, pass the test code through unchanged.
@@ -62,6 +65,7 @@ impl DocTest {
                 already_has_extern_crate: false,
                 test_id,
                 failed_ast: true,
+                can_be_merged: false,
             };
         };
         Self {
@@ -72,7 +76,10 @@ impl DocTest {
             everything_else,
             already_has_extern_crate,
             test_id,
-            failed_ast,
+            failed_ast: false,
+            // If the AST returned an error, we don't want this doctest to be merged with the
+            // others.
+            can_be_merged: !failed_ast,
         }
     }
 
@@ -85,6 +92,11 @@ impl DocTest {
         opts: &GlobalTestOptions,
         crate_name: Option<&str>,
     ) -> (String, usize) {
+        if self.failed_ast {
+            // If the AST failed to compile, no need to go generate a complete doctest, the error
+            // will be better this way.
+            return (test_code.to_string(), 0);
+        }
         let mut line_offset = 0;
         let mut prog = String::new();
         let everything_else = self.everything_else.trim();
@@ -323,6 +335,7 @@ fn check_for_main_and_extern_crate(
     crates: &str,
     edition: Edition,
     supports_color: &mut bool,
+    can_merge_doctests: bool,
 ) -> Result<(Option<Span>, bool, bool), FatalError> {
     let result = rustc_driver::catch_fatal_errors(|| {
         rustc_span::create_session_if_not_set_then(edition, |_| {
@@ -340,7 +353,7 @@ fn check_for_main_and_extern_crate(
             );
             // No need to double-check this if the "merged doctests" feature isn't enabled (so
             // before the 2024 edition).
-            if edition >= Edition::Edition2024 && parsing_result != ParsingResult::Ok {
+            if can_merge_doctests && parsing_result != ParsingResult::Ok {
                 // If we found an AST error, we want to ensure it's because of an expression being
                 // used outside of a function.
                 //
@@ -525,5 +538,5 @@ fn partition_source(s: &str, edition: Edition) -> (String, String, String) {
     debug!("crates:\n{crates}");
     debug!("after:\n{after}");
 
-    (before, after, crates)
+    (before, after.trim().to_owned(), crates)
 }
diff --git a/src/librustdoc/doctest/tests.rs b/src/librustdoc/doctest/tests.rs
index 533fc3a56eddd..982bfae588376 100644
--- a/src/librustdoc/doctest/tests.rs
+++ b/src/librustdoc/doctest/tests.rs
@@ -11,7 +11,7 @@ fn make_test(
     test_id: Option<&str>,
 ) -> (String, usize) {
     let doctest =
-        DocTest::new(test_code, crate_name, DEFAULT_EDITION, test_id.map(|s| s.to_string()));
+        DocTest::new(test_code, crate_name, DEFAULT_EDITION, false, test_id.map(|s| s.to_string()));
     let (code, line_offset) =
         doctest.generate_unique_doctest(test_code, dont_insert_main, opts, crate_name);
     (code, line_offset)
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index da6aa47fff262..879e44c171223 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -297,7 +297,7 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
                 attrs: vec![],
                 args_file: PathBuf::new(),
             };
-            let doctest = doctest::DocTest::new(&test, krate, edition, None);
+            let doctest = doctest::DocTest::new(&test, krate, edition, false, None);
             let (test, _) = doctest.generate_unique_doctest(&test, false, &opts, krate);
             let channel = if test.contains("#![feature(") { "&amp;version=nightly" } else { "" };
 
diff --git a/tests/rustdoc-ui/doctest/wrong-ast-2024.rs b/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
new file mode 100644
index 0000000000000..b0a700477b247
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
@@ -0,0 +1,20 @@
+//@ compile-flags:--test --test-args=--test-threads=1 -Zunstable-options --edition 2024
+//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test "wrong-ast.rs:\d+:\d+" -> "wrong-ast.rs:$$LINE:$$COL"
+//@ failure-status: 101
+
+/// ```
+/// /* plop
+/// ```
+pub fn one() {}
+
+/// ```
+/// } mod __doctest_1 { fn main() {
+/// ```
+pub fn two() {}
+
+/// ```should_panic
+/// panic!()
+/// ```
+pub fn three() {}
diff --git a/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout b/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
new file mode 100644
index 0000000000000..1dea271939967
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
@@ -0,0 +1,35 @@
+
+running 2 tests
+test $DIR/wrong-ast-2024.rs - one (line 7) ... FAILED
+test $DIR/wrong-ast-2024.rs - two (line 12) ... FAILED
+
+failures:
+
+---- $DIR/wrong-ast-2024.rs - one (line 7) stdout ----
+error[E0758]: unterminated block comment
+  --> $DIR/wrong-ast-2024.rs:8:1
+   |
+LL | /* plop
+   | ^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0758`.
+Couldn't compile the test.
+---- $DIR/wrong-ast-2024.rs - two (line 12) stdout ----
+error: unexpected closing delimiter: `}`
+  --> $DIR/wrong-ast-2024.rs:13:1
+   |
+LL | } mod __doctest_1 { fn main() {
+   | ^ unexpected closing delimiter
+
+error: aborting due to 1 previous error
+
+Couldn't compile the test.
+
+failures:
+    $DIR/wrong-ast-2024.rs - one (line 7)
+    $DIR/wrong-ast-2024.rs - two (line 12)
+
+test result: FAILED. 0 passed; 2 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-ui/doctest/wrong-ast.rs b/tests/rustdoc-ui/doctest/wrong-ast.rs
new file mode 100644
index 0000000000000..b3fbf630c327c
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/wrong-ast.rs
@@ -0,0 +1,20 @@
+//@ compile-flags:--test --test-args=--test-threads=1
+//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test "wrong-ast.rs:\d+:\d+" -> "wrong-ast.rs:$$LINE:$$COL"
+//@ failure-status: 101
+
+/// ```
+/// /* plop
+/// ```
+pub fn one() {}
+
+/// ```
+/// } mod __doctest_1 { fn main() {
+/// ```
+pub fn two() {}
+
+/// ```should_panic
+/// panic!()
+/// ```
+pub fn three() {}
diff --git a/tests/rustdoc-ui/doctest/wrong-ast.stdout b/tests/rustdoc-ui/doctest/wrong-ast.stdout
new file mode 100644
index 0000000000000..b50999d17d77e
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/wrong-ast.stdout
@@ -0,0 +1,36 @@
+
+running 3 tests
+test $DIR/wrong-ast.rs - one (line 7) ... FAILED
+test $DIR/wrong-ast.rs - three (line 17) ... ok
+test $DIR/wrong-ast.rs - two (line 12) ... FAILED
+
+failures:
+
+---- $DIR/wrong-ast.rs - one (line 7) stdout ----
+error[E0758]: unterminated block comment
+  --> $DIR/wrong-ast.rs:$LINE:$COL
+   |
+LL | /* plop
+   | ^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0758`.
+Couldn't compile the test.
+---- $DIR/wrong-ast.rs - two (line 12) stdout ----
+error: unexpected closing delimiter: `}`
+  --> $DIR/wrong-ast.rs:$LINE:$COL
+   |
+LL | } mod __doctest_1 { fn main() {
+   | ^ unexpected closing delimiter
+
+error: aborting due to 1 previous error
+
+Couldn't compile the test.
+
+failures:
+    $DIR/wrong-ast.rs - one (line 7)
+    $DIR/wrong-ast.rs - two (line 12)
+
+test result: FAILED. 1 passed; 2 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+

From 2fd8d1c1cee3bce5c088cd5537ec293f04d34e15 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 10 Jun 2024 22:58:24 +0200
Subject: [PATCH 204/685] Add/update `rustdoc-ui` tests to check new merged
 doctests

---
 .../doctest/failed-doctest-should-panic-2021.rs    | 12 ++++++++++++
 .../failed-doctest-should-panic-2021.stdout        | 14 ++++++++++++++
 .../doctest/failed-doctest-should-panic.rs         |  2 +-
 .../doctest/failed-doctest-should-panic.stdout     |  5 +++--
 tests/rustdoc-ui/doctest/wrong-ast-2024.rs         |  2 +-
 tests/rustdoc-ui/doctest/wrong-ast-2024.stdout     | 12 +++++++++---
 tests/rustdoc-ui/doctest/wrong-ast.rs              |  2 +-
 tests/rustdoc-ui/doctest/wrong-ast.stdout          |  2 +-
 8 files changed, 42 insertions(+), 9 deletions(-)
 create mode 100644 tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs
 create mode 100644 tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.stdout

diff --git a/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs b/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs
new file mode 100644
index 0000000000000..ad78bb545533d
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs
@@ -0,0 +1,12 @@
+// FIXME: if/when the output of the test harness can be tested on its own, this test should be
+// adapted to use that, and that normalize line can go away
+
+//@ compile-flags:--test --edition 2021
+//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ failure-status: 101
+
+/// ```should_panic
+/// println!("Hello, world!");
+/// ```
+pub struct Foo;
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.stdout b/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.stdout
new file mode 100644
index 0000000000000..63d987de8a9fa
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.stdout
@@ -0,0 +1,14 @@
+
+running 1 test
+test $DIR/failed-doctest-should-panic-2021.rs - Foo (line 9) ... FAILED
+
+failures:
+
+---- $DIR/failed-doctest-should-panic-2021.rs - Foo (line 9) stdout ----
+Test executable succeeded, but it's marked `should_panic`.
+
+failures:
+    $DIR/failed-doctest-should-panic-2021.rs - Foo (line 9)
+
+test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.rs b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.rs
index b24687993e5dc..4018e37105ff1 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.rs
+++ b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.rs
@@ -1,7 +1,7 @@
 // FIXME: if/when the output of the test harness can be tested on its own, this test should be
 // adapted to use that, and that normalize line can go away
 
-//@ compile-flags:--test
+//@ compile-flags:--test -Z unstable-options --edition 2024
 //@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
 //@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
index 57a20092a5d6c..71b0b10fa72e2 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
@@ -1,11 +1,12 @@
 
 running 1 test
-test $DIR/failed-doctest-should-panic.rs - Foo (line 9) ... FAILED
+test $DIR/failed-doctest-should-panic.rs - Foo (line 9) - should panic ... FAILED
 
 failures:
 
 ---- $DIR/failed-doctest-should-panic.rs - Foo (line 9) stdout ----
-Test executable succeeded, but it's marked `should_panic`.
+Hello, world!
+note: test did not panic as expected
 
 failures:
     $DIR/failed-doctest-should-panic.rs - Foo (line 9)
diff --git a/tests/rustdoc-ui/doctest/wrong-ast-2024.rs b/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
index b0a700477b247..fdcd3baa64273 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
+++ b/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
@@ -1,7 +1,7 @@
 //@ compile-flags:--test --test-args=--test-threads=1 -Zunstable-options --edition 2024
 //@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
 //@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test "wrong-ast.rs:\d+:\d+" -> "wrong-ast.rs:$$LINE:$$COL"
+//@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 //@ failure-status: 101
 
 /// ```
diff --git a/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout b/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
index 1dea271939967..22c8ce468fd7c 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
+++ b/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
@@ -1,4 +1,10 @@
 
+running 1 test
+test $DIR/wrong-ast-2024.rs - three (line 17) - should panic ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
+
 running 2 tests
 test $DIR/wrong-ast-2024.rs - one (line 7) ... FAILED
 test $DIR/wrong-ast-2024.rs - two (line 12) ... FAILED
@@ -7,10 +13,10 @@ failures:
 
 ---- $DIR/wrong-ast-2024.rs - one (line 7) stdout ----
 error[E0758]: unterminated block comment
-  --> $DIR/wrong-ast-2024.rs:8:1
+  --> $DIR/wrong-ast-2024.rs:$LINE:$COL
    |
 LL | /* plop
-   | ^^^^^^^^
+   | ^^^^^^^
 
 error: aborting due to 1 previous error
 
@@ -18,7 +24,7 @@ For more information about this error, try `rustc --explain E0758`.
 Couldn't compile the test.
 ---- $DIR/wrong-ast-2024.rs - two (line 12) stdout ----
 error: unexpected closing delimiter: `}`
-  --> $DIR/wrong-ast-2024.rs:13:1
+  --> $DIR/wrong-ast-2024.rs:$LINE:$COL
    |
 LL | } mod __doctest_1 { fn main() {
    | ^ unexpected closing delimiter
diff --git a/tests/rustdoc-ui/doctest/wrong-ast.rs b/tests/rustdoc-ui/doctest/wrong-ast.rs
index b3fbf630c327c..dae86fbfc59a1 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast.rs
+++ b/tests/rustdoc-ui/doctest/wrong-ast.rs
@@ -1,7 +1,7 @@
 //@ compile-flags:--test --test-args=--test-threads=1
 //@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
 //@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test "wrong-ast.rs:\d+:\d+" -> "wrong-ast.rs:$$LINE:$$COL"
+//@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 //@ failure-status: 101
 
 /// ```
diff --git a/tests/rustdoc-ui/doctest/wrong-ast.stdout b/tests/rustdoc-ui/doctest/wrong-ast.stdout
index b50999d17d77e..c827254d8c0f5 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast.stdout
+++ b/tests/rustdoc-ui/doctest/wrong-ast.stdout
@@ -11,7 +11,7 @@ error[E0758]: unterminated block comment
   --> $DIR/wrong-ast.rs:$LINE:$COL
    |
 LL | /* plop
-   | ^^^^^^^^
+   | ^^^^^^^
 
 error: aborting due to 1 previous error
 

From 010731d5b6d32b2fa464d8479fb5e99ea05fff8a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 10 Jun 2024 23:33:14 +0200
Subject: [PATCH 205/685] Add new `run-make` tests for doctests

---
 .../doctests-keep-binaries-2024/rmake.rs      | 65 +++++++++++++++++++
 .../run-make/doctests-keep-binaries-2024/t.rs | 11 ++++
 .../doctests-merge/doctest-2021.stdout        |  7 ++
 .../doctests-merge/doctest-2024.stdout        |  7 ++
 .../doctests-merge/doctest-standalone.rs      | 18 +++++
 .../doctests-merge/doctest-standalone.stdout  |  7 ++
 tests/run-make/doctests-merge/doctest.rs      | 18 +++++
 tests/run-make/doctests-merge/rmake.rs        | 38 +++++++++++
 8 files changed, 171 insertions(+)
 create mode 100644 tests/run-make/doctests-keep-binaries-2024/rmake.rs
 create mode 100644 tests/run-make/doctests-keep-binaries-2024/t.rs
 create mode 100644 tests/run-make/doctests-merge/doctest-2021.stdout
 create mode 100644 tests/run-make/doctests-merge/doctest-2024.stdout
 create mode 100644 tests/run-make/doctests-merge/doctest-standalone.rs
 create mode 100644 tests/run-make/doctests-merge/doctest-standalone.stdout
 create mode 100644 tests/run-make/doctests-merge/doctest.rs
 create mode 100644 tests/run-make/doctests-merge/rmake.rs

diff --git a/tests/run-make/doctests-keep-binaries-2024/rmake.rs b/tests/run-make/doctests-keep-binaries-2024/rmake.rs
new file mode 100644
index 0000000000000..a6fddf6d3365e
--- /dev/null
+++ b/tests/run-make/doctests-keep-binaries-2024/rmake.rs
@@ -0,0 +1,65 @@
+// Check that valid binaries are persisted by running them, regardless of whether the
+// --run or --no-run option is used.
+
+use run_make_support::fs_wrapper::{create_dir, remove_dir_all};
+use run_make_support::{run, rustc, rustdoc};
+use std::path::Path;
+
+fn setup_test_env<F: FnOnce(&Path, &Path)>(callback: F) {
+    let out_dir = Path::new("doctests");
+    create_dir(&out_dir);
+    rustc().input("t.rs").crate_type("rlib").run();
+    callback(&out_dir, Path::new("libt.rlib"));
+    remove_dir_all(out_dir);
+}
+
+fn check_generated_binaries() {
+    run("doctests/merged_doctest_2024/rust_out");
+}
+
+fn main() {
+    setup_test_env(|out_dir, extern_path| {
+        rustdoc()
+            .input("t.rs")
+            .arg("-Zunstable-options")
+            .arg("--test")
+            .arg("--persist-doctests")
+            .arg(out_dir)
+            .extern_("t", extern_path)
+            .edition("2024")
+            .run();
+        check_generated_binaries();
+    });
+    setup_test_env(|out_dir, extern_path| {
+        rustdoc()
+            .input("t.rs")
+            .arg("-Zunstable-options")
+            .arg("--test")
+            .arg("--persist-doctests")
+            .arg(out_dir)
+            .extern_("t", extern_path)
+            .arg("--no-run")
+            .edition("2024")
+            .run();
+        check_generated_binaries();
+    });
+    // Behavior with --test-run-directory with relative paths.
+    setup_test_env(|_, _| {
+        let run_dir_path = Path::new("rundir");
+        create_dir(&run_dir_path);
+
+        rustdoc()
+            .input("t.rs")
+            .arg("-Zunstable-options")
+            .arg("--test")
+            .arg("--persist-doctests")
+            .arg("doctests")
+            .arg("--test-run-directory")
+            .arg(run_dir_path)
+            .extern_("t", "libt.rlib")
+            .edition("2024")
+            .run();
+
+        remove_dir_all(run_dir_path);
+    });
+}
diff --git a/tests/run-make/doctests-keep-binaries-2024/t.rs b/tests/run-make/doctests-keep-binaries-2024/t.rs
new file mode 100644
index 0000000000000..c38cf0a0b25d4
--- /dev/null
+++ b/tests/run-make/doctests-keep-binaries-2024/t.rs
@@ -0,0 +1,11 @@
+/// Fungle the foople.
+/// ```
+/// t::foople();
+/// ```
+pub fn foople() {}
+
+/// Flomble the florp
+/// ```
+/// t::florp();
+/// ```
+pub fn florp() {}
diff --git a/tests/run-make/doctests-merge/doctest-2021.stdout b/tests/run-make/doctests-merge/doctest-2021.stdout
new file mode 100644
index 0000000000000..7da08d68faae3
--- /dev/null
+++ b/tests/run-make/doctests-merge/doctest-2021.stdout
@@ -0,0 +1,7 @@
+
+running 2 tests
+test doctest.rs - (line 4) ... ok
+test doctest.rs - init (line 8) ... ok
+
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/run-make/doctests-merge/doctest-2024.stdout b/tests/run-make/doctests-merge/doctest-2024.stdout
new file mode 100644
index 0000000000000..7da08d68faae3
--- /dev/null
+++ b/tests/run-make/doctests-merge/doctest-2024.stdout
@@ -0,0 +1,7 @@
+
+running 2 tests
+test doctest.rs - (line 4) ... ok
+test doctest.rs - init (line 8) ... ok
+
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/run-make/doctests-merge/doctest-standalone.rs b/tests/run-make/doctests-merge/doctest-standalone.rs
new file mode 100644
index 0000000000000..134ffb58285e8
--- /dev/null
+++ b/tests/run-make/doctests-merge/doctest-standalone.rs
@@ -0,0 +1,18 @@
+#![crate_name = "foo"]
+#![crate_type = "lib"]
+
+//! ```standalone
+//! foo::init();
+//! ```
+
+/// ```standalone
+/// foo::init();
+/// ```
+pub fn init() {
+    static mut IS_INIT: bool = false;
+
+    unsafe {
+        assert!(!IS_INIT);
+        IS_INIT = true;
+    }
+}
diff --git a/tests/run-make/doctests-merge/doctest-standalone.stdout b/tests/run-make/doctests-merge/doctest-standalone.stdout
new file mode 100644
index 0000000000000..ee9f62326ab02
--- /dev/null
+++ b/tests/run-make/doctests-merge/doctest-standalone.stdout
@@ -0,0 +1,7 @@
+
+running 2 tests
+test doctest-standalone.rs - (line 4) ... ok
+test doctest-standalone.rs - init (line 8) ... ok
+
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
diff --git a/tests/run-make/doctests-merge/doctest.rs b/tests/run-make/doctests-merge/doctest.rs
new file mode 100644
index 0000000000000..66a5d88db67f4
--- /dev/null
+++ b/tests/run-make/doctests-merge/doctest.rs
@@ -0,0 +1,18 @@
+#![crate_name = "foo"]
+#![crate_type = "lib"]
+
+//! ```
+//! foo::init();
+//! ```
+
+/// ```
+/// foo::init();
+/// ```
+pub fn init() {
+    static mut IS_INIT: bool = false;
+
+    unsafe {
+        assert!(!IS_INIT);
+        IS_INIT = true;
+    }
+}
diff --git a/tests/run-make/doctests-merge/rmake.rs b/tests/run-make/doctests-merge/rmake.rs
new file mode 100644
index 0000000000000..ac3951c6ceb3b
--- /dev/null
+++ b/tests/run-make/doctests-merge/rmake.rs
@@ -0,0 +1,38 @@
+use run_make_support::{cwd, diff, rustc, rustdoc};
+use std::path::Path;
+
+fn test_and_compare(input_file: &str, stdout_file: &str, edition: &str, dep: &Path) {
+    let mut cmd = rustdoc();
+
+    let output = cmd
+        .input(input_file)
+        .arg("--test")
+        .arg("-Zunstable-options")
+        .edition(edition)
+        .arg("--test-args=--test-threads=1")
+        .extern_("foo", dep.display().to_string())
+        .env("RUST_BACKTRACE", "short")
+        .run();
+
+    diff()
+        .expected_file(stdout_file)
+        .actual_text("output", output.stdout_utf8())
+        .normalize(r#"finished in \d+\.\d+s"#, "finished in $$TIME")
+        .run();
+}
+
+fn main() {
+    let out_file = cwd().join("libfoo.rlib");
+
+    rustc().input("doctest.rs").crate_type("rlib").output(&out_file).run();
+
+    // First we ensure that running with the 2024 edition will not fail at runtime.
+    test_and_compare("doctest.rs", "doctest-2024.stdout", "2024", &out_file);
+
+    // Then we ensure that running with an edition < 2024 will not fail at runtime.
+    test_and_compare("doctest.rs", "doctest-2021.stdout", "2021", &out_file);
+
+    // Now we check with the standalone attribute which should succeed in all cases.
+    test_and_compare("doctest-standalone.rs", "doctest-standalone.stdout", "2024", &out_file);
+    test_and_compare("doctest-standalone.rs", "doctest-standalone.stdout", "2021", &out_file);
+}

From 03118fa80a9596cc7cc1b55be49cb2001a39dbe2 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 11 Jun 2024 00:01:59 +0200
Subject: [PATCH 206/685] Simplify `has_main_fn` to be a boolean instead of a
 `Option<Span>`

---
 src/librustdoc/doctest.rs        |  8 +++--
 src/librustdoc/doctest/make.rs   | 58 +++++++++++++++++---------------
 src/librustdoc/doctest/runner.rs |  2 +-
 3 files changed, 37 insertions(+), 31 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 07bdccff278b8..1f7ccdd01713f 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -536,13 +536,17 @@ fn run_test(
         compiler.arg("--error-format=short");
         let input_file =
             doctest.test_opts.outdir.path().join(&format!("doctest_{}.rs", doctest.edition));
+            eprintln!("OUUUUUUUT>>>>>>> {input_file:?}");
         if std::fs::write(&input_file, &doctest.full_test_code).is_err() {
             // If we cannot write this file for any reason, we leave. All combined tests will be
             // tested as standalone tests.
             return Err(TestFailure::CompileError);
         }
         compiler.arg(input_file);
-        compiler.stderr(Stdio::null());
+        // compiler.stderr(Stdio::null());
+        let mut buffer = String::new();
+        eprintln!("Press ENTER");
+        let _ = std::io::stdin().read_line(&mut buffer);
     } else {
         compiler.arg("-");
         compiler.stdin(Stdio::piped());
@@ -764,7 +768,7 @@ struct CreateRunnableDoctests {
 
 impl CreateRunnableDoctests {
     fn new(rustdoc_options: RustdocOptions, opts: GlobalTestOptions) -> CreateRunnableDoctests {
-        let can_merge_doctests = rustdoc_options.edition >= Edition::Edition2024;
+        let can_merge_doctests = true;//rustdoc_options.edition >= Edition::Edition2024;
         CreateRunnableDoctests {
             standalone_tests: Vec::new(),
             mergeable_tests: FxHashMap::default(),
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index c95dace1a81d4..2e067c6277ec6 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -13,14 +13,14 @@ use rustc_session::parse::ParseSess;
 use rustc_span::edition::Edition;
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::sym;
-use rustc_span::{FileName, Span, DUMMY_SP};
+use rustc_span::FileName;
 
 use super::GlobalTestOptions;
 
 pub(crate) struct DocTest {
     pub(crate) supports_color: bool,
     pub(crate) already_has_extern_crate: bool,
-    pub(crate) main_fn_span: Option<Span>,
+    pub(crate) has_main_fn: bool,
     pub(crate) crate_attrs: String,
     pub(crate) crates: String,
     pub(crate) everything_else: String,
@@ -43,7 +43,7 @@ impl DocTest {
 
         // Uses librustc_ast to parse the doctest and find if there's a main fn and the extern
         // crate already is included.
-        let Ok((main_fn_span, already_has_extern_crate, failed_ast)) =
+        let Ok((has_main_fn, already_has_extern_crate, failed_ast)) =
             check_for_main_and_extern_crate(
                 crate_name,
                 source,
@@ -58,7 +58,7 @@ impl DocTest {
             // The error will be reported during compilation.
             return DocTest {
                 supports_color: false,
-                main_fn_span: None,
+                has_main_fn: false,
                 crate_attrs,
                 crates,
                 everything_else,
@@ -70,7 +70,7 @@ impl DocTest {
         };
         Self {
             supports_color,
-            main_fn_span,
+            has_main_fn,
             crate_attrs,
             crates,
             everything_else,
@@ -141,7 +141,7 @@ impl DocTest {
         }
 
         // FIXME: This code cannot yet handle no_std test cases yet
-        if dont_insert_main || self.main_fn_span.is_some() || prog.contains("![no_std]") {
+        if dont_insert_main || self.has_main_fn || prog.contains("![no_std]") {
             prog.push_str(everything_else);
         } else {
             let returns_result = everything_else.ends_with("(())");
@@ -218,7 +218,7 @@ fn cancel_error_count(psess: &ParseSess) {
 
 fn parse_source(
     source: String,
-    found_main_span: &mut Option<Span>,
+    has_main_fn: &mut bool,
     found_extern_crate: &mut bool,
     found_macro: &mut bool,
     crate_name: &Option<&str>,
@@ -263,22 +263,22 @@ fn parse_source(
     // functions, we would thing all top-level items (so basically nothing).
     fn check_item(
         item: &ast::Item,
-        found_main_span: &mut Option<Span>,
+        has_main_fn: &mut bool,
         found_extern_crate: &mut bool,
         found_macro: &mut bool,
         crate_name: &Option<&str>,
     ) {
         match item.kind {
-            ast::ItemKind::Fn(ref fn_item) if found_main_span.is_none() => {
+            ast::ItemKind::Fn(ref fn_item) if !*has_main_fn => {
                 if item.ident.name == sym::main {
-                    *found_main_span = Some(item.span);
+                    *has_main_fn = true;
                 }
                 if let Some(ref body) = fn_item.body {
                     for stmt in &body.stmts {
                         match stmt.kind {
                             ast::StmtKind::Item(ref item) => check_item(
                                 item,
-                                found_main_span,
+                                has_main_fn,
                                 found_extern_crate,
                                 found_macro,
                                 crate_name,
@@ -305,9 +305,9 @@ fn parse_source(
     loop {
         match parser.parse_item(ForceCollect::No) {
             Ok(Some(item)) => {
-                check_item(&item, found_main_span, found_extern_crate, found_macro, crate_name);
+                check_item(&item, has_main_fn, found_extern_crate, found_macro, crate_name);
 
-                if found_main_span.is_some() && *found_extern_crate {
+                if *has_main_fn && *found_extern_crate {
                     break;
                 }
             }
@@ -319,7 +319,7 @@ fn parse_source(
             }
         }
 
-        // The supplied slice is only used for diagnostics,
+        // The supplied item is only used for diagnostics,
         // which are swallowed here anyway.
         parser.maybe_consume_incorrect_semicolon(None);
     }
@@ -328,6 +328,7 @@ fn parse_source(
     parsing_result
 }
 
+/// Returns `(has_main_fn, already_has_extern_crate, failed_ast)`.
 fn check_for_main_and_extern_crate(
     crate_name: Option<&str>,
     original_source_code: &str,
@@ -336,16 +337,16 @@ fn check_for_main_and_extern_crate(
     edition: Edition,
     supports_color: &mut bool,
     can_merge_doctests: bool,
-) -> Result<(Option<Span>, bool, bool), FatalError> {
+) -> Result<(bool, bool, bool), FatalError> {
     let result = rustc_driver::catch_fatal_errors(|| {
         rustc_span::create_session_if_not_set_then(edition, |_| {
-            let mut found_main_span = None;
+            let mut has_main_fn = false;
             let mut found_extern_crate = crate_name.is_none();
             let mut found_macro = false;
 
             let mut parsing_result = parse_source(
                 format!("{crates}{everything_else}"),
-                &mut found_main_span,
+                &mut has_main_fn,
                 &mut found_extern_crate,
                 &mut found_macro,
                 &crate_name,
@@ -366,7 +367,7 @@ fn check_for_main_and_extern_crate(
                 // faster doctests run time.
                 parsing_result = parse_source(
                     format!("{crates}\nfn __doctest_wrap(){{{everything_else}\n}}"),
-                    &mut found_main_span,
+                    &mut has_main_fn,
                     &mut found_extern_crate,
                     &mut found_macro,
                     &crate_name,
@@ -374,13 +375,13 @@ fn check_for_main_and_extern_crate(
                 );
             }
 
-            (found_main_span, found_extern_crate, found_macro, parsing_result)
+            (has_main_fn, found_extern_crate, found_macro, parsing_result)
         })
     });
-    let (mut main_fn_span, already_has_extern_crate, found_macro, parsing_result) = match result {
+    let (mut has_main_fn, already_has_extern_crate, found_macro, parsing_result) = match result {
         Err(..) | Ok((_, _, _, ParsingResult::Failed)) => return Err(FatalError),
-        Ok((main_fn_span, already_has_extern_crate, found_macro, parsing_result)) => {
-            (main_fn_span, already_has_extern_crate, found_macro, parsing_result)
+        Ok((has_main_fn, already_has_extern_crate, found_macro, parsing_result)) => {
+            (has_main_fn, already_has_extern_crate, found_macro, parsing_result)
         }
     };
 
@@ -389,7 +390,7 @@ fn check_for_main_and_extern_crate(
     // function written inside a macro invocation. See
     // https://github.com/rust-lang/rust/issues/56898
     if found_macro
-        && main_fn_span.is_none()
+        && !has_main_fn
         && original_source_code
             .lines()
             .map(|line| {
@@ -398,10 +399,10 @@ fn check_for_main_and_extern_crate(
             })
             .any(|code| code.contains("fn main"))
     {
-        main_fn_span = Some(DUMMY_SP);
+        has_main_fn = true;
     }
 
-    Ok((main_fn_span, already_has_extern_crate, parsing_result != ParsingResult::Ok))
+    Ok((has_main_fn, already_has_extern_crate, parsing_result != ParsingResult::Ok))
 }
 
 fn check_if_attr_is_complete(source: &str, edition: Edition) -> bool {
@@ -448,6 +449,7 @@ fn check_if_attr_is_complete(source: &str, edition: Edition) -> bool {
     .unwrap_or(false)
 }
 
+/// Returns `(crate_attrs, content, crates)`.
 fn partition_source(s: &str, edition: Edition) -> (String, String, String) {
     #[derive(Copy, Clone, PartialEq)]
     enum PartitionState {
@@ -456,7 +458,7 @@ fn partition_source(s: &str, edition: Edition) -> (String, String, String) {
         Other,
     }
     let mut state = PartitionState::Attrs;
-    let mut before = String::new();
+    let mut crate_attrs = String::new();
     let mut crates = String::new();
     let mut after = String::new();
 
@@ -520,8 +522,8 @@ fn partition_source(s: &str, edition: Edition) -> (String, String, String) {
 
         match state {
             PartitionState::Attrs => {
-                before.push_str(line);
-                before.push('\n');
+                crate_attrs.push_str(line);
+                crate_attrs.push('\n');
             }
             PartitionState::Crates => {
                 crates.push_str(line);
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index a3b461cdc06ae..994a97adee28d 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -149,7 +149,7 @@ fn generate_mergeable_doctest(
         writeln!(output, "mod {test_id} {{\n").unwrap();
     } else {
         writeln!(output, "mod {test_id} {{\n{}", doctest.crates).unwrap();
-        if doctest.main_fn_span.is_some() {
+        if doctest.has_main_fn {
             output.push_str(&doctest.everything_else);
         } else {
             let returns_result = if doctest.everything_else.trim_end().ends_with("(())") {

From 6eabffbaec94510e40c344d2b2f43538ee78bef6 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 13 Jun 2024 01:17:36 +0200
Subject: [PATCH 207/685] Greatly improve handling of doctests attributes,
 making it possible to merge doctests more efficiently

---
 src/librustdoc/doctest.rs        |  11 +--
 src/librustdoc/doctest/make.rs   | 148 ++++++++++++++++++++++---------
 src/librustdoc/doctest/runner.rs |   9 +-
 3 files changed, 116 insertions(+), 52 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 1f7ccdd01713f..88f54be4cb183 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -536,17 +536,15 @@ fn run_test(
         compiler.arg("--error-format=short");
         let input_file =
             doctest.test_opts.outdir.path().join(&format!("doctest_{}.rs", doctest.edition));
-            eprintln!("OUUUUUUUT>>>>>>> {input_file:?}");
         if std::fs::write(&input_file, &doctest.full_test_code).is_err() {
             // If we cannot write this file for any reason, we leave. All combined tests will be
             // tested as standalone tests.
             return Err(TestFailure::CompileError);
         }
         compiler.arg(input_file);
+        // FIXME: Remove once done fixing bugs.
+        // FIXME: Should this call only be done if `nocapture` is not set?
         // compiler.stderr(Stdio::null());
-        let mut buffer = String::new();
-        eprintln!("Press ENTER");
-        let _ = std::io::stdin().read_line(&mut buffer);
     } else {
         compiler.arg("-");
         compiler.stdin(Stdio::piped());
@@ -768,7 +766,7 @@ struct CreateRunnableDoctests {
 
 impl CreateRunnableDoctests {
     fn new(rustdoc_options: RustdocOptions, opts: GlobalTestOptions) -> CreateRunnableDoctests {
-        let can_merge_doctests = true;//rustdoc_options.edition >= Edition::Edition2024;
+        let can_merge_doctests = true; //rustdoc_options.edition >= Edition::Edition2024;
         CreateRunnableDoctests {
             standalone_tests: Vec::new(),
             mergeable_tests: FxHashMap::default(),
@@ -818,8 +816,7 @@ impl CreateRunnableDoctests {
             || scraped_test.langstr.test_harness
             || scraped_test.langstr.standalone
             || self.rustdoc_options.nocapture
-            || self.rustdoc_options.test_args.iter().any(|arg| arg == "--show-output")
-            || doctest.crate_attrs.contains("#![no_std]");
+            || self.rustdoc_options.test_args.iter().any(|arg| arg == "--show-output");
         if is_standalone {
             let test_desc = self.generate_test_desc_and_fn(doctest, scraped_test);
             self.standalone_tests.push(test_desc);
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 2e067c6277ec6..92ab8eb56dd48 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -22,6 +22,9 @@ pub(crate) struct DocTest {
     pub(crate) already_has_extern_crate: bool,
     pub(crate) has_main_fn: bool,
     pub(crate) crate_attrs: String,
+    /// If this is a merged doctest, it will be put into `everything_else`, otherwise it will
+    /// put into `crate_attrs`.
+    pub(crate) maybe_crate_attrs: String,
     pub(crate) crates: String,
     pub(crate) everything_else: String,
     pub(crate) test_id: Option<String>,
@@ -38,7 +41,14 @@ impl DocTest {
         // If `test_id` is `None`, it means we're generating code for a code example "run" link.
         test_id: Option<String>,
     ) -> Self {
-        let (crate_attrs, everything_else, crates) = partition_source(source, edition);
+        let SourceInfo {
+            crate_attrs,
+            maybe_crate_attrs,
+            crates,
+            everything_else,
+            has_features,
+            has_no_std,
+        } = partition_source(source, edition);
         let mut supports_color = false;
 
         // Uses librustc_ast to parse the doctest and find if there's a main fn and the extern
@@ -56,10 +66,11 @@ impl DocTest {
         else {
             // If the parser panicked due to a fatal error, pass the test code through unchanged.
             // The error will be reported during compilation.
-            return DocTest {
+            return Self {
                 supports_color: false,
                 has_main_fn: false,
                 crate_attrs,
+                maybe_crate_attrs,
                 crates,
                 everything_else,
                 already_has_extern_crate: false,
@@ -72,14 +83,15 @@ impl DocTest {
             supports_color,
             has_main_fn,
             crate_attrs,
+            maybe_crate_attrs,
             crates,
             everything_else,
             already_has_extern_crate,
             test_id,
             failed_ast: false,
             // If the AST returned an error, we don't want this doctest to be merged with the
-            // others.
-            can_be_merged: !failed_ast,
+            // others. Same if it contains `#[feature]` or `#[no_std]`.
+            can_be_merged: !failed_ast && !has_no_std && !has_features,
         }
     }
 
@@ -118,6 +130,7 @@ impl DocTest {
         // Now push any outer attributes from the example, assuming they
         // are intended to be crate attributes.
         prog.push_str(&self.crate_attrs);
+        prog.push_str(&self.maybe_crate_attrs);
         prog.push_str(&self.crates);
 
         // Don't inject `extern crate std` because it's already injected by the
@@ -405,11 +418,22 @@ fn check_for_main_and_extern_crate(
     Ok((has_main_fn, already_has_extern_crate, parsing_result != ParsingResult::Ok))
 }
 
-fn check_if_attr_is_complete(source: &str, edition: Edition) -> bool {
+enum AttrKind {
+    CrateAttr,
+    Attr,
+    Feature,
+    NoStd,
+}
+
+/// Returns `Some` if the attribute is complete and `Some(true)` if it is an attribute that can be
+/// placed at the crate root.
+fn check_if_attr_is_complete(source: &str, edition: Edition) -> Option<AttrKind> {
     if source.is_empty() {
         // Empty content so nothing to check in here...
-        return true;
+        return None;
     }
+    let not_crate_attrs = [sym::forbid, sym::allow, sym::warn, sym::deny];
+
     rustc_driver::catch_fatal_errors(|| {
         rustc_span::create_session_if_not_set_then(edition, |_| {
             use rustc_errors::emitter::HumanEmitter;
@@ -435,33 +459,77 @@ fn check_if_attr_is_complete(source: &str, edition: Edition) -> bool {
                     errs.into_iter().for_each(|err| err.cancel());
                     // If there is an unclosed delimiter, an error will be returned by the
                     // tokentrees.
-                    return false;
+                    return None;
                 }
             };
             // If a parsing error happened, it's very likely that the attribute is incomplete.
-            if let Err(e) = parser.parse_attribute(InnerAttrPolicy::Permitted) {
-                e.cancel();
-                return false;
-            }
-            true
+            let ret = match parser.parse_attribute(InnerAttrPolicy::Permitted) {
+                Ok(attr) => {
+                    let attr_name = attr.name_or_empty();
+
+                    if attr_name == sym::feature {
+                        Some(AttrKind::Feature)
+                    } else if attr_name == sym::no_std {
+                        Some(AttrKind::NoStd)
+                    } else if not_crate_attrs.contains(&attr_name) {
+                        Some(AttrKind::Attr)
+                    } else {
+                        Some(AttrKind::CrateAttr)
+                    }
+                }
+                Err(e) => {
+                    e.cancel();
+                    None
+                }
+            };
+            ret
         })
     })
-    .unwrap_or(false)
+    .unwrap_or(None)
 }
 
-/// Returns `(crate_attrs, content, crates)`.
-fn partition_source(s: &str, edition: Edition) -> (String, String, String) {
+fn handle_attr(mod_attr_pending: &mut String, source_info: &mut SourceInfo, edition: Edition) {
+    if let Some(attr_kind) = check_if_attr_is_complete(mod_attr_pending, edition) {
+        let push_to = match attr_kind {
+            AttrKind::CrateAttr => &mut source_info.crate_attrs,
+            AttrKind::Attr => &mut source_info.maybe_crate_attrs,
+            AttrKind::Feature => {
+                source_info.has_features = true;
+                &mut source_info.crate_attrs
+            }
+            AttrKind::NoStd => {
+                source_info.has_no_std = true;
+                &mut source_info.crate_attrs
+            }
+        };
+        push_to.push_str(mod_attr_pending);
+        push_to.push('\n');
+        // If it's complete, then we can clear the pending content.
+        mod_attr_pending.clear();
+    } else if mod_attr_pending.ends_with('\\') {
+        mod_attr_pending.push('n');
+    }
+}
+
+#[derive(Default)]
+struct SourceInfo {
+    crate_attrs: String,
+    maybe_crate_attrs: String,
+    crates: String,
+    everything_else: String,
+    has_features: bool,
+    has_no_std: bool,
+}
+
+fn partition_source(s: &str, edition: Edition) -> SourceInfo {
     #[derive(Copy, Clone, PartialEq)]
     enum PartitionState {
         Attrs,
         Crates,
         Other,
     }
+    let mut source_info = SourceInfo::default();
     let mut state = PartitionState::Attrs;
-    let mut crate_attrs = String::new();
-    let mut crates = String::new();
-    let mut after = String::new();
-
     let mut mod_attr_pending = String::new();
 
     for line in s.lines() {
@@ -472,12 +540,9 @@ fn partition_source(s: &str, edition: Edition) -> (String, String, String) {
         match state {
             PartitionState::Attrs => {
                 state = if trimline.starts_with("#![") {
-                    if !check_if_attr_is_complete(line, edition) {
-                        mod_attr_pending = line.to_owned();
-                    } else {
-                        mod_attr_pending.clear();
-                    }
-                    PartitionState::Attrs
+                    mod_attr_pending = line.to_owned();
+                    handle_attr(&mut mod_attr_pending, &mut source_info, edition);
+                    continue;
                 } else if trimline.chars().all(|c| c.is_whitespace())
                     || (trimline.starts_with("//") && !trimline.starts_with("///"))
                 {
@@ -492,15 +557,10 @@ fn partition_source(s: &str, edition: Edition) -> (String, String, String) {
                         // If not, then we append the new line into the pending attribute to check
                         // if this time it's complete...
                         mod_attr_pending.push_str(line);
-                        if !trimline.is_empty()
-                            && check_if_attr_is_complete(&mod_attr_pending, edition)
-                        {
-                            // If it's complete, then we can clear the pending content.
-                            mod_attr_pending.clear();
+                        if !trimline.is_empty() {
+                            handle_attr(&mut mod_attr_pending, &mut source_info, edition);
                         }
-                        // In any case, this is considered as `PartitionState::Attrs` so it's
-                        // prepended before rustdoc's inserts.
-                        PartitionState::Attrs
+                        continue;
                     } else {
                         PartitionState::Other
                     }
@@ -522,23 +582,25 @@ fn partition_source(s: &str, edition: Edition) -> (String, String, String) {
 
         match state {
             PartitionState::Attrs => {
-                crate_attrs.push_str(line);
-                crate_attrs.push('\n');
+                source_info.crate_attrs.push_str(line);
+                source_info.crate_attrs.push('\n');
             }
             PartitionState::Crates => {
-                crates.push_str(line);
-                crates.push('\n');
+                source_info.crates.push_str(line);
+                source_info.crates.push('\n');
             }
             PartitionState::Other => {
-                after.push_str(line);
-                after.push('\n');
+                source_info.everything_else.push_str(line);
+                source_info.everything_else.push('\n');
             }
         }
     }
 
-    debug!("before:\n{before}");
-    debug!("crates:\n{crates}");
-    debug!("after:\n{after}");
+    source_info.everything_else = source_info.everything_else.trim().to_string();
+
+    debug!("crate_attrs:\n{}{}", source_info.crate_attrs, source_info.maybe_crate_attrs);
+    debug!("crates:\n{}", source_info.crates);
+    debug!("after:\n{}", source_info.everything_else);
 
-    (before, after.trim().to_owned(), crates)
+    source_info
 }
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index 994a97adee28d..adff94233bcf6 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -107,7 +107,11 @@ impl DocTestRunner {
 #[rustc_main]
 #[coverage(off)]
 fn main() {{
-test::test_main(&[{test_args}], vec![{ids}], None);
+test::test_main_static_with_args(
+    &[{test_args}],
+    &mut [{ids}],
+    None,
+);
 }}",
             output = self.output,
             ids = self.ids,
@@ -148,7 +152,8 @@ fn generate_mergeable_doctest(
         // We generate nothing else.
         writeln!(output, "mod {test_id} {{\n").unwrap();
     } else {
-        writeln!(output, "mod {test_id} {{\n{}", doctest.crates).unwrap();
+        writeln!(output, "mod {test_id} {{\n{}{}", doctest.crates, doctest.maybe_crate_attrs)
+            .unwrap();
         if doctest.has_main_fn {
             output.push_str(&doctest.everything_else);
         } else {

From b6831bbdda3aa9ea3cc5e6d02a75f93c025818d4 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 13 Jun 2024 16:39:56 +0200
Subject: [PATCH 208/685] Don't merge doctests with `#[global_allocator]`

---
 src/librustdoc/doctest/make.rs   | 131 +++++++++++++++----------------
 src/librustdoc/doctest/runner.rs |  14 ++--
 2 files changed, 70 insertions(+), 75 deletions(-)

diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 92ab8eb56dd48..c67dc4525d2c3 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -49,20 +49,26 @@ impl DocTest {
             has_features,
             has_no_std,
         } = partition_source(source, edition);
-        let mut supports_color = false;
 
         // Uses librustc_ast to parse the doctest and find if there's a main fn and the extern
         // crate already is included.
-        let Ok((has_main_fn, already_has_extern_crate, failed_ast)) =
-            check_for_main_and_extern_crate(
-                crate_name,
-                source,
-                &everything_else,
-                &crates,
-                edition,
-                &mut supports_color,
-                can_merge_doctests,
-            )
+        let Ok((
+            ParseSourceInfo {
+                has_main_fn,
+                found_extern_crate,
+                supports_color,
+                has_global_allocator,
+                ..
+            },
+            failed_ast,
+        )) = check_for_main_and_extern_crate(
+            crate_name,
+            source,
+            &everything_else,
+            &crates,
+            edition,
+            can_merge_doctests,
+        )
         else {
             // If the parser panicked due to a fatal error, pass the test code through unchanged.
             // The error will be reported during compilation.
@@ -86,12 +92,12 @@ impl DocTest {
             maybe_crate_attrs,
             crates,
             everything_else,
-            already_has_extern_crate,
+            already_has_extern_crate: found_extern_crate,
             test_id,
             failed_ast: false,
             // If the AST returned an error, we don't want this doctest to be merged with the
             // others. Same if it contains `#[feature]` or `#[no_std]`.
-            can_be_merged: !failed_ast && !has_no_std && !has_features,
+            can_be_merged: !failed_ast && !has_no_std && !has_features && !has_global_allocator,
         }
     }
 
@@ -231,11 +237,8 @@ fn cancel_error_count(psess: &ParseSess) {
 
 fn parse_source(
     source: String,
-    has_main_fn: &mut bool,
-    found_extern_crate: &mut bool,
-    found_macro: &mut bool,
+    info: &mut ParseSourceInfo,
     crate_name: &Option<&str>,
-    supports_color: &mut bool,
 ) -> ParsingResult {
     use rustc_errors::emitter::{Emitter, HumanEmitter};
     use rustc_errors::DiagCtxt;
@@ -251,7 +254,7 @@ fn parse_source(
         rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec(),
         false,
     );
-    *supports_color =
+    info.supports_color =
         HumanEmitter::new(stderr_destination(ColorConfig::Auto), fallback_bundle.clone())
             .supports_color();
 
@@ -274,43 +277,38 @@ fn parse_source(
     // Recurse through functions body. It is necessary because the doctest source code is
     // wrapped in a function to limit the number of AST errors. If we don't recurse into
     // functions, we would thing all top-level items (so basically nothing).
-    fn check_item(
-        item: &ast::Item,
-        has_main_fn: &mut bool,
-        found_extern_crate: &mut bool,
-        found_macro: &mut bool,
-        crate_name: &Option<&str>,
-    ) {
+    fn check_item(item: &ast::Item, info: &mut ParseSourceInfo, crate_name: &Option<&str>) {
+        if !info.has_global_allocator
+            && item.attrs.iter().any(|attr| attr.name_or_empty() == sym::global_allocator)
+        {
+            info.has_global_allocator = true;
+        }
         match item.kind {
-            ast::ItemKind::Fn(ref fn_item) if !*has_main_fn => {
+            ast::ItemKind::Fn(ref fn_item) if !info.has_main_fn => {
                 if item.ident.name == sym::main {
-                    *has_main_fn = true;
+                    info.has_main_fn = true;
                 }
                 if let Some(ref body) = fn_item.body {
                     for stmt in &body.stmts {
                         match stmt.kind {
-                            ast::StmtKind::Item(ref item) => check_item(
-                                item,
-                                has_main_fn,
-                                found_extern_crate,
-                                found_macro,
-                                crate_name,
-                            ),
-                            ast::StmtKind::MacCall(..) => *found_macro = true,
+                            ast::StmtKind::Item(ref item) => check_item(item, info, crate_name),
+                            ast::StmtKind::MacCall(..) => info.found_macro = true,
                             _ => {}
                         }
                     }
                 }
             }
             ast::ItemKind::ExternCrate(original) => {
-                if !*found_extern_crate && let Some(ref crate_name) = crate_name {
-                    *found_extern_crate = match original {
+                if !info.found_extern_crate
+                    && let Some(ref crate_name) = crate_name
+                {
+                    info.found_extern_crate = match original {
                         Some(name) => name.as_str() == *crate_name,
                         None => item.ident.as_str() == *crate_name,
                     };
                 }
             }
-            ast::ItemKind::MacCall(..) => *found_macro = true,
+            ast::ItemKind::MacCall(..) => info.found_macro = true,
             _ => {}
         }
     }
@@ -318,9 +316,9 @@ fn parse_source(
     loop {
         match parser.parse_item(ForceCollect::No) {
             Ok(Some(item)) => {
-                check_item(&item, has_main_fn, found_extern_crate, found_macro, crate_name);
+                check_item(&item, info, crate_name);
 
-                if *has_main_fn && *found_extern_crate {
+                if info.has_main_fn && info.found_extern_crate {
                     break;
                 }
             }
@@ -341,30 +339,30 @@ fn parse_source(
     parsing_result
 }
 
-/// Returns `(has_main_fn, already_has_extern_crate, failed_ast)`.
+#[derive(Default)]
+struct ParseSourceInfo {
+    has_main_fn: bool,
+    found_extern_crate: bool,
+    found_macro: bool,
+    supports_color: bool,
+    has_global_allocator: bool,
+}
+
 fn check_for_main_and_extern_crate(
     crate_name: Option<&str>,
     original_source_code: &str,
     everything_else: &str,
     crates: &str,
     edition: Edition,
-    supports_color: &mut bool,
     can_merge_doctests: bool,
-) -> Result<(bool, bool, bool), FatalError> {
+) -> Result<(ParseSourceInfo, bool), FatalError> {
     let result = rustc_driver::catch_fatal_errors(|| {
         rustc_span::create_session_if_not_set_then(edition, |_| {
-            let mut has_main_fn = false;
-            let mut found_extern_crate = crate_name.is_none();
-            let mut found_macro = false;
-
-            let mut parsing_result = parse_source(
-                format!("{crates}{everything_else}"),
-                &mut has_main_fn,
-                &mut found_extern_crate,
-                &mut found_macro,
-                &crate_name,
-                supports_color,
-            );
+            let mut info =
+                ParseSourceInfo { found_extern_crate: crate_name.is_none(), ..Default::default() };
+
+            let mut parsing_result =
+                parse_source(format!("{crates}{everything_else}"), &mut info, &crate_name);
             // No need to double-check this if the "merged doctests" feature isn't enabled (so
             // before the 2024 edition).
             if can_merge_doctests && parsing_result != ParsingResult::Ok {
@@ -380,30 +378,25 @@ fn check_for_main_and_extern_crate(
                 // faster doctests run time.
                 parsing_result = parse_source(
                     format!("{crates}\nfn __doctest_wrap(){{{everything_else}\n}}"),
-                    &mut has_main_fn,
-                    &mut found_extern_crate,
-                    &mut found_macro,
+                    &mut info,
                     &crate_name,
-                    supports_color,
                 );
             }
 
-            (has_main_fn, found_extern_crate, found_macro, parsing_result)
+            (info, parsing_result)
         })
     });
-    let (mut has_main_fn, already_has_extern_crate, found_macro, parsing_result) = match result {
-        Err(..) | Ok((_, _, _, ParsingResult::Failed)) => return Err(FatalError),
-        Ok((has_main_fn, already_has_extern_crate, found_macro, parsing_result)) => {
-            (has_main_fn, already_has_extern_crate, found_macro, parsing_result)
-        }
+    let (mut info, parsing_result) = match result {
+        Err(..) | Ok((_, ParsingResult::Failed)) => return Err(FatalError),
+        Ok((info, parsing_result)) => (info, parsing_result),
     };
 
     // If a doctest's `fn main` is being masked by a wrapper macro, the parsing loop above won't
     // see it. In that case, run the old text-based scan to see if they at least have a main
     // function written inside a macro invocation. See
     // https://github.com/rust-lang/rust/issues/56898
-    if found_macro
-        && !has_main_fn
+    if info.found_macro
+        && !info.has_main_fn
         && original_source_code
             .lines()
             .map(|line| {
@@ -412,10 +405,10 @@ fn check_for_main_and_extern_crate(
             })
             .any(|code| code.contains("fn main"))
     {
-        has_main_fn = true;
+        info.has_main_fn = true;
     }
 
-    Ok((has_main_fn, already_has_extern_crate, parsing_result != ParsingResult::Ok))
+    Ok((info, parsing_result != ParsingResult::Ok))
 }
 
 enum AttrKind {
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index adff94233bcf6..1a4a375aa16a4 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -45,11 +45,11 @@ impl DocTestRunner {
                 self.crate_attrs.insert(line.to_string());
             }
         }
-        if !self.ids.is_empty() {
-            self.ids.push(',');
-        }
+        // if !self.ids.is_empty() {
+        //     self.ids.push(',');
+        // }
         self.ids.push_str(&format!(
-            "{}::TEST",
+            "tests.push({}::TEST);\n",
             generate_mergeable_doctest(
                 doctest,
                 scraped_test,
@@ -107,9 +107,11 @@ impl DocTestRunner {
 #[rustc_main]
 #[coverage(off)]
 fn main() {{
-test::test_main_static_with_args(
+let mut tests = Vec::new();
+{ids}
+test::test_main(
     &[{test_args}],
-    &mut [{ids}],
+    tests,
     None,
 );
 }}",

From dcc77b4cbcaf94d5bca34680934c87d172a8d02f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 13 Jun 2024 18:43:53 +0200
Subject: [PATCH 209/685] Fix weird memory allocation failure in merged
 doctests by storing doctest list into a const

---
 src/librustdoc/doctest/runner.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index 1a4a375aa16a4..3f1ab7208f239 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -45,11 +45,11 @@ impl DocTestRunner {
                 self.crate_attrs.insert(line.to_string());
             }
         }
-        // if !self.ids.is_empty() {
-        //     self.ids.push(',');
-        // }
+        if !self.ids.is_empty() {
+            self.ids.push(',');
+        }
         self.ids.push_str(&format!(
-            "tests.push({}::TEST);\n",
+            "{}::TEST",
             generate_mergeable_doctest(
                 doctest,
                 scraped_test,
@@ -107,14 +107,14 @@ impl DocTestRunner {
 #[rustc_main]
 #[coverage(off)]
 fn main() {{
-let mut tests = Vec::new();
-{ids}
+const TESTS: [test::TestDescAndFn; {nb_tests}] = [{ids}];
 test::test_main(
     &[{test_args}],
-    tests,
+    Vec::from(TESTS),
     None,
 );
 }}",
+            nb_tests = self.nb_tests,
             output = self.output,
             ids = self.ids,
         )
@@ -192,7 +192,7 @@ pub const TEST: test::TestDescAndFn = test::TestDescAndFn {{
         compile_fail: false,
         no_run: {no_run},
         should_panic: test::ShouldPanic::{should_panic},
-        test_type: test::TestType::UnitTest,
+        test_type: test::TestType::DocTest,
     }},
     testfn: test::StaticTestFn(
         #[coverage(off)]

From 0f0681e941f7352ea16dba2ad227bbc0e029ccd9 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Fri, 14 Jun 2024 00:10:30 +0200
Subject: [PATCH 210/685] Make merged doctests run in their own process

---
 src/librustdoc/doctest.rs        |  8 ++-
 src/librustdoc/doctest/runner.rs | 96 +++++++++++++++++++++++++++-----
 2 files changed, 87 insertions(+), 17 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 88f54be4cb183..74adcb415fa78 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -629,9 +629,13 @@ fn run_test(
         let tool = make_maybe_absolute_path(tool.into());
         cmd = Command::new(tool);
         cmd.args(&rustdoc_options.runtool_args);
-        cmd.arg(output_file);
+        cmd.arg(&output_file);
     } else {
-        cmd = Command::new(output_file);
+        cmd = Command::new(&output_file);
+        if is_multiple_tests {
+            cmd.arg("*doctest-bin-path");
+            cmd.arg(&output_file);
+        }
     }
     if let Some(run_directory) = &rustdoc_options.test_run_directory {
         cmd.current_dir(run_directory);
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index 3f1ab7208f239..c774f7735bb06 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -75,8 +75,9 @@ impl DocTestRunner {
 #![allow(internal_features)]
 #![feature(test)]
 #![feature(rustc_attrs)]
-#![feature(coverage_attribute)]\n"
-            .to_string();
+#![feature(coverage_attribute)]
+"
+        .to_string();
 
         for crate_attr in &self.crate_attrs {
             code.push_str(crate_attr);
@@ -104,15 +105,67 @@ impl DocTestRunner {
             code,
             "\
 {output}
+
+mod __doctest_mod {{
+    pub static mut BINARY_PATH: Option<std::path::PathBuf> = None;
+    pub const RUN_OPTION: &str = \"*doctest-inner-test\";
+    pub const BIN_OPTION: &str = \"*doctest-bin-path\";
+
+    #[allow(unused)]
+    pub fn get_doctest_path() -> Option<&'static std::path::Path> {{
+        unsafe {{ self::BINARY_PATH.as_deref() }}
+    }}
+
+    #[allow(unused)]
+    pub fn doctest_runner(bin: &std::path::Path, test_nb: usize) -> Result<(), String> {{
+        let out = std::process::Command::new(bin)
+            .arg(self::RUN_OPTION)
+            .arg(test_nb.to_string())
+            .output()
+            .expect(\"failed to run command\");
+        if !out.status.success() {{
+            Err(String::from_utf8_lossy(&out.stderr).to_string())
+        }} else {{
+            Ok(())
+        }}
+    }}
+}}
+
 #[rustc_main]
 #[coverage(off)]
-fn main() {{
+fn main() -> std::process::ExitCode {{
 const TESTS: [test::TestDescAndFn; {nb_tests}] = [{ids}];
-test::test_main(
-    &[{test_args}],
-    Vec::from(TESTS),
-    None,
-);
+let bin_marker = std::ffi::OsStr::new(__doctest_mod::BIN_OPTION);
+let test_marker = std::ffi::OsStr::new(__doctest_mod::RUN_OPTION);
+
+let mut args = std::env::args_os().skip(1);
+while let Some(arg) = args.next() {{
+    if arg == bin_marker {{
+        let Some(binary) = args.next() else {{
+            panic!(\"missing argument after `{{}}`\", __doctest_mod::BIN_OPTION);
+        }};
+        unsafe {{ crate::__doctest_mod::BINARY_PATH = Some(binary.into()); }}
+        return std::process::Termination::report(test::test_main(
+            &[{test_args}],
+            Vec::from(TESTS),
+            None,
+        ));
+    }} else if arg == test_marker {{
+        let Some(nb_test) = args.next() else {{
+            panic!(\"missing argument after `{{}}`\", __doctest_mod::RUN_OPTION);
+        }};
+        if let Some(nb_test) = nb_test.to_str().and_then(|nb| nb.parse::<usize>().ok()) {{
+            if let Some(test) = TESTS.get(nb_test) {{
+                if let test::StaticTestFn(f) = test.testfn {{
+                    return std::process::Termination::report(f());
+                }}
+            }}
+        }}
+        panic!(\"Unexpected value after `{{}}`\", __doctest_mod::RUN_OPTION);
+    }}
+}}
+
+panic!(\"missing argument for merged doctest binary\");
 }}",
             nb_tests = self.nb_tests,
             output = self.output,
@@ -156,6 +209,10 @@ fn generate_mergeable_doctest(
     } else {
         writeln!(output, "mod {test_id} {{\n{}{}", doctest.crates, doctest.maybe_crate_attrs)
             .unwrap();
+        if scraped_test.langstr.no_run {
+            // To prevent having warnings about unused items since they're not called.
+            writeln!(output, "#![allow(unused)]").unwrap();
+        }
         if doctest.has_main_fn {
             output.push_str(&doctest.everything_else);
         } else {
@@ -167,14 +224,15 @@ fn generate_mergeable_doctest(
             write!(
                 output,
                 "\
-    fn main() {returns_result} {{
-        {}
-    }}",
+fn main() {returns_result} {{
+    {}
+}}",
                 doctest.everything_else
             )
             .unwrap();
         }
     }
+    let not_running = ignore || scraped_test.langstr.no_run;
     writeln!(
         output,
         "
@@ -196,7 +254,7 @@ pub const TEST: test::TestDescAndFn = test::TestDescAndFn {{
     }},
     testfn: test::StaticTestFn(
         #[coverage(off)]
-        || test::assert_test_result({runner}),
+        || {{{runner}}},
     )
 }};
 }}",
@@ -211,10 +269,18 @@ pub const TEST: test::TestDescAndFn = test::TestDescAndFn {{
         },
         // Setting `no_run` to `true` in `TestDesc` still makes the test run, so we simply
         // don't give it the function to run.
-        runner = if ignore || scraped_test.langstr.no_run {
-            "Ok::<(), String>(())"
+        runner = if not_running {
+            "test::assert_test_result(Ok::<(), String>(()))".to_string()
         } else {
-            "self::main()"
+            format!(
+                "
+if let Some(bin_path) = crate::__doctest_mod::get_doctest_path() {{
+    test::assert_test_result(crate::__doctest_mod::doctest_runner(bin_path, {id}))
+}} else {{
+    test::assert_test_result(self::main())
+}}
+",
+            )
         },
     )
     .unwrap();

From 995858eed36f649d91c04e8095370877e64a0560 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Fri, 14 Jun 2024 22:54:53 +0200
Subject: [PATCH 211/685] Don't change indent in merged doctests

---
 src/librustdoc/doctest/runner.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index c774f7735bb06..58f40ff11b97f 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -225,7 +225,7 @@ fn generate_mergeable_doctest(
                 output,
                 "\
 fn main() {returns_result} {{
-    {}
+{}
 }}",
                 doctest.everything_else
             )

From 475824d8110ffd67065609b0e00e28ad220d62b2 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Fri, 14 Jun 2024 22:55:44 +0200
Subject: [PATCH 212/685] Mark location doctest as standalone since file
 information will not work in merged doctest file

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

diff --git a/library/core/src/panic/location.rs b/library/core/src/panic/location.rs
index 8c04994ac0fc4..930edffd50517 100644
--- a/library/core/src/panic/location.rs
+++ b/library/core/src/panic/location.rs
@@ -44,7 +44,7 @@ impl<'a> Location<'a> {
     ///
     /// # Examples
     ///
-    /// ```
+    /// ```standalone
     /// use std::panic::Location;
     ///
     /// /// Returns the [`Location`] at which it is called.

From ec4d9101907bcb20cac7ff055fd1c1776292e0bf Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sat, 15 Jun 2024 18:20:58 +0200
Subject: [PATCH 213/685] Correctly handle `internal_features` attribute

---
 src/librustdoc/doctest/make.rs | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index c67dc4525d2c3..aaa8cb5ccf7d6 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -465,7 +465,19 @@ fn check_if_attr_is_complete(source: &str, edition: Edition) -> Option<AttrKind>
                     } else if attr_name == sym::no_std {
                         Some(AttrKind::NoStd)
                     } else if not_crate_attrs.contains(&attr_name) {
-                        Some(AttrKind::Attr)
+                        // There is one exception to these attributes:
+                        // `#![allow(internal_features)]`. If this attribute is used, we need to
+                        // consider it only as a crate-level attribute.
+                        if attr_name == sym::allow
+                            && let Some(list) = attr.meta_item_list()
+                            && list.iter().any(|sub_attr| {
+                                sub_attr.name_or_empty().as_str() == "internal_features"
+                            })
+                        {
+                            Some(AttrKind::CrateAttr)
+                        } else {
+                            Some(AttrKind::Attr)
+                        }
                     } else {
                         Some(AttrKind::CrateAttr)
                     }

From c5ae545fbd285cfd0aab251585c555021b6992d1 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 18 Jun 2024 15:23:01 +0200
Subject: [PATCH 214/685] If no argument is provided to merged doctests binary,
 they will be run in the same process (needed for miri)

---
 src/librustdoc/doctest/runner.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index 58f40ff11b97f..72ebe33bd0b5e 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -137,6 +137,7 @@ fn main() -> std::process::ExitCode {{
 const TESTS: [test::TestDescAndFn; {nb_tests}] = [{ids}];
 let bin_marker = std::ffi::OsStr::new(__doctest_mod::BIN_OPTION);
 let test_marker = std::ffi::OsStr::new(__doctest_mod::RUN_OPTION);
+let test_args = &[{test_args}];
 
 let mut args = std::env::args_os().skip(1);
 while let Some(arg) = args.next() {{
@@ -145,11 +146,7 @@ while let Some(arg) = args.next() {{
             panic!(\"missing argument after `{{}}`\", __doctest_mod::BIN_OPTION);
         }};
         unsafe {{ crate::__doctest_mod::BINARY_PATH = Some(binary.into()); }}
-        return std::process::Termination::report(test::test_main(
-            &[{test_args}],
-            Vec::from(TESTS),
-            None,
-        ));
+        return std::process::Termination::report(test::test_main(test_args, Vec::from(TESTS), None));
     }} else if arg == test_marker {{
         let Some(nb_test) = args.next() else {{
             panic!(\"missing argument after `{{}}`\", __doctest_mod::RUN_OPTION);
@@ -165,7 +162,8 @@ while let Some(arg) = args.next() {{
     }}
 }}
 
-panic!(\"missing argument for merged doctest binary\");
+eprintln!(\"WARNING: No argument provided so doctests will be run in the same process\");
+std::process::Termination::report(test::test_main(test_args, Vec::from(TESTS), None))
 }}",
             nb_tests = self.nb_tests,
             output = self.output,

From 0bd2c99ce8a3df2ae734748a69b4dc7644b5db1c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 18 Jun 2024 22:49:27 +0200
Subject: [PATCH 215/685] Only show rustdoc doctest compilation output if
 `nocapture` is used

---
 src/librustdoc/doctest.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 74adcb415fa78..7028666371bd5 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -542,9 +542,11 @@ fn run_test(
             return Err(TestFailure::CompileError);
         }
         compiler.arg(input_file);
-        // FIXME: Remove once done fixing bugs.
-        // FIXME: Should this call only be done if `nocapture` is not set?
-        // compiler.stderr(Stdio::null());
+        if !rustdoc_options.nocapture {
+            // If `nocapture` is disabled, then we don't display rustc's output when compiling
+            // the merged doctests.
+            compiler.stderr(Stdio::null());
+        }
     } else {
         compiler.arg("-");
         compiler.stdin(Stdio::piped());

From 112e44740e8344a139c551864471544b193a6188 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Wed, 19 Jun 2024 00:16:05 +0200
Subject: [PATCH 216/685] Disable merged doctests by default

---
 src/librustdoc/doctest.rs                                   | 2 +-
 tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 7028666371bd5..74ccc7a871bff 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -772,7 +772,7 @@ struct CreateRunnableDoctests {
 
 impl CreateRunnableDoctests {
     fn new(rustdoc_options: RustdocOptions, opts: GlobalTestOptions) -> CreateRunnableDoctests {
-        let can_merge_doctests = true; //rustdoc_options.edition >= Edition::Edition2024;
+        let can_merge_doctests = rustdoc_options.edition >= Edition::Edition2024;
         CreateRunnableDoctests {
             standalone_tests: Vec::new(),
             mergeable_tests: FxHashMap::default(),
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
index 71b0b10fa72e2..cb3456e087ebe 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
@@ -5,7 +5,6 @@ test $DIR/failed-doctest-should-panic.rs - Foo (line 9) - should panic ... FAILE
 failures:
 
 ---- $DIR/failed-doctest-should-panic.rs - Foo (line 9) stdout ----
-Hello, world!
 note: test did not panic as expected
 
 failures:

From 14f80f9e69be3802792736eb11584d9f39229c48 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Wed, 19 Jun 2024 15:29:25 +0200
Subject: [PATCH 217/685] Correctly handle macros using `$crate` in merged
 doctests

---
 src/librustdoc/doctest/make.rs | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index aaa8cb5ccf7d6..f7334c1815e73 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -58,6 +58,7 @@ impl DocTest {
                 found_extern_crate,
                 supports_color,
                 has_global_allocator,
+                has_macro_def,
                 ..
             },
             failed_ast,
@@ -85,6 +86,16 @@ impl DocTest {
                 can_be_merged: false,
             };
         };
+        // If the AST returned an error, we don't want this doctest to be merged with the
+        // others. Same if it contains `#[feature]` or `#[no_std]`.
+        let can_be_merged = can_merge_doctests
+            && !failed_ast
+            && !has_no_std
+            && !has_features
+            && !has_global_allocator
+            // If this is a merged doctest and a defined macro uses `$crate`, then the path will
+            // not work, so better not put it into merged doctests.
+            && !(has_macro_def && everything_else.contains("$crate"));
         Self {
             supports_color,
             has_main_fn,
@@ -95,9 +106,7 @@ impl DocTest {
             already_has_extern_crate: found_extern_crate,
             test_id,
             failed_ast: false,
-            // If the AST returned an error, we don't want this doctest to be merged with the
-            // others. Same if it contains `#[feature]` or `#[no_std]`.
-            can_be_merged: !failed_ast && !has_no_std && !has_features && !has_global_allocator,
+            can_be_merged,
         }
     }
 
@@ -309,6 +318,7 @@ fn parse_source(
                 }
             }
             ast::ItemKind::MacCall(..) => info.found_macro = true,
+            ast::ItemKind::MacroDef(..) => info.has_macro_def = true,
             _ => {}
         }
     }
@@ -346,6 +356,7 @@ struct ParseSourceInfo {
     found_macro: bool,
     supports_color: bool,
     has_global_allocator: bool,
+    has_macro_def: bool,
 }
 
 fn check_for_main_and_extern_crate(

From 84d9b67dabd195c21fd210150facd2a8eccac908 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Wed, 19 Jun 2024 15:54:08 +0200
Subject: [PATCH 218/685] Add 2024 edition doctests to cover corner cases

---
 tests/rustdoc-ui/2024-doctests-checks.rs     | 41 ++++++++++++++++++++
 tests/rustdoc-ui/2024-doctests-checks.stdout | 14 +++++++
 2 files changed, 55 insertions(+)
 create mode 100644 tests/rustdoc-ui/2024-doctests-checks.rs
 create mode 100644 tests/rustdoc-ui/2024-doctests-checks.stdout

diff --git a/tests/rustdoc-ui/2024-doctests-checks.rs b/tests/rustdoc-ui/2024-doctests-checks.rs
new file mode 100644
index 0000000000000..6f62c0f73ad81
--- /dev/null
+++ b/tests/rustdoc-ui/2024-doctests-checks.rs
@@ -0,0 +1,41 @@
+//@ check-pass
+//@ compile-flags: --test --test-args=--test-threads=1 -Zunstable-options --edition 2024
+//@ normalize-stdout-test: "tests/rustdoc-ui" -> "$$DIR"
+//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test "wrong-ast.rs:\d+:\d+" -> "wrong-ast.rs:$$LINE:$$COL"
+
+/// This one should fail: crate attributes should remain crate attributes
+/// in standalone doctests.
+///
+/// ```compile_fail
+/// #![deny(missing_docs)]
+///
+/// pub struct Bar;
+/// ```
+///
+/// This one should not impact the other merged doctests.
+///
+/// ```
+/// #![deny(unused)]
+/// ```
+///
+/// ```
+/// let x = 12;
+/// ```
+///
+/// This one should not be a merged doctest (because of `$crate`):
+///
+/// ```
+/// macro_rules! bla {
+///     () => {{
+///         $crate::foo();
+///     }}
+/// }
+///
+/// fn foo() {}
+///
+/// fn main() {
+///     bla!();
+/// }
+/// ```
+pub struct Foo;
diff --git a/tests/rustdoc-ui/2024-doctests-checks.stdout b/tests/rustdoc-ui/2024-doctests-checks.stdout
new file mode 100644
index 0000000000000..2c0136f767448
--- /dev/null
+++ b/tests/rustdoc-ui/2024-doctests-checks.stdout
@@ -0,0 +1,14 @@
+
+running 2 tests
+test $DIR/2024-doctests-checks.rs - Foo (line 18) ... ok
+test $DIR/2024-doctests-checks.rs - Foo (line 22) ... ok
+
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
+
+running 2 tests
+test $DIR/2024-doctests-checks.rs - Foo (line 10) - compile fail ... ok
+test $DIR/2024-doctests-checks.rs - Foo (line 28) ... ok
+
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+

From 6d552ba44698f7b1aed7fa0b96ad3214d15d433c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 20 Jun 2024 14:51:59 +0200
Subject: [PATCH 219/685] Improve code by removing unneeded function arguments

---
 src/librustdoc/doctest.rs          | 31 +++++++++---------------------
 src/librustdoc/doctest/markdown.rs |  2 --
 2 files changed, 9 insertions(+), 24 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 74ccc7a871bff..446fc83f9f244 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -151,8 +151,6 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<()
         expanded_args: options.expanded_args.clone(),
     };
 
-    let test_args = options.test_args.clone();
-    let nocapture = options.nocapture;
     let externs = options.externs.clone();
     let json_unused_externs = options.json_unused_externs;
 
@@ -202,15 +200,7 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<()
         })
     })?;
 
-    run_tests(
-        test_args,
-        nocapture,
-        opts,
-        &rustdoc_options,
-        &unused_extern_reports,
-        standalone_tests,
-        mergeable_tests,
-    );
+    run_tests(opts, &rustdoc_options, &unused_extern_reports, standalone_tests, mergeable_tests);
 
     let compiling_test_count = compiling_test_count.load(Ordering::SeqCst);
 
@@ -256,16 +246,16 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<()
 }
 
 pub(crate) fn run_tests(
-    mut test_args: Vec<String>,
-    nocapture: bool,
     opts: GlobalTestOptions,
     rustdoc_options: &Arc<RustdocOptions>,
     unused_extern_reports: &Arc<Mutex<Vec<UnusedExterns>>>,
     mut standalone_tests: Vec<test::TestDescAndFn>,
     mergeable_tests: FxHashMap<Edition, Vec<(DocTest, ScrapedDoctest)>>,
 ) {
+    let mut test_args = Vec::with_capacity(rustdoc_options.test_args.len() + 1);
     test_args.insert(0, "rustdoctest".to_string());
-    if nocapture {
+    test_args.extend_from_slice(&rustdoc_options.test_args);
+    if rustdoc_options.nocapture {
         test_args.push("--nocapture".to_string());
     }
 
@@ -283,7 +273,7 @@ pub(crate) fn run_tests(
 
         let rustdoc_test_options = IndividualTestOptions::new(
             &rustdoc_options,
-            &format!("merged_doctest_{edition}"),
+            &Some(format!("merged_doctest_{edition}")),
             PathBuf::from(format!("doctest_{edition}.rs")),
         );
 
@@ -685,10 +675,10 @@ struct IndividualTestOptions {
 }
 
 impl IndividualTestOptions {
-    fn new(options: &RustdocOptions, test_id: &str, test_path: PathBuf) -> Self {
+    fn new(options: &RustdocOptions, test_id: &Option<String>, test_path: PathBuf) -> Self {
         let outdir = if let Some(ref path) = options.persist_doctests {
             let mut path = path.clone();
-            path.push(&test_id);
+            path.push(&test_id.as_deref().unwrap_or_else(|| "<doctest>"));
 
             if let Err(err) = std::fs::create_dir_all(&path) {
                 eprintln!("Couldn't create directory for doctest executables: {err}");
@@ -858,11 +848,8 @@ fn generate_test_desc_and_fn(
     unused_externs: Arc<Mutex<Vec<UnusedExterns>>>,
 ) -> test::TestDescAndFn {
     let target_str = rustdoc_options.target.to_string();
-    let rustdoc_test_options = IndividualTestOptions::new(
-        &rustdoc_options,
-        test.test_id.as_deref().unwrap_or_else(|| "<doctest>"),
-        scraped_test.path(),
-    );
+    let rustdoc_test_options =
+        IndividualTestOptions::new(&rustdoc_options, &test.test_id, scraped_test.path());
 
     debug!("creating test {}: {}", scraped_test.name, scraped_test.text);
     test::TestDescAndFn {
diff --git a/src/librustdoc/doctest/markdown.rs b/src/librustdoc/doctest/markdown.rs
index 5f821634a82d2..5c9fd1e949c90 100644
--- a/src/librustdoc/doctest/markdown.rs
+++ b/src/librustdoc/doctest/markdown.rs
@@ -118,8 +118,6 @@ pub(crate) fn test(options: Options) -> Result<(), String> {
     let CreateRunnableDoctests { opts, rustdoc_options, standalone_tests, mergeable_tests, .. } =
         collector;
     crate::doctest::run_tests(
-        options.test_args,
-        options.nocapture,
         opts,
         &rustdoc_options,
         &Arc::new(Mutex::new(Vec::new())),

From bfabf1db446349e3cfce48f4fdd6d734e7031d5b Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 20 Jun 2024 15:42:46 +0200
Subject: [PATCH 220/685] Add documentation on `DocTest` and `RunnableDoctest`
 structs

---
 src/librustdoc/doctest.rs      | 1 +
 src/librustdoc/doctest/make.rs | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 446fc83f9f244..000683d069359 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -433,6 +433,7 @@ fn wrapped_rustc_command(rustc_wrappers: &[PathBuf], rustc_binary: &Path) -> Com
     command
 }
 
+/// This struct contains information needed for running a doctest.
 struct RunnableDoctest {
     full_test_code: String,
     full_test_line_offset: usize,
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index f7334c1815e73..5d248586739de 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -17,6 +17,8 @@ use rustc_span::FileName;
 
 use super::GlobalTestOptions;
 
+/// This struct contains information about the doctest itself which is then used to generate
+/// doctest source code appropriately.
 pub(crate) struct DocTest {
     pub(crate) supports_color: bool,
     pub(crate) already_has_extern_crate: bool,

From d512438435aa1ee1731e2d5a45d01b6f14493e15 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 20 Jun 2024 15:55:18 +0200
Subject: [PATCH 221/685] Run mergeable doctest as part of standalone doctests
 if there is only one

---
 src/librustdoc/doctest.rs                     | 77 ++++++++++---------
 tests/rustdoc-ui/2024-doctests-checks.rs      |  2 +-
 .../failed-doctest-should-panic.stdout        |  4 +-
 .../rustdoc-ui/doctest/wrong-ast-2024.stdout  | 11 +--
 tests/rustdoc-ui/run-as-standalone.rs         | 17 ++++
 tests/rustdoc-ui/run-as-standalone.stdout     |  7 ++
 6 files changed, 70 insertions(+), 48 deletions(-)
 create mode 100644 tests/rustdoc-ui/run-as-standalone.rs
 create mode 100644 tests/rustdoc-ui/run-as-standalone.stdout

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 000683d069359..d0e08d07e2409 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -267,50 +267,53 @@ pub(crate) fn run_tests(
         if doctests.is_empty() {
             continue;
         }
-        doctests.sort_by(|(_, a), (_, b)| a.name.cmp(&b.name));
+        // If there is only one mergeable doctest, the cost to run it would be higher than just
+        // running it alonside standalone doctests.
+        if doctests.len() > 1 {
+            doctests.sort_by(|(_, a), (_, b)| a.name.cmp(&b.name));
 
-        let mut tests_runner = runner::DocTestRunner::new();
+            let mut tests_runner = runner::DocTestRunner::new();
 
-        let rustdoc_test_options = IndividualTestOptions::new(
-            &rustdoc_options,
-            &Some(format!("merged_doctest_{edition}")),
-            PathBuf::from(format!("doctest_{edition}.rs")),
-        );
+            let rustdoc_test_options = IndividualTestOptions::new(
+                &rustdoc_options,
+                &Some(format!("merged_doctest_{edition}")),
+                PathBuf::from(format!("doctest_{edition}.rs")),
+            );
 
-        for (doctest, scraped_test) in &doctests {
-            tests_runner.add_test(doctest, scraped_test, &target_str);
-        }
-        if let Ok(success) = tests_runner.run_merged_tests(
-            rustdoc_test_options,
-            edition,
-            &opts,
-            &test_args,
-            rustdoc_options,
-        ) {
-            ran_edition_tests += 1;
-            if !success {
-                nb_errors += 1;
+            for (doctest, scraped_test) in &doctests {
+                tests_runner.add_test(doctest, scraped_test, &target_str);
+            }
+            if let Ok(success) = tests_runner.run_merged_tests(
+                rustdoc_test_options,
+                edition,
+                &opts,
+                &test_args,
+                rustdoc_options,
+            ) {
+                ran_edition_tests += 1;
+                if !success {
+                    nb_errors += 1;
+                }
+                continue;
             }
-            continue;
-        } else {
             // We failed to compile all compatible tests as one so we push them into the
             // `standalone_tests` doctests.
             debug!("Failed to compile compatible doctests for edition {} all at once", edition);
-            for (doctest, scraped_test) in doctests {
-                doctest.generate_unique_doctest(
-                    &scraped_test.text,
-                    scraped_test.langstr.test_harness,
-                    &opts,
-                    Some(&opts.crate_name),
-                );
-                standalone_tests.push(generate_test_desc_and_fn(
-                    doctest,
-                    scraped_test,
-                    opts.clone(),
-                    Arc::clone(&rustdoc_options),
-                    unused_extern_reports.clone(),
-                ));
-            }
+        }
+        for (doctest, scraped_test) in doctests {
+            doctest.generate_unique_doctest(
+                &scraped_test.text,
+                scraped_test.langstr.test_harness,
+                &opts,
+                Some(&opts.crate_name),
+            );
+            standalone_tests.push(generate_test_desc_and_fn(
+                doctest,
+                scraped_test,
+                opts.clone(),
+                Arc::clone(&rustdoc_options),
+                unused_extern_reports.clone(),
+            ));
         }
     }
 
diff --git a/tests/rustdoc-ui/2024-doctests-checks.rs b/tests/rustdoc-ui/2024-doctests-checks.rs
index 6f62c0f73ad81..f6b6faa8c6a2c 100644
--- a/tests/rustdoc-ui/2024-doctests-checks.rs
+++ b/tests/rustdoc-ui/2024-doctests-checks.rs
@@ -2,7 +2,7 @@
 //@ compile-flags: --test --test-args=--test-threads=1 -Zunstable-options --edition 2024
 //@ normalize-stdout-test: "tests/rustdoc-ui" -> "$$DIR"
 //@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test "wrong-ast.rs:\d+:\d+" -> "wrong-ast.rs:$$LINE:$$COL"
+//@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 
 /// This one should fail: crate attributes should remain crate attributes
 /// in standalone doctests.
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
index cb3456e087ebe..57a20092a5d6c 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
@@ -1,11 +1,11 @@
 
 running 1 test
-test $DIR/failed-doctest-should-panic.rs - Foo (line 9) - should panic ... FAILED
+test $DIR/failed-doctest-should-panic.rs - Foo (line 9) ... FAILED
 
 failures:
 
 ---- $DIR/failed-doctest-should-panic.rs - Foo (line 9) stdout ----
-note: test did not panic as expected
+Test executable succeeded, but it's marked `should_panic`.
 
 failures:
     $DIR/failed-doctest-should-panic.rs - Foo (line 9)
diff --git a/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout b/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
index 22c8ce468fd7c..08ec69199d390 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
+++ b/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
@@ -1,12 +1,7 @@
 
-running 1 test
-test $DIR/wrong-ast-2024.rs - three (line 17) - should panic ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
-
-
-running 2 tests
+running 3 tests
 test $DIR/wrong-ast-2024.rs - one (line 7) ... FAILED
+test $DIR/wrong-ast-2024.rs - three (line 17) ... ok
 test $DIR/wrong-ast-2024.rs - two (line 12) ... FAILED
 
 failures:
@@ -37,5 +32,5 @@ failures:
     $DIR/wrong-ast-2024.rs - one (line 7)
     $DIR/wrong-ast-2024.rs - two (line 12)
 
-test result: FAILED. 0 passed; 2 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+test result: FAILED. 1 passed; 2 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
 
diff --git a/tests/rustdoc-ui/run-as-standalone.rs b/tests/rustdoc-ui/run-as-standalone.rs
new file mode 100644
index 0000000000000..a0fb0340f8dfb
--- /dev/null
+++ b/tests/rustdoc-ui/run-as-standalone.rs
@@ -0,0 +1,17 @@
+// This test ensures that if there is only one mergeable doctest, then it is
+// instead run as part of standalone doctests.
+
+//@ compile-flags:--test --test-args=--test-threads=1 -Zunstable-options --edition 2024
+//@ normalize-stdout-test: "tests/rustdoc-ui" -> "$$DIR"
+//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+//@ check-pass
+
+/// ```
+/// let x = 12;
+/// ```
+///
+/// ```compile_fail
+/// let y = x;
+/// ```
+pub fn one() {}
diff --git a/tests/rustdoc-ui/run-as-standalone.stdout b/tests/rustdoc-ui/run-as-standalone.stdout
new file mode 100644
index 0000000000000..ec66f6753b10a
--- /dev/null
+++ b/tests/rustdoc-ui/run-as-standalone.stdout
@@ -0,0 +1,7 @@
+
+running 2 tests
+test $DIR/run-as-standalone.rs - one (line 10) ... ok
+test $DIR/run-as-standalone.rs - one (line 14) - compile fail ... ok
+
+test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+

From 1e1743a379885209ed969695d56762d38a9da09c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 20 Jun 2024 16:39:52 +0200
Subject: [PATCH 222/685] Reduce merged doctest source code size

---
 library/test/src/types.rs        | 34 ++++++++++++++++++++++++++++++++
 src/librustdoc/doctest/runner.rs | 32 +++++++-----------------------
 2 files changed, 41 insertions(+), 25 deletions(-)

diff --git a/library/test/src/types.rs b/library/test/src/types.rs
index c3be3466cb928..802cab989c6a9 100644
--- a/library/test/src/types.rs
+++ b/library/test/src/types.rs
@@ -250,3 +250,37 @@ pub struct TestDescAndFn {
     pub desc: TestDesc,
     pub testfn: TestFn,
 }
+
+impl TestDescAndFn {
+    pub const fn new_doctest(
+        test_name: &'static str,
+        ignore: bool,
+        source_file: &'static str,
+        start_line: usize,
+        no_run: bool,
+        should_panic: bool,
+        testfn: TestFn,
+    ) -> Self {
+        Self {
+            desc: TestDesc {
+                name: StaticTestName(test_name),
+                ignore,
+                ignore_message: None,
+                source_file,
+                start_line,
+                start_col: 0,
+                end_line: 0,
+                end_col: 0,
+                compile_fail: false,
+                no_run,
+                should_panic: if should_panic {
+                    options::ShouldPanic::Yes
+                } else {
+                    options::ShouldPanic::No
+                },
+                test_type: TestType::DocTest,
+            },
+            testfn,
+        }
+    }
+}
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index 72ebe33bd0b5e..55673fd562e32 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -235,36 +235,18 @@ fn main() {returns_result} {{
         output,
         "
 #[rustc_test_marker = {test_name:?}]
-pub const TEST: test::TestDescAndFn = test::TestDescAndFn {{
-    desc: test::TestDesc {{
-        name: test::StaticTestName({test_name:?}),
-        ignore: {ignore},
-        ignore_message: None,
-        source_file: {file:?},
-        start_line: {line},
-        start_col: 0,
-        end_line: 0,
-        end_col: 0,
-        compile_fail: false,
-        no_run: {no_run},
-        should_panic: test::ShouldPanic::{should_panic},
-        test_type: test::TestType::DocTest,
-    }},
-    testfn: test::StaticTestFn(
-        #[coverage(off)]
-        || {{{runner}}},
-    )
-}};
+pub const TEST: test::TestDescAndFn = test::TestDescAndFn::new_doctest(
+{test_name:?}, {ignore}, {file:?}, {line}, {no_run}, {should_panic},
+test::StaticTestFn(
+    #[coverage(off)]
+    || {{{runner}}},
+));
 }}",
         test_name = scraped_test.name,
         file = scraped_test.path(),
         line = scraped_test.line,
         no_run = scraped_test.langstr.no_run,
-        should_panic = if !scraped_test.langstr.no_run && scraped_test.langstr.should_panic {
-            "Yes"
-        } else {
-            "No"
-        },
+        should_panic = !scraped_test.langstr.no_run && scraped_test.langstr.should_panic,
         // Setting `no_run` to `true` in `TestDesc` still makes the test run, so we simply
         // don't give it the function to run.
         runner = if not_running {

From ffc18c5cfb4deeb7d04544fcb3561a952d95db1f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sun, 23 Jun 2024 14:33:13 +0200
Subject: [PATCH 223/685] Rename `DocTest` into `DocTestBuilder`

---
 src/librustdoc/doctest.rs        | 14 +++++++-------
 src/librustdoc/doctest/make.rs   |  4 ++--
 src/librustdoc/doctest/runner.rs |  8 ++++----
 src/librustdoc/doctest/tests.rs  | 11 ++++++++---
 src/librustdoc/html/markdown.rs  |  2 +-
 5 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index d0e08d07e2409..f0a13c9923090 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -11,7 +11,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::{Arc, Mutex};
 use std::{panic, str};
 
-pub(crate) use make::DocTest;
+pub(crate) use make::DocTestBuilder;
 pub(crate) use markdown::test as test_markdown;
 use rustc_ast as ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -250,7 +250,7 @@ pub(crate) fn run_tests(
     rustdoc_options: &Arc<RustdocOptions>,
     unused_extern_reports: &Arc<Mutex<Vec<UnusedExterns>>>,
     mut standalone_tests: Vec<test::TestDescAndFn>,
-    mergeable_tests: FxHashMap<Edition, Vec<(DocTest, ScrapedDoctest)>>,
+    mergeable_tests: FxHashMap<Edition, Vec<(DocTestBuilder, ScrapedDoctest)>>,
 ) {
     let mut test_args = Vec::with_capacity(rustdoc_options.test_args.len() + 1);
     test_args.insert(0, "rustdoctest".to_string());
@@ -754,7 +754,7 @@ pub(crate) trait DoctestVisitor {
 
 struct CreateRunnableDoctests {
     standalone_tests: Vec<test::TestDescAndFn>,
-    mergeable_tests: FxHashMap<Edition, Vec<(DocTest, ScrapedDoctest)>>,
+    mergeable_tests: FxHashMap<Edition, Vec<(DocTestBuilder, ScrapedDoctest)>>,
 
     rustdoc_options: Arc<RustdocOptions>,
     opts: GlobalTestOptions,
@@ -803,7 +803,7 @@ impl CreateRunnableDoctests {
         );
 
         let edition = scraped_test.edition(&self.rustdoc_options);
-        let doctest = DocTest::new(
+        let doctest = DocTestBuilder::new(
             &scraped_test.text,
             Some(&self.opts.crate_name),
             edition,
@@ -827,7 +827,7 @@ impl CreateRunnableDoctests {
 
     fn generate_test_desc_and_fn(
         &mut self,
-        test: DocTest,
+        test: DocTestBuilder,
         scraped_test: ScrapedDoctest,
     ) -> test::TestDescAndFn {
         if !scraped_test.langstr.compile_fail {
@@ -845,7 +845,7 @@ impl CreateRunnableDoctests {
 }
 
 fn generate_test_desc_and_fn(
-    test: DocTest,
+    test: DocTestBuilder,
     scraped_test: ScrapedDoctest,
     opts: GlobalTestOptions,
     rustdoc_options: Arc<RustdocOptions>,
@@ -892,7 +892,7 @@ fn generate_test_desc_and_fn(
 fn doctest_run_fn(
     test_opts: IndividualTestOptions,
     global_opts: GlobalTestOptions,
-    doctest: DocTest,
+    doctest: DocTestBuilder,
     scraped_test: ScrapedDoctest,
     rustdoc_options: Arc<RustdocOptions>,
     unused_externs: Arc<Mutex<Vec<UnusedExterns>>>,
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 5d248586739de..ed09fa8e88ebd 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -19,7 +19,7 @@ use super::GlobalTestOptions;
 
 /// This struct contains information about the doctest itself which is then used to generate
 /// doctest source code appropriately.
-pub(crate) struct DocTest {
+pub(crate) struct DocTestBuilder {
     pub(crate) supports_color: bool,
     pub(crate) already_has_extern_crate: bool,
     pub(crate) has_main_fn: bool,
@@ -34,7 +34,7 @@ pub(crate) struct DocTest {
     pub(crate) can_be_merged: bool,
 }
 
-impl DocTest {
+impl DocTestBuilder {
     pub(crate) fn new(
         source: &str,
         crate_name: Option<&str>,
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index 55673fd562e32..5c0a7bcaef9d2 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -4,8 +4,8 @@ use rustc_span::edition::Edition;
 use std::fmt::Write;
 
 use crate::doctest::{
-    run_test, DocTest, GlobalTestOptions, IndividualTestOptions, RunnableDoctest, RustdocOptions,
-    ScrapedDoctest, TestFailure, UnusedExterns,
+    run_test, DocTestBuilder, GlobalTestOptions, IndividualTestOptions, RunnableDoctest,
+    RustdocOptions, ScrapedDoctest, TestFailure, UnusedExterns,
 };
 use crate::html::markdown::{Ignore, LangString};
 
@@ -31,7 +31,7 @@ impl DocTestRunner {
 
     pub(crate) fn add_test(
         &mut self,
-        doctest: &DocTest,
+        doctest: &DocTestBuilder,
         scraped_test: &ScrapedDoctest,
         target_str: &str,
     ) {
@@ -193,7 +193,7 @@ std::process::Termination::report(test::test_main(test_args, Vec::from(TESTS), N
 
 /// Push new doctest content into `output`. Returns the test ID for this doctest.
 fn generate_mergeable_doctest(
-    doctest: &DocTest,
+    doctest: &DocTestBuilder,
     scraped_test: &ScrapedDoctest,
     ignore: bool,
     id: usize,
diff --git a/src/librustdoc/doctest/tests.rs b/src/librustdoc/doctest/tests.rs
index 982bfae588376..8c4079bcd8143 100644
--- a/src/librustdoc/doctest/tests.rs
+++ b/src/librustdoc/doctest/tests.rs
@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use super::{DocTest, GlobalTestOptions};
+use super::{DocTestBuilder, GlobalTestOptions};
 use rustc_span::edition::DEFAULT_EDITION;
 
 fn make_test(
@@ -10,8 +10,13 @@ fn make_test(
     opts: &GlobalTestOptions,
     test_id: Option<&str>,
 ) -> (String, usize) {
-    let doctest =
-        DocTest::new(test_code, crate_name, DEFAULT_EDITION, false, test_id.map(|s| s.to_string()));
+    let doctest = DocTestBuilder::new(
+        test_code,
+        crate_name,
+        DEFAULT_EDITION,
+        false,
+        test_id.map(|s| s.to_string()),
+    );
     let (code, line_offset) =
         doctest.generate_unique_doctest(test_code, dont_insert_main, opts, crate_name);
     (code, line_offset)
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index 879e44c171223..971337dda1e8f 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -297,7 +297,7 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
                 attrs: vec![],
                 args_file: PathBuf::new(),
             };
-            let doctest = doctest::DocTest::new(&test, krate, edition, false, None);
+            let doctest = doctest::DocTestBuilder::new(&test, krate, edition, false, None);
             let (test, _) = doctest.generate_unique_doctest(&test, false, &opts, krate);
             let channel = if test.contains("#![feature(") { "&amp;version=nightly" } else { "" };
 

From 0fbc32ce42ac842a98771b1c11c3f358f43d7814 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sun, 23 Jun 2024 14:56:27 +0200
Subject: [PATCH 224/685] If there are crate attributes, we prevent doctest to
 be merged with others

---
 src/librustdoc/doctest/make.rs | 31 ++++---------------------------
 1 file changed, 4 insertions(+), 27 deletions(-)

diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index ed09fa8e88ebd..848f447d4a842 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -43,14 +43,8 @@ impl DocTestBuilder {
         // If `test_id` is `None`, it means we're generating code for a code example "run" link.
         test_id: Option<String>,
     ) -> Self {
-        let SourceInfo {
-            crate_attrs,
-            maybe_crate_attrs,
-            crates,
-            everything_else,
-            has_features,
-            has_no_std,
-        } = partition_source(source, edition);
+        let SourceInfo { crate_attrs, maybe_crate_attrs, crates, everything_else } =
+            partition_source(source, edition);
 
         // Uses librustc_ast to parse the doctest and find if there's a main fn and the extern
         // crate already is included.
@@ -92,9 +86,8 @@ impl DocTestBuilder {
         // others. Same if it contains `#[feature]` or `#[no_std]`.
         let can_be_merged = can_merge_doctests
             && !failed_ast
-            && !has_no_std
-            && !has_features
             && !has_global_allocator
+            && crate_attrs.is_empty()
             // If this is a merged doctest and a defined macro uses `$crate`, then the path will
             // not work, so better not put it into merged doctests.
             && !(has_macro_def && everything_else.contains("$crate"));
@@ -427,8 +420,6 @@ fn check_for_main_and_extern_crate(
 enum AttrKind {
     CrateAttr,
     Attr,
-    Feature,
-    NoStd,
 }
 
 /// Returns `Some` if the attribute is complete and `Some(true)` if it is an attribute that can be
@@ -473,11 +464,7 @@ fn check_if_attr_is_complete(source: &str, edition: Edition) -> Option<AttrKind>
                 Ok(attr) => {
                     let attr_name = attr.name_or_empty();
 
-                    if attr_name == sym::feature {
-                        Some(AttrKind::Feature)
-                    } else if attr_name == sym::no_std {
-                        Some(AttrKind::NoStd)
-                    } else if not_crate_attrs.contains(&attr_name) {
+                    if not_crate_attrs.contains(&attr_name) {
                         // There is one exception to these attributes:
                         // `#![allow(internal_features)]`. If this attribute is used, we need to
                         // consider it only as a crate-level attribute.
@@ -511,14 +498,6 @@ fn handle_attr(mod_attr_pending: &mut String, source_info: &mut SourceInfo, edit
         let push_to = match attr_kind {
             AttrKind::CrateAttr => &mut source_info.crate_attrs,
             AttrKind::Attr => &mut source_info.maybe_crate_attrs,
-            AttrKind::Feature => {
-                source_info.has_features = true;
-                &mut source_info.crate_attrs
-            }
-            AttrKind::NoStd => {
-                source_info.has_no_std = true;
-                &mut source_info.crate_attrs
-            }
         };
         push_to.push_str(mod_attr_pending);
         push_to.push('\n');
@@ -535,8 +514,6 @@ struct SourceInfo {
     maybe_crate_attrs: String,
     crates: String,
     everything_else: String,
-    has_features: bool,
-    has_no_std: bool,
 }
 
 fn partition_source(s: &str, edition: Edition) -> SourceInfo {

From a3bc2c74786631846554915c7e1295ee48f5be85 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 24 Jun 2024 13:26:02 +0200
Subject: [PATCH 225/685] Improve code readability

---
 src/librustdoc/doctest.rs       | 13 +++++++++----
 src/librustdoc/doctest/make.rs  |  8 ++++++++
 src/librustdoc/doctest/tests.rs |  1 +
 src/librustdoc/html/markdown.rs |  2 +-
 4 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index f0a13c9923090..812e129865572 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -448,6 +448,12 @@ struct RunnableDoctest {
     no_run: bool,
 }
 
+impl RunnableDoctest {
+    fn path_for_merged_doctest(&self) -> PathBuf {
+        self.test_opts.outdir.path().join(&format!("doctest_{}.rs", self.edition))
+    }
+}
+
 fn run_test(
     doctest: RunnableDoctest,
     rustdoc_options: &RustdocOptions,
@@ -528,8 +534,7 @@ fn run_test(
     if is_multiple_tests {
         // It makes the compilation failure much faster if it is for a combined doctest.
         compiler.arg("--error-format=short");
-        let input_file =
-            doctest.test_opts.outdir.path().join(&format!("doctest_{}.rs", doctest.edition));
+        let input_file = doctest.path_for_merged_doctest();
         if std::fs::write(&input_file, &doctest.full_test_code).is_err() {
             // If we cannot write this file for any reason, we leave. All combined tests will be
             // tested as standalone tests.
@@ -809,9 +814,9 @@ impl CreateRunnableDoctests {
             edition,
             self.can_merge_doctests,
             Some(test_id),
+            Some(&scraped_test.langstr),
         );
-        let is_standalone = !self.can_merge_doctests
-            || !doctest.can_be_merged
+        let is_standalone = !doctest.can_be_merged
             || scraped_test.langstr.compile_fail
             || scraped_test.langstr.test_harness
             || scraped_test.langstr.standalone
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 848f447d4a842..1e8e403985bc8 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -1,6 +1,8 @@
 //! Logic for transforming the raw code given by the user into something actually
 //! runnable, e.g. by adding a `main` function if it doesn't already exist.
 
+use crate::html::markdown::LangString;
+
 use std::io;
 
 use rustc_ast as ast;
@@ -42,7 +44,13 @@ impl DocTestBuilder {
         can_merge_doctests: bool,
         // If `test_id` is `None`, it means we're generating code for a code example "run" link.
         test_id: Option<String>,
+        lang_str: Option<&LangString>,
     ) -> Self {
+        let can_merge_doctests = can_merge_doctests
+            && lang_str.is_some_and(|lang_str| {
+                !lang_str.compile_fail && !lang_str.test_harness && !lang_str.standalone
+            });
+
         let SourceInfo { crate_attrs, maybe_crate_attrs, crates, everything_else } =
             partition_source(source, edition);
 
diff --git a/src/librustdoc/doctest/tests.rs b/src/librustdoc/doctest/tests.rs
index 8c4079bcd8143..b076b6dccf5c7 100644
--- a/src/librustdoc/doctest/tests.rs
+++ b/src/librustdoc/doctest/tests.rs
@@ -16,6 +16,7 @@ fn make_test(
         DEFAULT_EDITION,
         false,
         test_id.map(|s| s.to_string()),
+        None,
     );
     let (code, line_offset) =
         doctest.generate_unique_doctest(test_code, dont_insert_main, opts, crate_name);
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index 971337dda1e8f..bc30f7fa43b2b 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -297,7 +297,7 @@ impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
                 attrs: vec![],
                 args_file: PathBuf::new(),
             };
-            let doctest = doctest::DocTestBuilder::new(&test, krate, edition, false, None);
+            let doctest = doctest::DocTestBuilder::new(&test, krate, edition, false, None, None);
             let (test, _) = doctest.generate_unique_doctest(&test, false, &opts, krate);
             let channel = if test.contains("#![feature(") { "&amp;version=nightly" } else { "" };
 

From 72aeffa78cccc8f368d6e8ad8027894e0b152f23 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 8 Jul 2024 14:40:36 +0200
Subject: [PATCH 226/685] Remove need for `unsafe` code in merged doctests

---
 src/librustdoc/doctest/runner.rs | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index 5c0a7bcaef9d2..46122bbeafd6f 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -107,13 +107,16 @@ impl DocTestRunner {
 {output}
 
 mod __doctest_mod {{
-    pub static mut BINARY_PATH: Option<std::path::PathBuf> = None;
+    use std::sync::OnceLock;
+    use std::path::PathBuf;
+
+    pub static BINARY_PATH: OnceLock<PathBuf> = OnceLock::new();
     pub const RUN_OPTION: &str = \"*doctest-inner-test\";
     pub const BIN_OPTION: &str = \"*doctest-bin-path\";
 
     #[allow(unused)]
-    pub fn get_doctest_path() -> Option<&'static std::path::Path> {{
-        unsafe {{ self::BINARY_PATH.as_deref() }}
+    pub fn doctest_path() -> Option<&'static PathBuf> {{
+        self::BINARY_PATH.get()
     }}
 
     #[allow(unused)]
@@ -145,7 +148,9 @@ while let Some(arg) = args.next() {{
         let Some(binary) = args.next() else {{
             panic!(\"missing argument after `{{}}`\", __doctest_mod::BIN_OPTION);
         }};
-        unsafe {{ crate::__doctest_mod::BINARY_PATH = Some(binary.into()); }}
+        if crate::__doctest_mod::BINARY_PATH.set(binary.into()).is_err() {{
+            panic!(\"`{{}}` option was used more than once\", bin_marker.to_string_lossy());
+        }}
         return std::process::Termination::report(test::test_main(test_args, Vec::from(TESTS), None));
     }} else if arg == test_marker {{
         let Some(nb_test) = args.next() else {{
@@ -254,7 +259,7 @@ test::StaticTestFn(
         } else {
             format!(
                 "
-if let Some(bin_path) = crate::__doctest_mod::get_doctest_path() {{
+if let Some(bin_path) = crate::__doctest_mod::doctest_path() {{
     test::assert_test_result(crate::__doctest_mod::doctest_runner(bin_path, {id}))
 }} else {{
     test::assert_test_result(self::main())

From 4b1db071d13a2c27ac1fb33158bcab93b56fb761 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 8 Jul 2024 15:01:17 +0200
Subject: [PATCH 227/685] Don't special-case if there is only one merged
 doctest

---
 src/librustdoc/doctest.rs                     | 52 +++++++++----------
 .../failed-doctest-should-panic.stdout        |  4 +-
 .../rustdoc-ui/doctest/wrong-ast-2024.stdout  | 11 ++--
 tests/rustdoc-ui/doctest/wrong-ast.rs         |  1 -
 tests/rustdoc-ui/doctest/wrong-ast.stdout     | 18 +++----
 tests/rustdoc-ui/run-as-standalone.rs         | 17 ------
 tests/rustdoc-ui/run-as-standalone.stdout     |  7 ---
 7 files changed, 43 insertions(+), 67 deletions(-)
 delete mode 100644 tests/rustdoc-ui/run-as-standalone.rs
 delete mode 100644 tests/rustdoc-ui/run-as-standalone.stdout

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 812e129865572..24e5e8761126b 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -267,39 +267,35 @@ pub(crate) fn run_tests(
         if doctests.is_empty() {
             continue;
         }
-        // If there is only one mergeable doctest, the cost to run it would be higher than just
-        // running it alonside standalone doctests.
-        if doctests.len() > 1 {
-            doctests.sort_by(|(_, a), (_, b)| a.name.cmp(&b.name));
+        doctests.sort_by(|(_, a), (_, b)| a.name.cmp(&b.name));
 
-            let mut tests_runner = runner::DocTestRunner::new();
+        let mut tests_runner = runner::DocTestRunner::new();
 
-            let rustdoc_test_options = IndividualTestOptions::new(
-                &rustdoc_options,
-                &Some(format!("merged_doctest_{edition}")),
-                PathBuf::from(format!("doctest_{edition}.rs")),
-            );
+        let rustdoc_test_options = IndividualTestOptions::new(
+            &rustdoc_options,
+            &Some(format!("merged_doctest_{edition}")),
+            PathBuf::from(format!("doctest_{edition}.rs")),
+        );
 
-            for (doctest, scraped_test) in &doctests {
-                tests_runner.add_test(doctest, scraped_test, &target_str);
-            }
-            if let Ok(success) = tests_runner.run_merged_tests(
-                rustdoc_test_options,
-                edition,
-                &opts,
-                &test_args,
-                rustdoc_options,
-            ) {
-                ran_edition_tests += 1;
-                if !success {
-                    nb_errors += 1;
-                }
-                continue;
+        for (doctest, scraped_test) in &doctests {
+            tests_runner.add_test(doctest, scraped_test, &target_str);
+        }
+        if let Ok(success) = tests_runner.run_merged_tests(
+            rustdoc_test_options,
+            edition,
+            &opts,
+            &test_args,
+            rustdoc_options,
+        ) {
+            ran_edition_tests += 1;
+            if !success {
+                nb_errors += 1;
             }
-            // We failed to compile all compatible tests as one so we push them into the
-            // `standalone_tests` doctests.
-            debug!("Failed to compile compatible doctests for edition {} all at once", edition);
+            continue;
         }
+        // We failed to compile all compatible tests as one so we push them into the
+        // `standalone_tests` doctests.
+        debug!("Failed to compile compatible doctests for edition {} all at once", edition);
         for (doctest, scraped_test) in doctests {
             doctest.generate_unique_doctest(
                 &scraped_test.text,
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
index 57a20092a5d6c..cb3456e087ebe 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
+++ b/tests/rustdoc-ui/doctest/failed-doctest-should-panic.stdout
@@ -1,11 +1,11 @@
 
 running 1 test
-test $DIR/failed-doctest-should-panic.rs - Foo (line 9) ... FAILED
+test $DIR/failed-doctest-should-panic.rs - Foo (line 9) - should panic ... FAILED
 
 failures:
 
 ---- $DIR/failed-doctest-should-panic.rs - Foo (line 9) stdout ----
-Test executable succeeded, but it's marked `should_panic`.
+note: test did not panic as expected
 
 failures:
     $DIR/failed-doctest-should-panic.rs - Foo (line 9)
diff --git a/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout b/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
index 08ec69199d390..22c8ce468fd7c 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
+++ b/tests/rustdoc-ui/doctest/wrong-ast-2024.stdout
@@ -1,7 +1,12 @@
 
-running 3 tests
+running 1 test
+test $DIR/wrong-ast-2024.rs - three (line 17) - should panic ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
+
+running 2 tests
 test $DIR/wrong-ast-2024.rs - one (line 7) ... FAILED
-test $DIR/wrong-ast-2024.rs - three (line 17) ... ok
 test $DIR/wrong-ast-2024.rs - two (line 12) ... FAILED
 
 failures:
@@ -32,5 +37,5 @@ failures:
     $DIR/wrong-ast-2024.rs - one (line 7)
     $DIR/wrong-ast-2024.rs - two (line 12)
 
-test result: FAILED. 1 passed; 2 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+test result: FAILED. 0 passed; 2 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
 
diff --git a/tests/rustdoc-ui/doctest/wrong-ast.rs b/tests/rustdoc-ui/doctest/wrong-ast.rs
index dae86fbfc59a1..e8faaea97ee20 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast.rs
+++ b/tests/rustdoc-ui/doctest/wrong-ast.rs
@@ -1,7 +1,6 @@
 //@ compile-flags:--test --test-args=--test-threads=1
 //@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
 //@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 //@ failure-status: 101
 
 /// ```
diff --git a/tests/rustdoc-ui/doctest/wrong-ast.stdout b/tests/rustdoc-ui/doctest/wrong-ast.stdout
index c827254d8c0f5..15494706c1643 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast.stdout
+++ b/tests/rustdoc-ui/doctest/wrong-ast.stdout
@@ -1,14 +1,14 @@
 
 running 3 tests
-test $DIR/wrong-ast.rs - one (line 7) ... FAILED
-test $DIR/wrong-ast.rs - three (line 17) ... ok
-test $DIR/wrong-ast.rs - two (line 12) ... FAILED
+test $DIR/wrong-ast.rs - one (line 6) ... FAILED
+test $DIR/wrong-ast.rs - three (line 16) ... ok
+test $DIR/wrong-ast.rs - two (line 11) ... FAILED
 
 failures:
 
----- $DIR/wrong-ast.rs - one (line 7) stdout ----
+---- $DIR/wrong-ast.rs - one (line 6) stdout ----
 error[E0758]: unterminated block comment
-  --> $DIR/wrong-ast.rs:$LINE:$COL
+  --> $DIR/wrong-ast.rs:7:1
    |
 LL | /* plop
    | ^^^^^^^
@@ -17,9 +17,9 @@ error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0758`.
 Couldn't compile the test.
----- $DIR/wrong-ast.rs - two (line 12) stdout ----
+---- $DIR/wrong-ast.rs - two (line 11) stdout ----
 error: unexpected closing delimiter: `}`
-  --> $DIR/wrong-ast.rs:$LINE:$COL
+  --> $DIR/wrong-ast.rs:12:1
    |
 LL | } mod __doctest_1 { fn main() {
    | ^ unexpected closing delimiter
@@ -29,8 +29,8 @@ error: aborting due to 1 previous error
 Couldn't compile the test.
 
 failures:
-    $DIR/wrong-ast.rs - one (line 7)
-    $DIR/wrong-ast.rs - two (line 12)
+    $DIR/wrong-ast.rs - one (line 6)
+    $DIR/wrong-ast.rs - two (line 11)
 
 test result: FAILED. 1 passed; 2 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
 
diff --git a/tests/rustdoc-ui/run-as-standalone.rs b/tests/rustdoc-ui/run-as-standalone.rs
deleted file mode 100644
index a0fb0340f8dfb..0000000000000
--- a/tests/rustdoc-ui/run-as-standalone.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// This test ensures that if there is only one mergeable doctest, then it is
-// instead run as part of standalone doctests.
-
-//@ compile-flags:--test --test-args=--test-threads=1 -Zunstable-options --edition 2024
-//@ normalize-stdout-test: "tests/rustdoc-ui" -> "$$DIR"
-//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
-//@ check-pass
-
-/// ```
-/// let x = 12;
-/// ```
-///
-/// ```compile_fail
-/// let y = x;
-/// ```
-pub fn one() {}
diff --git a/tests/rustdoc-ui/run-as-standalone.stdout b/tests/rustdoc-ui/run-as-standalone.stdout
deleted file mode 100644
index ec66f6753b10a..0000000000000
--- a/tests/rustdoc-ui/run-as-standalone.stdout
+++ /dev/null
@@ -1,7 +0,0 @@
-
-running 2 tests
-test $DIR/run-as-standalone.rs - one (line 10) ... ok
-test $DIR/run-as-standalone.rs - one (line 14) - compile fail ... ok
-
-test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
-

From ab3d90e037a3f37e6130b1aec0aca89f2e0de90b Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 9 Jul 2024 12:07:18 +0200
Subject: [PATCH 228/685] Unify naming of `DocTest`

---
 src/librustdoc/doctest.rs                     | 47 ++++++++++---------
 src/librustdoc/doctest/markdown.rs            | 12 ++---
 src/librustdoc/doctest/runner.rs              | 10 ++--
 src/librustdoc/doctest/rust.rs                | 13 +++--
 src/librustdoc/html/markdown.rs               |  4 +-
 .../passes/check_doc_test_visibility.rs       |  2 +-
 6 files changed, 46 insertions(+), 42 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 24e5e8761126b..91b93a9990323 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -163,7 +163,7 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<()
     let args_path = temp_dir.path().join("rustdoc-cfgs");
     crate::wrap_return(dcx, generate_args_file(&args_path, &options))?;
 
-    let CreateRunnableDoctests {
+    let CreateRunnableDocTests {
         standalone_tests,
         mergeable_tests,
         rustdoc_options,
@@ -179,7 +179,7 @@ pub(crate) fn run(dcx: DiagCtxtHandle<'_>, options: RustdocOptions) -> Result<()
                 let opts = scrape_test_config(crate_name, crate_attrs, args_path);
                 let enable_per_target_ignores = options.enable_per_target_ignores;
 
-                let mut collector = CreateRunnableDoctests::new(options, opts);
+                let mut collector = CreateRunnableDocTests::new(options, opts);
                 let hir_collector = HirCollector::new(
                     &compiler.sess,
                     tcx.hir(),
@@ -250,7 +250,7 @@ pub(crate) fn run_tests(
     rustdoc_options: &Arc<RustdocOptions>,
     unused_extern_reports: &Arc<Mutex<Vec<UnusedExterns>>>,
     mut standalone_tests: Vec<test::TestDescAndFn>,
-    mergeable_tests: FxHashMap<Edition, Vec<(DocTestBuilder, ScrapedDoctest)>>,
+    mergeable_tests: FxHashMap<Edition, Vec<(DocTestBuilder, ScrapedDocTest)>>,
 ) {
     let mut test_args = Vec::with_capacity(rustdoc_options.test_args.len() + 1);
     test_args.insert(0, "rustdoctest".to_string());
@@ -432,8 +432,13 @@ fn wrapped_rustc_command(rustc_wrappers: &[PathBuf], rustc_binary: &Path) -> Com
     command
 }
 
-/// This struct contains information needed for running a doctest.
-struct RunnableDoctest {
+/// Information needed for running a bundle of doctests.
+///
+/// This data structure contains the "full" test code, including the wrappers
+/// (if multiple doctests are merged), `main` function,
+/// and everything needed to calculate the compiler's command-line arguments.
+/// The `# ` prefix on boring lines has also been stripped.
+struct RunnableDocTest {
     full_test_code: String,
     full_test_line_offset: usize,
     test_opts: IndividualTestOptions,
@@ -444,14 +449,14 @@ struct RunnableDoctest {
     no_run: bool,
 }
 
-impl RunnableDoctest {
+impl RunnableDocTest {
     fn path_for_merged_doctest(&self) -> PathBuf {
         self.test_opts.outdir.path().join(&format!("doctest_{}.rs", self.edition))
     }
 }
 
 fn run_test(
-    doctest: RunnableDoctest,
+    doctest: RunnableDocTest,
     rustdoc_options: &RustdocOptions,
     supports_color: bool,
     is_multiple_tests: bool,
@@ -700,7 +705,7 @@ impl IndividualTestOptions {
 }
 
 /// A doctest scraped from the code, ready to be turned into a runnable test.
-pub(crate) struct ScrapedDoctest {
+pub(crate) struct ScrapedDocTest {
     filename: FileName,
     line: usize,
     langstr: LangString,
@@ -708,7 +713,7 @@ pub(crate) struct ScrapedDoctest {
     name: String,
 }
 
-impl ScrapedDoctest {
+impl ScrapedDocTest {
     fn new(
         filename: FileName,
         line: usize,
@@ -748,14 +753,14 @@ impl ScrapedDoctest {
     }
 }
 
-pub(crate) trait DoctestVisitor {
+pub(crate) trait DocTestVisitor {
     fn visit_test(&mut self, test: String, config: LangString, rel_line: MdRelLine);
     fn visit_header(&mut self, _name: &str, _level: u32) {}
 }
 
-struct CreateRunnableDoctests {
+struct CreateRunnableDocTests {
     standalone_tests: Vec<test::TestDescAndFn>,
-    mergeable_tests: FxHashMap<Edition, Vec<(DocTestBuilder, ScrapedDoctest)>>,
+    mergeable_tests: FxHashMap<Edition, Vec<(DocTestBuilder, ScrapedDocTest)>>,
 
     rustdoc_options: Arc<RustdocOptions>,
     opts: GlobalTestOptions,
@@ -765,10 +770,10 @@ struct CreateRunnableDoctests {
     can_merge_doctests: bool,
 }
 
-impl CreateRunnableDoctests {
-    fn new(rustdoc_options: RustdocOptions, opts: GlobalTestOptions) -> CreateRunnableDoctests {
+impl CreateRunnableDocTests {
+    fn new(rustdoc_options: RustdocOptions, opts: GlobalTestOptions) -> CreateRunnableDocTests {
         let can_merge_doctests = rustdoc_options.edition >= Edition::Edition2024;
-        CreateRunnableDoctests {
+        CreateRunnableDocTests {
             standalone_tests: Vec::new(),
             mergeable_tests: FxHashMap::default(),
             rustdoc_options: Arc::new(rustdoc_options),
@@ -780,7 +785,7 @@ impl CreateRunnableDoctests {
         }
     }
 
-    fn add_test(&mut self, scraped_test: ScrapedDoctest) {
+    fn add_test(&mut self, scraped_test: ScrapedDocTest) {
         // For example `module/file.rs` would become `module_file_rs`
         let file = scraped_test
             .filename
@@ -829,7 +834,7 @@ impl CreateRunnableDoctests {
     fn generate_test_desc_and_fn(
         &mut self,
         test: DocTestBuilder,
-        scraped_test: ScrapedDoctest,
+        scraped_test: ScrapedDocTest,
     ) -> test::TestDescAndFn {
         if !scraped_test.langstr.compile_fail {
             self.compiling_test_count.fetch_add(1, Ordering::SeqCst);
@@ -847,7 +852,7 @@ impl CreateRunnableDoctests {
 
 fn generate_test_desc_and_fn(
     test: DocTestBuilder,
-    scraped_test: ScrapedDoctest,
+    scraped_test: ScrapedDocTest,
     opts: GlobalTestOptions,
     rustdoc_options: Arc<RustdocOptions>,
     unused_externs: Arc<Mutex<Vec<UnusedExterns>>>,
@@ -894,7 +899,7 @@ fn doctest_run_fn(
     test_opts: IndividualTestOptions,
     global_opts: GlobalTestOptions,
     doctest: DocTestBuilder,
-    scraped_test: ScrapedDoctest,
+    scraped_test: ScrapedDocTest,
     rustdoc_options: Arc<RustdocOptions>,
     unused_externs: Arc<Mutex<Vec<UnusedExterns>>>,
 ) -> Result<(), String> {
@@ -907,7 +912,7 @@ fn doctest_run_fn(
         &global_opts,
         Some(&global_opts.crate_name),
     );
-    let runnable_test = RunnableDoctest {
+    let runnable_test = RunnableDocTest {
         full_test_code,
         full_test_line_offset,
         test_opts,
@@ -980,7 +985,7 @@ fn doctest_run_fn(
 }
 
 #[cfg(test)] // used in tests
-impl DoctestVisitor for Vec<usize> {
+impl DocTestVisitor for Vec<usize> {
     fn visit_test(&mut self, _test: String, _config: LangString, rel_line: MdRelLine) {
         self.push(1 + rel_line.offset());
     }
diff --git a/src/librustdoc/doctest/markdown.rs b/src/librustdoc/doctest/markdown.rs
index 5c9fd1e949c90..4806d86558997 100644
--- a/src/librustdoc/doctest/markdown.rs
+++ b/src/librustdoc/doctest/markdown.rs
@@ -7,23 +7,23 @@ use rustc_span::FileName;
 use tempfile::tempdir;
 
 use super::{
-    generate_args_file, CreateRunnableDoctests, DoctestVisitor, GlobalTestOptions, ScrapedDoctest,
+    generate_args_file, CreateRunnableDocTests, DocTestVisitor, GlobalTestOptions, ScrapedDocTest,
 };
 use crate::config::Options;
 use crate::html::markdown::{find_testable_code, ErrorCodes, LangString, MdRelLine};
 
 struct MdCollector {
-    tests: Vec<ScrapedDoctest>,
+    tests: Vec<ScrapedDocTest>,
     cur_path: Vec<String>,
     filename: FileName,
 }
 
-impl DoctestVisitor for MdCollector {
+impl DocTestVisitor for MdCollector {
     fn visit_test(&mut self, test: String, config: LangString, rel_line: MdRelLine) {
         let filename = self.filename.clone();
         // First line of Markdown is line 1.
         let line = 1 + rel_line.offset();
-        self.tests.push(ScrapedDoctest::new(filename, line, self.cur_path.clone(), config, test));
+        self.tests.push(ScrapedDocTest::new(filename, line, self.cur_path.clone(), config, test));
     }
 
     fn visit_header(&mut self, name: &str, level: u32) {
@@ -113,9 +113,9 @@ pub(crate) fn test(options: Options) -> Result<(), String> {
         None,
     );
 
-    let mut collector = CreateRunnableDoctests::new(options.clone(), opts);
+    let mut collector = CreateRunnableDocTests::new(options.clone(), opts);
     md_collector.tests.into_iter().for_each(|t| collector.add_test(t));
-    let CreateRunnableDoctests { opts, rustdoc_options, standalone_tests, mergeable_tests, .. } =
+    let CreateRunnableDocTests { opts, rustdoc_options, standalone_tests, mergeable_tests, .. } =
         collector;
     crate::doctest::run_tests(
         opts,
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index 46122bbeafd6f..0d73e02cbd751 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -4,8 +4,8 @@ use rustc_span::edition::Edition;
 use std::fmt::Write;
 
 use crate::doctest::{
-    run_test, DocTestBuilder, GlobalTestOptions, IndividualTestOptions, RunnableDoctest,
-    RustdocOptions, ScrapedDoctest, TestFailure, UnusedExterns,
+    run_test, DocTestBuilder, GlobalTestOptions, IndividualTestOptions, RunnableDocTest,
+    RustdocOptions, ScrapedDocTest, TestFailure, UnusedExterns,
 };
 use crate::html::markdown::{Ignore, LangString};
 
@@ -32,7 +32,7 @@ impl DocTestRunner {
     pub(crate) fn add_test(
         &mut self,
         doctest: &DocTestBuilder,
-        scraped_test: &ScrapedDoctest,
+        scraped_test: &ScrapedDocTest,
         target_str: &str,
     ) {
         let ignore = match scraped_test.langstr.ignore {
@@ -175,7 +175,7 @@ std::process::Termination::report(test::test_main(test_args, Vec::from(TESTS), N
             ids = self.ids,
         )
         .expect("failed to generate test code");
-        let runnable_test = RunnableDoctest {
+        let runnable_test = RunnableDocTest {
             full_test_code: code,
             full_test_line_offset: 0,
             test_opts: test_options,
@@ -199,7 +199,7 @@ std::process::Termination::report(test::test_main(test_args, Vec::from(TESTS), N
 /// Push new doctest content into `output`. Returns the test ID for this doctest.
 fn generate_mergeable_doctest(
     doctest: &DocTestBuilder,
-    scraped_test: &ScrapedDoctest,
+    scraped_test: &ScrapedDocTest,
     ignore: bool,
     id: usize,
     output: &mut String,
diff --git a/src/librustdoc/doctest/rust.rs b/src/librustdoc/doctest/rust.rs
index 17c29ba413a4a..243fb5d05fdb7 100644
--- a/src/librustdoc/doctest/rust.rs
+++ b/src/librustdoc/doctest/rust.rs
@@ -14,14 +14,13 @@ use rustc_session::Session;
 use rustc_span::source_map::SourceMap;
 use rustc_span::{BytePos, FileName, Pos, Span, DUMMY_SP};
 
-use super::{DoctestVisitor, ScrapedDoctest};
-use crate::clean::types::AttributesExt;
-use crate::clean::Attributes;
+use super::{DocTestVisitor, ScrapedDocTest};
+use crate::clean::{types::AttributesExt, Attributes};
 use crate::html::markdown::{self, ErrorCodes, LangString, MdRelLine};
 
 struct RustCollector {
     source_map: Lrc<SourceMap>,
-    tests: Vec<ScrapedDoctest>,
+    tests: Vec<ScrapedDocTest>,
     cur_path: Vec<String>,
     position: Span,
 }
@@ -48,10 +47,10 @@ impl RustCollector {
     }
 }
 
-impl DoctestVisitor for RustCollector {
+impl DocTestVisitor for RustCollector {
     fn visit_test(&mut self, test: String, config: LangString, rel_line: MdRelLine) {
         let line = self.get_base_line() + rel_line.offset();
-        self.tests.push(ScrapedDoctest::new(
+        self.tests.push(ScrapedDocTest::new(
             self.get_filename(),
             line,
             self.cur_path.clone(),
@@ -89,7 +88,7 @@ impl<'a, 'tcx> HirCollector<'a, 'tcx> {
         Self { sess, map, codes, enable_per_target_ignores, tcx, collector }
     }
 
-    pub fn collect_crate(mut self) -> Vec<ScrapedDoctest> {
+    pub fn collect_crate(mut self) -> Vec<ScrapedDocTest> {
         let tcx = self.tcx;
         self.visit_testable("".to_string(), CRATE_DEF_ID, tcx.hir().span(CRATE_HIR_ID), |this| {
             tcx.hir().walk_toplevel_module(this)
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index bc30f7fa43b2b..7bfe5d87d399f 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -738,7 +738,7 @@ impl MdRelLine {
     }
 }
 
-pub(crate) fn find_testable_code<T: doctest::DoctestVisitor>(
+pub(crate) fn find_testable_code<T: doctest::DocTestVisitor>(
     doc: &str,
     tests: &mut T,
     error_codes: ErrorCodes,
@@ -748,7 +748,7 @@ pub(crate) fn find_testable_code<T: doctest::DoctestVisitor>(
     find_codes(doc, tests, error_codes, enable_per_target_ignores, extra_info, false)
 }
 
-pub(crate) fn find_codes<T: doctest::DoctestVisitor>(
+pub(crate) fn find_codes<T: doctest::DocTestVisitor>(
     doc: &str,
     tests: &mut T,
     error_codes: ErrorCodes,
diff --git a/src/librustdoc/passes/check_doc_test_visibility.rs b/src/librustdoc/passes/check_doc_test_visibility.rs
index d78afdffc626d..5015d66595504 100644
--- a/src/librustdoc/passes/check_doc_test_visibility.rs
+++ b/src/librustdoc/passes/check_doc_test_visibility.rs
@@ -45,7 +45,7 @@ pub(crate) struct Tests {
     pub(crate) found_tests: usize,
 }
 
-impl crate::doctest::DoctestVisitor for Tests {
+impl crate::doctest::DocTestVisitor for Tests {
     fn visit_test(&mut self, _: String, config: LangString, _: MdRelLine) {
         if config.rust && config.ignore == Ignore::None {
             self.found_tests += 1;

From baf8ce83b82dce7d263aeb48d5a1cc7241d05739 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 9 Jul 2024 14:21:43 +0200
Subject: [PATCH 229/685] Move `is_multiple_tests` argument into
 `RunnableDocTest`

---
 src/librustdoc/doctest.rs        | 22 +++++++++-------------
 src/librustdoc/doctest/runner.rs | 10 +++-------
 2 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 91b93a9990323..de641901e7a53 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -447,6 +447,7 @@ struct RunnableDocTest {
     line: usize,
     edition: Edition,
     no_run: bool,
+    is_multiple_tests: bool,
 }
 
 impl RunnableDocTest {
@@ -459,7 +460,6 @@ fn run_test(
     doctest: RunnableDocTest,
     rustdoc_options: &RustdocOptions,
     supports_color: bool,
-    is_multiple_tests: bool,
     report_unused_externs: impl Fn(UnusedExterns),
 ) -> Result<(), TestFailure> {
     let langstr = &doctest.langstr;
@@ -480,7 +480,7 @@ fn run_test(
     }
 
     compiler.arg("--edition").arg(&doctest.edition.to_string());
-    if !is_multiple_tests {
+    if !doctest.is_multiple_tests {
         // Setting these environment variables is unneeded if this is a merged doctest.
         compiler.env("UNSTABLE_RUSTDOC_TEST_PATH", &doctest.test_opts.path);
         compiler.env(
@@ -532,7 +532,7 @@ fn run_test(
 
     // If this is a merged doctest, we need to write it into a file instead of using stdin
     // because if the size of the merged doctests is too big, it'll simply break stdin.
-    if is_multiple_tests {
+    if doctest.is_multiple_tests {
         // It makes the compilation failure much faster if it is for a combined doctest.
         compiler.arg("--error-format=short");
         let input_file = doctest.path_for_merged_doctest();
@@ -556,7 +556,7 @@ fn run_test(
     debug!("compiler invocation for doctest: {compiler:?}");
 
     let mut child = compiler.spawn().expect("Failed to spawn rustc process");
-    let output = if is_multiple_tests {
+    let output = if doctest.is_multiple_tests {
         let status = child.wait().expect("Failed to wait");
         process::Output { status, stdout: Vec::new(), stderr: Vec::new() }
     } else {
@@ -634,7 +634,7 @@ fn run_test(
         cmd.arg(&output_file);
     } else {
         cmd = Command::new(&output_file);
-        if is_multiple_tests {
+        if doctest.is_multiple_tests {
             cmd.arg("*doctest-bin-path");
             cmd.arg(&output_file);
         }
@@ -643,7 +643,7 @@ fn run_test(
         cmd.current_dir(run_directory);
     }
 
-    let result = if is_multiple_tests || rustdoc_options.nocapture {
+    let result = if doctest.is_multiple_tests || rustdoc_options.nocapture {
         cmd.status().map(|status| process::Output {
             status,
             stdout: Vec::new(),
@@ -921,14 +921,10 @@ fn doctest_run_fn(
         line: scraped_test.line,
         edition: scraped_test.edition(&rustdoc_options),
         no_run: scraped_test.no_run(&rustdoc_options),
+        is_multiple_tests: false,
     };
-    let res = run_test(
-        runnable_test,
-        &rustdoc_options,
-        doctest.supports_color,
-        false,
-        report_unused_externs,
-    );
+    let res =
+        run_test(runnable_test, &rustdoc_options, doctest.supports_color, report_unused_externs);
 
     if let Err(err) = res {
         match err {
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index 0d73e02cbd751..b7d9bffb23a04 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -184,14 +184,10 @@ std::process::Termination::report(test::test_main(test_args, Vec::from(TESTS), N
             line: 0,
             edition,
             no_run: false,
+            is_multiple_tests: true,
         };
-        let ret = run_test(
-            runnable_test,
-            rustdoc_options,
-            self.supports_color,
-            true,
-            |_: UnusedExterns| {},
-        );
+        let ret =
+            run_test(runnable_test, rustdoc_options, self.supports_color, |_: UnusedExterns| {});
         if let Err(TestFailure::CompileError) = ret { Err(()) } else { Ok(ret.is_ok()) }
     }
 }

From c9f730e2236a2ee37f59b03e6a017b198ed40b38 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 9 Jul 2024 14:24:04 +0200
Subject: [PATCH 230/685] Improve documentation for internal doctest API

---
 src/librustdoc/doctest.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index de641901e7a53..29cece6faaa15 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -456,6 +456,10 @@ impl RunnableDocTest {
     }
 }
 
+/// Execute a `RunnableDoctest`.
+///
+/// This is the function that calculates the compiler command line, invokes the compiler, then
+/// invokes the test or tests in a separate executable (if applicable).
 fn run_test(
     doctest: RunnableDocTest,
     rustdoc_options: &RustdocOptions,
@@ -705,6 +709,15 @@ impl IndividualTestOptions {
 }
 
 /// A doctest scraped from the code, ready to be turned into a runnable test.
+///
+/// The pipeline goes: [`clean`] AST -> `ScrapedDoctest` -> [`RunnableDoctest`].
+/// [`run_merged_tests`] converts a bunch of scraped doctests to a single runnable doctest,
+/// while [`generate_unique_doctest`] does the standalones.
+///
+/// [`clean`]: crate::clean
+/// [`RunnableDoctest`]: crate::doctest::RunnableDoctest
+/// [`run_merged_tests`]: crate::doctest::runner::DocTestRunner::run_merged_tests
+/// [`generate_unique_doctest`]: crate::doctest::make::DocTestBuilder::generate_unique_doctest
 pub(crate) struct ScrapedDocTest {
     filename: FileName,
     line: usize,

From cbf6fe05e78c59e98d09a21bc90a7559b0cd8d5a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 9 Jul 2024 14:34:55 +0200
Subject: [PATCH 231/685] Add more merged doctests tests

---
 tests/rustdoc-ui/doctest/merged-ignore-no_run.rs   | 14 ++++++++++++++
 .../rustdoc-ui/doctest/merged-ignore-no_run.stdout |  7 +++++++
 2 files changed, 21 insertions(+)
 create mode 100644 tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
 create mode 100644 tests/rustdoc-ui/doctest/merged-ignore-no_run.stdout

diff --git a/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs b/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
new file mode 100644
index 0000000000000..1a2f9492057e0
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
@@ -0,0 +1,14 @@
+//@ compile-flags:--test --test-args=--test-threads=1 -Zunstable-options --edition 2024
+//@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
+//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ check-pass
+
+/// ```ignore (test)
+/// let x = 12;
+/// ```
+pub fn ignored() {}
+
+/// ```no_run
+/// panic!("blob");
+/// ```
+pub fn no_run() {}
diff --git a/tests/rustdoc-ui/doctest/merged-ignore-no_run.stdout b/tests/rustdoc-ui/doctest/merged-ignore-no_run.stdout
new file mode 100644
index 0000000000000..f2cb1e7e72f70
--- /dev/null
+++ b/tests/rustdoc-ui/doctest/merged-ignore-no_run.stdout
@@ -0,0 +1,7 @@
+
+running 2 tests
+test $DIR/merged-ignore-no_run.rs - ignored (line 6) ... ignored
+test $DIR/merged-ignore-no_run.rs - no_run (line 11) - compile ... ok
+
+test result: ok. 1 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in $TIME
+

From 7dcb841de040c85cf8e53e533917d6eade2c1777 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 11 Jul 2024 22:53:30 +0200
Subject: [PATCH 232/685] Add doctest to ensure that doctests with crate-level
 attributes are not part of merged doctest

---
 .../2024-doctests-crate-attribute.rs          | 22 +++++++++++++++++++
 .../2024-doctests-crate-attribute.stdout      | 12 ++++++++++
 2 files changed, 34 insertions(+)
 create mode 100644 tests/rustdoc-ui/2024-doctests-crate-attribute.rs
 create mode 100644 tests/rustdoc-ui/2024-doctests-crate-attribute.stdout

diff --git a/tests/rustdoc-ui/2024-doctests-crate-attribute.rs b/tests/rustdoc-ui/2024-doctests-crate-attribute.rs
new file mode 100644
index 0000000000000..781a773d952a8
--- /dev/null
+++ b/tests/rustdoc-ui/2024-doctests-crate-attribute.rs
@@ -0,0 +1,22 @@
+//@ check-pass
+//@ compile-flags: --test --test-args=--test-threads=1 -Zunstable-options --edition 2024
+//@ normalize-stdout-test: "tests/rustdoc-ui" -> "$$DIR"
+//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+
+/// This doctest is used to ensure that if a crate attribute is present,
+/// it will not be part of the merged doctests.
+///
+/// ```
+/// #![doc(html_playground_url = "foo")]
+///
+/// pub struct Bar;
+/// ```
+///
+/// This one will allow us to confirm that the doctest above will be a
+/// standalone one (there will be two separate doctests passes).
+///
+/// ```
+/// let x = 12;
+/// ```
+pub struct Foo;
diff --git a/tests/rustdoc-ui/2024-doctests-crate-attribute.stdout b/tests/rustdoc-ui/2024-doctests-crate-attribute.stdout
new file mode 100644
index 0000000000000..29702ce8929bd
--- /dev/null
+++ b/tests/rustdoc-ui/2024-doctests-crate-attribute.stdout
@@ -0,0 +1,12 @@
+
+running 1 test
+test $DIR/2024-doctests-crate-attribute.rs - Foo (line 19) ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+
+
+running 1 test
+test $DIR/2024-doctests-crate-attribute.rs - Foo (line 10) ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+

From 903d2db4d22e947354385ed2fff42d0816143cfc Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 11 Jul 2024 23:37:55 +0200
Subject: [PATCH 233/685] Only keep "useful" code in
 `tests/rustdoc-ui/2024-doctests-checks.rs`

---
 tests/rustdoc-ui/2024-doctests-checks.rs     | 18 ++----------------
 tests/rustdoc-ui/2024-doctests-checks.stdout | 14 ++++++--------
 2 files changed, 8 insertions(+), 24 deletions(-)

diff --git a/tests/rustdoc-ui/2024-doctests-checks.rs b/tests/rustdoc-ui/2024-doctests-checks.rs
index f6b6faa8c6a2c..6f4db3a90f818 100644
--- a/tests/rustdoc-ui/2024-doctests-checks.rs
+++ b/tests/rustdoc-ui/2024-doctests-checks.rs
@@ -4,26 +4,12 @@
 //@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 
-/// This one should fail: crate attributes should remain crate attributes
-/// in standalone doctests.
-///
-/// ```compile_fail
-/// #![deny(missing_docs)]
-///
-/// pub struct Bar;
-/// ```
-///
-/// This one should not impact the other merged doctests.
-///
-/// ```
-/// #![deny(unused)]
-/// ```
-///
 /// ```
 /// let x = 12;
 /// ```
 ///
-/// This one should not be a merged doctest (because of `$crate`):
+/// This one should not be a merged doctest (because of `$crate`). The output
+/// will confirm it by displaying both merged and standalone doctest passes.
 ///
 /// ```
 /// macro_rules! bla {
diff --git a/tests/rustdoc-ui/2024-doctests-checks.stdout b/tests/rustdoc-ui/2024-doctests-checks.stdout
index 2c0136f767448..d1064084a8564 100644
--- a/tests/rustdoc-ui/2024-doctests-checks.stdout
+++ b/tests/rustdoc-ui/2024-doctests-checks.stdout
@@ -1,14 +1,12 @@
 
-running 2 tests
-test $DIR/2024-doctests-checks.rs - Foo (line 18) ... ok
-test $DIR/2024-doctests-checks.rs - Foo (line 22) ... ok
+running 1 test
+test $DIR/2024-doctests-checks.rs - Foo (line 7) ... ok
 
-test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
 
 
-running 2 tests
-test $DIR/2024-doctests-checks.rs - Foo (line 10) - compile fail ... ok
-test $DIR/2024-doctests-checks.rs - Foo (line 28) ... ok
+running 1 test
+test $DIR/2024-doctests-checks.rs - Foo (line 14) ... ok
 
-test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
 

From a708d0bc779afad3b23eea4a323b00d5de7a2fa9 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Fri, 12 Jul 2024 11:26:25 +0200
Subject: [PATCH 234/685] Fix commands syntax in rustdoc-ui tests

---
 tests/rustdoc-ui/2024-doctests-checks.rs                     | 4 ++--
 tests/rustdoc-ui/2024-doctests-crate-attribute.rs            | 4 ++--
 tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs | 2 +-
 tests/rustdoc-ui/doctest/merged-ignore-no_run.rs             | 2 +-
 tests/rustdoc-ui/doctest/wrong-ast-2024.rs                   | 4 ++--
 tests/rustdoc-ui/doctest/wrong-ast.rs                        | 2 +-
 6 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/tests/rustdoc-ui/2024-doctests-checks.rs b/tests/rustdoc-ui/2024-doctests-checks.rs
index 6f4db3a90f818..464cf5b200df0 100644
--- a/tests/rustdoc-ui/2024-doctests-checks.rs
+++ b/tests/rustdoc-ui/2024-doctests-checks.rs
@@ -1,8 +1,8 @@
 //@ check-pass
 //@ compile-flags: --test --test-args=--test-threads=1 -Zunstable-options --edition 2024
 //@ normalize-stdout-test: "tests/rustdoc-ui" -> "$$DIR"
-//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 
 /// ```
 /// let x = 12;
diff --git a/tests/rustdoc-ui/2024-doctests-crate-attribute.rs b/tests/rustdoc-ui/2024-doctests-crate-attribute.rs
index 781a773d952a8..4984fdfe1949a 100644
--- a/tests/rustdoc-ui/2024-doctests-crate-attribute.rs
+++ b/tests/rustdoc-ui/2024-doctests-crate-attribute.rs
@@ -1,8 +1,8 @@
 //@ check-pass
 //@ compile-flags: --test --test-args=--test-threads=1 -Zunstable-options --edition 2024
 //@ normalize-stdout-test: "tests/rustdoc-ui" -> "$$DIR"
-//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 
 /// This doctest is used to ensure that if a crate attribute is present,
 /// it will not be part of the merged doctests.
diff --git a/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs b/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs
index ad78bb545533d..4fe513b406691 100644
--- a/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs
+++ b/tests/rustdoc-ui/doctest/failed-doctest-should-panic-2021.rs
@@ -3,7 +3,7 @@
 
 //@ compile-flags:--test --edition 2021
 //@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 /// ```should_panic
diff --git a/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs b/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
index 1a2f9492057e0..4c21d54295106 100644
--- a/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
+++ b/tests/rustdoc-ui/doctest/merged-ignore-no_run.rs
@@ -1,6 +1,6 @@
 //@ compile-flags:--test --test-args=--test-threads=1 -Zunstable-options --edition 2024
 //@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ check-pass
 
 /// ```ignore (test)
diff --git a/tests/rustdoc-ui/doctest/wrong-ast-2024.rs b/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
index fdcd3baa64273..7b4fa8fd2c9b9 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
+++ b/tests/rustdoc-ui/doctest/wrong-ast-2024.rs
@@ -1,7 +1,7 @@
 //@ compile-flags:--test --test-args=--test-threads=1 -Zunstable-options --edition 2024
 //@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
-//@ normalize-stdout-test ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
+//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test: ".rs:\d+:\d+" -> ".rs:$$LINE:$$COL"
 //@ failure-status: 101
 
 /// ```
diff --git a/tests/rustdoc-ui/doctest/wrong-ast.rs b/tests/rustdoc-ui/doctest/wrong-ast.rs
index e8faaea97ee20..92286b33dcfb3 100644
--- a/tests/rustdoc-ui/doctest/wrong-ast.rs
+++ b/tests/rustdoc-ui/doctest/wrong-ast.rs
@@ -1,6 +1,6 @@
 //@ compile-flags:--test --test-args=--test-threads=1
 //@ normalize-stdout-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
-//@ normalize-stdout-test "finished in \d+\.\d+s" -> "finished in $$TIME"
+//@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
 //@ failure-status: 101
 
 /// ```

From f1c1c4921637f39e617f3128977773b8ff6b7de0 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 29 Jul 2024 14:38:47 +0200
Subject: [PATCH 235/685] Run fmt

---
 src/librustdoc/doctest/make.rs                      | 3 +--
 src/librustdoc/doctest/runner.rs                    | 4 ++--
 src/librustdoc/doctest/rust.rs                      | 3 ++-
 src/librustdoc/doctest/tests.rs                     | 3 ++-
 tests/run-make/doctests-keep-binaries-2024/rmake.rs | 3 ++-
 tests/run-make/doctests-merge/rmake.rs              | 3 ++-
 6 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 1e8e403985bc8..aed079e5887b0 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -1,8 +1,6 @@
 //! Logic for transforming the raw code given by the user into something actually
 //! runnable, e.g. by adding a `main` function if it doesn't already exist.
 
-use crate::html::markdown::LangString;
-
 use std::io;
 
 use rustc_ast as ast;
@@ -18,6 +16,7 @@ use rustc_span::symbol::sym;
 use rustc_span::FileName;
 
 use super::GlobalTestOptions;
+use crate::html::markdown::LangString;
 
 /// This struct contains information about the doctest itself which is then used to generate
 /// doctest source code appropriately.
diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index b7d9bffb23a04..b91333e5f8135 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -1,8 +1,8 @@
+use std::fmt::Write;
+
 use rustc_data_structures::fx::FxHashSet;
 use rustc_span::edition::Edition;
 
-use std::fmt::Write;
-
 use crate::doctest::{
     run_test, DocTestBuilder, GlobalTestOptions, IndividualTestOptions, RunnableDocTest,
     RustdocOptions, ScrapedDocTest, TestFailure, UnusedExterns,
diff --git a/src/librustdoc/doctest/rust.rs b/src/librustdoc/doctest/rust.rs
index 243fb5d05fdb7..abd66f15dc0c1 100644
--- a/src/librustdoc/doctest/rust.rs
+++ b/src/librustdoc/doctest/rust.rs
@@ -15,7 +15,8 @@ use rustc_span::source_map::SourceMap;
 use rustc_span::{BytePos, FileName, Pos, Span, DUMMY_SP};
 
 use super::{DocTestVisitor, ScrapedDocTest};
-use crate::clean::{types::AttributesExt, Attributes};
+use crate::clean::types::AttributesExt;
+use crate::clean::Attributes;
 use crate::html::markdown::{self, ErrorCodes, LangString, MdRelLine};
 
 struct RustCollector {
diff --git a/src/librustdoc/doctest/tests.rs b/src/librustdoc/doctest/tests.rs
index b076b6dccf5c7..160d0f222b4e0 100644
--- a/src/librustdoc/doctest/tests.rs
+++ b/src/librustdoc/doctest/tests.rs
@@ -1,8 +1,9 @@
 use std::path::PathBuf;
 
-use super::{DocTestBuilder, GlobalTestOptions};
 use rustc_span::edition::DEFAULT_EDITION;
 
+use super::{DocTestBuilder, GlobalTestOptions};
+
 fn make_test(
     test_code: &str,
     crate_name: Option<&str>,
diff --git a/tests/run-make/doctests-keep-binaries-2024/rmake.rs b/tests/run-make/doctests-keep-binaries-2024/rmake.rs
index a6fddf6d3365e..791867fa05f10 100644
--- a/tests/run-make/doctests-keep-binaries-2024/rmake.rs
+++ b/tests/run-make/doctests-keep-binaries-2024/rmake.rs
@@ -1,9 +1,10 @@
 // Check that valid binaries are persisted by running them, regardless of whether the
 // --run or --no-run option is used.
 
+use std::path::Path;
+
 use run_make_support::fs_wrapper::{create_dir, remove_dir_all};
 use run_make_support::{run, rustc, rustdoc};
-use std::path::Path;
 
 fn setup_test_env<F: FnOnce(&Path, &Path)>(callback: F) {
     let out_dir = Path::new("doctests");
diff --git a/tests/run-make/doctests-merge/rmake.rs b/tests/run-make/doctests-merge/rmake.rs
index ac3951c6ceb3b..a25da7403e24b 100644
--- a/tests/run-make/doctests-merge/rmake.rs
+++ b/tests/run-make/doctests-merge/rmake.rs
@@ -1,6 +1,7 @@
-use run_make_support::{cwd, diff, rustc, rustdoc};
 use std::path::Path;
 
+use run_make_support::{cwd, diff, rustc, rustdoc};
+
 fn test_and_compare(input_file: &str, stdout_file: &str, edition: &str, dep: &Path) {
     let mut cmd = rustdoc();
 

From 488614d2dd0f2e42281792a189f6e7d2bf55230d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 29 Jul 2024 15:45:16 +0200
Subject: [PATCH 236/685] Update
 `tests/run-make/doctests-keep-binaries-2024/rmake.rs` test to new run-make
 API

---
 tests/run-make/doctests-keep-binaries-2024/rmake.rs | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/tests/run-make/doctests-keep-binaries-2024/rmake.rs b/tests/run-make/doctests-keep-binaries-2024/rmake.rs
index 791867fa05f10..c3e586fc1054d 100644
--- a/tests/run-make/doctests-keep-binaries-2024/rmake.rs
+++ b/tests/run-make/doctests-keep-binaries-2024/rmake.rs
@@ -3,15 +3,14 @@
 
 use std::path::Path;
 
-use run_make_support::fs_wrapper::{create_dir, remove_dir_all};
-use run_make_support::{run, rustc, rustdoc};
+use run_make_support::{rfs, run, rustc, rustdoc};
 
 fn setup_test_env<F: FnOnce(&Path, &Path)>(callback: F) {
     let out_dir = Path::new("doctests");
-    create_dir(&out_dir);
+    rfs::create_dir(&out_dir);
     rustc().input("t.rs").crate_type("rlib").run();
     callback(&out_dir, Path::new("libt.rlib"));
-    remove_dir_all(out_dir);
+    rfs::remove_dir_all(out_dir);
 }
 
 fn check_generated_binaries() {
@@ -47,7 +46,7 @@ fn main() {
     // Behavior with --test-run-directory with relative paths.
     setup_test_env(|_, _| {
         let run_dir_path = Path::new("rundir");
-        create_dir(&run_dir_path);
+        rfs::create_dir(&run_dir_path);
 
         rustdoc()
             .input("t.rs")
@@ -61,6 +60,6 @@ fn main() {
             .edition("2024")
             .run();
 
-        remove_dir_all(run_dir_path);
+        rfs::remove_dir_all(run_dir_path);
     });
 }

From 1d75f78ea26f79b21f63cdc45bd3f711d0bd3f20 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Wed, 7 Aug 2024 19:53:34 +0200
Subject: [PATCH 237/685] Ignore cross compile check for
 `tests/run-make/doctests-keep-binaries-2024` test

---
 tests/run-make/doctests-keep-binaries-2024/rmake.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/run-make/doctests-keep-binaries-2024/rmake.rs b/tests/run-make/doctests-keep-binaries-2024/rmake.rs
index c3e586fc1054d..3e8ffcbf24457 100644
--- a/tests/run-make/doctests-keep-binaries-2024/rmake.rs
+++ b/tests/run-make/doctests-keep-binaries-2024/rmake.rs
@@ -1,6 +1,8 @@
 // Check that valid binaries are persisted by running them, regardless of whether the
 // --run or --no-run option is used.
 
+//@ ignore-cross-compile
+
 use std::path::Path;
 
 use run_make_support::{rfs, run, rustc, rustdoc};

From 05fb8ff4f5602ebf470f6c870906aef9df16d8db Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 12 Aug 2024 22:59:06 +0200
Subject: [PATCH 238/685] Fix intra-doc link

---
 src/librustdoc/doctest.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 29cece6faaa15..743c1ed507eeb 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -438,7 +438,7 @@ fn wrapped_rustc_command(rustc_wrappers: &[PathBuf], rustc_binary: &Path) -> Com
 /// (if multiple doctests are merged), `main` function,
 /// and everything needed to calculate the compiler's command-line arguments.
 /// The `# ` prefix on boring lines has also been stripped.
-struct RunnableDocTest {
+pub(crate) struct RunnableDocTest {
     full_test_code: String,
     full_test_line_offset: usize,
     test_opts: IndividualTestOptions,
@@ -710,12 +710,11 @@ impl IndividualTestOptions {
 
 /// A doctest scraped from the code, ready to be turned into a runnable test.
 ///
-/// The pipeline goes: [`clean`] AST -> `ScrapedDoctest` -> [`RunnableDoctest`].
+/// The pipeline goes: [`clean`] AST -> `ScrapedDoctest` -> `RunnableDoctest`.
 /// [`run_merged_tests`] converts a bunch of scraped doctests to a single runnable doctest,
 /// while [`generate_unique_doctest`] does the standalones.
 ///
 /// [`clean`]: crate::clean
-/// [`RunnableDoctest`]: crate::doctest::RunnableDoctest
 /// [`run_merged_tests`]: crate::doctest::runner::DocTestRunner::run_merged_tests
 /// [`generate_unique_doctest`]: crate::doctest::make::DocTestBuilder::generate_unique_doctest
 pub(crate) struct ScrapedDocTest {

From 5082e25263064e93aa03ba7374ebbbdf5454eac5 Mon Sep 17 00:00:00 2001
From: Michael Woerister <michaelwoerister@posteo>
Date: Tue, 13 Aug 2024 20:16:14 +0200
Subject: [PATCH 239/685] Add mw back to review rotation

---
 triagebot.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/triagebot.toml b/triagebot.toml
index 33108f743cb94..a98d5f6a7c215 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -913,7 +913,7 @@ cc = ["@kobzol"]
 [assign]
 warn_non_default_branch = true
 contributing_url = "https://rustc-dev-guide.rust-lang.org/getting-started.html"
-users_on_vacation = ["jyn514", "jhpratt", "oli-obk", "michaelwoerister"]
+users_on_vacation = ["jyn514", "jhpratt", "oli-obk"]
 
 [assign.adhoc_groups]
 compiler-team = [

From fe4fa2f1dad8be386dfb9c7315fac79afc853414 Mon Sep 17 00:00:00 2001
From: beetrees <b@beetr.ee>
Date: Sun, 21 Jul 2024 16:52:04 +0100
Subject: [PATCH 240/685] Use the `enum2$` Natvis visualiser for repr128
 C-style enums

---
 .../src/debuginfo/metadata/enums/cpp_like.rs  | 14 ++--
 .../src/debuginfo/metadata/enums/mod.rs       | 54 ++-------------
 .../src/debuginfo/metadata/enums/native.rs    |  9 ++-
 .../rustc_codegen_ssa/src/debuginfo/mod.rs    | 69 +++++++++++++++++--
 .../src/debuginfo/type_names.rs               |  7 +-
 tests/debuginfo/msvc-pretty-enums.rs          | 50 ++++++++++++++
 6 files changed, 136 insertions(+), 67 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs
index 13006638bb3a3..181022087f3bf 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs
@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use libc::c_uint;
 use rustc_codegen_ssa::debuginfo::type_names::compute_debuginfo_type_name;
-use rustc_codegen_ssa::debuginfo::wants_c_like_enum_debuginfo;
+use rustc_codegen_ssa::debuginfo::{tag_base_type, wants_c_like_enum_debuginfo};
 use rustc_codegen_ssa::traits::ConstMethods;
 use rustc_index::IndexVec;
 use rustc_middle::bug;
@@ -12,7 +12,7 @@ use rustc_target::abi::{Align, Endian, Size, TagEncoding, VariantIdx, Variants};
 use smallvec::smallvec;
 
 use crate::common::CodegenCx;
-use crate::debuginfo::metadata::enums::{tag_base_type, DiscrResult};
+use crate::debuginfo::metadata::enums::DiscrResult;
 use crate::debuginfo::metadata::type_map::{self, Stub, UniqueTypeId};
 use crate::debuginfo::metadata::{
     build_field_di_node, file_metadata, size_and_align_of, type_di_node, unknown_file_metadata,
@@ -190,7 +190,7 @@ pub(super) fn build_enum_type_di_node<'ll, 'tcx>(
     let enum_type_and_layout = cx.layout_of(enum_type);
     let enum_type_name = compute_debuginfo_type_name(cx.tcx, enum_type, false);
 
-    assert!(!wants_c_like_enum_debuginfo(enum_type_and_layout));
+    assert!(!wants_c_like_enum_debuginfo(cx.tcx, enum_type_and_layout));
 
     type_map::build_type_with_children(
         cx,
@@ -265,7 +265,7 @@ pub(super) fn build_coroutine_di_node<'ll, 'tcx>(
     let coroutine_type_and_layout = cx.layout_of(coroutine_type);
     let coroutine_type_name = compute_debuginfo_type_name(cx.tcx, coroutine_type, false);
 
-    assert!(!wants_c_like_enum_debuginfo(coroutine_type_and_layout));
+    assert!(!wants_c_like_enum_debuginfo(cx.tcx, coroutine_type_and_layout));
 
     type_map::build_type_with_children(
         cx,
@@ -381,7 +381,7 @@ fn build_union_fields_for_enum<'ll, 'tcx>(
     tag_field: usize,
     untagged_variant_index: Option<VariantIdx>,
 ) -> SmallVec<&'ll DIType> {
-    let tag_base_type = super::tag_base_type(cx, enum_type_and_layout);
+    let tag_base_type = tag_base_type(cx.tcx, enum_type_and_layout);
 
     let variant_names_type_di_node = build_variant_names_type_di_node(
         cx,
@@ -676,7 +676,7 @@ fn build_union_fields_for_direct_tag_coroutine<'ll, 'tcx>(
     let variant_range = coroutine_args.variant_range(coroutine_def_id, cx.tcx);
     let variant_count = (variant_range.start.as_u32()..variant_range.end.as_u32()).len();
 
-    let tag_base_type = tag_base_type(cx, coroutine_type_and_layout);
+    let tag_base_type = tag_base_type(cx.tcx, coroutine_type_and_layout);
 
     let variant_names_type_di_node = build_variant_names_type_di_node(
         cx,
@@ -803,7 +803,7 @@ fn build_union_fields_for_direct_tag_enum_or_coroutine<'ll, 'tcx>(
 
     assert_eq!(
         cx.size_and_align_of(enum_type_and_layout.field(cx, tag_field).ty),
-        cx.size_and_align_of(super::tag_base_type(cx, enum_type_and_layout))
+        cx.size_and_align_of(self::tag_base_type(cx.tcx, enum_type_and_layout))
     );
 
     // ... and a field for the tag. If the tag is 128 bits wide, this will actually
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs
index fc3adaf068111..77cbcd86cdd10 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs
@@ -1,17 +1,15 @@
 use std::borrow::Cow;
 
 use rustc_codegen_ssa::debuginfo::type_names::{compute_debuginfo_type_name, cpp_like_debuginfo};
-use rustc_codegen_ssa::debuginfo::wants_c_like_enum_debuginfo;
+use rustc_codegen_ssa::debuginfo::{tag_base_type, wants_c_like_enum_debuginfo};
 use rustc_hir::def::CtorKind;
 use rustc_index::IndexSlice;
 use rustc_middle::bug;
 use rustc_middle::mir::CoroutineLayout;
-use rustc_middle::ty::layout::{IntegerExt, LayoutOf, PrimitiveExt, TyAndLayout};
+use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, AdtDef, CoroutineArgs, CoroutineArgsExt, Ty, VariantDef};
 use rustc_span::Symbol;
-use rustc_target::abi::{
-    FieldIdx, HasDataLayout, Integer, Primitive, TagEncoding, VariantIdx, Variants,
-};
+use rustc_target::abi::{FieldIdx, TagEncoding, VariantIdx, Variants};
 
 use super::type_map::{DINodeCreationResult, UniqueTypeId};
 use super::{size_and_align_of, SmallVec};
@@ -39,7 +37,7 @@ pub(super) fn build_enum_type_di_node<'ll, 'tcx>(
 
     let enum_type_and_layout = cx.layout_of(enum_type);
 
-    if wants_c_like_enum_debuginfo(enum_type_and_layout) {
+    if wants_c_like_enum_debuginfo(cx.tcx, enum_type_and_layout) {
         return build_c_style_enum_di_node(cx, enum_adt_def, enum_type_and_layout);
     }
 
@@ -74,7 +72,7 @@ fn build_c_style_enum_di_node<'ll, 'tcx>(
         di_node: build_enumeration_type_di_node(
             cx,
             &compute_debuginfo_type_name(cx.tcx, enum_type_and_layout.ty, false),
-            tag_base_type(cx, enum_type_and_layout),
+            tag_base_type(cx.tcx, enum_type_and_layout),
             enum_adt_def.discriminants(cx.tcx).map(|(variant_index, discr)| {
                 let name = Cow::from(enum_adt_def.variant(variant_index).name.as_str());
                 (name, discr.val)
@@ -85,48 +83,6 @@ fn build_c_style_enum_di_node<'ll, 'tcx>(
     }
 }
 
-/// Extract the type with which we want to describe the tag of the given enum or coroutine.
-fn tag_base_type<'ll, 'tcx>(
-    cx: &CodegenCx<'ll, 'tcx>,
-    enum_type_and_layout: TyAndLayout<'tcx>,
-) -> Ty<'tcx> {
-    assert!(match enum_type_and_layout.ty.kind() {
-        ty::Coroutine(..) => true,
-        ty::Adt(adt_def, _) => adt_def.is_enum(),
-        _ => false,
-    });
-
-    match enum_type_and_layout.layout.variants() {
-        // A single-variant enum has no discriminant.
-        Variants::Single { .. } => {
-            bug!("tag_base_type() called for enum without tag: {:?}", enum_type_and_layout)
-        }
-
-        Variants::Multiple { tag_encoding: TagEncoding::Niche { .. }, tag, .. } => {
-            // Niche tags are always normalized to unsized integers of the correct size.
-            match tag.primitive() {
-                Primitive::Int(t, _) => t,
-                Primitive::Float(f) => Integer::from_size(f.size()).unwrap(),
-                // FIXME(erikdesjardins): handle non-default addrspace ptr sizes
-                Primitive::Pointer(_) => {
-                    // If the niche is the NULL value of a reference, then `discr_enum_ty` will be
-                    // a RawPtr. CodeView doesn't know what to do with enums whose base type is a
-                    // pointer so we fix this up to just be `usize`.
-                    // DWARF might be able to deal with this but with an integer type we are on
-                    // the safe side there too.
-                    cx.data_layout().ptr_sized_integer()
-                }
-            }
-            .to_ty(cx.tcx, false)
-        }
-
-        Variants::Multiple { tag_encoding: TagEncoding::Direct, tag, .. } => {
-            // Direct tags preserve the sign.
-            tag.primitive().to_ty(cx.tcx)
-        }
-    }
-}
-
 /// Build a DW_TAG_enumeration_type debuginfo node, with the given base type and variants.
 /// This is a helper function and does not register anything in the type map by itself.
 ///
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs
index d7e3b47e0bd5b..238fbad4dfd64 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/native.rs
@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use libc::c_uint;
 use rustc_codegen_ssa::debuginfo::type_names::compute_debuginfo_type_name;
-use rustc_codegen_ssa::debuginfo::wants_c_like_enum_debuginfo;
+use rustc_codegen_ssa::debuginfo::{tag_base_type, wants_c_like_enum_debuginfo};
 use rustc_codegen_ssa::traits::ConstMethods;
 use rustc_middle::bug;
 use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
@@ -11,7 +11,6 @@ use rustc_target::abi::{Size, TagEncoding, VariantIdx, Variants};
 use smallvec::smallvec;
 
 use crate::common::CodegenCx;
-use crate::debuginfo::metadata::enums::tag_base_type;
 use crate::debuginfo::metadata::type_map::{self, Stub, StubInfo, UniqueTypeId};
 use crate::debuginfo::metadata::{
     file_metadata, size_and_align_of, type_di_node, unknown_file_metadata, visibility_di_flags,
@@ -54,7 +53,7 @@ pub(super) fn build_enum_type_di_node<'ll, 'tcx>(
 
     let visibility_flags = visibility_di_flags(cx, enum_adt_def.did(), enum_adt_def.did());
 
-    assert!(!wants_c_like_enum_debuginfo(enum_type_and_layout));
+    assert!(!wants_c_like_enum_debuginfo(cx.tcx, enum_type_and_layout));
 
     type_map::build_type_with_children(
         cx,
@@ -131,7 +130,7 @@ pub(super) fn build_coroutine_di_node<'ll, 'tcx>(
     let containing_scope = get_namespace_for_item(cx, coroutine_def_id);
     let coroutine_type_and_layout = cx.layout_of(coroutine_type);
 
-    assert!(!wants_c_like_enum_debuginfo(coroutine_type_and_layout));
+    assert!(!wants_c_like_enum_debuginfo(cx.tcx, coroutine_type_and_layout));
 
     let coroutine_type_name = compute_debuginfo_type_name(cx.tcx, coroutine_type, false);
 
@@ -321,7 +320,7 @@ fn build_discr_member_di_node<'ll, 'tcx>(
         &Variants::Single { .. } => None,
 
         &Variants::Multiple { tag_field, .. } => {
-            let tag_base_type = tag_base_type(cx, enum_or_coroutine_type_and_layout);
+            let tag_base_type = tag_base_type(cx.tcx, enum_or_coroutine_type_and_layout);
             let (size, align) = cx.size_and_align_of(tag_base_type);
 
             unsafe {
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/mod.rs b/compiler/rustc_codegen_ssa/src/debuginfo/mod.rs
index 1eaf593a6d77b..0918660e6be88 100644
--- a/compiler/rustc_codegen_ssa/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/debuginfo/mod.rs
@@ -1,6 +1,7 @@
-use rustc_middle::ty::layout::TyAndLayout;
-use rustc_middle::ty::{self};
-use rustc_target::abi::Size;
+use rustc_middle::bug;
+use rustc_middle::ty::layout::{IntegerExt, PrimitiveExt, TyAndLayout};
+use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_target::abi::{Integer, Primitive, Size, TagEncoding, Variants};
 
 // FIXME(eddyb) find a place for this (or a way to replace it).
 pub mod type_names;
@@ -11,13 +12,25 @@ pub mod type_names;
 /// NOTE: This is somewhat inconsistent right now: For empty enums and enums with a single
 ///       fieldless variant, we generate DW_TAG_struct_type, although a
 ///       DW_TAG_enumeration_type would be a better fit.
-pub fn wants_c_like_enum_debuginfo(enum_type_and_layout: TyAndLayout<'_>) -> bool {
+pub fn wants_c_like_enum_debuginfo<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    enum_type_and_layout: TyAndLayout<'tcx>,
+) -> bool {
     match enum_type_and_layout.ty.kind() {
         ty::Adt(adt_def, _) => {
             if !adt_def.is_enum() {
                 return false;
             }
 
+            if type_names::cpp_like_debuginfo(tcx)
+                && tag_base_type_opt(tcx, enum_type_and_layout)
+                    .map(|ty| ty.primitive_size(tcx).bits())
+                    == Some(128)
+            {
+                // C++-like debuginfo never uses the C-like representation for 128-bit enums.
+                return false;
+            }
+
             match adt_def.variants().len() {
                 0 => false,
                 1 => {
@@ -33,3 +46,51 @@ pub fn wants_c_like_enum_debuginfo(enum_type_and_layout: TyAndLayout<'_>) -> boo
         _ => false,
     }
 }
+
+/// Extract the type with which we want to describe the tag of the given enum or coroutine.
+pub fn tag_base_type<'tcx>(tcx: TyCtxt<'tcx>, enum_type_and_layout: TyAndLayout<'tcx>) -> Ty<'tcx> {
+    tag_base_type_opt(tcx, enum_type_and_layout).unwrap_or_else(|| {
+        bug!("tag_base_type() called for enum without tag: {:?}", enum_type_and_layout)
+    })
+}
+
+pub fn tag_base_type_opt<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    enum_type_and_layout: TyAndLayout<'tcx>,
+) -> Option<Ty<'tcx>> {
+    assert!(match enum_type_and_layout.ty.kind() {
+        ty::Coroutine(..) => true,
+        ty::Adt(adt_def, _) => adt_def.is_enum(),
+        _ => false,
+    });
+
+    match enum_type_and_layout.layout.variants() {
+        // A single-variant enum has no discriminant.
+        Variants::Single { .. } => None,
+
+        Variants::Multiple { tag_encoding: TagEncoding::Niche { .. }, tag, .. } => {
+            // Niche tags are always normalized to unsized integers of the correct size.
+            Some(
+                match tag.primitive() {
+                    Primitive::Int(t, _) => t,
+                    Primitive::Float(f) => Integer::from_size(f.size()).unwrap(),
+                    // FIXME(erikdesjardins): handle non-default addrspace ptr sizes
+                    Primitive::Pointer(_) => {
+                        // If the niche is the NULL value of a reference, then `discr_enum_ty` will be
+                        // a RawPtr. CodeView doesn't know what to do with enums whose base type is a
+                        // pointer so we fix this up to just be `usize`.
+                        // DWARF might be able to deal with this but with an integer type we are on
+                        // the safe side there too.
+                        tcx.data_layout.ptr_sized_integer()
+                    }
+                }
+                .to_ty(tcx, false),
+            )
+        }
+
+        Variants::Multiple { tag_encoding: TagEncoding::Direct, tag, .. } => {
+            // Direct tags preserve the sign.
+            Some(tag.primitive().to_ty(tcx))
+        }
+    }
+}
diff --git a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
index 2755803892751..97f52ea1457cf 100644
--- a/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
+++ b/compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs
@@ -85,7 +85,7 @@ fn push_debuginfo_type_name<'tcx>(
             let layout_for_cpp_like_fallback = if cpp_like_debuginfo && def.is_enum() {
                 match tcx.layout_of(ParamEnv::reveal_all().and(t)) {
                     Ok(layout) => {
-                        if !wants_c_like_enum_debuginfo(layout) {
+                        if !wants_c_like_enum_debuginfo(tcx, layout) {
                             Some(layout)
                         } else {
                             // This is a C-like enum so we don't want to use the fallback encoding
@@ -106,6 +106,7 @@ fn push_debuginfo_type_name<'tcx>(
 
             if let Some(ty_and_layout) = layout_for_cpp_like_fallback {
                 msvc_enum_fallback(
+                    tcx,
                     ty_and_layout,
                     &|output, visited| {
                         push_item_name(tcx, def.did(), true, output);
@@ -421,6 +422,7 @@ fn push_debuginfo_type_name<'tcx>(
             if cpp_like_debuginfo && t.is_coroutine() {
                 let ty_and_layout = tcx.layout_of(ParamEnv::reveal_all().and(t)).unwrap();
                 msvc_enum_fallback(
+                    tcx,
                     ty_and_layout,
                     &|output, visited| {
                         push_closure_or_coroutine_name(tcx, def_id, args, true, output, visited);
@@ -455,12 +457,13 @@ fn push_debuginfo_type_name<'tcx>(
     // debugger. For more information, look in
     // rustc_codegen_llvm/src/debuginfo/metadata/enums/cpp_like.rs.
     fn msvc_enum_fallback<'tcx>(
+        tcx: TyCtxt<'tcx>,
         ty_and_layout: TyAndLayout<'tcx>,
         push_inner: &dyn Fn(/*output*/ &mut String, /*visited*/ &mut FxHashSet<Ty<'tcx>>),
         output: &mut String,
         visited: &mut FxHashSet<Ty<'tcx>>,
     ) {
-        assert!(!wants_c_like_enum_debuginfo(ty_and_layout));
+        assert!(!wants_c_like_enum_debuginfo(tcx, ty_and_layout));
         output.push_str("enum2$<");
         push_inner(output, visited);
         push_close_angle_bracket(true, output);
diff --git a/tests/debuginfo/msvc-pretty-enums.rs b/tests/debuginfo/msvc-pretty-enums.rs
index a6032cc864235..a2e2b32cfd116 100644
--- a/tests/debuginfo/msvc-pretty-enums.rs
+++ b/tests/debuginfo/msvc-pretty-enums.rs
@@ -206,6 +206,30 @@
 // cdb-command: dx -r2 arbitrary_discr2,d
 // cdb-check: arbitrary_discr2,d : Def [Type: enum2$<msvc_pretty_enums::ArbitraryDiscr>]
 // cdb-check:     [+0x[...]] __0              : 5678 [Type: unsigned int]
+//
+// cdb-command: dx c_style_u128_a
+// cdb-check: c_style_u128_a   : A [Type: enum2$<msvc_pretty_enums::CStyleU128>]
+//
+// cdb-command: dx c_style_u128_b
+// cdb-check: c_style_u128_b   : B [Type: enum2$<msvc_pretty_enums::CStyleU128>]
+//
+// cdb-command: dx c_style_u128_c
+// cdb-check: c_style_u128_c   : C [Type: enum2$<msvc_pretty_enums::CStyleU128>]
+//
+// cdb-command: dx c_style_u128_d
+// cdb-check: c_style_u128_d   : D [Type: enum2$<msvc_pretty_enums::CStyleU128>]
+//
+// cdb-command: dx c_style_i128_a
+// cdb-check: c_style_i128_a   : A [Type: enum2$<msvc_pretty_enums::CStyleI128>]
+//
+// cdb-command: dx c_style_i128_b
+// cdb-check: c_style_i128_b   : B [Type: enum2$<msvc_pretty_enums::CStyleI128>]
+//
+// cdb-command: dx c_style_i128_c
+// cdb-check: c_style_i128_c   : C [Type: enum2$<msvc_pretty_enums::CStyleI128>]
+//
+// cdb-command: dx c_style_i128_d
+// cdb-check: c_style_i128_d   : D [Type: enum2$<msvc_pretty_enums::CStyleI128>]
 #![feature(rustc_attrs)]
 #![feature(repr128)]
 #![feature(arbitrary_enum_discriminant)]
@@ -270,6 +294,22 @@ enum ArbitraryDiscr {
     Def(u32) = 5000_000,
 }
 
+#[repr(u128)]
+pub enum CStyleU128 {
+    A = 0_u128,
+    B = 1_u128,
+    C = u64::MAX as u128 + 1,
+    D = u128::MAX,
+}
+
+#[repr(i128)]
+pub enum CStyleI128 {
+    A = 0_i128,
+    B = -1_i128,
+    C = i128::MIN,
+    D = i128::MAX,
+}
+
 fn main() {
     let a = Some(CStyleEnum::Low);
     let b = Option::<CStyleEnum>::None;
@@ -313,6 +353,16 @@ fn main() {
     let arbitrary_discr1 = ArbitraryDiscr::Abc(1234);
     let arbitrary_discr2 = ArbitraryDiscr::Def(5678);
 
+    let c_style_u128_a = CStyleU128::A;
+    let c_style_u128_b = CStyleU128::B;
+    let c_style_u128_c = CStyleU128::C;
+    let c_style_u128_d = CStyleU128::D;
+
+    let c_style_i128_a = CStyleI128::A;
+    let c_style_i128_b = CStyleI128::B;
+    let c_style_i128_c = CStyleI128::C;
+    let c_style_i128_d = CStyleI128::D;
+
     zzz(); // #break
 }
 

From 850bcbdc2e18b3e80d7c12cfcc72a5a219ad3872 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 13 Aug 2024 14:17:04 -0400
Subject: [PATCH 241/685] Test showing previous behavior

---
 .../build_correct_coerce.main.built.after.mir  | 18 ++++++++++++++++++
 tests/mir-opt/build_correct_coerce.rs          | 12 ++++++++++++
 2 files changed, 30 insertions(+)
 create mode 100644 tests/mir-opt/build_correct_coerce.main.built.after.mir
 create mode 100644 tests/mir-opt/build_correct_coerce.rs

diff --git a/tests/mir-opt/build_correct_coerce.main.built.after.mir b/tests/mir-opt/build_correct_coerce.main.built.after.mir
new file mode 100644
index 0000000000000..10778bb605e0e
--- /dev/null
+++ b/tests/mir-opt/build_correct_coerce.main.built.after.mir
@@ -0,0 +1,18 @@
+// MIR for `main` after built
+
+fn main() -> () {
+    let mut _0: ();
+    let _1: for<'a> fn(&'a (), &'a ());
+    scope 1 {
+        debug x => _1;
+    }
+
+    bb0: {
+        StorageLive(_1);
+        _1 = foo as for<'a, 'b> fn(&'a (), &'b ()) (PointerCoercion(ReifyFnPointer));
+        FakeRead(ForLet(None), _1);
+        _0 = const ();
+        StorageDead(_1);
+        return;
+    }
+}
diff --git a/tests/mir-opt/build_correct_coerce.rs b/tests/mir-opt/build_correct_coerce.rs
new file mode 100644
index 0000000000000..b6c861636dcaa
--- /dev/null
+++ b/tests/mir-opt/build_correct_coerce.rs
@@ -0,0 +1,12 @@
+// skip-filecheck
+
+// Validate that we record the target for the `as` coercion as `for<'a> fn(&'a (), &'a ())`,
+// and not `for<'a, 'b>(&'a (), &'b ())`. We previously did the latter due to a bug in
+// the code that records adjustments in HIR typeck.
+
+fn foo<'a, 'b>(_: &'a (), _: &'b ()) {}
+
+// EMIT_MIR build_correct_coerce.main.built.after.mir
+fn main() {
+    let x = foo as for<'a> fn(&'a (), &'a ());
+}

From 5df13af56fb1e4454a057e62d96f7bf2a331a563 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 12 Aug 2024 11:59:04 -0400
Subject: [PATCH 242/685] Use the right type when coercing fn items to pointers

---
 compiler/rustc_borrowck/src/type_check/mod.rs          |  8 ++++----
 compiler/rustc_hir_typeck/src/coercion.rs              |  2 +-
 .../mir-opt/build_correct_coerce.main.built.after.mir  |  2 +-
 tests/ui/higher-ranked/subtyping-fn-ptr-coercion.rs    | 10 ++++++++++
 tests/ui/impl-trait/recursive-ice-101862.stderr        |  4 ++--
 tests/ui/traits/next-solver/alias-bound-unsound.rs     |  1 +
 tests/ui/traits/next-solver/alias-bound-unsound.stderr |  8 +++++++-
 7 files changed, 26 insertions(+), 9 deletions(-)
 create mode 100644 tests/ui/higher-ranked/subtyping-fn-ptr-coercion.rs

diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index b13773ffe1460..7da181544324a 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1989,9 +1989,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
                         let ty_fn_ptr_from = Ty::new_fn_ptr(tcx, fn_sig);
 
-                        if let Err(terr) = self.eq_types(
-                            *ty,
+                        if let Err(terr) = self.sub_types(
                             ty_fn_ptr_from,
+                            *ty,
                             location.to_locations(),
                             ConstraintCategory::Cast { unsize_to: None },
                         ) {
@@ -2014,9 +2014,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                         let ty_fn_ptr_from =
                             Ty::new_fn_ptr(tcx, tcx.signature_unclosure(sig, *safety));
 
-                        if let Err(terr) = self.eq_types(
-                            *ty,
+                        if let Err(terr) = self.sub_types(
                             ty_fn_ptr_from,
+                            *ty,
                             location.to_locations(),
                             ConstraintCategory::Cast { unsize_to: None },
                         ) {
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index fcd3798eb48e6..d2fc5a39b1ca0 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -137,7 +137,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 at.lub(DefineOpaqueTypes::Yes, b, a)
             } else {
                 at.sup(DefineOpaqueTypes::Yes, b, a)
-                    .map(|InferOk { value: (), obligations }| InferOk { value: a, obligations })
+                    .map(|InferOk { value: (), obligations }| InferOk { value: b, obligations })
             };
 
             // In the new solver, lazy norm may allow us to shallowly equate
diff --git a/tests/mir-opt/build_correct_coerce.main.built.after.mir b/tests/mir-opt/build_correct_coerce.main.built.after.mir
index 10778bb605e0e..061174d69bb05 100644
--- a/tests/mir-opt/build_correct_coerce.main.built.after.mir
+++ b/tests/mir-opt/build_correct_coerce.main.built.after.mir
@@ -9,7 +9,7 @@ fn main() -> () {
 
     bb0: {
         StorageLive(_1);
-        _1 = foo as for<'a, 'b> fn(&'a (), &'b ()) (PointerCoercion(ReifyFnPointer));
+        _1 = foo as for<'a> fn(&'a (), &'a ()) (PointerCoercion(ReifyFnPointer));
         FakeRead(ForLet(None), _1);
         _0 = const ();
         StorageDead(_1);
diff --git a/tests/ui/higher-ranked/subtyping-fn-ptr-coercion.rs b/tests/ui/higher-ranked/subtyping-fn-ptr-coercion.rs
new file mode 100644
index 0000000000000..0cecf6808f229
--- /dev/null
+++ b/tests/ui/higher-ranked/subtyping-fn-ptr-coercion.rs
@@ -0,0 +1,10 @@
+//@ check-pass
+
+// Check that we use subtyping when reifying a closure into a function pointer.
+
+fn foo(x: &str) {}
+
+fn main() {
+    let c = |_: &str| {};
+    let x = c as fn(&'static str);
+}
diff --git a/tests/ui/impl-trait/recursive-ice-101862.stderr b/tests/ui/impl-trait/recursive-ice-101862.stderr
index f4148720c3331..970373422e8a5 100644
--- a/tests/ui/impl-trait/recursive-ice-101862.stderr
+++ b/tests/ui/impl-trait/recursive-ice-101862.stderr
@@ -11,13 +11,13 @@ LL |     vec![].append(&mut ice(x.as_ref()));
    = note: `#[warn(unconditional_recursion)]` on by default
 
 error[E0792]: expected generic type parameter, found `&str`
-  --> $DIR/recursive-ice-101862.rs:6:5
+  --> $DIR/recursive-ice-101862.rs:6:19
    |
 LL | pub fn ice(x: impl AsRef<str>) -> impl IntoIterator<Item = ()> {
    |               --------------- this generic parameter must be used with a generic type parameter
 LL |
 LL |     vec![].append(&mut ice(x.as_ref()));
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                   ^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/traits/next-solver/alias-bound-unsound.rs b/tests/ui/traits/next-solver/alias-bound-unsound.rs
index a5bd3e7afa846..272e5db3b7ad2 100644
--- a/tests/ui/traits/next-solver/alias-bound-unsound.rs
+++ b/tests/ui/traits/next-solver/alias-bound-unsound.rs
@@ -27,5 +27,6 @@ fn main() {
     //~| ERROR overflow evaluating the requirement `&<() as Foo>::Item well-formed`
     //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
     //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
+    //~| ERROR overflow evaluating the requirement `<() as Foo>::Item == _`
     println!("{x}");
 }
diff --git a/tests/ui/traits/next-solver/alias-bound-unsound.stderr b/tests/ui/traits/next-solver/alias-bound-unsound.stderr
index a5c2f215134a9..e5cf5b6bc3d30 100644
--- a/tests/ui/traits/next-solver/alias-bound-unsound.stderr
+++ b/tests/ui/traits/next-solver/alias-bound-unsound.stderr
@@ -44,6 +44,12 @@ LL |     drop(<() as Foo>::copy_me(&x));
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
-error: aborting due to 6 previous errors
+error[E0275]: overflow evaluating the requirement `<() as Foo>::Item == _`
+  --> $DIR/alias-bound-unsound.rs:24:31
+   |
+LL |     drop(<() as Foo>::copy_me(&x));
+   |                               ^^
+
+error: aborting due to 7 previous errors
 
 For more information about this error, try `rustc --explain E0275`.

From 0a34ce49ceab68a75dd34f1e76555396a8b5b2c8 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Tue, 13 Aug 2024 12:29:46 -0700
Subject: [PATCH 243/685] Add and use `IndexVec::append`

---
 compiler/rustc_index/src/vec.rs            | 5 +++++
 compiler/rustc_mir_transform/src/inline.rs | 4 ++--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_index/src/vec.rs b/compiler/rustc_index/src/vec.rs
index 7438c97eb581c..1cb8bc861af98 100644
--- a/compiler/rustc_index/src/vec.rs
+++ b/compiler/rustc_index/src/vec.rs
@@ -188,6 +188,11 @@ impl<I: Idx, T> IndexVec<I, T> {
         let min_new_len = elem.index() + 1;
         self.raw.resize_with(min_new_len, fill_value);
     }
+
+    #[inline]
+    pub fn append(&mut self, other: &mut Self) {
+        self.raw.append(&mut other.raw);
+    }
 }
 
 /// `IndexVec` is often used as a map, so it provides some map-like APIs.
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 324ddc5e799d5..61fc5fc881606 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -726,7 +726,7 @@ impl<'tcx> Inliner<'tcx> {
 
         // Insert all of the (mapped) parts of the callee body into the caller.
         caller_body.local_decls.extend(callee_body.drain_vars_and_temps());
-        caller_body.source_scopes.extend(&mut callee_body.source_scopes.drain(..));
+        caller_body.source_scopes.append(&mut callee_body.source_scopes);
         if self
             .tcx
             .sess
@@ -740,7 +740,7 @@ impl<'tcx> Inliner<'tcx> {
             // still getting consistent results from the mir-opt tests.
             caller_body.var_debug_info.append(&mut callee_body.var_debug_info);
         }
-        caller_body.basic_blocks_mut().extend(callee_body.basic_blocks_mut().drain(..));
+        caller_body.basic_blocks_mut().append(callee_body.basic_blocks_mut());
 
         caller_body[callsite.block].terminator = Some(Terminator {
             source_info: callsite.source_info,

From bac19686a5f7a4cfa7dd4e311769a7e5c50931a3 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 13 Aug 2024 16:44:37 -0400
Subject: [PATCH 244/685] Use is_lang_item more

---
 compiler/rustc_hir_typeck/src/check.rs                 | 10 +++-------
 compiler/rustc_lint/src/for_loops_over_fallibles.rs    |  7 +++++--
 compiler/rustc_lint/src/traits.rs                      |  2 +-
 compiler/rustc_middle/src/ty/diagnostics.rs            |  8 ++++----
 compiler/rustc_middle/src/ty/instance.rs               |  2 +-
 compiler/rustc_middle/src/ty/print/pretty.rs           |  4 +++-
 compiler/rustc_middle/src/ty/sty.rs                    |  2 +-
 compiler/rustc_monomorphize/src/partitioning.rs        |  4 +++-
 .../src/error_reporting/traits/fulfillment_errors.rs   |  3 +--
 .../src/error_reporting/traits/suggestions.rs          |  2 +-
 .../src/traits/query/type_op/prove_predicate.rs        |  4 ++--
 compiler/rustc_ty_utils/src/abi.rs                     |  2 +-
 12 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/check.rs b/compiler/rustc_hir_typeck/src/check.rs
index 89df464cca040..cd357e4a7adb5 100644
--- a/compiler/rustc_hir_typeck/src/check.rs
+++ b/compiler/rustc_hir_typeck/src/check.rs
@@ -160,15 +160,11 @@ pub(super) fn check_fn<'a, 'tcx>(
     fcx.demand_suptype(span, ret_ty, actual_return_ty);
 
     // Check that a function marked as `#[panic_handler]` has signature `fn(&PanicInfo) -> !`
-    if let Some(panic_impl_did) = tcx.lang_items().panic_impl()
-        && panic_impl_did == fn_def_id.to_def_id()
-    {
-        check_panic_info_fn(tcx, panic_impl_did.expect_local(), fn_sig);
+    if tcx.is_lang_item(fn_def_id.to_def_id(), LangItem::PanicImpl) {
+        check_panic_info_fn(tcx, fn_def_id, fn_sig);
     }
 
-    if let Some(lang_start_defid) = tcx.lang_items().start_fn()
-        && lang_start_defid == fn_def_id.to_def_id()
-    {
+    if tcx.is_lang_item(fn_def_id.to_def_id(), LangItem::Start) {
         check_lang_start_fn(tcx, fn_sig, fn_def_id);
     }
 
diff --git a/compiler/rustc_lint/src/for_loops_over_fallibles.rs b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
index 6cb5263ac5432..2793d48dc512b 100644
--- a/compiler/rustc_lint/src/for_loops_over_fallibles.rs
+++ b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
@@ -1,5 +1,5 @@
 use hir::{Expr, Pat};
-use rustc_hir as hir;
+use rustc_hir::{self as hir, LangItem};
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::ty;
@@ -126,7 +126,10 @@ fn extract_iterator_next_call<'tcx>(
 ) -> Option<&'tcx Expr<'tcx>> {
     // This won't work for `Iterator::next(iter)`, is this an issue?
     if let hir::ExprKind::MethodCall(_, recv, _, _) = expr.kind
-        && cx.typeck_results().type_dependent_def_id(expr.hir_id) == cx.tcx.lang_items().next_fn()
+        && cx
+            .typeck_results()
+            .type_dependent_def_id(expr.hir_id)
+            .is_some_and(|def_id| cx.tcx.is_lang_item(def_id, LangItem::IteratorNext))
     {
         Some(recv)
     } else {
diff --git a/compiler/rustc_lint/src/traits.rs b/compiler/rustc_lint/src/traits.rs
index fea96b5366e6c..a0fe4b5af7402 100644
--- a/compiler/rustc_lint/src/traits.rs
+++ b/compiler/rustc_lint/src/traits.rs
@@ -114,7 +114,7 @@ impl<'tcx> LateLintPass<'tcx> for DropTraitConstraints {
         let hir::TyKind::TraitObject(bounds, _lifetime, _syntax) = &ty.kind else { return };
         for (bound, modifier) in &bounds[..] {
             let def_id = bound.trait_ref.trait_def_id();
-            if cx.tcx.lang_items().drop_trait() == def_id
+            if def_id.is_some_and(|def_id| cx.tcx.is_lang_item(def_id, LangItem::Drop))
                 && *modifier != hir::TraitBoundModifier::Maybe
             {
                 let Some(def_id) = cx.tcx.get_diagnostic_item(sym::needs_drop) else { return };
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index 5acc0b7ac7ff1..c14dadc68c903 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -6,10 +6,9 @@ use std::ops::ControlFlow;
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{into_diag_arg_using_display, Applicability, Diag, DiagArgValue, IntoDiagArg};
-use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
-use rustc_hir::{PredicateOrigin, WherePredicate};
+use rustc_hir::{self as hir, LangItem, PredicateOrigin, WherePredicate};
 use rustc_span::{BytePos, Span};
 use rustc_type_ir::TyKind::*;
 
@@ -290,8 +289,9 @@ pub fn suggest_constraining_type_params<'a>(
         let Some(param) = param else { return false };
 
         {
-            let mut sized_constraints =
-                constraints.extract_if(|(_, def_id)| *def_id == tcx.lang_items().sized_trait());
+            let mut sized_constraints = constraints.extract_if(|(_, def_id)| {
+                def_id.is_some_and(|def_id| tcx.is_lang_item(def_id, LangItem::Sized))
+            });
             if let Some((_, def_id)) = sized_constraints.next() {
                 applicability = Applicability::MaybeIncorrect;
 
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index 0496c571f5e0a..6f19739de45ff 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -838,7 +838,7 @@ impl<'tcx> Instance<'tcx> {
             return None;
         };
 
-        if tcx.lang_items().get(coroutine_callable_item) == Some(trait_item_id) {
+        if tcx.is_lang_item(trait_item_id, coroutine_callable_item) {
             let ty::Coroutine(_, id_args) = *tcx.type_of(coroutine_def_id).skip_binder().kind()
             else {
                 bug!()
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 29d72183dd3ff..4635de02e90a8 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1145,7 +1145,9 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                         let term = if let Some(ty) = term.skip_binder().as_type()
                             && let ty::Alias(ty::Projection, proj) = ty.kind()
                             && let Some(assoc) = tcx.opt_associated_item(proj.def_id)
-                            && assoc.trait_container(tcx) == tcx.lang_items().coroutine_trait()
+                            && assoc
+                                .trait_container(tcx)
+                                .is_some_and(|def_id| tcx.is_lang_item(def_id, LangItem::Coroutine))
                             && assoc.name == rustc_span::sym::Return
                         {
                             if let ty::Coroutine(_, args) = args.type_at(0).kind() {
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 8c97de1c59b26..03de8a5e68901 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -1915,7 +1915,7 @@ impl<'tcx> Ty<'tcx> {
 
     pub fn is_c_void(self, tcx: TyCtxt<'_>) -> bool {
         match self.kind() {
-            ty::Adt(adt, _) => tcx.lang_items().get(LangItem::CVoid) == Some(adt.did()),
+            ty::Adt(adt, _) => tcx.is_lang_item(adt.did(), LangItem::CVoid),
             _ => false,
         }
     }
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
index 65a3d8d1742d9..f96329a3403b3 100644
--- a/compiler/rustc_monomorphize/src/partitioning.rs
+++ b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -648,7 +648,9 @@ fn characteristic_def_id_of_mono_item<'tcx>(
 
             if let Some(impl_def_id) = tcx.impl_of_method(def_id) {
                 if tcx.sess.opts.incremental.is_some()
-                    && tcx.trait_id_of_impl(impl_def_id) == tcx.lang_items().drop_trait()
+                    && tcx
+                        .trait_id_of_impl(impl_def_id)
+                        .is_some_and(|def_id| tcx.is_lang_item(def_id, LangItem::Drop))
                 {
                     // Put `Drop::drop` into the same cgu as `drop_in_place`
                     // since `drop_in_place` is the only thing that can
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 95d4509c100a2..98df664adfcca 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -230,8 +230,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                             post_message,
                         );
 
-                        let (err_msg, safe_transmute_explanation) = if Some(main_trait_ref.def_id())
-                            == self.tcx.lang_items().transmute_trait()
+                        let (err_msg, safe_transmute_explanation) = if self.tcx.is_lang_item(main_trait_ref.def_id(), LangItem::TransmuteTrait)
                         {
                             // Recompute the safe transmute reason and use that for the error reporting
                             match self.get_safe_transmute_error_and_reason(
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index 9269177eb5035..7bc74e2afe5fc 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -2829,7 +2829,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                                     // Do not suggest relaxing if there is an explicit `Sized` obligation.
                                     && !bounds.iter()
                                         .filter_map(|bound| bound.trait_ref())
-                                        .any(|tr| tr.trait_def_id() == tcx.lang_items().sized_trait())
+                                        .any(|tr| tr.trait_def_id().is_some_and(|def_id| tcx.is_lang_item(def_id, LangItem::Sized)))
                                 {
                                     let (span, separator) = if let [.., last] = bounds {
                                         (last.span().shrink_to_hi(), " +")
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs
index 294c6bfc1243d..d6687c762c311 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/prove_predicate.rs
@@ -1,3 +1,4 @@
+use rustc_hir::LangItem;
 use rustc_infer::traits::Obligation;
 pub use rustc_middle::traits::query::type_op::ProvePredicate;
 use rustc_middle::traits::query::NoSolution;
@@ -20,8 +21,7 @@ impl<'tcx> super::QueryTypeOp<'tcx> for ProvePredicate<'tcx> {
         // such cases.
         if let ty::PredicateKind::Clause(ty::ClauseKind::Trait(trait_ref)) =
             key.value.predicate.kind().skip_binder()
-            && let Some(sized_def_id) = tcx.lang_items().sized_trait()
-            && trait_ref.def_id() == sized_def_id
+            && tcx.is_lang_item(trait_ref.def_id(), LangItem::Sized)
             && trait_ref.self_ty().is_trivially_sized(tcx)
         {
             return Some(());
diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index d90c3bedc7017..34c426f2aa6df 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -621,7 +621,7 @@ fn fn_abi_new_uncached<'tcx>(
     let rust_abi = matches!(sig.abi, RustIntrinsic | Rust | RustCall);
 
     let is_drop_in_place =
-        fn_def_id.is_some() && fn_def_id == cx.tcx.lang_items().drop_in_place_fn();
+        fn_def_id.is_some_and(|def_id| cx.tcx.is_lang_item(def_id, LangItem::DropInPlace));
 
     let arg_of = |ty: Ty<'tcx>, arg_idx: Option<usize>| -> Result<_, &'tcx FnAbiError<'tcx>> {
         let span = tracing::debug_span!("arg_of");

From 249a588cadc31b78cb6e57017a2a86f861648638 Mon Sep 17 00:00:00 2001
From: Nadrieril <nadrieril+git@gmail.com>
Date: Tue, 13 Aug 2024 22:58:54 +0200
Subject: [PATCH 245/685] Remove a no-longer-true `assert`

---
 .../src/thir/pattern/check_match.rs           | 10 ++-
 .../empty-types.exhaustive_patterns.stderr    | 44 +++++-----
 .../usefulness/empty-types.never_pats.stderr  | 86 +++++++++++--------
 .../usefulness/empty-types.normal.stderr      | 86 +++++++++++--------
 tests/ui/pattern/usefulness/empty-types.rs    | 11 ++-
 5 files changed, 138 insertions(+), 99 deletions(-)

diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index 07bf222fcca46..85b9dacb1293c 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -702,10 +702,12 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             && adt.is_enum()
             && let Constructor::Variant(variant_index) = witness_1.ctor()
         {
-            let variant = adt.variant(*variant_index);
-            let inhabited = variant.inhabited_predicate(self.tcx, *adt).instantiate(self.tcx, args);
-            assert!(inhabited.apply(self.tcx, cx.param_env, cx.module));
-            !inhabited.apply_ignore_module(self.tcx, cx.param_env)
+            let variant_inhabited = adt
+                .variant(*variant_index)
+                .inhabited_predicate(self.tcx, *adt)
+                .instantiate(self.tcx, args);
+            variant_inhabited.apply(self.tcx, cx.param_env, cx.module)
+                && !variant_inhabited.apply_ignore_module(self.tcx, cx.param_env)
         } else {
             false
         };
diff --git a/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
index 17cb6fbd94b88..f6f341d6f2f1e 100644
--- a/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
@@ -254,7 +254,7 @@ LL |             _ => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:279:9
+  --> $DIR/empty-types.rs:281:9
    |
 LL |         _ => {}
    |         ^
@@ -262,7 +262,7 @@ LL |         _ => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:282:9
+  --> $DIR/empty-types.rs:284:9
    |
 LL |         (_, _) => {}
    |         ^^^^^^
@@ -270,7 +270,7 @@ LL |         (_, _) => {}
    = note: this pattern matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:285:9
+  --> $DIR/empty-types.rs:287:9
    |
 LL |         Ok(_) => {}
    |         ^^^^^
@@ -278,7 +278,7 @@ LL |         Ok(_) => {}
    = note: this pattern matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:286:9
+  --> $DIR/empty-types.rs:288:9
    |
 LL |         Err(_) => {}
    |         ^^^^^^
@@ -286,7 +286,7 @@ LL |         Err(_) => {}
    = note: this pattern matches no values because `Result<!, !>` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
-  --> $DIR/empty-types.rs:318:11
+  --> $DIR/empty-types.rs:327:11
    |
 LL |     match slice_never {}
    |           ^^^^^^^^^^^
@@ -300,7 +300,7 @@ LL +     }
    |
 
 error[E0004]: non-exhaustive patterns: `&[]` not covered
-  --> $DIR/empty-types.rs:329:11
+  --> $DIR/empty-types.rs:338:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ pattern `&[]` not covered
@@ -313,7 +313,7 @@ LL +         &[] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `&[]` not covered
-  --> $DIR/empty-types.rs:343:11
+  --> $DIR/empty-types.rs:352:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ pattern `&[]` not covered
@@ -327,7 +327,7 @@ LL +         &[] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: type `[!]` is non-empty
-  --> $DIR/empty-types.rs:350:11
+  --> $DIR/empty-types.rs:359:11
    |
 LL |     match *slice_never {}
    |           ^^^^^^^^^^^^
@@ -341,7 +341,7 @@ LL +     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:359:9
+  --> $DIR/empty-types.rs:368:9
    |
 LL |         _ => {}
    |         ^
@@ -349,7 +349,7 @@ LL |         _ => {}
    = note: this pattern matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:362:9
+  --> $DIR/empty-types.rs:371:9
    |
 LL |         [_, _, _] => {}
    |         ^^^^^^^^^
@@ -357,7 +357,7 @@ LL |         [_, _, _] => {}
    = note: this pattern matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:365:9
+  --> $DIR/empty-types.rs:374:9
    |
 LL |         [_, ..] => {}
    |         ^^^^^^^
@@ -365,7 +365,7 @@ LL |         [_, ..] => {}
    = note: this pattern matches no values because `[!; 3]` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
-  --> $DIR/empty-types.rs:379:11
+  --> $DIR/empty-types.rs:388:11
    |
 LL |     match array_0_never {}
    |           ^^^^^^^^^^^^^
@@ -379,7 +379,7 @@ LL +     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:386:9
+  --> $DIR/empty-types.rs:395:9
    |
 LL |         [] => {}
    |         -- matches all the values already
@@ -387,7 +387,7 @@ LL |         _ => {}
    |         ^ unreachable pattern
 
 error[E0004]: non-exhaustive patterns: `[]` not covered
-  --> $DIR/empty-types.rs:388:11
+  --> $DIR/empty-types.rs:397:11
    |
 LL |     match array_0_never {
    |           ^^^^^^^^^^^^^ pattern `[]` not covered
@@ -401,7 +401,7 @@ LL +         [] => todo!()
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:407:9
+  --> $DIR/empty-types.rs:416:9
    |
 LL |         Some(_) => {}
    |         ^^^^^^^
@@ -409,7 +409,7 @@ LL |         Some(_) => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:412:9
+  --> $DIR/empty-types.rs:421:9
    |
 LL |         Some(_a) => {}
    |         ^^^^^^^^
@@ -417,7 +417,7 @@ LL |         Some(_a) => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:417:9
+  --> $DIR/empty-types.rs:426:9
    |
 LL |         None => {}
    |         ---- matches all the values already
@@ -426,7 +426,7 @@ LL |         _ => {}
    |         ^ unreachable pattern
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:422:9
+  --> $DIR/empty-types.rs:431:9
    |
 LL |         None => {}
    |         ---- matches all the values already
@@ -435,7 +435,7 @@ LL |         _a => {}
    |         ^^ unreachable pattern
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:594:9
+  --> $DIR/empty-types.rs:603:9
    |
 LL |         _ => {}
    |         ^
@@ -443,7 +443,7 @@ LL |         _ => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:597:9
+  --> $DIR/empty-types.rs:606:9
    |
 LL |         _x => {}
    |         ^^
@@ -451,7 +451,7 @@ LL |         _x => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:600:9
+  --> $DIR/empty-types.rs:609:9
    |
 LL |         _ if false => {}
    |         ^
@@ -459,7 +459,7 @@ LL |         _ if false => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:603:9
+  --> $DIR/empty-types.rs:612:9
    |
 LL |         _x if false => {}
    |         ^^
diff --git a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
index 1ecb15f2cae3a..55a138c2d1cb2 100644
--- a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
@@ -296,7 +296,7 @@ LL |             _ => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:279:9
+  --> $DIR/empty-types.rs:281:9
    |
 LL |         _ => {}
    |         ^
@@ -304,7 +304,7 @@ LL |         _ => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:282:9
+  --> $DIR/empty-types.rs:284:9
    |
 LL |         (_, _) => {}
    |         ^^^^^^
@@ -312,7 +312,7 @@ LL |         (_, _) => {}
    = note: this pattern matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:285:9
+  --> $DIR/empty-types.rs:287:9
    |
 LL |         Ok(_) => {}
    |         ^^^^^
@@ -320,15 +320,29 @@ LL |         Ok(_) => {}
    = note: this pattern matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:286:9
+  --> $DIR/empty-types.rs:288:9
    |
 LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: this pattern matches no values because `Result<!, !>` is uninhabited
 
+error[E0005]: refutable pattern in local binding
+  --> $DIR/empty-types.rs:297:13
+   |
+LL |         let Ok(_) = *ptr_result_never_err;
+   |             ^^^^^ pattern `Err(!)` not covered
+   |
+   = note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
+   = note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
+   = note: the matched value is of type `Result<u8, !>`
+help: you might want to use `if let` to ignore the variant that isn't matched
+   |
+LL |         if let Ok(_) = *ptr_result_never_err { todo!() };
+   |         ++                                   +++++++++++
+
 error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
-  --> $DIR/empty-types.rs:307:11
+  --> $DIR/empty-types.rs:316:11
    |
 LL |     match *x {}
    |           ^^
@@ -342,7 +356,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `(!, !)` is non-empty
-  --> $DIR/empty-types.rs:309:11
+  --> $DIR/empty-types.rs:318:11
    |
 LL |     match *x {}
    |           ^^
@@ -356,7 +370,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(!)` and `Err(!)` not covered
-  --> $DIR/empty-types.rs:311:11
+  --> $DIR/empty-types.rs:320:11
    |
 LL |     match *x {}
    |           ^^ patterns `Ok(!)` and `Err(!)` not covered
@@ -378,7 +392,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `[!; 3]` is non-empty
-  --> $DIR/empty-types.rs:313:11
+  --> $DIR/empty-types.rs:322:11
    |
 LL |     match *x {}
    |           ^^
@@ -392,7 +406,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
-  --> $DIR/empty-types.rs:318:11
+  --> $DIR/empty-types.rs:327:11
    |
 LL |     match slice_never {}
    |           ^^^^^^^^^^^
@@ -406,7 +420,7 @@ LL +     }
    |
 
 error[E0004]: non-exhaustive patterns: `&[!, ..]` not covered
-  --> $DIR/empty-types.rs:320:11
+  --> $DIR/empty-types.rs:329:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ pattern `&[!, ..]` not covered
@@ -420,7 +434,7 @@ LL +         &[!, ..]
    |
 
 error[E0004]: non-exhaustive patterns: `&[]`, `&[!]` and `&[!, !]` not covered
-  --> $DIR/empty-types.rs:329:11
+  --> $DIR/empty-types.rs:338:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ patterns `&[]`, `&[!]` and `&[!, !]` not covered
@@ -433,7 +447,7 @@ LL +         &[] | &[!] | &[!, !] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `&[]` and `&[!, ..]` not covered
-  --> $DIR/empty-types.rs:343:11
+  --> $DIR/empty-types.rs:352:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ patterns `&[]` and `&[!, ..]` not covered
@@ -447,7 +461,7 @@ LL +         &[] | &[!, ..] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: type `[!]` is non-empty
-  --> $DIR/empty-types.rs:350:11
+  --> $DIR/empty-types.rs:359:11
    |
 LL |     match *slice_never {}
    |           ^^^^^^^^^^^^
@@ -461,7 +475,7 @@ LL +     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:359:9
+  --> $DIR/empty-types.rs:368:9
    |
 LL |         _ => {}
    |         ^
@@ -469,7 +483,7 @@ LL |         _ => {}
    = note: this pattern matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:362:9
+  --> $DIR/empty-types.rs:371:9
    |
 LL |         [_, _, _] => {}
    |         ^^^^^^^^^
@@ -477,7 +491,7 @@ LL |         [_, _, _] => {}
    = note: this pattern matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:365:9
+  --> $DIR/empty-types.rs:374:9
    |
 LL |         [_, ..] => {}
    |         ^^^^^^^
@@ -485,7 +499,7 @@ LL |         [_, ..] => {}
    = note: this pattern matches no values because `[!; 3]` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
-  --> $DIR/empty-types.rs:379:11
+  --> $DIR/empty-types.rs:388:11
    |
 LL |     match array_0_never {}
    |           ^^^^^^^^^^^^^
@@ -499,7 +513,7 @@ LL +     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:386:9
+  --> $DIR/empty-types.rs:395:9
    |
 LL |         [] => {}
    |         -- matches all the values already
@@ -507,7 +521,7 @@ LL |         _ => {}
    |         ^ unreachable pattern
 
 error[E0004]: non-exhaustive patterns: `[]` not covered
-  --> $DIR/empty-types.rs:388:11
+  --> $DIR/empty-types.rs:397:11
    |
 LL |     match array_0_never {
    |           ^^^^^^^^^^^^^ pattern `[]` not covered
@@ -521,7 +535,7 @@ LL +         [] => todo!()
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:407:9
+  --> $DIR/empty-types.rs:416:9
    |
 LL |         Some(_) => {}
    |         ^^^^^^^
@@ -529,7 +543,7 @@ LL |         Some(_) => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:412:9
+  --> $DIR/empty-types.rs:421:9
    |
 LL |         Some(_a) => {}
    |         ^^^^^^^^
@@ -537,7 +551,7 @@ LL |         Some(_a) => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:417:9
+  --> $DIR/empty-types.rs:426:9
    |
 LL |         None => {}
    |         ---- matches all the values already
@@ -546,7 +560,7 @@ LL |         _ => {}
    |         ^ unreachable pattern
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:422:9
+  --> $DIR/empty-types.rs:431:9
    |
 LL |         None => {}
    |         ---- matches all the values already
@@ -555,7 +569,7 @@ LL |         _a => {}
    |         ^^ unreachable pattern
 
 error[E0004]: non-exhaustive patterns: `&Some(!)` not covered
-  --> $DIR/empty-types.rs:442:11
+  --> $DIR/empty-types.rs:451:11
    |
 LL |     match ref_opt_never {
    |           ^^^^^^^^^^^^^ pattern `&Some(!)` not covered
@@ -574,7 +588,7 @@ LL +         &Some(!)
    |
 
 error[E0004]: non-exhaustive patterns: `Some(!)` not covered
-  --> $DIR/empty-types.rs:483:11
+  --> $DIR/empty-types.rs:492:11
    |
 LL |     match *ref_opt_never {
    |           ^^^^^^^^^^^^^^ pattern `Some(!)` not covered
@@ -593,7 +607,7 @@ LL +         Some(!)
    |
 
 error[E0004]: non-exhaustive patterns: `Err(!)` not covered
-  --> $DIR/empty-types.rs:531:11
+  --> $DIR/empty-types.rs:540:11
    |
 LL |     match *ref_res_never {
    |           ^^^^^^^^^^^^^^ pattern `Err(!)` not covered
@@ -612,7 +626,7 @@ LL +         Err(!)
    |
 
 error[E0004]: non-exhaustive patterns: `Err(!)` not covered
-  --> $DIR/empty-types.rs:542:11
+  --> $DIR/empty-types.rs:551:11
    |
 LL |     match *ref_res_never {
    |           ^^^^^^^^^^^^^^ pattern `Err(!)` not covered
@@ -631,7 +645,7 @@ LL +         Err(!)
    |
 
 error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
-  --> $DIR/empty-types.rs:561:11
+  --> $DIR/empty-types.rs:570:11
    |
 LL |     match *ref_tuple_half_never {}
    |           ^^^^^^^^^^^^^^^^^^^^^
@@ -645,7 +659,7 @@ LL +     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:594:9
+  --> $DIR/empty-types.rs:603:9
    |
 LL |         _ => {}
    |         ^
@@ -653,7 +667,7 @@ LL |         _ => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:597:9
+  --> $DIR/empty-types.rs:606:9
    |
 LL |         _x => {}
    |         ^^
@@ -661,7 +675,7 @@ LL |         _x => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:600:9
+  --> $DIR/empty-types.rs:609:9
    |
 LL |         _ if false => {}
    |         ^
@@ -669,7 +683,7 @@ LL |         _ if false => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:603:9
+  --> $DIR/empty-types.rs:612:9
    |
 LL |         _x if false => {}
    |         ^^
@@ -677,7 +691,7 @@ LL |         _x if false => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: `&!` not covered
-  --> $DIR/empty-types.rs:628:11
+  --> $DIR/empty-types.rs:637:11
    |
 LL |     match ref_never {
    |           ^^^^^^^^^ pattern `&!` not covered
@@ -693,7 +707,7 @@ LL +         &!
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(!)` not covered
-  --> $DIR/empty-types.rs:644:11
+  --> $DIR/empty-types.rs:653:11
    |
 LL |     match *ref_result_never {
    |           ^^^^^^^^^^^^^^^^^ pattern `Ok(!)` not covered
@@ -712,7 +726,7 @@ LL +         Ok(!)
    |
 
 error[E0004]: non-exhaustive patterns: `Some(!)` not covered
-  --> $DIR/empty-types.rs:664:11
+  --> $DIR/empty-types.rs:673:11
    |
 LL |     match *x {
    |           ^^ pattern `Some(!)` not covered
@@ -730,7 +744,7 @@ LL ~         None => {},
 LL +         Some(!)
    |
 
-error: aborting due to 64 previous errors; 1 warning emitted
+error: aborting due to 65 previous errors; 1 warning emitted
 
 Some errors have detailed explanations: E0004, E0005.
 For more information about an error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/empty-types.normal.stderr b/tests/ui/pattern/usefulness/empty-types.normal.stderr
index c3421cd592edb..83b3989ffdefb 100644
--- a/tests/ui/pattern/usefulness/empty-types.normal.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.normal.stderr
@@ -287,7 +287,7 @@ LL |             _ => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:279:9
+  --> $DIR/empty-types.rs:281:9
    |
 LL |         _ => {}
    |         ^
@@ -295,7 +295,7 @@ LL |         _ => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:282:9
+  --> $DIR/empty-types.rs:284:9
    |
 LL |         (_, _) => {}
    |         ^^^^^^
@@ -303,7 +303,7 @@ LL |         (_, _) => {}
    = note: this pattern matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:285:9
+  --> $DIR/empty-types.rs:287:9
    |
 LL |         Ok(_) => {}
    |         ^^^^^
@@ -311,15 +311,29 @@ LL |         Ok(_) => {}
    = note: this pattern matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:286:9
+  --> $DIR/empty-types.rs:288:9
    |
 LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: this pattern matches no values because `Result<!, !>` is uninhabited
 
+error[E0005]: refutable pattern in local binding
+  --> $DIR/empty-types.rs:297:13
+   |
+LL |         let Ok(_) = *ptr_result_never_err;
+   |             ^^^^^ pattern `Err(_)` not covered
+   |
+   = note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant
+   = note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html
+   = note: the matched value is of type `Result<u8, !>`
+help: you might want to use `if let` to ignore the variant that isn't matched
+   |
+LL |         if let Ok(_) = *ptr_result_never_err { todo!() };
+   |         ++                                   +++++++++++
+
 error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
-  --> $DIR/empty-types.rs:307:11
+  --> $DIR/empty-types.rs:316:11
    |
 LL |     match *x {}
    |           ^^
@@ -333,7 +347,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `(!, !)` is non-empty
-  --> $DIR/empty-types.rs:309:11
+  --> $DIR/empty-types.rs:318:11
    |
 LL |     match *x {}
    |           ^^
@@ -347,7 +361,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` and `Err(_)` not covered
-  --> $DIR/empty-types.rs:311:11
+  --> $DIR/empty-types.rs:320:11
    |
 LL |     match *x {}
    |           ^^ patterns `Ok(_)` and `Err(_)` not covered
@@ -369,7 +383,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `[!; 3]` is non-empty
-  --> $DIR/empty-types.rs:313:11
+  --> $DIR/empty-types.rs:322:11
    |
 LL |     match *x {}
    |           ^^
@@ -383,7 +397,7 @@ LL ~     }
    |
 
 error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
-  --> $DIR/empty-types.rs:318:11
+  --> $DIR/empty-types.rs:327:11
    |
 LL |     match slice_never {}
    |           ^^^^^^^^^^^
@@ -397,7 +411,7 @@ LL +     }
    |
 
 error[E0004]: non-exhaustive patterns: `&[_, ..]` not covered
-  --> $DIR/empty-types.rs:320:11
+  --> $DIR/empty-types.rs:329:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ pattern `&[_, ..]` not covered
@@ -411,7 +425,7 @@ LL +         &[_, ..] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `&[]`, `&[_]` and `&[_, _]` not covered
-  --> $DIR/empty-types.rs:329:11
+  --> $DIR/empty-types.rs:338:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ patterns `&[]`, `&[_]` and `&[_, _]` not covered
@@ -424,7 +438,7 @@ LL +         &[] | &[_] | &[_, _] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `&[]` and `&[_, ..]` not covered
-  --> $DIR/empty-types.rs:343:11
+  --> $DIR/empty-types.rs:352:11
    |
 LL |     match slice_never {
    |           ^^^^^^^^^^^ patterns `&[]` and `&[_, ..]` not covered
@@ -438,7 +452,7 @@ LL +         &[] | &[_, ..] => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: type `[!]` is non-empty
-  --> $DIR/empty-types.rs:350:11
+  --> $DIR/empty-types.rs:359:11
    |
 LL |     match *slice_never {}
    |           ^^^^^^^^^^^^
@@ -452,7 +466,7 @@ LL +     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:359:9
+  --> $DIR/empty-types.rs:368:9
    |
 LL |         _ => {}
    |         ^
@@ -460,7 +474,7 @@ LL |         _ => {}
    = note: this pattern matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:362:9
+  --> $DIR/empty-types.rs:371:9
    |
 LL |         [_, _, _] => {}
    |         ^^^^^^^^^
@@ -468,7 +482,7 @@ LL |         [_, _, _] => {}
    = note: this pattern matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:365:9
+  --> $DIR/empty-types.rs:374:9
    |
 LL |         [_, ..] => {}
    |         ^^^^^^^
@@ -476,7 +490,7 @@ LL |         [_, ..] => {}
    = note: this pattern matches no values because `[!; 3]` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
-  --> $DIR/empty-types.rs:379:11
+  --> $DIR/empty-types.rs:388:11
    |
 LL |     match array_0_never {}
    |           ^^^^^^^^^^^^^
@@ -490,7 +504,7 @@ LL +     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:386:9
+  --> $DIR/empty-types.rs:395:9
    |
 LL |         [] => {}
    |         -- matches all the values already
@@ -498,7 +512,7 @@ LL |         _ => {}
    |         ^ unreachable pattern
 
 error[E0004]: non-exhaustive patterns: `[]` not covered
-  --> $DIR/empty-types.rs:388:11
+  --> $DIR/empty-types.rs:397:11
    |
 LL |     match array_0_never {
    |           ^^^^^^^^^^^^^ pattern `[]` not covered
@@ -512,7 +526,7 @@ LL +         [] => todo!()
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:407:9
+  --> $DIR/empty-types.rs:416:9
    |
 LL |         Some(_) => {}
    |         ^^^^^^^
@@ -520,7 +534,7 @@ LL |         Some(_) => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:412:9
+  --> $DIR/empty-types.rs:421:9
    |
 LL |         Some(_a) => {}
    |         ^^^^^^^^
@@ -528,7 +542,7 @@ LL |         Some(_a) => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:417:9
+  --> $DIR/empty-types.rs:426:9
    |
 LL |         None => {}
    |         ---- matches all the values already
@@ -537,7 +551,7 @@ LL |         _ => {}
    |         ^ unreachable pattern
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:422:9
+  --> $DIR/empty-types.rs:431:9
    |
 LL |         None => {}
    |         ---- matches all the values already
@@ -546,7 +560,7 @@ LL |         _a => {}
    |         ^^ unreachable pattern
 
 error[E0004]: non-exhaustive patterns: `&Some(_)` not covered
-  --> $DIR/empty-types.rs:442:11
+  --> $DIR/empty-types.rs:451:11
    |
 LL |     match ref_opt_never {
    |           ^^^^^^^^^^^^^ pattern `&Some(_)` not covered
@@ -565,7 +579,7 @@ LL +         &Some(_) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Some(_)` not covered
-  --> $DIR/empty-types.rs:483:11
+  --> $DIR/empty-types.rs:492:11
    |
 LL |     match *ref_opt_never {
    |           ^^^^^^^^^^^^^^ pattern `Some(_)` not covered
@@ -584,7 +598,7 @@ LL +         Some(_) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Err(_)` not covered
-  --> $DIR/empty-types.rs:531:11
+  --> $DIR/empty-types.rs:540:11
    |
 LL |     match *ref_res_never {
    |           ^^^^^^^^^^^^^^ pattern `Err(_)` not covered
@@ -603,7 +617,7 @@ LL +         Err(_) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Err(_)` not covered
-  --> $DIR/empty-types.rs:542:11
+  --> $DIR/empty-types.rs:551:11
    |
 LL |     match *ref_res_never {
    |           ^^^^^^^^^^^^^^ pattern `Err(_)` not covered
@@ -622,7 +636,7 @@ LL +         Err(_) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: type `(u32, !)` is non-empty
-  --> $DIR/empty-types.rs:561:11
+  --> $DIR/empty-types.rs:570:11
    |
 LL |     match *ref_tuple_half_never {}
    |           ^^^^^^^^^^^^^^^^^^^^^
@@ -636,7 +650,7 @@ LL +     }
    |
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:594:9
+  --> $DIR/empty-types.rs:603:9
    |
 LL |         _ => {}
    |         ^
@@ -644,7 +658,7 @@ LL |         _ => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:597:9
+  --> $DIR/empty-types.rs:606:9
    |
 LL |         _x => {}
    |         ^^
@@ -652,7 +666,7 @@ LL |         _x => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:600:9
+  --> $DIR/empty-types.rs:609:9
    |
 LL |         _ if false => {}
    |         ^
@@ -660,7 +674,7 @@ LL |         _ if false => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error: unreachable pattern
-  --> $DIR/empty-types.rs:603:9
+  --> $DIR/empty-types.rs:612:9
    |
 LL |         _x if false => {}
    |         ^^
@@ -668,7 +682,7 @@ LL |         _x if false => {}
    = note: this pattern matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: `&_` not covered
-  --> $DIR/empty-types.rs:628:11
+  --> $DIR/empty-types.rs:637:11
    |
 LL |     match ref_never {
    |           ^^^^^^^^^ pattern `&_` not covered
@@ -684,7 +698,7 @@ LL +         &_ => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
-  --> $DIR/empty-types.rs:644:11
+  --> $DIR/empty-types.rs:653:11
    |
 LL |     match *ref_result_never {
    |           ^^^^^^^^^^^^^^^^^ pattern `Ok(_)` not covered
@@ -703,7 +717,7 @@ LL +         Ok(_) => todo!()
    |
 
 error[E0004]: non-exhaustive patterns: `Some(_)` not covered
-  --> $DIR/empty-types.rs:664:11
+  --> $DIR/empty-types.rs:673:11
    |
 LL |     match *x {
    |           ^^ pattern `Some(_)` not covered
@@ -721,7 +735,7 @@ LL ~         None => {},
 LL +         Some(_) => todo!()
    |
 
-error: aborting due to 64 previous errors
+error: aborting due to 65 previous errors
 
 Some errors have detailed explanations: E0004, E0005.
 For more information about an error, try `rustc --explain E0004`.
diff --git a/tests/ui/pattern/usefulness/empty-types.rs b/tests/ui/pattern/usefulness/empty-types.rs
index 639c48cea12c5..d561a0e9c128b 100644
--- a/tests/ui/pattern/usefulness/empty-types.rs
+++ b/tests/ui/pattern/usefulness/empty-types.rs
@@ -17,7 +17,7 @@
 #[derive(Copy, Clone)]
 enum Void {}
 
-/// A bunch of never situations that can't be normally constructed.
+/// A bunch of never situations that can't be normally constructed so we take them as argument.
 #[derive(Copy, Clone)]
 struct NeverBundle {
     never: !,
@@ -272,6 +272,8 @@ fn nested_validity_tracking(bundle: NeverBundle) {
     let ref_never: &! = &never;
     let tuple_never: (!, !) = bundle.tuple_never;
     let result_never: Result<!, !> = bundle.result_never;
+    let result_never_err: Result<u8, !> = Ok(0);
+    let ptr_result_never_err: *const Result<u8, !> = &result_never_err as *const _;
     let union_never = Uninit::<!>::new();
 
     // These should be considered known_valid and warn unreachable.
@@ -287,6 +289,13 @@ fn nested_validity_tracking(bundle: NeverBundle) {
     }
 
     // These should be considered !known_valid and not warn unreachable.
+    unsafe {
+        match *ptr_result_never_err {
+            Ok(_) => {}
+            Err(_) => {}
+        }
+        let Ok(_) = *ptr_result_never_err; //[normal,never_pats]~ ERROR refutable pattern
+    }
     match ref_never {
         &_ => {}
     }

From 8419c0956e1cee2799984b7b9520a0118ec0cb9c Mon Sep 17 00:00:00 2001
From: Folkert <folkert@folkertdev.nl>
Date: Sat, 10 Aug 2024 18:13:03 +0200
Subject: [PATCH 246/685] stabilize `asm_const`

---
 compiler/rustc_ast_lowering/messages.ftl      |   2 -
 compiler/rustc_ast_lowering/src/asm.rs        |  17 +--
 compiler/rustc_codegen_gcc/tests/run/asm.rs   |  15 +-
 compiler/rustc_feature/src/accepted.rs        |   2 +
 compiler/rustc_feature/src/unstable.rs        |   2 -
 library/core/src/lib.rs                       |   2 +-
 .../src/language-features/asm-const.md        |  11 --
 tests/assembly/asm/global_asm.rs              |   1 -
 tests/assembly/asm/msp430-types.rs            |   2 +-
 tests/ui/asm/aarch64/bad-reg.rs               |   2 -
 tests/ui/asm/aarch64/bad-reg.stderr           |  44 +++---
 tests/ui/asm/aarch64/const.rs                 |   2 -
 tests/ui/asm/aarch64/parse-error.rs           |   2 -
 tests/ui/asm/aarch64/parse-error.stderr       | 118 +++++++-------
 tests/ui/asm/aarch64/type-check-3.rs          |   2 +-
 tests/ui/asm/aarch64/type-check-4.rs          |   5 +-
 tests/ui/asm/aarch64/type-check-4.stderr      |   6 +-
 tests/ui/asm/bad-template.rs                  |   2 +-
 tests/ui/asm/const-error.rs                   |   8 +-
 tests/ui/asm/const-error.stderr               |   6 +-
 tests/ui/asm/fail-const-eval-issue-121099.rs  |   1 -
 .../asm/fail-const-eval-issue-121099.stderr   |   4 +-
 tests/ui/asm/generic-const.rs                 |   2 -
 tests/ui/asm/invalid-const-operand.rs         |   2 -
 tests/ui/asm/invalid-const-operand.stderr     |  16 +-
 tests/ui/asm/naked-functions.rs               |   2 +-
 tests/ui/asm/named-asm-labels.rs              |   6 +-
 tests/ui/asm/named-asm-labels.stderr          |  44 +++---
 tests/ui/asm/parse-error.rs                   |   2 -
 tests/ui/asm/parse-error.stderr               | 144 +++++++++---------
 tests/ui/asm/type-check-1.rs                  |   2 -
 tests/ui/asm/type-check-1.stderr              |  16 +-
 tests/ui/asm/x86_64/bad-reg.rs                |   2 -
 tests/ui/asm/x86_64/bad-reg.stderr            |  60 ++++----
 tests/ui/asm/x86_64/const.rs                  |   2 -
 tests/ui/asm/x86_64/type-check-3.rs           |   2 -
 tests/ui/asm/x86_64/type-check-3.stderr       |  26 ++--
 tests/ui/asm/x86_64/type-check-4.rs           |   2 -
 tests/ui/asm/x86_64/type-check-4.stderr       |   6 +-
 tests/ui/asm/x86_64/x86_64_parse_error.rs     |   2 -
 tests/ui/asm/x86_64/x86_64_parse_error.stderr |  10 +-
 .../feature-gates/feature-gate-asm_const.rs   |  16 --
 .../feature-gate-asm_const.stderr             |  23 ---
 43 files changed, 276 insertions(+), 367 deletions(-)
 delete mode 100644 src/doc/unstable-book/src/language-features/asm-const.md
 delete mode 100644 tests/ui/feature-gates/feature-gate-asm_const.rs
 delete mode 100644 tests/ui/feature-gates/feature-gate-asm_const.stderr

diff --git a/compiler/rustc_ast_lowering/messages.ftl b/compiler/rustc_ast_lowering/messages.ftl
index 0a7f75039f64d..a5ee6713be8ed 100644
--- a/compiler/rustc_ast_lowering/messages.ftl
+++ b/compiler/rustc_ast_lowering/messages.ftl
@@ -175,8 +175,6 @@ ast_lowering_underscore_expr_lhs_assign =
     .label = `_` not allowed here
 
 ast_lowering_unstable_inline_assembly = inline assembly is not stable yet on this architecture
-ast_lowering_unstable_inline_assembly_const_operands =
-    const operands for inline assembly are unstable
 ast_lowering_unstable_inline_assembly_label_operands =
     label operands for inline assembly are unstable
 ast_lowering_unstable_may_unwind = the `may_unwind` option is unstable
diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index 8acca78379b2e..7d9d689e6d7e9 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -183,20 +183,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             out_expr: out_expr.as_ref().map(|expr| self.lower_expr(expr)),
                         }
                     }
-                    InlineAsmOperand::Const { anon_const } => {
-                        if !self.tcx.features().asm_const {
-                            feature_err(
-                                sess,
-                                sym::asm_const,
-                                *op_sp,
-                                fluent::ast_lowering_unstable_inline_assembly_const_operands,
-                            )
-                            .emit();
-                        }
-                        hir::InlineAsmOperand::Const {
-                            anon_const: self.lower_anon_const_to_anon_const(anon_const),
-                        }
-                    }
+                    InlineAsmOperand::Const { anon_const } => hir::InlineAsmOperand::Const {
+                        anon_const: self.lower_anon_const_to_anon_const(anon_const),
+                    },
                     InlineAsmOperand::Sym { sym } => {
                         let static_def_id = self
                             .resolver
diff --git a/compiler/rustc_codegen_gcc/tests/run/asm.rs b/compiler/rustc_codegen_gcc/tests/run/asm.rs
index 56f2aac3d0a1e..4e05d026868e7 100644
--- a/compiler/rustc_codegen_gcc/tests/run/asm.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/asm.rs
@@ -3,12 +3,10 @@
 // Run-time:
 //   status: 0
 
-#![feature(asm_const)]
-
-#[cfg(target_arch="x86_64")]
+#[cfg(target_arch = "x86_64")]
 use std::arch::{asm, global_asm};
 
-#[cfg(target_arch="x86_64")]
+#[cfg(target_arch = "x86_64")]
 global_asm!(
     "
     .global add_asm
@@ -22,7 +20,7 @@ extern "C" {
     fn add_asm(a: i64, b: i64) -> i64;
 }
 
-#[cfg(target_arch="x86_64")]
+#[cfg(target_arch = "x86_64")]
 pub unsafe fn mem_cpy(dst: *mut u8, src: *const u8, len: usize) {
     asm!(
         "rep movsb",
@@ -33,7 +31,7 @@ pub unsafe fn mem_cpy(dst: *mut u8, src: *const u8, len: usize) {
     );
 }
 
-#[cfg(target_arch="x86_64")]
+#[cfg(target_arch = "x86_64")]
 fn asm() {
     unsafe {
         asm!("nop");
@@ -178,9 +176,8 @@ fn asm() {
     assert_eq!(array1, array2);
 }
 
-#[cfg(not(target_arch="x86_64"))]
-fn asm() {
-}
+#[cfg(not(target_arch = "x86_64"))]
+fn asm() {}
 
 fn main() {
     asm();
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 44286cfeeefaa..03b40e28f8b4b 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -60,6 +60,8 @@ declare_features! (
     (accepted, adx_target_feature, "1.61.0", Some(44839)),
     /// Allows explicit discriminants on non-unit enum variants.
     (accepted, arbitrary_enum_discriminant, "1.66.0", Some(60553)),
+    /// Allows using `const` operands in inline assembly.
+    (accepted, asm_const, "CURRENT_RUSTC_VERSION", Some(93332)),
     /// Allows using `sym` operands in inline assembly.
     (accepted, asm_sym, "1.66.0", Some(93333)),
     /// Allows the definition of associated constants in `trait` or `impl` blocks.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 47810bc9165ef..24f691ea7fa20 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -348,8 +348,6 @@ declare_features! (
     (unstable, alloc_error_handler, "1.29.0", Some(51540)),
     /// Allows trait methods with arbitrary self types.
     (unstable, arbitrary_self_types, "1.23.0", Some(44874)),
-    /// Allows using `const` operands in inline assembly.
-    (unstable, asm_const, "1.58.0", Some(93332)),
     /// Enables experimental inline assembly support for additional architectures.
     (unstable, asm_experimental_arch, "1.58.0", Some(93335)),
     /// Allows using `label` operands in inline assembly.
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 07daa32afa8a3..7b8744e2e8202 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -192,12 +192,12 @@
 //
 // Language features:
 // tidy-alphabetical-start
+#![cfg_attr(bootstrap, feature(asm_const))]
 #![cfg_attr(bootstrap, feature(min_exhaustive_patterns))]
 #![feature(abi_unadjusted)]
 #![feature(adt_const_params)]
 #![feature(allow_internal_unsafe)]
 #![feature(allow_internal_unstable)]
-#![feature(asm_const)]
 #![feature(auto_traits)]
 #![feature(cfg_sanitize)]
 #![feature(cfg_target_has_atomic)]
diff --git a/src/doc/unstable-book/src/language-features/asm-const.md b/src/doc/unstable-book/src/language-features/asm-const.md
deleted file mode 100644
index 670c4df414f31..0000000000000
--- a/src/doc/unstable-book/src/language-features/asm-const.md
+++ /dev/null
@@ -1,11 +0,0 @@
-# `asm_const`
-
-The tracking issue for this feature is: [#93332]
-
-[#93332]: https://github.com/rust-lang/rust/issues/93332
-
-------------------------
-
-This feature adds a `const <expr>` operand type to `asm!` and `global_asm!`.
-- `<expr>` must be an integer constant expression.
-- The value of the expression is formatted as a string and substituted directly into the asm template string.
diff --git a/tests/assembly/asm/global_asm.rs b/tests/assembly/asm/global_asm.rs
index 22cf4bdb15b70..8a4bf98c7450b 100644
--- a/tests/assembly/asm/global_asm.rs
+++ b/tests/assembly/asm/global_asm.rs
@@ -4,7 +4,6 @@
 //@ compile-flags: -C llvm-args=--x86-asm-syntax=intel
 //@ compile-flags: -C symbol-mangling-version=v0
 
-#![feature(asm_const)]
 #![crate_type = "rlib"]
 
 use std::arch::global_asm;
diff --git a/tests/assembly/asm/msp430-types.rs b/tests/assembly/asm/msp430-types.rs
index 4f51d4020a66b..ae09b8b070da2 100644
--- a/tests/assembly/asm/msp430-types.rs
+++ b/tests/assembly/asm/msp430-types.rs
@@ -2,7 +2,7 @@
 //@ compile-flags: --target msp430-none-elf
 //@ needs-llvm-components: msp430
 
-#![feature(no_core, lang_items, rustc_attrs, asm_experimental_arch, asm_const)]
+#![feature(no_core, lang_items, rustc_attrs, asm_experimental_arch)]
 #![crate_type = "rlib"]
 #![no_core]
 #![allow(non_camel_case_types)]
diff --git a/tests/ui/asm/aarch64/bad-reg.rs b/tests/ui/asm/aarch64/bad-reg.rs
index 1e54b6505db87..b99e5fe4b9e33 100644
--- a/tests/ui/asm/aarch64/bad-reg.rs
+++ b/tests/ui/asm/aarch64/bad-reg.rs
@@ -1,8 +1,6 @@
 //@ only-aarch64
 //@ compile-flags: -C target-feature=+neon
 
-#![feature(asm_const)]
-
 use std::arch::asm;
 
 fn main() {
diff --git a/tests/ui/asm/aarch64/bad-reg.stderr b/tests/ui/asm/aarch64/bad-reg.stderr
index 717a788caf67d..370752ad0f11c 100644
--- a/tests/ui/asm/aarch64/bad-reg.stderr
+++ b/tests/ui/asm/aarch64/bad-reg.stderr
@@ -1,17 +1,17 @@
 error: invalid register class `foo`: unknown register class
-  --> $DIR/bad-reg.rs:14:20
+  --> $DIR/bad-reg.rs:12:20
    |
 LL |         asm!("{}", in(foo) foo);
    |                    ^^^^^^^^^^^
 
 error: invalid register `foo`: unknown register
-  --> $DIR/bad-reg.rs:16:18
+  --> $DIR/bad-reg.rs:14:18
    |
 LL |         asm!("", in("foo") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid asm template modifier for this register class
-  --> $DIR/bad-reg.rs:18:15
+  --> $DIR/bad-reg.rs:16:15
    |
 LL |         asm!("{:z}", in(reg) foo);
    |               ^^^^   ----------- argument
@@ -21,7 +21,7 @@ LL |         asm!("{:z}", in(reg) foo);
    = note: the `reg` register class supports the following template modifiers: `w`, `x`
 
 error: invalid asm template modifier for this register class
-  --> $DIR/bad-reg.rs:20:15
+  --> $DIR/bad-reg.rs:18:15
    |
 LL |         asm!("{:r}", in(vreg) foo);
    |               ^^^^   ------------ argument
@@ -31,7 +31,7 @@ LL |         asm!("{:r}", in(vreg) foo);
    = note: the `vreg` register class supports the following template modifiers: `b`, `h`, `s`, `d`, `q`, `v`
 
 error: invalid asm template modifier for this register class
-  --> $DIR/bad-reg.rs:22:15
+  --> $DIR/bad-reg.rs:20:15
    |
 LL |         asm!("{:r}", in(vreg_low16) foo);
    |               ^^^^   ------------------ argument
@@ -41,7 +41,7 @@ LL |         asm!("{:r}", in(vreg_low16) foo);
    = note: the `vreg_low16` register class supports the following template modifiers: `b`, `h`, `s`, `d`, `q`, `v`
 
 error: asm template modifiers are not allowed for `const` arguments
-  --> $DIR/bad-reg.rs:24:15
+  --> $DIR/bad-reg.rs:22:15
    |
 LL |         asm!("{:a}", const 0);
    |               ^^^^   ------- argument
@@ -49,7 +49,7 @@ LL |         asm!("{:a}", const 0);
    |               template modifier
 
 error: asm template modifiers are not allowed for `sym` arguments
-  --> $DIR/bad-reg.rs:26:15
+  --> $DIR/bad-reg.rs:24:15
    |
 LL |         asm!("{:a}", sym main);
    |               ^^^^   -------- argument
@@ -57,49 +57,49 @@ LL |         asm!("{:a}", sym main);
    |               template modifier
 
 error: invalid register `x29`: the frame pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:28:18
+  --> $DIR/bad-reg.rs:26:18
    |
 LL |         asm!("", in("x29") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `sp`: the stack pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:30:18
+  --> $DIR/bad-reg.rs:28:18
    |
 LL |         asm!("", in("sp") foo);
    |                  ^^^^^^^^^^^^
 
 error: invalid register `xzr`: the zero register cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:32:18
+  --> $DIR/bad-reg.rs:30:18
    |
 LL |         asm!("", in("xzr") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `x19`: x19 is used internally by LLVM and cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:34:18
+  --> $DIR/bad-reg.rs:32:18
    |
 LL |         asm!("", in("x19") foo);
    |                  ^^^^^^^^^^^^^
 
 error: register class `preg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:37:18
+  --> $DIR/bad-reg.rs:35:18
    |
 LL |         asm!("", in("p0") foo);
    |                  ^^^^^^^^^^^^
 
 error: register class `preg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:41:20
+  --> $DIR/bad-reg.rs:39:20
    |
 LL |         asm!("{}", in(preg) foo);
    |                    ^^^^^^^^^^^^
 
 error: register class `preg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:44:20
+  --> $DIR/bad-reg.rs:42:20
    |
 LL |         asm!("{}", out(preg) _);
    |                    ^^^^^^^^^^^
 
 error: register `w0` conflicts with register `x0`
-  --> $DIR/bad-reg.rs:50:32
+  --> $DIR/bad-reg.rs:48:32
    |
 LL |         asm!("", in("x0") foo, in("w0") bar);
    |                  ------------  ^^^^^^^^^^^^ register `w0`
@@ -107,7 +107,7 @@ LL |         asm!("", in("x0") foo, in("w0") bar);
    |                  register `x0`
 
 error: register `x0` conflicts with register `x0`
-  --> $DIR/bad-reg.rs:52:32
+  --> $DIR/bad-reg.rs:50:32
    |
 LL |         asm!("", in("x0") foo, out("x0") bar);
    |                  ------------  ^^^^^^^^^^^^^ register `x0`
@@ -115,13 +115,13 @@ LL |         asm!("", in("x0") foo, out("x0") bar);
    |                  register `x0`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:52:18
+  --> $DIR/bad-reg.rs:50:18
    |
 LL |         asm!("", in("x0") foo, out("x0") bar);
    |                  ^^^^^^^^^^^^
 
 error: register `q0` conflicts with register `v0`
-  --> $DIR/bad-reg.rs:55:32
+  --> $DIR/bad-reg.rs:53:32
    |
 LL |         asm!("", in("v0") foo, in("q0") bar);
    |                  ------------  ^^^^^^^^^^^^ register `q0`
@@ -129,7 +129,7 @@ LL |         asm!("", in("v0") foo, in("q0") bar);
    |                  register `v0`
 
 error: register `q0` conflicts with register `v0`
-  --> $DIR/bad-reg.rs:57:32
+  --> $DIR/bad-reg.rs:55:32
    |
 LL |         asm!("", in("v0") foo, out("q0") bar);
    |                  ------------  ^^^^^^^^^^^^^ register `q0`
@@ -137,13 +137,13 @@ LL |         asm!("", in("v0") foo, out("q0") bar);
    |                  register `v0`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:57:18
+  --> $DIR/bad-reg.rs:55:18
    |
 LL |         asm!("", in("v0") foo, out("q0") bar);
    |                  ^^^^^^^^^^^^
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:37:27
+  --> $DIR/bad-reg.rs:35:27
    |
 LL |         asm!("", in("p0") foo);
    |                           ^^^
@@ -151,7 +151,7 @@ LL |         asm!("", in("p0") foo);
    = note: register class `preg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:41:29
+  --> $DIR/bad-reg.rs:39:29
    |
 LL |         asm!("{}", in(preg) foo);
    |                             ^^^
diff --git a/tests/ui/asm/aarch64/const.rs b/tests/ui/asm/aarch64/const.rs
index a1fadb2115ba6..3eab5138d7d79 100644
--- a/tests/ui/asm/aarch64/const.rs
+++ b/tests/ui/asm/aarch64/const.rs
@@ -2,8 +2,6 @@
 //@ run-pass
 //@ needs-asm-support
 
-#![feature(asm_const)]
-
 use std::arch::{asm, global_asm};
 
 fn const_generic<const X: usize>() -> usize {
diff --git a/tests/ui/asm/aarch64/parse-error.rs b/tests/ui/asm/aarch64/parse-error.rs
index ac73bbf99c9a3..aa731c35dda88 100644
--- a/tests/ui/asm/aarch64/parse-error.rs
+++ b/tests/ui/asm/aarch64/parse-error.rs
@@ -1,7 +1,5 @@
 //@ only-aarch64
 
-#![feature(asm_const)]
-
 use std::arch::{asm, global_asm};
 
 fn main() {
diff --git a/tests/ui/asm/aarch64/parse-error.stderr b/tests/ui/asm/aarch64/parse-error.stderr
index e2c798c798ee6..7b273282ee6a3 100644
--- a/tests/ui/asm/aarch64/parse-error.stderr
+++ b/tests/ui/asm/aarch64/parse-error.stderr
@@ -1,107 +1,107 @@
 error: requires at least a template string argument
-  --> $DIR/parse-error.rs:11:9
+  --> $DIR/parse-error.rs:9:9
    |
 LL |         asm!();
    |         ^^^^^^
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:13:14
+  --> $DIR/parse-error.rs:11:14
    |
 LL |         asm!(foo);
    |              ^^^
 
 error: expected token: `,`
-  --> $DIR/parse-error.rs:15:19
+  --> $DIR/parse-error.rs:13:19
    |
 LL |         asm!("{}" foo);
    |                   ^^^ expected `,`
 
 error: expected operand, clobber_abi, options, or additional template string
-  --> $DIR/parse-error.rs:17:20
+  --> $DIR/parse-error.rs:15:20
    |
 LL |         asm!("{}", foo);
    |                    ^^^ expected operand, clobber_abi, options, or additional template string
 
 error: expected `(`, found `foo`
-  --> $DIR/parse-error.rs:19:23
+  --> $DIR/parse-error.rs:17:23
    |
 LL |         asm!("{}", in foo);
    |                       ^^^ expected `(`
 
 error: expected `)`, found `foo`
-  --> $DIR/parse-error.rs:21:27
+  --> $DIR/parse-error.rs:19:27
    |
 LL |         asm!("{}", in(reg foo));
    |                           ^^^ expected `)`
 
 error: expected expression, found end of macro arguments
-  --> $DIR/parse-error.rs:23:27
+  --> $DIR/parse-error.rs:21:27
    |
 LL |         asm!("{}", in(reg));
    |                           ^ expected expression
 
 error: expected register class or explicit register
-  --> $DIR/parse-error.rs:25:26
+  --> $DIR/parse-error.rs:23:26
    |
 LL |         asm!("{}", inout(=) foo => bar);
    |                          ^
 
 error: expected expression, found end of macro arguments
-  --> $DIR/parse-error.rs:27:37
+  --> $DIR/parse-error.rs:25:37
    |
 LL |         asm!("{}", inout(reg) foo =>);
    |                                     ^ expected expression
 
 error: expected one of `!`, `,`, `.`, `::`, `?`, `{`, or an operator, found `=>`
-  --> $DIR/parse-error.rs:29:32
+  --> $DIR/parse-error.rs:27:32
    |
 LL |         asm!("{}", in(reg) foo => bar);
    |                                ^^ expected one of 7 possible tokens
 
 error: expected a path for argument to `sym`
-  --> $DIR/parse-error.rs:31:24
+  --> $DIR/parse-error.rs:29:24
    |
 LL |         asm!("{}", sym foo + bar);
    |                        ^^^^^^^^^
 
 error: expected one of `)`, `att_syntax`, `may_unwind`, `nomem`, `noreturn`, `nostack`, `preserves_flags`, `pure`, `raw`, or `readonly`, found `foo`
-  --> $DIR/parse-error.rs:33:26
+  --> $DIR/parse-error.rs:31:26
    |
 LL |         asm!("", options(foo));
    |                          ^^^ expected one of 10 possible tokens
 
 error: expected one of `)` or `,`, found `foo`
-  --> $DIR/parse-error.rs:35:32
+  --> $DIR/parse-error.rs:33:32
    |
 LL |         asm!("", options(nomem foo));
    |                                ^^^ expected one of `)` or `,`
 
 error: expected one of `)`, `att_syntax`, `may_unwind`, `nomem`, `noreturn`, `nostack`, `preserves_flags`, `pure`, `raw`, or `readonly`, found `foo`
-  --> $DIR/parse-error.rs:37:33
+  --> $DIR/parse-error.rs:35:33
    |
 LL |         asm!("", options(nomem, foo));
    |                                 ^^^ expected one of 10 possible tokens
 
 error: expected string literal
-  --> $DIR/parse-error.rs:41:30
+  --> $DIR/parse-error.rs:39:30
    |
 LL |         asm!("", clobber_abi(foo));
    |                              ^^^ not a string literal
 
 error: expected one of `)` or `,`, found `foo`
-  --> $DIR/parse-error.rs:43:34
+  --> $DIR/parse-error.rs:41:34
    |
 LL |         asm!("", clobber_abi("C" foo));
    |                                  ^^^ expected one of `)` or `,`
 
 error: expected string literal
-  --> $DIR/parse-error.rs:45:35
+  --> $DIR/parse-error.rs:43:35
    |
 LL |         asm!("", clobber_abi("C", foo));
    |                                   ^^^ not a string literal
 
 error: duplicate argument named `a`
-  --> $DIR/parse-error.rs:52:36
+  --> $DIR/parse-error.rs:50:36
    |
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                     -------------  ^^^^^^^^^^^^^ duplicate argument
@@ -109,7 +109,7 @@ LL |         asm!("{a}", a = const foo, a = const bar);
    |                     previously here
 
 error: argument never used
-  --> $DIR/parse-error.rs:52:36
+  --> $DIR/parse-error.rs:50:36
    |
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                                    ^^^^^^^^^^^^^ argument never used
@@ -117,13 +117,13 @@ LL |         asm!("{a}", a = const foo, a = const bar);
    = help: if this argument is intentionally unused, consider using it in an asm comment: `"/* {1} */"`
 
 error: explicit register arguments cannot have names
-  --> $DIR/parse-error.rs:57:18
+  --> $DIR/parse-error.rs:55:18
    |
 LL |         asm!("", a = in("x0") foo);
    |                  ^^^^^^^^^^^^^^^^
 
 error: positional arguments cannot follow named arguments or explicit register arguments
-  --> $DIR/parse-error.rs:63:35
+  --> $DIR/parse-error.rs:61:35
    |
 LL |         asm!("{1}", in("x0") foo, const bar);
    |                     ------------  ^^^^^^^^^ positional argument
@@ -131,19 +131,19 @@ LL |         asm!("{1}", in("x0") foo, const bar);
    |                     explicit register argument
 
 error: expected one of `clobber_abi`, `const`, `in`, `inlateout`, `inout`, `label`, `lateout`, `options`, `out`, or `sym`, found `""`
-  --> $DIR/parse-error.rs:66:29
+  --> $DIR/parse-error.rs:64:29
    |
 LL |         asm!("", options(), "");
    |                             ^^ expected one of 10 possible tokens
 
 error: expected one of `clobber_abi`, `const`, `in`, `inlateout`, `inout`, `label`, `lateout`, `options`, `out`, or `sym`, found `"{}"`
-  --> $DIR/parse-error.rs:68:33
+  --> $DIR/parse-error.rs:66:33
    |
 LL |         asm!("{}", in(reg) foo, "{}", out(reg) foo);
    |                                 ^^^^ expected one of 10 possible tokens
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:70:14
+  --> $DIR/parse-error.rs:68:14
    |
 LL |         asm!(format!("{{{}}}", 0), in(reg) foo);
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -151,7 +151,7 @@ LL |         asm!(format!("{{{}}}", 0), in(reg) foo);
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:72:21
+  --> $DIR/parse-error.rs:70:21
    |
 LL |         asm!("{1}", format!("{{{}}}", 0), in(reg) foo, out(reg) bar);
    |                     ^^^^^^^^^^^^^^^^^^^^
@@ -159,127 +159,127 @@ LL |         asm!("{1}", format!("{{{}}}", 0), in(reg) foo, out(reg) bar);
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: _ cannot be used for input operands
-  --> $DIR/parse-error.rs:74:28
+  --> $DIR/parse-error.rs:72:28
    |
 LL |         asm!("{}", in(reg) _);
    |                            ^
 
 error: _ cannot be used for input operands
-  --> $DIR/parse-error.rs:76:31
+  --> $DIR/parse-error.rs:74:31
    |
 LL |         asm!("{}", inout(reg) _);
    |                               ^
 
 error: _ cannot be used for input operands
-  --> $DIR/parse-error.rs:78:35
+  --> $DIR/parse-error.rs:76:35
    |
 LL |         asm!("{}", inlateout(reg) _);
    |                                   ^
 
 error: requires at least a template string argument
-  --> $DIR/parse-error.rs:85:1
+  --> $DIR/parse-error.rs:83:1
    |
 LL | global_asm!();
    | ^^^^^^^^^^^^^
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:87:13
+  --> $DIR/parse-error.rs:85:13
    |
 LL | global_asm!(FOO);
    |             ^^^
 
 error: expected token: `,`
-  --> $DIR/parse-error.rs:89:18
+  --> $DIR/parse-error.rs:87:18
    |
 LL | global_asm!("{}" FOO);
    |                  ^^^ expected `,`
 
 error: expected operand, options, or additional template string
-  --> $DIR/parse-error.rs:91:19
+  --> $DIR/parse-error.rs:89:19
    |
 LL | global_asm!("{}", FOO);
    |                   ^^^ expected operand, options, or additional template string
 
 error: expected expression, found end of macro arguments
-  --> $DIR/parse-error.rs:93:24
+  --> $DIR/parse-error.rs:91:24
    |
 LL | global_asm!("{}", const);
    |                        ^ expected expression
 
 error: expected one of `,`, `.`, `?`, or an operator, found `FOO`
-  --> $DIR/parse-error.rs:95:30
+  --> $DIR/parse-error.rs:93:30
    |
 LL | global_asm!("{}", const(reg) FOO);
    |                              ^^^ expected one of `,`, `.`, `?`, or an operator
 
 error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
-  --> $DIR/parse-error.rs:97:25
+  --> $DIR/parse-error.rs:95:25
    |
 LL | global_asm!("", options(FOO));
    |                         ^^^ expected one of `)`, `att_syntax`, or `raw`
 
 error: the `nomem` option cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:99:25
+  --> $DIR/parse-error.rs:97:25
    |
 LL | global_asm!("", options(nomem FOO));
    |                         ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
 
 error: expected one of `)` or `,`, found `FOO`
-  --> $DIR/parse-error.rs:99:31
+  --> $DIR/parse-error.rs:97:31
    |
 LL | global_asm!("", options(nomem FOO));
    |                               ^^^ expected one of `)` or `,`
 
 error: the `nomem` option cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:102:25
+  --> $DIR/parse-error.rs:100:25
    |
 LL | global_asm!("", options(nomem, FOO));
    |                         ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
 
 error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
-  --> $DIR/parse-error.rs:102:32
+  --> $DIR/parse-error.rs:100:32
    |
 LL | global_asm!("", options(nomem, FOO));
    |                                ^^^ expected one of `)`, `att_syntax`, or `raw`
 
 error: expected string literal
-  --> $DIR/parse-error.rs:106:29
+  --> $DIR/parse-error.rs:104:29
    |
 LL | global_asm!("", clobber_abi(FOO));
    |                             ^^^ not a string literal
 
 error: expected one of `)` or `,`, found `FOO`
-  --> $DIR/parse-error.rs:108:33
+  --> $DIR/parse-error.rs:106:33
    |
 LL | global_asm!("", clobber_abi("C" FOO));
    |                                 ^^^ expected one of `)` or `,`
 
 error: expected string literal
-  --> $DIR/parse-error.rs:110:34
+  --> $DIR/parse-error.rs:108:34
    |
 LL | global_asm!("", clobber_abi("C", FOO));
    |                                  ^^^ not a string literal
 
 error: `clobber_abi` cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:112:19
+  --> $DIR/parse-error.rs:110:19
    |
 LL | global_asm!("{}", clobber_abi("C"), const FOO);
    |                   ^^^^^^^^^^^^^^^^
 
 error: `clobber_abi` cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:114:28
+  --> $DIR/parse-error.rs:112:28
    |
 LL | global_asm!("", options(), clobber_abi("C"));
    |                            ^^^^^^^^^^^^^^^^
 
 error: `clobber_abi` cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:116:30
+  --> $DIR/parse-error.rs:114:30
    |
 LL | global_asm!("{}", options(), clobber_abi("C"), const FOO);
    |                              ^^^^^^^^^^^^^^^^
 
 error: duplicate argument named `a`
-  --> $DIR/parse-error.rs:118:35
+  --> $DIR/parse-error.rs:116:35
    |
 LL | global_asm!("{a}", a = const FOO, a = const BAR);
    |                    -------------  ^^^^^^^^^^^^^ duplicate argument
@@ -287,7 +287,7 @@ LL | global_asm!("{a}", a = const FOO, a = const BAR);
    |                    previously here
 
 error: argument never used
-  --> $DIR/parse-error.rs:118:35
+  --> $DIR/parse-error.rs:116:35
    |
 LL | global_asm!("{a}", a = const FOO, a = const BAR);
    |                                   ^^^^^^^^^^^^^ argument never used
@@ -295,19 +295,19 @@ LL | global_asm!("{a}", a = const FOO, a = const BAR);
    = help: if this argument is intentionally unused, consider using it in an asm comment: `"/* {1} */"`
 
 error: expected one of `clobber_abi`, `const`, `options`, or `sym`, found `""`
-  --> $DIR/parse-error.rs:121:28
+  --> $DIR/parse-error.rs:119:28
    |
 LL | global_asm!("", options(), "");
    |                            ^^ expected one of `clobber_abi`, `const`, `options`, or `sym`
 
 error: expected one of `clobber_abi`, `const`, `options`, or `sym`, found `"{}"`
-  --> $DIR/parse-error.rs:123:30
+  --> $DIR/parse-error.rs:121:30
    |
 LL | global_asm!("{}", const FOO, "{}", const FOO);
    |                              ^^^^ expected one of `clobber_abi`, `const`, `options`, or `sym`
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:125:13
+  --> $DIR/parse-error.rs:123:13
    |
 LL | global_asm!(format!("{{{}}}", 0), const FOO);
    |             ^^^^^^^^^^^^^^^^^^^^
@@ -315,7 +315,7 @@ LL | global_asm!(format!("{{{}}}", 0), const FOO);
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:127:20
+  --> $DIR/parse-error.rs:125:20
    |
 LL | global_asm!("{1}", format!("{{{}}}", 0), const FOO, const BAR);
    |                    ^^^^^^^^^^^^^^^^^^^^
@@ -323,7 +323,7 @@ LL | global_asm!("{1}", format!("{{{}}}", 0), const FOO, const BAR);
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:39:37
+  --> $DIR/parse-error.rs:37:37
    |
 LL |         asm!("{}", options(), const foo);
    |                                     ^^^ non-constant value
@@ -334,7 +334,7 @@ LL |     const foo: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:47:44
+  --> $DIR/parse-error.rs:45:44
    |
 LL |         asm!("{}", clobber_abi("C"), const foo);
    |                                            ^^^ non-constant value
@@ -345,7 +345,7 @@ LL |     const foo: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:50:55
+  --> $DIR/parse-error.rs:48:55
    |
 LL |         asm!("{}", options(), clobber_abi("C"), const foo);
    |                                                       ^^^ non-constant value
@@ -356,7 +356,7 @@ LL |     const foo: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:52:31
+  --> $DIR/parse-error.rs:50:31
    |
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                               ^^^ non-constant value
@@ -367,7 +367,7 @@ LL |     const foo: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:52:46
+  --> $DIR/parse-error.rs:50:46
    |
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                                              ^^^ non-constant value
@@ -378,7 +378,7 @@ LL |     const bar: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:59:45
+  --> $DIR/parse-error.rs:57:45
    |
 LL |         asm!("{a}", in("x0") foo, a = const bar);
    |                                             ^^^ non-constant value
@@ -389,7 +389,7 @@ LL |     const bar: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:61:45
+  --> $DIR/parse-error.rs:59:45
    |
 LL |         asm!("{a}", in("x0") foo, a = const bar);
    |                                             ^^^ non-constant value
@@ -400,7 +400,7 @@ LL |     const bar: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:63:41
+  --> $DIR/parse-error.rs:61:41
    |
 LL |         asm!("{1}", in("x0") foo, const bar);
    |                                         ^^^ non-constant value
diff --git a/tests/ui/asm/aarch64/type-check-3.rs b/tests/ui/asm/aarch64/type-check-3.rs
index 3fc8e5060693a..b64473f98c090 100644
--- a/tests/ui/asm/aarch64/type-check-3.rs
+++ b/tests/ui/asm/aarch64/type-check-3.rs
@@ -1,7 +1,7 @@
 //@ only-aarch64
 //@ compile-flags: -C target-feature=+neon
 
-#![feature(repr_simd, asm_const)]
+#![feature(repr_simd)]
 
 use std::arch::aarch64::float64x2_t;
 use std::arch::{asm, global_asm};
diff --git a/tests/ui/asm/aarch64/type-check-4.rs b/tests/ui/asm/aarch64/type-check-4.rs
index f00b4d4c46fa5..41eb9de5669f6 100644
--- a/tests/ui/asm/aarch64/type-check-4.rs
+++ b/tests/ui/asm/aarch64/type-check-4.rs
@@ -1,7 +1,7 @@
 //@ only-aarch64
 //@ compile-flags: -C target-feature=+neon
 
-#![feature(repr_simd, asm_const)]
+#![feature(repr_simd)]
 
 use std::arch::aarch64::float64x2_t;
 use std::arch::{asm, global_asm};
@@ -10,8 +10,7 @@ use std::arch::{asm, global_asm};
 #[derive(Copy, Clone)]
 struct Simd256bit(f64, f64, f64, f64);
 
-fn main() {
-}
+fn main() {}
 
 // Constants must be... constant
 
diff --git a/tests/ui/asm/aarch64/type-check-4.stderr b/tests/ui/asm/aarch64/type-check-4.stderr
index 3e675f69e842b..89eb8467cdefd 100644
--- a/tests/ui/asm/aarch64/type-check-4.stderr
+++ b/tests/ui/asm/aarch64/type-check-4.stderr
@@ -1,5 +1,5 @@
 error[E0658]: referencing statics in constants is unstable
-  --> $DIR/type-check-4.rs:25:25
+  --> $DIR/type-check-4.rs:24:25
    |
 LL | global_asm!("{}", const S);
    |                         ^
@@ -11,7 +11,7 @@ LL | global_asm!("{}", const S);
    = help: to fix this, the value can be extracted to a `const` and then used.
 
 error[E0658]: referencing statics in constants is unstable
-  --> $DIR/type-check-4.rs:28:35
+  --> $DIR/type-check-4.rs:27:35
    |
 LL | global_asm!("{}", const const_foo(S));
    |                                   ^
@@ -23,7 +23,7 @@ LL | global_asm!("{}", const const_foo(S));
    = help: to fix this, the value can be extracted to a `const` and then used.
 
 error[E0658]: referencing statics in constants is unstable
-  --> $DIR/type-check-4.rs:31:35
+  --> $DIR/type-check-4.rs:30:35
    |
 LL | global_asm!("{}", const const_bar(S));
    |                                   ^
diff --git a/tests/ui/asm/bad-template.rs b/tests/ui/asm/bad-template.rs
index 41a906e32a4ba..6b00905a39326 100644
--- a/tests/ui/asm/bad-template.rs
+++ b/tests/ui/asm/bad-template.rs
@@ -6,7 +6,7 @@
 //@ [x86_64] needs-llvm-components: x86
 //@ [aarch64] needs-llvm-components: aarch64
 
-#![feature(no_core, lang_items, rustc_attrs, asm_const)]
+#![feature(no_core, lang_items, rustc_attrs)]
 #![no_core]
 
 #[rustc_builtin_macro]
diff --git a/tests/ui/asm/const-error.rs b/tests/ui/asm/const-error.rs
index f2cead399b6fb..40d0590c33e9d 100644
--- a/tests/ui/asm/const-error.rs
+++ b/tests/ui/asm/const-error.rs
@@ -1,15 +1,15 @@
 //@ only-x86_64
 //@ needs-asm-support
 
-#![feature(asm_const)]
-
 // Test to make sure that we emit const errors eagerly for inline asm
 
 use std::arch::asm;
 
 fn test<T>() {
-    unsafe { asm!("/* {} */", const 1 / 0); }
-    //~^ ERROR evaluation of
+    unsafe {
+        asm!("/* {} */", const 1 / 0);
+        //~^ ERROR evaluation of
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/asm/const-error.stderr b/tests/ui/asm/const-error.stderr
index fe31183217726..02e54457e89b9 100644
--- a/tests/ui/asm/const-error.stderr
+++ b/tests/ui/asm/const-error.stderr
@@ -1,8 +1,8 @@
 error[E0080]: evaluation of `test::<T>::{constant#0}` failed
-  --> $DIR/const-error.rs:11:37
+  --> $DIR/const-error.rs:10:32
    |
-LL |     unsafe { asm!("/* {} */", const 1 / 0); }
-   |                                     ^^^^^ attempt to divide `1_i32` by zero
+LL |         asm!("/* {} */", const 1 / 0);
+   |                                ^^^^^ attempt to divide `1_i32` by zero
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/asm/fail-const-eval-issue-121099.rs b/tests/ui/asm/fail-const-eval-issue-121099.rs
index bed6fc9b39f9d..36d00b1e5d23c 100644
--- a/tests/ui/asm/fail-const-eval-issue-121099.rs
+++ b/tests/ui/asm/fail-const-eval-issue-121099.rs
@@ -1,6 +1,5 @@
 //@ build-fail
 //@ needs-asm-support
-#![feature(asm_const)]
 
 use std::arch::global_asm;
 
diff --git a/tests/ui/asm/fail-const-eval-issue-121099.stderr b/tests/ui/asm/fail-const-eval-issue-121099.stderr
index 51d283218d227..5d86c3a5f7bdd 100644
--- a/tests/ui/asm/fail-const-eval-issue-121099.stderr
+++ b/tests/ui/asm/fail-const-eval-issue-121099.stderr
@@ -1,11 +1,11 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/fail-const-eval-issue-121099.rs:9:31
+  --> $DIR/fail-const-eval-issue-121099.rs:8:31
    |
 LL | global_asm!("/* {} */", const 1 << 500);
    |                               ^^^^^^^^ attempt to shift left by `500_i32`, which would overflow
 
 error[E0080]: evaluation of constant value failed
-  --> $DIR/fail-const-eval-issue-121099.rs:11:31
+  --> $DIR/fail-const-eval-issue-121099.rs:10:31
    |
 LL | global_asm!("/* {} */", const 1 / 0);
    |                               ^^^^^ attempt to divide `1_i32` by zero
diff --git a/tests/ui/asm/generic-const.rs b/tests/ui/asm/generic-const.rs
index 133d093d200ec..3b69a4e86e3e8 100644
--- a/tests/ui/asm/generic-const.rs
+++ b/tests/ui/asm/generic-const.rs
@@ -1,8 +1,6 @@
 //@ needs-asm-support
 //@ build-pass
 
-#![feature(asm_const)]
-
 use std::arch::asm;
 
 fn foofoo<const N: usize>() {}
diff --git a/tests/ui/asm/invalid-const-operand.rs b/tests/ui/asm/invalid-const-operand.rs
index eff335ff6aaa3..a688f5042db5c 100644
--- a/tests/ui/asm/invalid-const-operand.rs
+++ b/tests/ui/asm/invalid-const-operand.rs
@@ -2,8 +2,6 @@
 //@ ignore-nvptx64
 //@ ignore-spirv
 
-#![feature(asm_const)]
-
 use std::arch::{asm, global_asm};
 
 // Const operands must be integers and must be constants.
diff --git a/tests/ui/asm/invalid-const-operand.stderr b/tests/ui/asm/invalid-const-operand.stderr
index a6d742b53c217..bda4b0355b7c4 100644
--- a/tests/ui/asm/invalid-const-operand.stderr
+++ b/tests/ui/asm/invalid-const-operand.stderr
@@ -1,5 +1,5 @@
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/invalid-const-operand.rs:42:26
+  --> $DIR/invalid-const-operand.rs:40:26
    |
 LL |         asm!("{}", const x);
    |                          ^ non-constant value
@@ -10,7 +10,7 @@ LL |         const x: /* Type */ = 0;
    |         ~~~~~  ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/invalid-const-operand.rs:45:36
+  --> $DIR/invalid-const-operand.rs:43:36
    |
 LL |         asm!("{}", const const_foo(x));
    |                                    ^ non-constant value
@@ -21,7 +21,7 @@ LL |         const x: /* Type */ = 0;
    |         ~~~~~  ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/invalid-const-operand.rs:48:36
+  --> $DIR/invalid-const-operand.rs:46:36
    |
 LL |         asm!("{}", const const_bar(x));
    |                                    ^ non-constant value
@@ -32,7 +32,7 @@ LL |         const x: /* Type */ = 0;
    |         ~~~~~  ++++++++++++
 
 error: invalid type for `const` operand
-  --> $DIR/invalid-const-operand.rs:14:19
+  --> $DIR/invalid-const-operand.rs:12:19
    |
 LL | global_asm!("{}", const 0f32);
    |                   ^^^^^^----
@@ -42,7 +42,7 @@ LL | global_asm!("{}", const 0f32);
    = help: `const` operands must be of an integer type
 
 error: invalid type for `const` operand
-  --> $DIR/invalid-const-operand.rs:16:19
+  --> $DIR/invalid-const-operand.rs:14:19
    |
 LL | global_asm!("{}", const 0 as *mut u8);
    |                   ^^^^^^------------
@@ -52,7 +52,7 @@ LL | global_asm!("{}", const 0 as *mut u8);
    = help: `const` operands must be of an integer type
 
 error: invalid type for `const` operand
-  --> $DIR/invalid-const-operand.rs:26:20
+  --> $DIR/invalid-const-operand.rs:24:20
    |
 LL |         asm!("{}", const 0f32);
    |                    ^^^^^^----
@@ -62,7 +62,7 @@ LL |         asm!("{}", const 0f32);
    = help: `const` operands must be of an integer type
 
 error: invalid type for `const` operand
-  --> $DIR/invalid-const-operand.rs:28:20
+  --> $DIR/invalid-const-operand.rs:26:20
    |
 LL |         asm!("{}", const 0 as *mut u8);
    |                    ^^^^^^------------
@@ -72,7 +72,7 @@ LL |         asm!("{}", const 0 as *mut u8);
    = help: `const` operands must be of an integer type
 
 error: invalid type for `const` operand
-  --> $DIR/invalid-const-operand.rs:30:20
+  --> $DIR/invalid-const-operand.rs:28:20
    |
 LL |         asm!("{}", const &0);
    |                    ^^^^^^--
diff --git a/tests/ui/asm/naked-functions.rs b/tests/ui/asm/naked-functions.rs
index cb1e5c325c239..116a84506c570 100644
--- a/tests/ui/asm/naked-functions.rs
+++ b/tests/ui/asm/naked-functions.rs
@@ -3,7 +3,7 @@
 //@ ignore-spirv
 
 #![feature(naked_functions)]
-#![feature(asm_const, asm_unwind, linkage)]
+#![feature(asm_unwind, linkage)]
 #![crate_type = "lib"]
 
 use std::arch::asm;
diff --git a/tests/ui/asm/named-asm-labels.rs b/tests/ui/asm/named-asm-labels.rs
index d2ca6fe8808bc..043aab9029d7d 100644
--- a/tests/ui/asm/named-asm-labels.rs
+++ b/tests/ui/asm/named-asm-labels.rs
@@ -10,7 +10,7 @@
 // which causes less readable LLVM errors and in the worst cases causes ICEs
 // or segfaults based on system dependent behavior and codegen flags.
 
-#![feature(naked_functions, asm_const)]
+#![feature(naked_functions)]
 
 use std::arch::{asm, global_asm};
 
@@ -128,6 +128,7 @@ fn main() {
 
         // Tests usage of colons in non-label positions
         asm!(":lo12:FOO"); // this is apparently valid aarch64
+
         // is there an example that is valid x86 for this test?
         asm!(":bbb nop");
 
@@ -176,7 +177,8 @@ fn main() {
 // label or LTO can cause labels to break
 #[naked]
 pub extern "C" fn foo() -> i32 {
-    unsafe { asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1, options(noreturn)) } //~ ERROR avoid using named labels
+    unsafe { asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1, options(noreturn)) }
+    //~^ ERROR avoid using named labels
 }
 
 // Make sure that non-naked attributes *do* still let the lint happen
diff --git a/tests/ui/asm/named-asm-labels.stderr b/tests/ui/asm/named-asm-labels.stderr
index 20b7d64f9e752..e5e177fb8b83e 100644
--- a/tests/ui/asm/named-asm-labels.stderr
+++ b/tests/ui/asm/named-asm-labels.stderr
@@ -328,7 +328,7 @@ LL |             ab: nop // ab: does foo
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:143:19
+  --> $DIR/named-asm-labels.rs:144:19
    |
 LL |             asm!("test_{}: nop", in(reg) 10);
    |                   ^^^^^^^
@@ -338,7 +338,7 @@ LL |             asm!("test_{}: nop", in(reg) 10);
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:145:15
+  --> $DIR/named-asm-labels.rs:146:15
    |
 LL |         asm!("test_{}: nop", const 10);
    |               ^^^^^^^
@@ -348,7 +348,7 @@ LL |         asm!("test_{}: nop", const 10);
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:146:15
+  --> $DIR/named-asm-labels.rs:147:15
    |
 LL |         asm!("test_{}: nop", sym main);
    |               ^^^^^^^
@@ -358,7 +358,7 @@ LL |         asm!("test_{}: nop", sym main);
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:147:15
+  --> $DIR/named-asm-labels.rs:148:15
    |
 LL |         asm!("{}_test: nop", const 10);
    |               ^^^^^^^
@@ -368,7 +368,7 @@ LL |         asm!("{}_test: nop", const 10);
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:148:15
+  --> $DIR/named-asm-labels.rs:149:15
    |
 LL |         asm!("test_{}_test: nop", const 10);
    |               ^^^^^^^^^^^^
@@ -378,7 +378,7 @@ LL |         asm!("test_{}_test: nop", const 10);
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:149:15
+  --> $DIR/named-asm-labels.rs:150:15
    |
 LL |         asm!("{}: nop", const 10);
    |               ^^
@@ -388,7 +388,7 @@ LL |         asm!("{}: nop", const 10);
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:151:15
+  --> $DIR/named-asm-labels.rs:152:15
    |
 LL |         asm!("{uwu}: nop", uwu = const 10);
    |               ^^^^^
@@ -398,7 +398,7 @@ LL |         asm!("{uwu}: nop", uwu = const 10);
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:152:15
+  --> $DIR/named-asm-labels.rs:153:15
    |
 LL |         asm!("{0}: nop", const 10);
    |               ^^^
@@ -408,7 +408,7 @@ LL |         asm!("{0}: nop", const 10);
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:153:15
+  --> $DIR/named-asm-labels.rs:154:15
    |
 LL |         asm!("{1}: nop", "/* {0} */", const 10, const 20);
    |               ^^^
@@ -418,7 +418,7 @@ LL |         asm!("{1}: nop", "/* {0} */", const 10, const 20);
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:156:14
+  --> $DIR/named-asm-labels.rs:157:14
    |
 LL |         asm!(include_str!("named-asm-labels.s"));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -428,7 +428,7 @@ LL |         asm!(include_str!("named-asm-labels.s"));
    = note: the label may be declared in the expansion of a macro
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:156:14
+  --> $DIR/named-asm-labels.rs:157:14
    |
 LL |         asm!(include_str!("named-asm-labels.s"));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -439,7 +439,7 @@ LL |         asm!(include_str!("named-asm-labels.s"));
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:156:14
+  --> $DIR/named-asm-labels.rs:157:14
    |
 LL |         asm!(include_str!("named-asm-labels.s"));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -450,7 +450,7 @@ LL |         asm!(include_str!("named-asm-labels.s"));
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:156:14
+  --> $DIR/named-asm-labels.rs:157:14
    |
 LL |         asm!(include_str!("named-asm-labels.s"));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -461,7 +461,7 @@ LL |         asm!(include_str!("named-asm-labels.s"));
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 warning: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:170:19
+  --> $DIR/named-asm-labels.rs:171:19
    |
 LL |             asm!("warned: nop");
    |                   ^^^^^^
@@ -469,13 +469,13 @@ LL |             asm!("warned: nop");
    = help: only local labels of the form `<number>:` should be used in inline asm
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 note: the lint level is defined here
-  --> $DIR/named-asm-labels.rs:168:16
+  --> $DIR/named-asm-labels.rs:169:16
    |
 LL |         #[warn(named_asm_labels)]
    |                ^^^^^^^^^^^^^^^^
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:179:20
+  --> $DIR/named-asm-labels.rs:180:20
    |
 LL |     unsafe { asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1, options(noreturn)) }
    |                    ^^^^^
@@ -484,7 +484,7 @@ LL |     unsafe { asm!(".Lfoo: mov rax, {}; ret;", "nop", const 1, options(noret
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:185:20
+  --> $DIR/named-asm-labels.rs:187:20
    |
 LL |     unsafe { asm!(".Lbar: mov rax, {}; ret;", "nop", const 1, options(noreturn)) }
    |                    ^^^^^
@@ -493,7 +493,7 @@ LL |     unsafe { asm!(".Lbar: mov rax, {}; ret;", "nop", const 1, options(noret
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:193:20
+  --> $DIR/named-asm-labels.rs:195:20
    |
 LL |     unsafe { asm!(".Laaa: nop; ret;", options(noreturn)) }
    |                    ^^^^^
@@ -502,7 +502,7 @@ LL |     unsafe { asm!(".Laaa: nop; ret;", options(noreturn)) }
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:203:24
+  --> $DIR/named-asm-labels.rs:205:24
    |
 LL |         unsafe { asm!(".Lbbb: nop; ret;", options(noreturn)) }
    |                        ^^^^^
@@ -511,7 +511,7 @@ LL |         unsafe { asm!(".Lbbb: nop; ret;", options(noreturn)) }
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:212:15
+  --> $DIR/named-asm-labels.rs:214:15
    |
 LL |         asm!("closure1: nop");
    |               ^^^^^^^^
@@ -520,7 +520,7 @@ LL |         asm!("closure1: nop");
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:216:15
+  --> $DIR/named-asm-labels.rs:218:15
    |
 LL |         asm!("closure2: nop");
    |               ^^^^^^^^
@@ -529,7 +529,7 @@ LL |         asm!("closure2: nop");
    = note: see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
 
 error: avoid using named labels in inline assembly
-  --> $DIR/named-asm-labels.rs:226:19
+  --> $DIR/named-asm-labels.rs:228:19
    |
 LL |             asm!("closure3: nop");
    |                   ^^^^^^^^
diff --git a/tests/ui/asm/parse-error.rs b/tests/ui/asm/parse-error.rs
index 16ae02828642d..4d7b522f5fc5b 100644
--- a/tests/ui/asm/parse-error.rs
+++ b/tests/ui/asm/parse-error.rs
@@ -1,7 +1,5 @@
 //@ needs-asm-support
 
-#![feature(asm_const)]
-
 use std::arch::{asm, global_asm};
 
 fn main() {
diff --git a/tests/ui/asm/parse-error.stderr b/tests/ui/asm/parse-error.stderr
index f5f8d537d86b8..6d0e629b93775 100644
--- a/tests/ui/asm/parse-error.stderr
+++ b/tests/ui/asm/parse-error.stderr
@@ -1,167 +1,167 @@
 error: requires at least a template string argument
-  --> $DIR/parse-error.rs:11:9
+  --> $DIR/parse-error.rs:9:9
    |
 LL |         asm!();
    |         ^^^^^^
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:13:14
+  --> $DIR/parse-error.rs:11:14
    |
 LL |         asm!(foo);
    |              ^^^
 
 error: expected token: `,`
-  --> $DIR/parse-error.rs:15:19
+  --> $DIR/parse-error.rs:13:19
    |
 LL |         asm!("{}" foo);
    |                   ^^^ expected `,`
 
 error: expected operand, clobber_abi, options, or additional template string
-  --> $DIR/parse-error.rs:17:20
+  --> $DIR/parse-error.rs:15:20
    |
 LL |         asm!("{}", foo);
    |                    ^^^ expected operand, clobber_abi, options, or additional template string
 
 error: expected `(`, found `foo`
-  --> $DIR/parse-error.rs:19:23
+  --> $DIR/parse-error.rs:17:23
    |
 LL |         asm!("{}", in foo);
    |                       ^^^ expected `(`
 
 error: expected `)`, found `foo`
-  --> $DIR/parse-error.rs:21:27
+  --> $DIR/parse-error.rs:19:27
    |
 LL |         asm!("{}", in(reg foo));
    |                           ^^^ expected `)`
 
 error: expected expression, found end of macro arguments
-  --> $DIR/parse-error.rs:23:27
+  --> $DIR/parse-error.rs:21:27
    |
 LL |         asm!("{}", in(reg));
    |                           ^ expected expression
 
 error: expected register class or explicit register
-  --> $DIR/parse-error.rs:25:26
+  --> $DIR/parse-error.rs:23:26
    |
 LL |         asm!("{}", inout(=) foo => bar);
    |                          ^
 
 error: expected expression, found end of macro arguments
-  --> $DIR/parse-error.rs:27:37
+  --> $DIR/parse-error.rs:25:37
    |
 LL |         asm!("{}", inout(reg) foo =>);
    |                                     ^ expected expression
 
 error: expected one of `!`, `,`, `.`, `::`, `?`, `{`, or an operator, found `=>`
-  --> $DIR/parse-error.rs:29:32
+  --> $DIR/parse-error.rs:27:32
    |
 LL |         asm!("{}", in(reg) foo => bar);
    |                                ^^ expected one of 7 possible tokens
 
 error: expected a path for argument to `sym`
-  --> $DIR/parse-error.rs:31:24
+  --> $DIR/parse-error.rs:29:24
    |
 LL |         asm!("{}", sym foo + bar);
    |                        ^^^^^^^^^
 
 error: expected one of `)`, `att_syntax`, `may_unwind`, `nomem`, `noreturn`, `nostack`, `preserves_flags`, `pure`, `raw`, or `readonly`, found `foo`
-  --> $DIR/parse-error.rs:33:26
+  --> $DIR/parse-error.rs:31:26
    |
 LL |         asm!("", options(foo));
    |                          ^^^ expected one of 10 possible tokens
 
 error: expected one of `)` or `,`, found `foo`
-  --> $DIR/parse-error.rs:35:32
+  --> $DIR/parse-error.rs:33:32
    |
 LL |         asm!("", options(nomem foo));
    |                                ^^^ expected one of `)` or `,`
 
 error: expected one of `)`, `att_syntax`, `may_unwind`, `nomem`, `noreturn`, `nostack`, `preserves_flags`, `pure`, `raw`, or `readonly`, found `foo`
-  --> $DIR/parse-error.rs:37:33
+  --> $DIR/parse-error.rs:35:33
    |
 LL |         asm!("", options(nomem, foo));
    |                                 ^^^ expected one of 10 possible tokens
 
 error: at least one abi must be provided as an argument to `clobber_abi`
-  --> $DIR/parse-error.rs:44:30
+  --> $DIR/parse-error.rs:42:30
    |
 LL |         asm!("", clobber_abi());
    |                              ^
 
 error: expected string literal
-  --> $DIR/parse-error.rs:46:30
+  --> $DIR/parse-error.rs:44:30
    |
 LL |         asm!("", clobber_abi(foo));
    |                              ^^^ not a string literal
 
 error: expected one of `)` or `,`, found `foo`
-  --> $DIR/parse-error.rs:48:34
+  --> $DIR/parse-error.rs:46:34
    |
 LL |         asm!("", clobber_abi("C" foo));
    |                                  ^^^ expected one of `)` or `,`
 
 error: expected string literal
-  --> $DIR/parse-error.rs:50:35
+  --> $DIR/parse-error.rs:48:35
    |
 LL |         asm!("", clobber_abi("C", foo));
    |                                   ^^^ not a string literal
 
 error: expected string literal
-  --> $DIR/parse-error.rs:52:30
+  --> $DIR/parse-error.rs:50:30
    |
 LL |         asm!("", clobber_abi(1));
    |                              ^ not a string literal
 
 error: expected string literal
-  --> $DIR/parse-error.rs:54:30
+  --> $DIR/parse-error.rs:52:30
    |
 LL |         asm!("", clobber_abi(()));
    |                              ^ not a string literal
 
 error: expected string literal
-  --> $DIR/parse-error.rs:56:30
+  --> $DIR/parse-error.rs:54:30
    |
 LL |         asm!("", clobber_abi(uwu));
    |                              ^^^ not a string literal
 
 error: expected string literal
-  --> $DIR/parse-error.rs:58:30
+  --> $DIR/parse-error.rs:56:30
    |
 LL |         asm!("", clobber_abi({}));
    |                              ^ not a string literal
 
 error: expected string literal
-  --> $DIR/parse-error.rs:60:30
+  --> $DIR/parse-error.rs:58:30
    |
 LL |         asm!("", clobber_abi(loop {}));
    |                              ^^^^ not a string literal
 
 error: expected string literal
-  --> $DIR/parse-error.rs:62:30
+  --> $DIR/parse-error.rs:60:30
    |
 LL |         asm!("", clobber_abi(if));
    |                              ^^ not a string literal
 
 error: expected string literal
-  --> $DIR/parse-error.rs:64:30
+  --> $DIR/parse-error.rs:62:30
    |
 LL |         asm!("", clobber_abi(do));
    |                              ^^ not a string literal
 
 error: expected string literal
-  --> $DIR/parse-error.rs:66:30
+  --> $DIR/parse-error.rs:64:30
    |
 LL |         asm!("", clobber_abi(<));
    |                              ^ not a string literal
 
 error: expected string literal
-  --> $DIR/parse-error.rs:68:30
+  --> $DIR/parse-error.rs:66:30
    |
 LL |         asm!("", clobber_abi(.));
    |                              ^ not a string literal
 
 error: duplicate argument named `a`
-  --> $DIR/parse-error.rs:76:36
+  --> $DIR/parse-error.rs:74:36
    |
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                     -------------  ^^^^^^^^^^^^^ duplicate argument
@@ -169,7 +169,7 @@ LL |         asm!("{a}", a = const foo, a = const bar);
    |                     previously here
 
 error: argument never used
-  --> $DIR/parse-error.rs:76:36
+  --> $DIR/parse-error.rs:74:36
    |
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                                    ^^^^^^^^^^^^^ argument never used
@@ -177,19 +177,19 @@ LL |         asm!("{a}", a = const foo, a = const bar);
    = help: if this argument is intentionally unused, consider using it in an asm comment: `"/* {1} */"`
 
 error: expected one of `clobber_abi`, `const`, `in`, `inlateout`, `inout`, `label`, `lateout`, `options`, `out`, or `sym`, found `""`
-  --> $DIR/parse-error.rs:82:29
+  --> $DIR/parse-error.rs:80:29
    |
 LL |         asm!("", options(), "");
    |                             ^^ expected one of 10 possible tokens
 
 error: expected one of `clobber_abi`, `const`, `in`, `inlateout`, `inout`, `label`, `lateout`, `options`, `out`, or `sym`, found `"{}"`
-  --> $DIR/parse-error.rs:84:33
+  --> $DIR/parse-error.rs:82:33
    |
 LL |         asm!("{}", in(reg) foo, "{}", out(reg) foo);
    |                                 ^^^^ expected one of 10 possible tokens
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:86:14
+  --> $DIR/parse-error.rs:84:14
    |
 LL |         asm!(format!("{{{}}}", 0), in(reg) foo);
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -197,7 +197,7 @@ LL |         asm!(format!("{{{}}}", 0), in(reg) foo);
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:88:21
+  --> $DIR/parse-error.rs:86:21
    |
 LL |         asm!("{1}", format!("{{{}}}", 0), in(reg) foo, out(reg) bar);
    |                     ^^^^^^^^^^^^^^^^^^^^
@@ -205,139 +205,139 @@ LL |         asm!("{1}", format!("{{{}}}", 0), in(reg) foo, out(reg) bar);
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: _ cannot be used for input operands
-  --> $DIR/parse-error.rs:90:28
+  --> $DIR/parse-error.rs:88:28
    |
 LL |         asm!("{}", in(reg) _);
    |                            ^
 
 error: _ cannot be used for input operands
-  --> $DIR/parse-error.rs:92:31
+  --> $DIR/parse-error.rs:90:31
    |
 LL |         asm!("{}", inout(reg) _);
    |                               ^
 
 error: _ cannot be used for input operands
-  --> $DIR/parse-error.rs:94:35
+  --> $DIR/parse-error.rs:92:35
    |
 LL |         asm!("{}", inlateout(reg) _);
    |                                   ^
 
 error: requires at least a template string argument
-  --> $DIR/parse-error.rs:101:1
+  --> $DIR/parse-error.rs:99:1
    |
 LL | global_asm!();
    | ^^^^^^^^^^^^^
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:103:13
+  --> $DIR/parse-error.rs:101:13
    |
 LL | global_asm!(FOO);
    |             ^^^
 
 error: expected token: `,`
-  --> $DIR/parse-error.rs:105:18
+  --> $DIR/parse-error.rs:103:18
    |
 LL | global_asm!("{}" FOO);
    |                  ^^^ expected `,`
 
 error: expected operand, options, or additional template string
-  --> $DIR/parse-error.rs:107:19
+  --> $DIR/parse-error.rs:105:19
    |
 LL | global_asm!("{}", FOO);
    |                   ^^^ expected operand, options, or additional template string
 
 error: expected expression, found end of macro arguments
-  --> $DIR/parse-error.rs:109:24
+  --> $DIR/parse-error.rs:107:24
    |
 LL | global_asm!("{}", const);
    |                        ^ expected expression
 
 error: expected one of `,`, `.`, `?`, or an operator, found `FOO`
-  --> $DIR/parse-error.rs:111:30
+  --> $DIR/parse-error.rs:109:30
    |
 LL | global_asm!("{}", const(reg) FOO);
    |                              ^^^ expected one of `,`, `.`, `?`, or an operator
 
 error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
-  --> $DIR/parse-error.rs:113:25
+  --> $DIR/parse-error.rs:111:25
    |
 LL | global_asm!("", options(FOO));
    |                         ^^^ expected one of `)`, `att_syntax`, or `raw`
 
 error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
-  --> $DIR/parse-error.rs:115:25
+  --> $DIR/parse-error.rs:113:25
    |
 LL | global_asm!("", options(FOO,));
    |                         ^^^ expected one of `)`, `att_syntax`, or `raw`
 
 error: the `nomem` option cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:117:25
+  --> $DIR/parse-error.rs:115:25
    |
 LL | global_asm!("", options(nomem FOO));
    |                         ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
 
 error: expected one of `)` or `,`, found `FOO`
-  --> $DIR/parse-error.rs:117:31
+  --> $DIR/parse-error.rs:115:31
    |
 LL | global_asm!("", options(nomem FOO));
    |                               ^^^ expected one of `)` or `,`
 
 error: the `nomem` option cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:120:25
+  --> $DIR/parse-error.rs:118:25
    |
 LL | global_asm!("", options(nomem, FOO));
    |                         ^^^^^ the `nomem` option is not meaningful for global-scoped inline assembly
 
 error: expected one of `)`, `att_syntax`, or `raw`, found `FOO`
-  --> $DIR/parse-error.rs:120:32
+  --> $DIR/parse-error.rs:118:32
    |
 LL | global_asm!("", options(nomem, FOO));
    |                                ^^^ expected one of `)`, `att_syntax`, or `raw`
 
 error: expected string literal
-  --> $DIR/parse-error.rs:124:29
+  --> $DIR/parse-error.rs:122:29
    |
 LL | global_asm!("", clobber_abi(FOO));
    |                             ^^^ not a string literal
 
 error: expected one of `)` or `,`, found `FOO`
-  --> $DIR/parse-error.rs:126:33
+  --> $DIR/parse-error.rs:124:33
    |
 LL | global_asm!("", clobber_abi("C" FOO));
    |                                 ^^^ expected one of `)` or `,`
 
 error: expected string literal
-  --> $DIR/parse-error.rs:128:34
+  --> $DIR/parse-error.rs:126:34
    |
 LL | global_asm!("", clobber_abi("C", FOO));
    |                                  ^^^ not a string literal
 
 error: `clobber_abi` cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:130:19
+  --> $DIR/parse-error.rs:128:19
    |
 LL | global_asm!("{}", clobber_abi("C"), const FOO);
    |                   ^^^^^^^^^^^^^^^^
 
 error: `clobber_abi` cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:132:28
+  --> $DIR/parse-error.rs:130:28
    |
 LL | global_asm!("", options(), clobber_abi("C"));
    |                            ^^^^^^^^^^^^^^^^
 
 error: `clobber_abi` cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:134:30
+  --> $DIR/parse-error.rs:132:30
    |
 LL | global_asm!("{}", options(), clobber_abi("C"), const FOO);
    |                              ^^^^^^^^^^^^^^^^
 
 error: `clobber_abi` cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:136:17
+  --> $DIR/parse-error.rs:134:17
    |
 LL | global_asm!("", clobber_abi("C"), clobber_abi("C"));
    |                 ^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^
 
 error: duplicate argument named `a`
-  --> $DIR/parse-error.rs:138:35
+  --> $DIR/parse-error.rs:136:35
    |
 LL | global_asm!("{a}", a = const FOO, a = const BAR);
    |                    -------------  ^^^^^^^^^^^^^ duplicate argument
@@ -345,7 +345,7 @@ LL | global_asm!("{a}", a = const FOO, a = const BAR);
    |                    previously here
 
 error: argument never used
-  --> $DIR/parse-error.rs:138:35
+  --> $DIR/parse-error.rs:136:35
    |
 LL | global_asm!("{a}", a = const FOO, a = const BAR);
    |                                   ^^^^^^^^^^^^^ argument never used
@@ -353,19 +353,19 @@ LL | global_asm!("{a}", a = const FOO, a = const BAR);
    = help: if this argument is intentionally unused, consider using it in an asm comment: `"/* {1} */"`
 
 error: expected one of `clobber_abi`, `const`, `options`, or `sym`, found `""`
-  --> $DIR/parse-error.rs:141:28
+  --> $DIR/parse-error.rs:139:28
    |
 LL | global_asm!("", options(), "");
    |                            ^^ expected one of `clobber_abi`, `const`, `options`, or `sym`
 
 error: expected one of `clobber_abi`, `const`, `options`, or `sym`, found `"{}"`
-  --> $DIR/parse-error.rs:143:30
+  --> $DIR/parse-error.rs:141:30
    |
 LL | global_asm!("{}", const FOO, "{}", const FOO);
    |                              ^^^^ expected one of `clobber_abi`, `const`, `options`, or `sym`
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:145:13
+  --> $DIR/parse-error.rs:143:13
    |
 LL | global_asm!(format!("{{{}}}", 0), const FOO);
    |             ^^^^^^^^^^^^^^^^^^^^
@@ -373,7 +373,7 @@ LL | global_asm!(format!("{{{}}}", 0), const FOO);
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: asm template must be a string literal
-  --> $DIR/parse-error.rs:147:20
+  --> $DIR/parse-error.rs:145:20
    |
 LL | global_asm!("{1}", format!("{{{}}}", 0), const FOO, const BAR);
    |                    ^^^^^^^^^^^^^^^^^^^^
@@ -381,43 +381,43 @@ LL | global_asm!("{1}", format!("{{{}}}", 0), const FOO, const BAR);
    = note: this error originates in the macro `format` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: the `in` operand cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:150:19
+  --> $DIR/parse-error.rs:148:19
    |
 LL | global_asm!("{}", in(reg));
    |                   ^^ the `in` operand is not meaningful for global-scoped inline assembly, remove it
 
 error: the `out` operand cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:152:19
+  --> $DIR/parse-error.rs:150:19
    |
 LL | global_asm!("{}", out(reg));
    |                   ^^^ the `out` operand is not meaningful for global-scoped inline assembly, remove it
 
 error: the `lateout` operand cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:154:19
+  --> $DIR/parse-error.rs:152:19
    |
 LL | global_asm!("{}", lateout(reg));
    |                   ^^^^^^^ the `lateout` operand is not meaningful for global-scoped inline assembly, remove it
 
 error: the `inout` operand cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:156:19
+  --> $DIR/parse-error.rs:154:19
    |
 LL | global_asm!("{}", inout(reg));
    |                   ^^^^^ the `inout` operand is not meaningful for global-scoped inline assembly, remove it
 
 error: the `inlateout` operand cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:158:19
+  --> $DIR/parse-error.rs:156:19
    |
 LL | global_asm!("{}", inlateout(reg));
    |                   ^^^^^^^^^ the `inlateout` operand is not meaningful for global-scoped inline assembly, remove it
 
 error: the `label` operand cannot be used with `global_asm!`
-  --> $DIR/parse-error.rs:160:19
+  --> $DIR/parse-error.rs:158:19
    |
 LL | global_asm!("{}", label(reg));
    |                   ^^^^^ the `label` operand is not meaningful for global-scoped inline assembly, remove it
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:39:37
+  --> $DIR/parse-error.rs:37:37
    |
 LL |         asm!("{}", options(), const foo);
    |                                     ^^^ non-constant value
@@ -428,7 +428,7 @@ LL |     const foo: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:71:44
+  --> $DIR/parse-error.rs:69:44
    |
 LL |         asm!("{}", clobber_abi("C"), const foo);
    |                                            ^^^ non-constant value
@@ -439,7 +439,7 @@ LL |     const foo: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:74:55
+  --> $DIR/parse-error.rs:72:55
    |
 LL |         asm!("{}", options(), clobber_abi("C"), const foo);
    |                                                       ^^^ non-constant value
@@ -450,7 +450,7 @@ LL |     const foo: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:76:31
+  --> $DIR/parse-error.rs:74:31
    |
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                               ^^^ non-constant value
@@ -461,7 +461,7 @@ LL |     const foo: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/parse-error.rs:76:46
+  --> $DIR/parse-error.rs:74:46
    |
 LL |         asm!("{a}", a = const foo, a = const bar);
    |                                              ^^^ non-constant value
diff --git a/tests/ui/asm/type-check-1.rs b/tests/ui/asm/type-check-1.rs
index 22669dce280bb..4dc30fb58385c 100644
--- a/tests/ui/asm/type-check-1.rs
+++ b/tests/ui/asm/type-check-1.rs
@@ -2,8 +2,6 @@
 //@ ignore-nvptx64
 //@ ignore-spirv
 
-#![feature(asm_const)]
-
 use std::arch::{asm, global_asm};
 
 fn main() {
diff --git a/tests/ui/asm/type-check-1.stderr b/tests/ui/asm/type-check-1.stderr
index d47e6ae1d2a97..aa9eed2fce65c 100644
--- a/tests/ui/asm/type-check-1.stderr
+++ b/tests/ui/asm/type-check-1.stderr
@@ -1,17 +1,17 @@
 error: invalid asm output
-  --> $DIR/type-check-1.rs:14:29
+  --> $DIR/type-check-1.rs:12:29
    |
 LL |         asm!("{}", out(reg) 1 + 2);
    |                             ^^^^^ cannot assign to this expression
 
 error: invalid asm output
-  --> $DIR/type-check-1.rs:16:31
+  --> $DIR/type-check-1.rs:14:31
    |
 LL |         asm!("{}", inout(reg) 1 + 2);
    |                               ^^^^^ cannot assign to this expression
 
 error[E0277]: the size for values of type `[u64]` cannot be known at compilation time
-  --> $DIR/type-check-1.rs:22:28
+  --> $DIR/type-check-1.rs:20:28
    |
 LL |         asm!("{}", in(reg) v[..]);
    |                            ^^^^^ doesn't have a size known at compile-time
@@ -20,7 +20,7 @@ LL |         asm!("{}", in(reg) v[..]);
    = note: all inline asm arguments must have a statically known size
 
 error[E0277]: the size for values of type `[u64]` cannot be known at compilation time
-  --> $DIR/type-check-1.rs:25:29
+  --> $DIR/type-check-1.rs:23:29
    |
 LL |         asm!("{}", out(reg) v[..]);
    |                             ^^^^^ doesn't have a size known at compile-time
@@ -29,7 +29,7 @@ LL |         asm!("{}", out(reg) v[..]);
    = note: all inline asm arguments must have a statically known size
 
 error[E0277]: the size for values of type `[u64]` cannot be known at compilation time
-  --> $DIR/type-check-1.rs:28:31
+  --> $DIR/type-check-1.rs:26:31
    |
 LL |         asm!("{}", inout(reg) v[..]);
    |                               ^^^^^ doesn't have a size known at compile-time
@@ -38,7 +38,7 @@ LL |         asm!("{}", inout(reg) v[..]);
    = note: all inline asm arguments must have a statically known size
 
 error: cannot use value of type `[u64]` for inline assembly
-  --> $DIR/type-check-1.rs:22:28
+  --> $DIR/type-check-1.rs:20:28
    |
 LL |         asm!("{}", in(reg) v[..]);
    |                            ^^^^^
@@ -46,7 +46,7 @@ LL |         asm!("{}", in(reg) v[..]);
    = note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
 
 error: cannot use value of type `[u64]` for inline assembly
-  --> $DIR/type-check-1.rs:25:29
+  --> $DIR/type-check-1.rs:23:29
    |
 LL |         asm!("{}", out(reg) v[..]);
    |                             ^^^^^
@@ -54,7 +54,7 @@ LL |         asm!("{}", out(reg) v[..]);
    = note: only integers, floats, SIMD vectors, pointers and function pointers can be used as arguments for inline assembly
 
 error: cannot use value of type `[u64]` for inline assembly
-  --> $DIR/type-check-1.rs:28:31
+  --> $DIR/type-check-1.rs:26:31
    |
 LL |         asm!("{}", inout(reg) v[..]);
    |                               ^^^^^
diff --git a/tests/ui/asm/x86_64/bad-reg.rs b/tests/ui/asm/x86_64/bad-reg.rs
index d41c46d57bb13..2a189a91c5a47 100644
--- a/tests/ui/asm/x86_64/bad-reg.rs
+++ b/tests/ui/asm/x86_64/bad-reg.rs
@@ -1,8 +1,6 @@
 //@ only-x86_64
 //@ compile-flags: -C target-feature=+avx2
 
-#![feature(asm_const)]
-
 use std::arch::asm;
 
 fn main() {
diff --git a/tests/ui/asm/x86_64/bad-reg.stderr b/tests/ui/asm/x86_64/bad-reg.stderr
index 8017008e97d75..3df1f7b220869 100644
--- a/tests/ui/asm/x86_64/bad-reg.stderr
+++ b/tests/ui/asm/x86_64/bad-reg.stderr
@@ -1,17 +1,17 @@
 error: invalid register class `foo`: unknown register class
-  --> $DIR/bad-reg.rs:14:20
+  --> $DIR/bad-reg.rs:12:20
    |
 LL |         asm!("{}", in(foo) foo);
    |                    ^^^^^^^^^^^
 
 error: invalid register `foo`: unknown register
-  --> $DIR/bad-reg.rs:16:18
+  --> $DIR/bad-reg.rs:14:18
    |
 LL |         asm!("", in("foo") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid asm template modifier for this register class
-  --> $DIR/bad-reg.rs:18:15
+  --> $DIR/bad-reg.rs:16:15
    |
 LL |         asm!("{:z}", in(reg) foo);
    |               ^^^^   ----------- argument
@@ -21,7 +21,7 @@ LL |         asm!("{:z}", in(reg) foo);
    = note: the `reg` register class supports the following template modifiers: `l`, `x`, `e`, `r`
 
 error: invalid asm template modifier for this register class
-  --> $DIR/bad-reg.rs:20:15
+  --> $DIR/bad-reg.rs:18:15
    |
 LL |         asm!("{:r}", in(xmm_reg) foo);
    |               ^^^^   --------------- argument
@@ -31,7 +31,7 @@ LL |         asm!("{:r}", in(xmm_reg) foo);
    = note: the `xmm_reg` register class supports the following template modifiers: `x`, `y`, `z`
 
 error: asm template modifiers are not allowed for `const` arguments
-  --> $DIR/bad-reg.rs:22:15
+  --> $DIR/bad-reg.rs:20:15
    |
 LL |         asm!("{:a}", const 0);
    |               ^^^^   ------- argument
@@ -39,7 +39,7 @@ LL |         asm!("{:a}", const 0);
    |               template modifier
 
 error: asm template modifiers are not allowed for `sym` arguments
-  --> $DIR/bad-reg.rs:24:15
+  --> $DIR/bad-reg.rs:22:15
    |
 LL |         asm!("{:a}", sym main);
    |               ^^^^   -------- argument
@@ -47,67 +47,67 @@ LL |         asm!("{:a}", sym main);
    |               template modifier
 
 error: invalid register `ebp`: the frame pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:26:18
+  --> $DIR/bad-reg.rs:24:18
    |
 LL |         asm!("", in("ebp") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `rsp`: the stack pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:28:18
+  --> $DIR/bad-reg.rs:26:18
    |
 LL |         asm!("", in("rsp") foo);
    |                  ^^^^^^^^^^^^^
 
 error: invalid register `ip`: the instruction pointer cannot be used as an operand for inline asm
-  --> $DIR/bad-reg.rs:30:18
+  --> $DIR/bad-reg.rs:28:18
    |
 LL |         asm!("", in("ip") foo);
    |                  ^^^^^^^^^^^^
 
 error: register class `x87_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:33:18
+  --> $DIR/bad-reg.rs:31:18
    |
 LL |         asm!("", in("st(2)") foo);
    |                  ^^^^^^^^^^^^^^^
 
 error: register class `mmx_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:36:18
+  --> $DIR/bad-reg.rs:34:18
    |
 LL |         asm!("", in("mm0") foo);
    |                  ^^^^^^^^^^^^^
 
 error: register class `kreg0` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:39:18
+  --> $DIR/bad-reg.rs:37:18
    |
 LL |         asm!("", in("k0") foo);
    |                  ^^^^^^^^^^^^
 
 error: register class `x87_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:44:20
+  --> $DIR/bad-reg.rs:42:20
    |
 LL |         asm!("{}", in(x87_reg) foo);
    |                    ^^^^^^^^^^^^^^^
 
 error: register class `mmx_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:47:20
+  --> $DIR/bad-reg.rs:45:20
    |
 LL |         asm!("{}", in(mmx_reg) foo);
    |                    ^^^^^^^^^^^^^^^
 
 error: register class `x87_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:50:20
+  --> $DIR/bad-reg.rs:48:20
    |
 LL |         asm!("{}", out(x87_reg) _);
    |                    ^^^^^^^^^^^^^^
 
 error: register class `mmx_reg` can only be used as a clobber, not as an input or output
-  --> $DIR/bad-reg.rs:52:20
+  --> $DIR/bad-reg.rs:50:20
    |
 LL |         asm!("{}", out(mmx_reg) _);
    |                    ^^^^^^^^^^^^^^
 
 error: register `al` conflicts with register `eax`
-  --> $DIR/bad-reg.rs:58:33
+  --> $DIR/bad-reg.rs:56:33
    |
 LL |         asm!("", in("eax") foo, in("al") bar);
    |                  -------------  ^^^^^^^^^^^^ register `al`
@@ -115,7 +115,7 @@ LL |         asm!("", in("eax") foo, in("al") bar);
    |                  register `eax`
 
 error: register `rax` conflicts with register `rax`
-  --> $DIR/bad-reg.rs:61:33
+  --> $DIR/bad-reg.rs:59:33
    |
 LL |         asm!("", in("rax") foo, out("rax") bar);
    |                  -------------  ^^^^^^^^^^^^^^ register `rax`
@@ -123,13 +123,13 @@ LL |         asm!("", in("rax") foo, out("rax") bar);
    |                  register `rax`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:61:18
+  --> $DIR/bad-reg.rs:59:18
    |
 LL |         asm!("", in("rax") foo, out("rax") bar);
    |                  ^^^^^^^^^^^^^
 
 error: register `ymm0` conflicts with register `xmm0`
-  --> $DIR/bad-reg.rs:66:34
+  --> $DIR/bad-reg.rs:64:34
    |
 LL |         asm!("", in("xmm0") foo, in("ymm0") bar);
    |                  --------------  ^^^^^^^^^^^^^^ register `ymm0`
@@ -137,7 +137,7 @@ LL |         asm!("", in("xmm0") foo, in("ymm0") bar);
    |                  register `xmm0`
 
 error: register `ymm0` conflicts with register `xmm0`
-  --> $DIR/bad-reg.rs:68:34
+  --> $DIR/bad-reg.rs:66:34
    |
 LL |         asm!("", in("xmm0") foo, out("ymm0") bar);
    |                  --------------  ^^^^^^^^^^^^^^^ register `ymm0`
@@ -145,13 +145,13 @@ LL |         asm!("", in("xmm0") foo, out("ymm0") bar);
    |                  register `xmm0`
    |
 help: use `lateout` instead of `out` to avoid conflict
-  --> $DIR/bad-reg.rs:68:18
+  --> $DIR/bad-reg.rs:66:18
    |
 LL |         asm!("", in("xmm0") foo, out("ymm0") bar);
    |                  ^^^^^^^^^^^^^^
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:33:30
+  --> $DIR/bad-reg.rs:31:30
    |
 LL |         asm!("", in("st(2)") foo);
    |                              ^^^
@@ -159,7 +159,7 @@ LL |         asm!("", in("st(2)") foo);
    = note: register class `x87_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:36:28
+  --> $DIR/bad-reg.rs:34:28
    |
 LL |         asm!("", in("mm0") foo);
    |                            ^^^
@@ -167,7 +167,7 @@ LL |         asm!("", in("mm0") foo);
    = note: register class `mmx_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:39:27
+  --> $DIR/bad-reg.rs:37:27
    |
 LL |         asm!("", in("k0") foo);
    |                           ^^^
@@ -175,7 +175,7 @@ LL |         asm!("", in("k0") foo);
    = note: register class `kreg0` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:44:32
+  --> $DIR/bad-reg.rs:42:32
    |
 LL |         asm!("{}", in(x87_reg) foo);
    |                                ^^^
@@ -183,7 +183,7 @@ LL |         asm!("{}", in(x87_reg) foo);
    = note: register class `x87_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:47:32
+  --> $DIR/bad-reg.rs:45:32
    |
 LL |         asm!("{}", in(mmx_reg) foo);
    |                                ^^^
@@ -191,7 +191,7 @@ LL |         asm!("{}", in(mmx_reg) foo);
    = note: register class `mmx_reg` supports these types: 
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:58:42
+  --> $DIR/bad-reg.rs:56:42
    |
 LL |         asm!("", in("eax") foo, in("al") bar);
    |                                          ^^^
@@ -199,7 +199,7 @@ LL |         asm!("", in("eax") foo, in("al") bar);
    = note: register class `reg_byte` supports these types: i8
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:63:27
+  --> $DIR/bad-reg.rs:61:27
    |
 LL |         asm!("", in("al") foo, lateout("al") bar);
    |                           ^^^
@@ -207,7 +207,7 @@ LL |         asm!("", in("al") foo, lateout("al") bar);
    = note: register class `reg_byte` supports these types: i8
 
 error: type `i32` cannot be used with this register class
-  --> $DIR/bad-reg.rs:63:46
+  --> $DIR/bad-reg.rs:61:46
    |
 LL |         asm!("", in("al") foo, lateout("al") bar);
    |                                              ^^^
diff --git a/tests/ui/asm/x86_64/const.rs b/tests/ui/asm/x86_64/const.rs
index 817a338a5b99f..eaaaf92e823b4 100644
--- a/tests/ui/asm/x86_64/const.rs
+++ b/tests/ui/asm/x86_64/const.rs
@@ -2,8 +2,6 @@
 //@ run-pass
 //@ needs-asm-support
 
-#![feature(asm_const)]
-
 use std::arch::{asm, global_asm};
 
 fn const_generic<const X: usize>() -> usize {
diff --git a/tests/ui/asm/x86_64/type-check-3.rs b/tests/ui/asm/x86_64/type-check-3.rs
index bd242af3dbc07..bfb795d262455 100644
--- a/tests/ui/asm/x86_64/type-check-3.rs
+++ b/tests/ui/asm/x86_64/type-check-3.rs
@@ -1,8 +1,6 @@
 //@ only-x86_64
 //@ compile-flags: -C target-feature=+avx512f
 
-#![feature(asm_const)]
-
 use std::arch::{asm, global_asm};
 
 use std::arch::x86_64::{_mm256_setzero_ps, _mm_setzero_ps};
diff --git a/tests/ui/asm/x86_64/type-check-3.stderr b/tests/ui/asm/x86_64/type-check-3.stderr
index 202b97ca5c0e8..5a7b349413e45 100644
--- a/tests/ui/asm/x86_64/type-check-3.stderr
+++ b/tests/ui/asm/x86_64/type-check-3.stderr
@@ -1,5 +1,5 @@
 error: type `i128` cannot be used with this register class
-  --> $DIR/type-check-3.rs:14:28
+  --> $DIR/type-check-3.rs:12:28
    |
 LL |         asm!("{}", in(reg) 0i128);
    |                            ^^^^^
@@ -7,7 +7,7 @@ LL |         asm!("{}", in(reg) 0i128);
    = note: register class `reg` supports these types: i16, i32, i64, f16, f32, f64
 
 error: type `__m128` cannot be used with this register class
-  --> $DIR/type-check-3.rs:16:28
+  --> $DIR/type-check-3.rs:14:28
    |
 LL |         asm!("{}", in(reg) _mm_setzero_ps());
    |                            ^^^^^^^^^^^^^^^^
@@ -15,7 +15,7 @@ LL |         asm!("{}", in(reg) _mm_setzero_ps());
    = note: register class `reg` supports these types: i16, i32, i64, f16, f32, f64
 
 error: type `__m256` cannot be used with this register class
-  --> $DIR/type-check-3.rs:18:28
+  --> $DIR/type-check-3.rs:16:28
    |
 LL |         asm!("{}", in(reg) _mm256_setzero_ps());
    |                            ^^^^^^^^^^^^^^^^^^^
@@ -23,7 +23,7 @@ LL |         asm!("{}", in(reg) _mm256_setzero_ps());
    = note: register class `reg` supports these types: i16, i32, i64, f16, f32, f64
 
 error: type `u8` cannot be used with this register class
-  --> $DIR/type-check-3.rs:20:32
+  --> $DIR/type-check-3.rs:18:32
    |
 LL |         asm!("{}", in(xmm_reg) 0u8);
    |                                ^^^
@@ -31,7 +31,7 @@ LL |         asm!("{}", in(xmm_reg) 0u8);
    = note: register class `xmm_reg` supports these types: i32, i64, f16, f32, f64, f128, i8x16, i16x8, i32x4, i64x2, f16x8, f32x4, f64x2
 
 error: `avx512bw` target feature is not enabled
-  --> $DIR/type-check-3.rs:29:29
+  --> $DIR/type-check-3.rs:27:29
    |
 LL |         asm!("{}", in(kreg) 0u64);
    |                             ^^^^
@@ -39,7 +39,7 @@ LL |         asm!("{}", in(kreg) 0u64);
    = note: this is required to use type `u64` with register class `kreg`
 
 warning: formatting may not be suitable for sub-register argument
-  --> $DIR/type-check-3.rs:34:15
+  --> $DIR/type-check-3.rs:32:15
    |
 LL |         asm!("{0} {0}", in(reg) 0i16);
    |               ^^^ ^^^           ---- for this argument
@@ -49,7 +49,7 @@ LL |         asm!("{0} {0}", in(reg) 0i16);
    = note: `#[warn(asm_sub_register)]` on by default
 
 warning: formatting may not be suitable for sub-register argument
-  --> $DIR/type-check-3.rs:36:15
+  --> $DIR/type-check-3.rs:34:15
    |
 LL |         asm!("{0} {0:x}", in(reg) 0i16);
    |               ^^^                 ---- for this argument
@@ -58,7 +58,7 @@ LL |         asm!("{0} {0:x}", in(reg) 0i16);
    = help: or use `{0:r}` to keep the default formatting of `rax` (for 64-bit values)
 
 warning: formatting may not be suitable for sub-register argument
-  --> $DIR/type-check-3.rs:38:15
+  --> $DIR/type-check-3.rs:36:15
    |
 LL |         asm!("{}", in(reg) 0i32);
    |               ^^           ---- for this argument
@@ -67,7 +67,7 @@ LL |         asm!("{}", in(reg) 0i32);
    = help: or use `{0:r}` to keep the default formatting of `rax` (for 64-bit values)
 
 warning: formatting may not be suitable for sub-register argument
-  --> $DIR/type-check-3.rs:41:15
+  --> $DIR/type-check-3.rs:39:15
    |
 LL |         asm!("{}", in(ymm_reg) 0i64);
    |               ^^               ---- for this argument
@@ -76,7 +76,7 @@ LL |         asm!("{}", in(ymm_reg) 0i64);
    = help: or use `{0:y}` to keep the default formatting of `ymm0` (for 256-bit values)
 
 error: type `i8` cannot be used with this register class
-  --> $DIR/type-check-3.rs:52:28
+  --> $DIR/type-check-3.rs:50:28
    |
 LL |         asm!("{}", in(reg) 0i8);
    |                            ^^^
@@ -85,7 +85,7 @@ LL |         asm!("{}", in(reg) 0i8);
    = help: consider using the `reg_byte` register class instead
 
 error: incompatible types for asm inout argument
-  --> $DIR/type-check-3.rs:64:33
+  --> $DIR/type-check-3.rs:62:33
    |
 LL |         asm!("{:r}", inout(reg) 0u32 => val_f32);
    |                                 ^^^^    ^^^^^^^ type `f32`
@@ -95,7 +95,7 @@ LL |         asm!("{:r}", inout(reg) 0u32 => val_f32);
    = note: asm inout arguments must have the same type, unless they are both pointers or integers of the same size
 
 error: incompatible types for asm inout argument
-  --> $DIR/type-check-3.rs:66:33
+  --> $DIR/type-check-3.rs:64:33
    |
 LL |         asm!("{:r}", inout(reg) 0u32 => val_ptr);
    |                                 ^^^^    ^^^^^^^ type `*mut u8`
@@ -105,7 +105,7 @@ LL |         asm!("{:r}", inout(reg) 0u32 => val_ptr);
    = note: asm inout arguments must have the same type, unless they are both pointers or integers of the same size
 
 error: incompatible types for asm inout argument
-  --> $DIR/type-check-3.rs:68:33
+  --> $DIR/type-check-3.rs:66:33
    |
 LL |         asm!("{:r}", inout(reg) main => val_u32);
    |                                 ^^^^    ^^^^^^^ type `u32`
diff --git a/tests/ui/asm/x86_64/type-check-4.rs b/tests/ui/asm/x86_64/type-check-4.rs
index f7bf60d04dfdf..9503cd6d8ab2b 100644
--- a/tests/ui/asm/x86_64/type-check-4.rs
+++ b/tests/ui/asm/x86_64/type-check-4.rs
@@ -1,8 +1,6 @@
 //@ only-x86_64
 //@ compile-flags: -C target-feature=+avx512f
 
-#![feature(asm_const)]
-
 use std::arch::{asm, global_asm};
 
 use std::arch::x86_64::{_mm256_setzero_ps, _mm_setzero_ps};
diff --git a/tests/ui/asm/x86_64/type-check-4.stderr b/tests/ui/asm/x86_64/type-check-4.stderr
index cbdc051b3436b..f1bbc9e7d33de 100644
--- a/tests/ui/asm/x86_64/type-check-4.stderr
+++ b/tests/ui/asm/x86_64/type-check-4.stderr
@@ -1,5 +1,5 @@
 error[E0658]: referencing statics in constants is unstable
-  --> $DIR/type-check-4.rs:21:25
+  --> $DIR/type-check-4.rs:19:25
    |
 LL | global_asm!("{}", const S);
    |                         ^
@@ -11,7 +11,7 @@ LL | global_asm!("{}", const S);
    = help: to fix this, the value can be extracted to a `const` and then used.
 
 error[E0658]: referencing statics in constants is unstable
-  --> $DIR/type-check-4.rs:24:35
+  --> $DIR/type-check-4.rs:22:35
    |
 LL | global_asm!("{}", const const_foo(S));
    |                                   ^
@@ -23,7 +23,7 @@ LL | global_asm!("{}", const const_foo(S));
    = help: to fix this, the value can be extracted to a `const` and then used.
 
 error[E0658]: referencing statics in constants is unstable
-  --> $DIR/type-check-4.rs:27:35
+  --> $DIR/type-check-4.rs:25:35
    |
 LL | global_asm!("{}", const const_bar(S));
    |                                   ^
diff --git a/tests/ui/asm/x86_64/x86_64_parse_error.rs b/tests/ui/asm/x86_64/x86_64_parse_error.rs
index 850033d4ce03b..3df0febf6b070 100644
--- a/tests/ui/asm/x86_64/x86_64_parse_error.rs
+++ b/tests/ui/asm/x86_64/x86_64_parse_error.rs
@@ -1,7 +1,5 @@
 //@ only-x86_64
 
-#![feature(asm_const)]
-
 use std::arch::asm;
 
 fn main() {
diff --git a/tests/ui/asm/x86_64/x86_64_parse_error.stderr b/tests/ui/asm/x86_64/x86_64_parse_error.stderr
index 9751f7b09d0eb..b64f6c1127eb6 100644
--- a/tests/ui/asm/x86_64/x86_64_parse_error.stderr
+++ b/tests/ui/asm/x86_64/x86_64_parse_error.stderr
@@ -1,11 +1,11 @@
 error: explicit register arguments cannot have names
-  --> $DIR/x86_64_parse_error.rs:11:18
+  --> $DIR/x86_64_parse_error.rs:9:18
    |
 LL |         asm!("", a = in("eax") foo);
    |                  ^^^^^^^^^^^^^^^^^
 
 error: positional arguments cannot follow named arguments or explicit register arguments
-  --> $DIR/x86_64_parse_error.rs:17:36
+  --> $DIR/x86_64_parse_error.rs:15:36
    |
 LL |         asm!("{1}", in("eax") foo, const bar);
    |                     -------------  ^^^^^^^^^ positional argument
@@ -13,7 +13,7 @@ LL |         asm!("{1}", in("eax") foo, const bar);
    |                     explicit register argument
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/x86_64_parse_error.rs:13:46
+  --> $DIR/x86_64_parse_error.rs:11:46
    |
 LL |         asm!("{a}", in("eax") foo, a = const bar);
    |                                              ^^^ non-constant value
@@ -24,7 +24,7 @@ LL |     const bar: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/x86_64_parse_error.rs:15:46
+  --> $DIR/x86_64_parse_error.rs:13:46
    |
 LL |         asm!("{a}", in("eax") foo, a = const bar);
    |                                              ^^^ non-constant value
@@ -35,7 +35,7 @@ LL |     const bar: /* Type */ = 0;
    |     ~~~~~    ++++++++++++
 
 error[E0435]: attempt to use a non-constant value in a constant
-  --> $DIR/x86_64_parse_error.rs:17:42
+  --> $DIR/x86_64_parse_error.rs:15:42
    |
 LL |         asm!("{1}", in("eax") foo, const bar);
    |                                          ^^^ non-constant value
diff --git a/tests/ui/feature-gates/feature-gate-asm_const.rs b/tests/ui/feature-gates/feature-gate-asm_const.rs
deleted file mode 100644
index 42d5ba69222d0..0000000000000
--- a/tests/ui/feature-gates/feature-gate-asm_const.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-//@ only-x86_64
-
-use std::arch::asm;
-
-unsafe fn foo<const N: usize>() {
-    asm!("mov eax, {}", const N + 1);
-    //~^ ERROR const operands for inline assembly are unstable
-}
-
-fn main() {
-    unsafe {
-        foo::<0>();
-        asm!("mov eax, {}", const 123);
-        //~^ ERROR const operands for inline assembly are unstable
-    }
-}
diff --git a/tests/ui/feature-gates/feature-gate-asm_const.stderr b/tests/ui/feature-gates/feature-gate-asm_const.stderr
deleted file mode 100644
index 4f83fee675933..0000000000000
--- a/tests/ui/feature-gates/feature-gate-asm_const.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-error[E0658]: const operands for inline assembly are unstable
-  --> $DIR/feature-gate-asm_const.rs:6:25
-   |
-LL |     asm!("mov eax, {}", const N + 1);
-   |                         ^^^^^^^^^^^
-   |
-   = note: see issue #93332 <https://github.com/rust-lang/rust/issues/93332> for more information
-   = help: add `#![feature(asm_const)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: const operands for inline assembly are unstable
-  --> $DIR/feature-gate-asm_const.rs:13:29
-   |
-LL |         asm!("mov eax, {}", const 123);
-   |                             ^^^^^^^^^
-   |
-   = note: see issue #93332 <https://github.com/rust-lang/rust/issues/93332> for more information
-   = help: add `#![feature(asm_const)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0658`.

From b89d1976d1968697fd1dbb1db636d24ec641f625 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Tue, 13 Aug 2024 18:20:48 -0400
Subject: [PATCH 247/685] Require gdb version on some tests

---
 tests/debuginfo/by-value-non-immediate-argument.rs | 8 +-------
 tests/debuginfo/macro-stepping.rs                  | 1 +
 tests/debuginfo/method-on-enum.rs                  | 2 +-
 tests/debuginfo/option-like-enum.rs                | 2 +-
 4 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/tests/debuginfo/by-value-non-immediate-argument.rs b/tests/debuginfo/by-value-non-immediate-argument.rs
index cf1008387cbb9..68717b7953374 100644
--- a/tests/debuginfo/by-value-non-immediate-argument.rs
+++ b/tests/debuginfo/by-value-non-immediate-argument.rs
@@ -1,11 +1,5 @@
-// The gdb that we use in CI for aarch64-unknown-linux-gnu and x86_64-pc-windows-gnu seems unable
-// to handle by-value non-immediate arguments, which is the whole point of this test.
-// gdb on those platforms (or the version we test) just prints <optimized out> for structs/tuples
-// and attempts to read memory at 0x0 for enums.
-//@ ignore-aarch64: #128973
-//@ ignore-windows-gnu
-
 //@ min-lldb-version: 1800
+//@ min-gdb-version: 13.0
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/macro-stepping.rs b/tests/debuginfo/macro-stepping.rs
index bb465d9fb2932..d469cbb761fcb 100644
--- a/tests/debuginfo/macro-stepping.rs
+++ b/tests/debuginfo/macro-stepping.rs
@@ -2,6 +2,7 @@
 //@ ignore-android
 //@ ignore-aarch64
 //@ min-lldb-version: 310
+//@ min-gdb-version: 13.0
 
 //@ aux-build:macro-stepping.rs
 
diff --git a/tests/debuginfo/method-on-enum.rs b/tests/debuginfo/method-on-enum.rs
index c84dc34850780..7bee54451aa91 100644
--- a/tests/debuginfo/method-on-enum.rs
+++ b/tests/debuginfo/method-on-enum.rs
@@ -1,5 +1,5 @@
 //@ min-lldb-version: 1800
-//@ ignore-i686-pc-windows-gnu
+//@ min-gdb-version: 13.0
 
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/option-like-enum.rs b/tests/debuginfo/option-like-enum.rs
index 10e512a16c5da..da556d613d088 100644
--- a/tests/debuginfo/option-like-enum.rs
+++ b/tests/debuginfo/option-like-enum.rs
@@ -1,5 +1,5 @@
 //@ min-lldb-version: 1800
-//@ ignore-i686-pc-windows-gnu
+//@ min-gdb-version: 13.0
 
 //@ compile-flags:-g
 

From 822961f2920b8617e2bce4e4052711da0acc7410 Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Tue, 13 Aug 2024 19:05:05 -0400
Subject: [PATCH 248/685] Update cargo

---
 src/tools/cargo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/cargo b/src/tools/cargo
index 0d8d22f83b066..2f738d617c6ea 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 0d8d22f83b066503f6b2b755925197e959e58b4f
+Subproject commit 2f738d617c6ead388f899802dd1a7fd66858a691

From ce67e68cce3f4582db48b86c51a35c76d1103654 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Tue, 13 Aug 2024 16:16:57 -0700
Subject: [PATCH 249/685] Update `indexmap` and use `IndexMap::append`

---
 Cargo.lock                                      | 4 ++--
 compiler/rustc_data_structures/Cargo.toml       | 2 +-
 compiler/rustc_monomorphize/src/partitioning.rs | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4bd99b7fbe7ac..1aa0b2ea4a398 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1775,9 +1775,9 @@ checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683"
 
 [[package]]
 name = "indexmap"
-version = "2.2.6"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+checksum = "93ead53efc7ea8ed3cfb0c79fc8023fbb782a5432b52830b6518941cebe6505c"
 dependencies = [
  "equivalent",
  "hashbrown",
diff --git a/compiler/rustc_data_structures/Cargo.toml b/compiler/rustc_data_structures/Cargo.toml
index 3794a6e043c6d..69cbf8c416105 100644
--- a/compiler/rustc_data_structures/Cargo.toml
+++ b/compiler/rustc_data_structures/Cargo.toml
@@ -10,7 +10,7 @@ bitflags = "2.4.1"
 either = "1.0"
 elsa = "=1.7.1"
 ena = "0.14.3"
-indexmap = { version = "2.0.0" }
+indexmap = { version = "2.4.0" }
 jobserver_crate = { version = "0.1.28", package = "jobserver" }
 measureme = "11"
 rustc-hash = "1.1.0"
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
index 65a3d8d1742d9..92902185e8b75 100644
--- a/compiler/rustc_monomorphize/src/partitioning.rs
+++ b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -371,7 +371,7 @@ fn merge_codegen_units<'tcx>(
         // Move the items from `cgu_src` to `cgu_dst`. Some of them may be
         // duplicate inlined items, in which case the destination CGU is
         // unaffected. Recalculate size estimates afterwards.
-        cgu_dst.items_mut().extend(cgu_src.items_mut().drain(..));
+        cgu_dst.items_mut().append(cgu_src.items_mut());
         cgu_dst.compute_size_estimate();
 
         // Record that `cgu_dst` now contains all the stuff that was in
@@ -410,7 +410,7 @@ fn merge_codegen_units<'tcx>(
         // Move the items from `smallest` to `second_smallest`. Some of them
         // may be duplicate inlined items, in which case the destination CGU is
         // unaffected. Recalculate size estimates afterwards.
-        second_smallest.items_mut().extend(smallest.items_mut().drain(..));
+        second_smallest.items_mut().append(smallest.items_mut());
         second_smallest.compute_size_estimate();
 
         // Don't update `cgu_contents`, that's only for incremental builds.

From 5ef895e2cfe6a82f631aaa89c27dd18fa6c90b73 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Tue, 13 Aug 2024 16:43:52 -0700
Subject: [PATCH 250/685] Re-update to LLVM 19 rc2

The update in #128677 was accidentally reverted in #128962.
---
 src/llvm-project | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm-project b/src/llvm-project
index 57ae1a3474057..ccf4c38bdd73f 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 57ae1a3474057fead2c438928ed368b3740bf0ec
+Subproject commit ccf4c38bdd73f1a37ec266c73bdaef80e39f8cf6

From 3ed63dd8435bf14c958f2d500010eb14bd7c11d8 Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Wed, 14 Aug 2024 02:12:14 +0200
Subject: [PATCH 251/685] Promote Mac Catalyst targets to tier 2, and ship with
 rustup

- aarch64-apple-ios-macabi
- x86_64-apple-ios-macabi
---
 .../spec/targets/aarch64_apple_ios_macabi.rs  |  2 +-
 .../spec/targets/x86_64_apple_ios_macabi.rs   |  2 +-
 src/ci/github-actions/jobs.yml                |  6 ++++--
 src/doc/rustc/src/platform-support.md         |  4 ++--
 .../src/platform-support/apple-ios-macabi.md  | 20 +++++++++++--------
 src/tools/build-manifest/src/main.rs          |  2 ++
 6 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs
index 85c40ec60c41f..32c2367d5bfdb 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_apple_ios_macabi.rs
@@ -10,7 +10,7 @@ pub fn target() -> Target {
         llvm_target: mac_catalyst_llvm_target(arch).into(),
         metadata: crate::spec::TargetMetadata {
             description: Some("Apple Catalyst on ARM64".into()),
-            tier: Some(3),
+            tier: Some(2),
             host_tools: Some(false),
             std: Some(true),
         },
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs
index d3ba17cf02710..c23a20ff0848e 100644
--- a/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs
+++ b/compiler/rustc_target/src/spec/targets/x86_64_apple_ios_macabi.rs
@@ -10,7 +10,7 @@ pub fn target() -> Target {
         llvm_target: mac_catalyst_llvm_target(arch).into(),
         metadata: crate::spec::TargetMetadata {
             description: Some("Apple Catalyst on x86_64".into()),
-            tier: Some(3),
+            tier: Some(2),
             host_tools: Some(false),
             std: Some(true),
         },
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 638f14ad53fef..4de44c6dd39d7 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -285,8 +285,10 @@ auto:
 
   - image: dist-apple-various
     env:
-      SCRIPT: ./x.py dist bootstrap --include-default-paths --host='' --target=aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim
-      RUST_CONFIGURE_ARGS: --enable-sanitizers --enable-profiler --set rust.jemalloc
+      SCRIPT: ./x.py dist bootstrap --include-default-paths --host='' --target=aarch64-apple-ios,x86_64-apple-ios,aarch64-apple-ios-sim,aarch64-apple-ios-macabi,x86_64-apple-ios-macabi
+      # Mac Catalyst cannot currently compile the sanitizer:
+      # https://github.com/rust-lang/rust/issues/129069
+      RUST_CONFIGURE_ARGS: --enable-sanitizers --enable-profiler --set rust.jemalloc --set target.aarch64-apple-ios-macabi.sanitizers=false --set target.x86_64-apple-ios-macabi.sanitizers=false
       RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
       MACOSX_DEPLOYMENT_TARGET: 10.12
       SELECT_XCODE: /Applications/Xcode_14.3.1.app
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index bd12172ecbb4c..91d92e23055a3 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -136,6 +136,7 @@ so Rustup may install the documentation for a similar tier 1 target instead.
 target | std | notes
 -------|:---:|-------
 [`aarch64-apple-ios`](platform-support/apple-ios.md) | ✓ | ARM64 iOS
+[`aarch64-apple-ios-macabi`](platform-support/apple-ios-macabi.md) | ✓ | Mac Catalyst on ARM64
 [`aarch64-apple-ios-sim`](platform-support/apple-ios.md) | ✓ | Apple iOS Simulator on ARM64
 `aarch64-fuchsia` | ✓ | Alias for `aarch64-unknown-fuchsia`
 [`aarch64-unknown-fuchsia`](platform-support/fuchsia.md) | ✓ | ARM64 Fuchsia
@@ -196,6 +197,7 @@ target | std | notes
 [`wasm32-wasip1`](platform-support/wasm32-wasip1.md) | ✓ | WebAssembly with WASI
 [`wasm32-wasip1-threads`](platform-support/wasm32-wasip1-threads.md) | ✓ | WebAssembly with WASI Preview 1 and threads
 [`x86_64-apple-ios`](platform-support/apple-ios.md) | ✓ | 64-bit x86 iOS
+[`x86_64-apple-ios-macabi`](platform-support/apple-ios-macabi.md) | ✓ | Mac Catalyst on x86_64
 [`x86_64-fortanix-unknown-sgx`](platform-support/x86_64-fortanix-unknown-sgx.md) | ✓ | [Fortanix ABI] for 64-bit Intel SGX
 `x86_64-fuchsia` | ✓ | Alias for `x86_64-unknown-fuchsia`
 [`x86_64-unknown-fuchsia`](platform-support/fuchsia.md) | ✓ | 64-bit x86 Fuchsia
@@ -245,7 +247,6 @@ target | std | host | notes
 -------|:---:|:----:|-------
 [`arm64e-apple-ios`](platform-support/arm64e-apple-ios.md) | ✓ | | ARM64e Apple iOS
 [`arm64e-apple-darwin`](platform-support/arm64e-apple-darwin.md)  | ✓ | ✓ | ARM64e Apple Darwin
-[`aarch64-apple-ios-macabi`](platform-support/apple-ios-macabi.md) | ✓ |  | Apple Catalyst on ARM64
 [`aarch64-apple-tvos`](platform-support/apple-tvos.md) | ✓ |  | ARM64 tvOS
 [`aarch64-apple-tvos-sim`](platform-support/apple-tvos.md) | ✓ |  | ARM64 tvOS Simulator
 [`aarch64-apple-watchos`](platform-support/apple-watchos.md) | ✓ |  | ARM64 Apple WatchOS
@@ -370,7 +371,6 @@ target | std | host | notes
 `thumbv7neon-unknown-linux-musleabihf` | ? |  | Thumb2-mode Armv7-A Linux with NEON, musl 1.2.3
 [`wasm32-wasip2`](platform-support/wasm32-wasip2.md) | ✓ |  | WebAssembly
 [`wasm64-unknown-unknown`](platform-support/wasm64-unknown-unknown.md) | ? |  | WebAssembly
-[`x86_64-apple-ios-macabi`](platform-support/apple-ios-macabi.md) | ✓ |  | Apple Catalyst on x86_64
 [`x86_64-apple-tvos`](platform-support/apple-tvos.md) | ✓ |  | x86 64-bit tvOS
 [`x86_64-apple-watchos-sim`](platform-support/apple-watchos.md) | ✓ |  | x86 64-bit Apple WatchOS simulator
 [`x86_64-pc-nto-qnx710`](platform-support/nto-qnx.md) | ✓ |  | x86 64-bit QNX Neutrino 7.1 RTOS |
diff --git a/src/doc/rustc/src/platform-support/apple-ios-macabi.md b/src/doc/rustc/src/platform-support/apple-ios-macabi.md
index 15ba31e0f0645..678630873b135 100644
--- a/src/doc/rustc/src/platform-support/apple-ios-macabi.md
+++ b/src/doc/rustc/src/platform-support/apple-ios-macabi.md
@@ -2,7 +2,7 @@
 
 Apple Mac Catalyst targets.
 
-**Tier: 3**
+**Tier: 2 (without Host Tools)**
 
 - `aarch64-apple-ios-macabi`: Mac Catalyst on ARM64.
 - `x86_64-apple-ios-macabi`: Mac Catalyst on 64-bit x86.
@@ -32,15 +32,19 @@ case `IPHONEOS_DEPLOYMENT_TARGET`.
 
 ## Building the target
 
-The targets can be built by enabling them for a `rustc` build in
-`config.toml`, by adding, for example:
-
-```toml
-[build]
-target = ["aarch64-apple-ios-macabi", "x86_64-apple-ios-macabi"]
+The targets are distributed through `rustup`, and can be installed using one
+of:
+```console
+$ rustup target add aarch64-apple-ios-macabi
+$ rustup target add x86_64-apple-ios-macabi
 ```
 
-Using the unstable `-Zbuild-std` with a nightly Cargo may also work.
+### Sanitizers
+
+Due to CMake having poor support for Mac Catalyst, sanitizer runtimes are not
+currently available, see [#129069].
+
+[#129069]: https://github.com/rust-lang/rust/issues/129069
 
 ## Building Rust programs
 
diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs
index 2b263f848e89e..92b21f7dbaa6f 100644
--- a/src/tools/build-manifest/src/main.rs
+++ b/src/tools/build-manifest/src/main.rs
@@ -54,6 +54,7 @@ static TARGETS: &[&str] = &[
     "arm64e-apple-darwin",
     "aarch64-apple-ios",
     "arm64e-apple-ios",
+    "aarch64-apple-ios-macabi",
     "aarch64-apple-ios-sim",
     "aarch64-unknown-fuchsia",
     "aarch64-linux-android",
@@ -161,6 +162,7 @@ static TARGETS: &[&str] = &[
     "wasm32-wasip2",
     "x86_64-apple-darwin",
     "x86_64-apple-ios",
+    "x86_64-apple-ios-macabi",
     "x86_64-fortanix-unknown-sgx",
     "x86_64-unknown-fuchsia",
     "x86_64-linux-android",

From 342b374043039a1903f632a69dc239f7ceff9866 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 14 Aug 2024 10:25:21 +1000
Subject: [PATCH 252/685] Port `run-make/sysroot-crates-are-unstable` to rmake

---
 src/tools/tidy/src/allowed_run_make_makefiles.txt   | 1 -
 tests/run-make/sysroot-crates-are-unstable/Makefile | 2 --
 tests/run-make/sysroot-crates-are-unstable/rmake.rs | 5 +++++
 3 files changed, 5 insertions(+), 3 deletions(-)
 delete mode 100644 tests/run-make/sysroot-crates-are-unstable/Makefile
 create mode 100644 tests/run-make/sysroot-crates-are-unstable/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 14f0a9cd23d21..89735359e1a75 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -21,6 +21,5 @@ run-make/reproducible-build/Makefile
 run-make/rlib-format-packed-bundled-libs/Makefile
 run-make/split-debuginfo/Makefile
 run-make/symbol-mangling-hashed/Makefile
-run-make/sysroot-crates-are-unstable/Makefile
 run-make/translation/Makefile
 run-make/x86_64-fortanix-unknown-sgx-lvi/Makefile
diff --git a/tests/run-make/sysroot-crates-are-unstable/Makefile b/tests/run-make/sysroot-crates-are-unstable/Makefile
deleted file mode 100644
index 1e267fb9576ba..0000000000000
--- a/tests/run-make/sysroot-crates-are-unstable/Makefile
+++ /dev/null
@@ -1,2 +0,0 @@
-all:
-	'$(PYTHON)' test.py
diff --git a/tests/run-make/sysroot-crates-are-unstable/rmake.rs b/tests/run-make/sysroot-crates-are-unstable/rmake.rs
new file mode 100644
index 0000000000000..24da387eb8016
--- /dev/null
+++ b/tests/run-make/sysroot-crates-are-unstable/rmake.rs
@@ -0,0 +1,5 @@
+use run_make_support::python_command;
+
+fn main() {
+    python_command().arg("test.py").run();
+}

From bbcfd90cd17a5d8a812cf3dcf9e5197b72ddde4b Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Wed, 14 Aug 2024 08:49:41 +1000
Subject: [PATCH 253/685] Convert a `&mut self` to `&self`.

---
 compiler/rustc_parse/src/parser/expr.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index cf5d65708ab0f..bb3cddccce25b 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -1206,7 +1206,7 @@ impl<'a> Parser<'a> {
     }
 
     fn mk_expr_tuple_field_access(
-        &mut self,
+        &self,
         lo: Span,
         ident_span: Span,
         base: P<Expr>,

From b76f6a3b1a5124e4ade1e54299e74e3026192196 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Wed, 14 Aug 2024 08:04:02 +0300
Subject: [PATCH 254/685] print values of incompatible options

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/config/config.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 2f28d1d2cbe5b..6dc3e69d8ba3c 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -47,7 +47,7 @@ pub enum DryRun {
     UserSelected,
 }
 
-#[derive(Copy, Clone, Default, PartialEq, Eq)]
+#[derive(Copy, Clone, Default, Debug, Eq, PartialEq)]
 pub enum DebuginfoLevel {
     #[default]
     None,
@@ -117,7 +117,7 @@ impl Display for DebuginfoLevel {
 /// 2) MSVC
 /// - Self-contained: `-Clinker=<path to rust-lld>`
 /// - External: `-Clinker=lld`
-#[derive(Copy, Clone, Default, PartialEq)]
+#[derive(Copy, Clone, Default, Debug, PartialEq)]
 pub enum LldMode {
     /// Do not use LLD
     #[default]
@@ -2667,11 +2667,14 @@ fn check_incompatible_options_for_ci_rustc(
 ) -> Result<(), String> {
     macro_rules! err {
         ($current:expr, $expected:expr) => {
-            if let Some(current) = $current {
-                if Some(current) != $expected {
+            if let Some(current) = &$current {
+                if Some(current) != $expected.as_ref() {
                     return Err(format!(
-                        "ERROR: Setting `rust.{}` is incompatible with `rust.download-rustc`.",
-                        stringify!($expected).replace("_", "-")
+                        "ERROR: Setting `rust.{}` is incompatible with `rust.download-rustc`. \
+                        Current value: {:?}, Expected value(s): None/{:?}",
+                        stringify!($expected).replace("_", "-"),
+                        $current,
+                        $expected
                     ));
                 };
             };

From 43320d5d6c53d506bfedff3abde40a9e26b0441a Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Wed, 14 Aug 2024 08:06:50 +0300
Subject: [PATCH 255/685] do not check incompatibility if `config.toml` isn't
 present

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/config/config.rs | 36 +++++++++++++------------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 6dc3e69d8ba3c..b955593ecf64d 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -2320,27 +2320,29 @@ impl Config {
                 Some(commit) => {
                     self.download_ci_rustc(commit);
 
-                    let builder_config_path =
-                        self.out.join(self.build.triple).join("ci-rustc/builder-config");
-                    let ci_config_toml = Self::get_toml(&builder_config_path);
-                    let current_config_toml = Self::get_toml(self.config.as_ref().unwrap());
-
-                    // Check the config compatibility
-                    let res = check_incompatible_options_for_ci_rustc(
-                        current_config_toml,
-                        ci_config_toml,
-                    );
+                    if let Some(config_path) = &self.config {
+                        let builder_config_path =
+                            self.out.join(self.build.triple).join("ci-rustc/builder-config");
+                        let ci_config_toml = Self::get_toml(&builder_config_path);
+                        let current_config_toml = Self::get_toml(config_path);
+
+                        // Check the config compatibility
+                        let res = check_incompatible_options_for_ci_rustc(
+                            current_config_toml,
+                            ci_config_toml,
+                        );
 
-                    let disable_ci_rustc_if_incompatible =
-                        env::var_os("DISABLE_CI_RUSTC_IF_INCOMPATIBLE")
+                        let disable_ci_rustc_if_incompatible =
+                            env::var_os("DISABLE_CI_RUSTC_IF_INCOMPATIBLE")
                             .is_some_and(|s| s == "1" || s == "true");
 
-                    if disable_ci_rustc_if_incompatible && res.is_err() {
-                        println!("WARNING: download-rustc is disabled with `DISABLE_CI_RUSTC_IF_INCOMPATIBLE` env.");
-                        return None;
-                    }
+                        if disable_ci_rustc_if_incompatible && res.is_err() {
+                            println!("WARNING: download-rustc is disabled with `DISABLE_CI_RUSTC_IF_INCOMPATIBLE` env.");
+                            return None;
+                        }
 
-                    res.unwrap();
+                        res.unwrap();
+                    }
 
                     Some(commit.clone())
                 }

From 8557b56ec7ed3b9d94d0fcbbec97547ffb45e568 Mon Sep 17 00:00:00 2001
From: Jaic1 <506933131@qq.com>
Date: Wed, 14 Aug 2024 13:38:03 +0800
Subject: [PATCH 256/685] Add `|` to make the html doc of `Level` rendered
 correctly

---
 compiler/rustc_errors/src/lib.rs | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 3bc03a1e51655..fd203c3831897 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -1837,23 +1837,23 @@ impl DelayedDiagInner {
     }
 }
 
-/// Level              is_error  EmissionGuarantee         Top-level  Sub   Used in lints?
-/// -----              --------  -----------------         ---------  ---   --------------
-/// Bug                yes       BugAbort                  yes        -     -
-/// Fatal              yes       FatalAbort/FatalError(*)  yes        -     -
-/// Error              yes       ErrorGuaranteed           yes        -     yes
-/// DelayedBug         yes       ErrorGuaranteed           yes        -     -
-/// ForceWarning       -         ()                        yes        -     lint-only
-/// Warning            -         ()                        yes        yes   yes
-/// Note               -         ()                        rare       yes   -
-/// OnceNote           -         ()                        -          yes   lint-only
-/// Help               -         ()                        rare       yes   -
-/// OnceHelp           -         ()                        -          yes   lint-only
-/// FailureNote        -         ()                        rare       -     -
-/// Allow              -         ()                        yes        -     lint-only
-/// Expect             -         ()                        yes        -     lint-only
+/// | Level        | is_error | EmissionGuarantee            | Top-level | Sub | Used in lints?
+/// | -----        | -------- | -----------------            | --------- | --- | --------------
+/// | Bug          | yes      | BugAbort                     | yes       | -   | -
+/// | Fatal        | yes      | FatalAbort/FatalError[^star] | yes       | -   | -
+/// | Error        | yes      | ErrorGuaranteed              | yes       | -   | yes
+/// | DelayedBug   | yes      | ErrorGuaranteed              | yes       | -   | -
+/// | ForceWarning | -        | ()                           | yes       | -   | lint-only
+/// | Warning      | -        | ()                           | yes       | yes | yes
+/// | Note         | -        | ()                           | rare      | yes | -
+/// | OnceNote     | -        | ()                           | -         | yes | lint-only
+/// | Help         | -        | ()                           | rare      | yes | -
+/// | OnceHelp     | -        | ()                           | -         | yes | lint-only
+/// | FailureNote  | -        | ()                           | rare      | -   | -
+/// | Allow        | -        | ()                           | yes       | -   | lint-only
+/// | Expect       | -        | ()                           | yes       | -   | lint-only
 ///
-/// (*) `FatalAbort` normally, `FatalError` in the non-aborting "almost fatal" case that is
+/// [^star]: `FatalAbort` normally, `FatalError` in the non-aborting "almost fatal" case that is
 ///     occasionally used.
 ///
 #[derive(Copy, PartialEq, Eq, Clone, Hash, Debug, Encodable, Decodable)]

From ef91e65644fca1aa68482d7738078f709f323e8b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 14 Aug 2024 07:43:43 +0200
Subject: [PATCH 257/685] 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 9dad0df254cb8..d88a4ccc85bd2 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-1d8f135b20fac63c493d5963ce02963b46ca0986
+e9c965df7b75ab5b1ae8f9a2680839ac1a1a3880

From c96493829baac8242ab3b7640c28184eb360aff0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 14 Aug 2024 07:46:54 +0200
Subject: [PATCH 258/685] fmt

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

diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 84354c77aa48e..047ac0f39d122 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -56,9 +56,9 @@ extern crate either;
 extern crate tracing;
 
 // The rustc crates we need
-extern crate rustc_attr;
 extern crate rustc_apfloat;
 extern crate rustc_ast;
+extern crate rustc_attr;
 extern crate rustc_const_eval;
 extern crate rustc_data_structures;
 extern crate rustc_errors;

From db3f92144d6f3b4db8aa19357dee42dd256f1f13 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 14 Aug 2024 07:47:24 +0200
Subject: [PATCH 259/685] CI: need nightly toolchain for auto-rustup PR

---
 src/tools/miri/.github/workflows/ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/tools/miri/.github/workflows/ci.yml b/src/tools/miri/.github/workflows/ci.yml
index efdeaeffe1592..22c833a5488fa 100644
--- a/src/tools/miri/.github/workflows/ci.yml
+++ b/src/tools/miri/.github/workflows/ci.yml
@@ -123,6 +123,8 @@ jobs:
         run: |
           git config --global user.name 'The Miri Cronjob Bot'
           git config --global user.email 'miri@cron.bot'
+      - name: Install nightly toolchain
+        run: rustup toolchain install nightly --profile minimal
       - name: get changes from rustc
         run: ./miri rustc-pull
       - name: Install rustup-toolchain-install-master

From 7923b20dd9587743372b3fdf7b48eae220200f6e Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 9 Aug 2024 17:44:47 +1000
Subject: [PATCH 260/685] Use `impl PartialEq<TokenKind> for Token` more.

This lets us compare a `Token` with a `TokenKind`. It's used a lot, but
can be used even more, avoiding the need for some `.kind` uses.
---
 compiler/rustc_builtin_macros/src/asm.rs      |  4 +-
 compiler/rustc_expand/src/mbe/macro_rules.rs  |  2 +-
 compiler/rustc_lint/src/builtin.rs            |  2 +-
 compiler/rustc_parse/src/lexer/tokentrees.rs  |  2 +-
 compiler/rustc_parse/src/parser/attr.rs       |  6 +-
 .../rustc_parse/src/parser/diagnostics.rs     | 55 +++++++--------
 compiler/rustc_parse/src/parser/expr.rs       | 69 +++++++++----------
 compiler/rustc_parse/src/parser/generics.rs   |  2 +-
 compiler/rustc_parse/src/parser/item.rs       | 38 +++++-----
 compiler/rustc_parse/src/parser/mod.rs        |  8 +--
 compiler/rustc_parse/src/parser/pat.rs        | 20 +++---
 compiler/rustc_parse/src/parser/path.rs       |  8 +--
 compiler/rustc_parse/src/parser/stmt.rs       |  4 +-
 compiler/rustc_parse/src/parser/ty.rs         | 17 +++--
 src/tools/clippy/clippy_dev/src/new_lint.rs   |  4 +-
 src/tools/rustfmt/src/parse/macros/mod.rs     |  8 +--
 16 files changed, 121 insertions(+), 128 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/asm.rs b/compiler/rustc_builtin_macros/src/asm.rs
index ed54c0c86626e..ae2627d693867 100644
--- a/compiler/rustc_builtin_macros/src/asm.rs
+++ b/compiler/rustc_builtin_macros/src/asm.rs
@@ -328,7 +328,7 @@ pub fn parse_asm_args<'a>(
 /// Otherwise, the suggestion will be incorrect.
 fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
     // Tool-only output
-    let full_span = if p.token.kind == token::Comma { span.to(p.token.span) } else { span };
+    let full_span = if p.token == token::Comma { span.to(p.token.span) } else { span };
     p.dcx().emit_err(errors::AsmOptAlreadyprovided { span, symbol, full_span });
 }
 
@@ -338,7 +338,7 @@ fn err_duplicate_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
 /// Otherwise, the suggestion will be incorrect.
 fn err_unsupported_option(p: &Parser<'_>, symbol: Symbol, span: Span) {
     // Tool-only output
-    let full_span = if p.token.kind == token::Comma { span.to(p.token.span) } else { span };
+    let full_span = if p.token == token::Comma { span.to(p.token.span) } else { span };
     p.dcx().emit_err(errors::GlobalAsmUnsupportedOption { span, symbol, full_span });
 }
 
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 6f177107e7025..256713ef73000 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -1154,7 +1154,7 @@ fn check_matcher_core<'tt>(
                         && matches!(kind, NonterminalKind::Pat(PatParam { inferred: true }))
                         && matches!(
                             next_token,
-                            TokenTree::Token(token) if token.kind == BinOp(token::BinOpToken::Or)
+                            TokenTree::Token(token) if *token == BinOp(token::BinOpToken::Or)
                         )
                     {
                         // It is suggestion to use pat_param, for example: $x:pat -> $x:pat_param.
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 6b36944b20889..5f6e7fb314d9f 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -1853,7 +1853,7 @@ impl KeywordIdents {
                         if !prev_dollar {
                             self.check_ident_token(cx, UnderMacro(true), ident);
                         }
-                    } else if token.kind == TokenKind::Dollar {
+                    } else if *token == TokenKind::Dollar {
                         prev_dollar = true;
                         continue;
                     }
diff --git a/compiler/rustc_parse/src/lexer/tokentrees.rs b/compiler/rustc_parse/src/lexer/tokentrees.rs
index fb4ed5b93b27f..e7a7105803fcd 100644
--- a/compiler/rustc_parse/src/lexer/tokentrees.rs
+++ b/compiler/rustc_parse/src/lexer/tokentrees.rs
@@ -229,7 +229,7 @@ impl<'psess, 'src> TokenTreesReader<'psess, 'src> {
             } else {
                 let this_spacing = if next_tok.is_punct() {
                     Spacing::Joint
-                } else if next_tok.kind == token::Eof {
+                } else if next_tok == token::Eof {
                     Spacing::Alone
                 } else {
                     Spacing::JointHidden
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index 8fdfbcee38546..645fde25cd440 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -162,7 +162,7 @@ impl<'a> Parser<'a> {
         }
         loop {
             // skip any other attributes, we want the item
-            if snapshot.token.kind == token::Pound {
+            if snapshot.token == token::Pound {
                 if let Err(err) = snapshot.parse_attribute(InnerAttrPolicy::Permitted) {
                     err.cancel();
                     return Some(replacement_span);
@@ -343,7 +343,7 @@ impl<'a> Parser<'a> {
 
         // Presumably, the majority of the time there will only be one attr.
         let mut expanded_attrs = Vec::with_capacity(1);
-        while self.token.kind != token::Eof {
+        while self.token != token::Eof {
             let lo = self.token.span;
             let item = self.parse_attr_item(ForceCollect::Yes)?;
             expanded_attrs.push((item, lo.to(self.prev_token.span)));
@@ -359,7 +359,7 @@ impl<'a> Parser<'a> {
     pub(crate) fn parse_meta_seq_top(&mut self) -> PResult<'a, ThinVec<ast::NestedMetaItem>> {
         // Presumably, the majority of the time there will only be one attr.
         let mut nmis = ThinVec::with_capacity(1);
-        while self.token.kind != token::Eof {
+        while self.token != token::Eof {
             nmis.push(self.parse_meta_item_inner()?);
             if !self.eat(&token::Comma) {
                 break;
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 47ca85ba060b9..ba4e222a41a51 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -474,8 +474,8 @@ impl<'a> Parser<'a> {
                     // If this isn't the case however, and the suggestion is a token the
                     // content of which is the same as the found token's, we remove it as well.
                     if !eq {
-                        if let TokenType::Token(kind) = &token {
-                            if kind == &self.token.kind {
+                        if let TokenType::Token(kind) = token {
+                            if self.token == *kind {
                                 return false;
                             }
                         }
@@ -506,7 +506,7 @@ impl<'a> Parser<'a> {
             } else if !sm.is_multiline(self.prev_token.span.until(self.token.span)) {
                 // The current token is in the same line as the prior token, not recoverable.
             } else if [token::Comma, token::Colon].contains(&self.token.kind)
-                && self.prev_token.kind == token::CloseDelim(Delimiter::Parenthesis)
+                && self.prev_token == token::CloseDelim(Delimiter::Parenthesis)
             {
                 // Likely typo: The current token is on a new line and is expected to be
                 // `.`, `;`, `?`, or an operator after a close delimiter token.
@@ -518,7 +518,7 @@ impl<'a> Parser<'a> {
                 // https://github.com/rust-lang/rust/issues/72253
             } else if self.look_ahead(1, |t| {
                 t == &token::CloseDelim(Delimiter::Brace)
-                    || t.can_begin_expr() && t.kind != token::Colon
+                    || t.can_begin_expr() && *t != token::Colon
             }) && [token::Comma, token::Colon].contains(&self.token.kind)
             {
                 // Likely typo: `,` → `;` or `:` → `;`. This is triggered if the current token is
@@ -562,7 +562,7 @@ impl<'a> Parser<'a> {
             }
         }
 
-        if self.token.kind == TokenKind::EqEq
+        if self.token == TokenKind::EqEq
             && self.prev_token.is_ident()
             && expected.iter().any(|tok| matches!(tok, TokenType::Token(TokenKind::Eq)))
         {
@@ -655,9 +655,9 @@ impl<'a> Parser<'a> {
         // positive for a `cr#` that wasn't intended to start a c-string literal, but identifying
         // that in the parser requires unbounded lookahead, so we only add a hint to the existing
         // error rather than replacing it entirely.
-        if ((self.prev_token.kind == TokenKind::Ident(sym::c, IdentIsRaw::No)
+        if ((self.prev_token == TokenKind::Ident(sym::c, IdentIsRaw::No)
             && matches!(&self.token.kind, TokenKind::Literal(token::Lit { kind: token::Str, .. })))
-            || (self.prev_token.kind == TokenKind::Ident(sym::cr, IdentIsRaw::No)
+            || (self.prev_token == TokenKind::Ident(sym::cr, IdentIsRaw::No)
                 && matches!(
                     &self.token.kind,
                     TokenKind::Literal(token::Lit { kind: token::Str, .. }) | token::Pound
@@ -673,7 +673,7 @@ impl<'a> Parser<'a> {
         // `pub` may be used for an item or `pub(crate)`
         if self.prev_token.is_ident_named(sym::public)
             && (self.token.can_begin_item()
-                || self.token.kind == TokenKind::OpenDelim(Delimiter::Parenthesis))
+                || self.token == TokenKind::OpenDelim(Delimiter::Parenthesis))
         {
             err.span_suggestion_short(
                 self.prev_token.span,
@@ -772,7 +772,7 @@ impl<'a> Parser<'a> {
             ),
         );
         if self.token == token::Pound
-            && self.look_ahead(1, |t| t.kind == token::OpenDelim(Delimiter::Bracket))
+            && self.look_ahead(1, |t| *t == token::OpenDelim(Delimiter::Bracket))
         {
             // We have
             // #[attr]
@@ -867,7 +867,7 @@ impl<'a> Parser<'a> {
                 let str_span = self.prev_token.span;
                 let mut span = self.token.span;
                 let mut count = 0;
-                while self.token.kind == TokenKind::Pound
+                while self.token == TokenKind::Pound
                     && !sm.is_multiline(span.shrink_to_hi().until(self.token.span.shrink_to_lo()))
                 {
                     span = span.with_hi(self.token.span.hi());
@@ -1167,7 +1167,7 @@ impl<'a> Parser<'a> {
             return;
         }
 
-        if token::PathSep == self.token.kind && segment.args.is_none() {
+        if self.token == token::PathSep && segment.args.is_none() {
             let snapshot = self.create_snapshot_for_diagnostic();
             self.bump();
             let lo = self.token.span;
@@ -1176,13 +1176,11 @@ impl<'a> Parser<'a> {
                     let span = lo.to(self.prev_token.span);
                     // Detect trailing `>` like in `x.collect::Vec<_>>()`.
                     let mut trailing_span = self.prev_token.span.shrink_to_hi();
-                    while self.token.kind == token::BinOp(token::Shr)
-                        || self.token.kind == token::Gt
-                    {
+                    while self.token == token::BinOp(token::Shr) || self.token == token::Gt {
                         trailing_span = trailing_span.to(self.token.span);
                         self.bump();
                     }
-                    if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) {
+                    if self.token == token::OpenDelim(Delimiter::Parenthesis) {
                         // Recover from bad turbofish: `foo.collect::Vec<_>()`.
                         segment.args = Some(AngleBracketedArgs { args, span }.into());
 
@@ -1430,7 +1428,7 @@ impl<'a> Parser<'a> {
                             self.restore_snapshot(snapshot);
                         }
                     }
-                    return if token::PathSep == self.token.kind {
+                    return if self.token == token::PathSep {
                         // We have some certainty that this was a bad turbofish at this point.
                         // `foo< bar >::`
                         if let ExprKind::Binary(o, ..) = inner_op.kind
@@ -1462,7 +1460,7 @@ impl<'a> Parser<'a> {
                                 Err(self.dcx().create_err(err))
                             }
                         }
-                    } else if token::OpenDelim(Delimiter::Parenthesis) == self.token.kind {
+                    } else if self.token == token::OpenDelim(Delimiter::Parenthesis) {
                         // We have high certainty that this was a bad turbofish at this point.
                         // `foo< bar >(`
                         if let ExprKind::Binary(o, ..) = inner_op.kind
@@ -1528,7 +1526,7 @@ impl<'a> Parser<'a> {
         ];
         self.consume_tts(1, &modifiers);
 
-        if self.token.kind == token::Eof {
+        if self.token == token::Eof {
             // Not entirely sure that what we consumed were fn arguments, rollback.
             self.restore_snapshot(snapshot);
             Err(())
@@ -1811,7 +1809,7 @@ impl<'a> Parser<'a> {
     /// This function gets called in places where a semicolon is NOT expected and if there's a
     /// semicolon it emits the appropriate error and returns true.
     pub fn maybe_consume_incorrect_semicolon(&mut self, previous_item: Option<&Item>) -> bool {
-        if self.token.kind != TokenKind::Semi {
+        if self.token != TokenKind::Semi {
             return false;
         }
 
@@ -2405,10 +2403,10 @@ impl<'a> Parser<'a> {
         modifier: &[(token::TokenKind, i64)],
     ) {
         while acc > 0 {
-            if let Some((_, val)) = modifier.iter().find(|(t, _)| *t == self.token.kind) {
+            if let Some((_, val)) = modifier.iter().find(|(t, _)| self.token == *t) {
                 acc += *val;
             }
-            if self.token.kind == token::Eof {
+            if self.token == token::Eof {
                 break;
             }
             self.bump();
@@ -2598,7 +2596,7 @@ impl<'a> Parser<'a> {
                 }
             })
             .is_some()
-            || self.token.kind == TokenKind::Dot;
+            || self.token == TokenKind::Dot;
         // This will be true when a trait object type `Foo +` or a path which was a `const fn` with
         // type params has been parsed.
         let was_op =
@@ -2617,7 +2615,7 @@ impl<'a> Parser<'a> {
         })() {
             Ok(expr) => {
                 // Find a mistake like `MyTrait<Assoc == S::Assoc>`.
-                if token::EqEq == snapshot.token.kind {
+                if snapshot.token == token::EqEq {
                     err.span_suggestion(
                         snapshot.token.span,
                         "if you meant to use an associated type binding, replace `==` with `=`",
@@ -2627,7 +2625,7 @@ impl<'a> Parser<'a> {
                     let guar = err.emit();
                     let value = self.mk_expr_err(start.to(expr.span), guar);
                     return Ok(GenericArg::Const(AnonConst { id: ast::DUMMY_NODE_ID, value }));
-                } else if token::Colon == snapshot.token.kind
+                } else if snapshot.token == token::Colon
                     && expr.span.lo() == snapshot.token.span.hi()
                     && matches!(expr.kind, ExprKind::Path(..))
                 {
@@ -2642,8 +2640,7 @@ impl<'a> Parser<'a> {
                     return Ok(GenericArg::Type(
                         self.mk_ty(start.to(expr.span), TyKind::Err(guar)),
                     ));
-                } else if token::Comma == self.token.kind || self.token.kind.should_end_const_arg()
-                {
+                } else if self.token == token::Comma || self.token.kind.should_end_const_arg() {
                     // Avoid the following output by checking that we consumed a full const arg:
                     // help: expressions must be enclosed in braces to be used as const generic
                     //       arguments
@@ -2846,8 +2843,8 @@ impl<'a> Parser<'a> {
     pub(crate) fn maybe_recover_unexpected_block_label(&mut self) -> bool {
         // Check for `'a : {`
         if !(self.check_lifetime()
-            && self.look_ahead(1, |tok| tok.kind == token::Colon)
-            && self.look_ahead(2, |tok| tok.kind == token::OpenDelim(Delimiter::Brace)))
+            && self.look_ahead(1, |t| *t == token::Colon)
+            && self.look_ahead(2, |t| *t == token::OpenDelim(Delimiter::Brace)))
         {
             return false;
         }
@@ -3001,7 +2998,7 @@ impl<'a> Parser<'a> {
         // >>>>>>>
         let mut end = None;
         loop {
-            if self.token.kind == TokenKind::Eof {
+            if self.token == TokenKind::Eof {
                 break;
             }
             if let Some(span) = self.conflict_marker(&TokenKind::OrOr, &TokenKind::BinOp(token::Or))
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index bb3cddccce25b..536160c813616 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -165,7 +165,7 @@ impl<'a> Parser<'a> {
 
             // Look for JS' `===` and `!==` and recover
             if (op.node == AssocOp::Equal || op.node == AssocOp::NotEqual)
-                && self.token.kind == token::Eq
+                && self.token == token::Eq
                 && self.prev_token.span.hi() == self.token.span.lo()
             {
                 let sp = op.span.to(self.token.span);
@@ -190,7 +190,7 @@ impl<'a> Parser<'a> {
 
             // Look for PHP's `<>` and recover
             if op.node == AssocOp::Less
-                && self.token.kind == token::Gt
+                && self.token == token::Gt
                 && self.prev_token.span.hi() == self.token.span.lo()
             {
                 let sp = op.span.to(self.token.span);
@@ -208,7 +208,7 @@ impl<'a> Parser<'a> {
 
             // Look for C++'s `<=>` and recover
             if op.node == AssocOp::LessEqual
-                && self.token.kind == token::Gt
+                && self.token == token::Gt
                 && self.prev_token.span.hi() == self.token.span.lo()
             {
                 let sp = op.span.to(self.token.span);
@@ -882,7 +882,7 @@ impl<'a> Parser<'a> {
         let mut res = ensure_sufficient_stack(|| {
             loop {
                 let has_question =
-                    if self.prev_token.kind == TokenKind::Ident(kw::Return, IdentIsRaw::No) {
+                    if self.prev_token == TokenKind::Ident(kw::Return, IdentIsRaw::No) {
                         // We are using noexpect here because we don't expect a `?` directly after
                         // a `return` which could be suggested otherwise.
                         self.eat_noexpect(&token::Question)
@@ -894,20 +894,19 @@ impl<'a> Parser<'a> {
                     e = self.mk_expr(lo.to(self.prev_token.span), ExprKind::Try(e));
                     continue;
                 }
-                let has_dot =
-                    if self.prev_token.kind == TokenKind::Ident(kw::Return, IdentIsRaw::No) {
-                        // We are using noexpect here because we don't expect a `.` directly after
-                        // a `return` which could be suggested otherwise.
-                        self.eat_noexpect(&token::Dot)
-                    } else if self.token.kind == TokenKind::RArrow && self.may_recover() {
-                        // Recovery for `expr->suffix`.
-                        self.bump();
-                        let span = self.prev_token.span;
-                        self.dcx().emit_err(errors::ExprRArrowCall { span });
-                        true
-                    } else {
-                        self.eat(&token::Dot)
-                    };
+                let has_dot = if self.prev_token == TokenKind::Ident(kw::Return, IdentIsRaw::No) {
+                    // We are using noexpect here because we don't expect a `.` directly after
+                    // a `return` which could be suggested otherwise.
+                    self.eat_noexpect(&token::Dot)
+                } else if self.token == TokenKind::RArrow && self.may_recover() {
+                    // Recovery for `expr->suffix`.
+                    self.bump();
+                    let span = self.prev_token.span;
+                    self.dcx().emit_err(errors::ExprRArrowCall { span });
+                    true
+                } else {
+                    self.eat(&token::Dot)
+                };
                 if has_dot {
                     // expr.f
                     e = self.parse_dot_suffix_expr(lo, e)?;
@@ -1221,7 +1220,7 @@ impl<'a> Parser<'a> {
 
     /// Parse a function call expression, `expr(...)`.
     fn parse_expr_fn_call(&mut self, lo: Span, fun: P<Expr>) -> P<Expr> {
-        let snapshot = if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) {
+        let snapshot = if self.token == token::OpenDelim(Delimiter::Parenthesis) {
             Some((self.create_snapshot_for_diagnostic(), fun.kind.clone()))
         } else {
             None
@@ -1585,7 +1584,7 @@ impl<'a> Parser<'a> {
                 // Suggests using '<=' if there is an error parsing qpath when the previous token
                 // is an '=' token. Only emits suggestion if the '<' token and '=' token are
                 // directly adjacent (i.e. '=<')
-                if maybe_eq_tok.kind == TokenKind::Eq && maybe_eq_tok.span.hi() == lt_span.lo() {
+                if maybe_eq_tok == TokenKind::Eq && maybe_eq_tok.span.hi() == lt_span.lo() {
                     let eq_lt = maybe_eq_tok.span.to(lt_span);
                     err.span_suggestion(eq_lt, "did you mean", "<=", Applicability::Unspecified);
                 }
@@ -2230,7 +2229,7 @@ impl<'a> Parser<'a> {
             return Ok(());
         }
 
-        if self.token.kind == token::Comma {
+        if self.token == token::Comma {
             if !self.psess.source_map().is_multiline(prev_span.until(self.token.span)) {
                 return Ok(());
             }
@@ -2360,7 +2359,7 @@ impl<'a> Parser<'a> {
             None => {}
         }
 
-        if self.token.kind == TokenKind::Semi
+        if self.token == TokenKind::Semi
             && matches!(self.token_cursor.stack.last(), Some((.., Delimiter::Parenthesis)))
             && self.may_recover()
         {
@@ -2557,7 +2556,7 @@ impl<'a> Parser<'a> {
                             );
                         } else {
                             // Look for usages of '=>' where '>=' might be intended
-                            if maybe_fatarrow.kind == token::FatArrow {
+                            if maybe_fatarrow == token::FatArrow {
                                 err.span_suggestion(
                                     maybe_fatarrow.span,
                                     "you might have meant to write a \"greater than or equal to\" comparison",
@@ -2606,7 +2605,7 @@ impl<'a> Parser<'a> {
                 missing_let: None,
                 comparison: None,
             };
-            if self.prev_token.kind == token::BinOp(token::Or) {
+            if self.prev_token == token::BinOp(token::Or) {
                 // This was part of a closure, the that part of the parser recover.
                 return Err(self.dcx().create_err(err));
             } else {
@@ -2742,7 +2741,7 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_for_head(&mut self) -> PResult<'a, (P<Pat>, P<Expr>)> {
-        let begin_paren = if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) {
+        let begin_paren = if self.token == token::OpenDelim(Delimiter::Parenthesis) {
             // Record whether we are about to parse `for (`.
             // This is used below for recovery in case of `for ( $stuff ) $block`
             // in which case we will suggest `for $stuff $block`.
@@ -2776,7 +2775,7 @@ impl<'a> Parser<'a> {
                         return Err(err);
                     }
                 };
-                return if self.token.kind == token::CloseDelim(Delimiter::Parenthesis) {
+                return if self.token == token::CloseDelim(Delimiter::Parenthesis) {
                     // We know for sure we have seen `for ($SOMETHING in $EXPR)`, so we recover the
                     // parser state and emit a targeted suggestion.
                     let span = vec![start_span, self.token.span];
@@ -2995,7 +2994,7 @@ impl<'a> Parser<'a> {
         first_expr: &P<Expr>,
         arrow_span: Span,
     ) -> Option<(Span, ErrorGuaranteed)> {
-        if self.token.kind != token::Semi {
+        if self.token != token::Semi {
             return None;
         }
         let start_snapshot = self.create_snapshot_for_diagnostic();
@@ -3024,18 +3023,18 @@ impl<'a> Parser<'a> {
         // We might have either a `,` -> `;` typo, or a block without braces. We need
         // a more subtle parsing strategy.
         loop {
-            if self.token.kind == token::CloseDelim(Delimiter::Brace) {
+            if self.token == token::CloseDelim(Delimiter::Brace) {
                 // We have reached the closing brace of the `match` expression.
                 return Some(err(self, stmts));
             }
-            if self.token.kind == token::Comma {
+            if self.token == token::Comma {
                 self.restore_snapshot(start_snapshot);
                 return None;
             }
             let pre_pat_snapshot = self.create_snapshot_for_diagnostic();
             match self.parse_pat_no_top_alt(None, None) {
                 Ok(_pat) => {
-                    if self.token.kind == token::FatArrow {
+                    if self.token == token::FatArrow {
                         // Reached arm end.
                         self.restore_snapshot(pre_pat_snapshot);
                         return Some(err(self, stmts));
@@ -3286,7 +3285,7 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_match_arm_pat_and_guard(&mut self) -> PResult<'a, (P<Pat>, Option<P<Expr>>)> {
-        if self.token.kind == token::OpenDelim(Delimiter::Parenthesis) {
+        if self.token == token::OpenDelim(Delimiter::Parenthesis) {
             // Detect and recover from `($pat if $cond) => $arm`.
             let left = self.token.span;
             match self.parse_pat_allow_top_alt(
@@ -3344,7 +3343,7 @@ impl<'a> Parser<'a> {
                     self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore);
                     let msg = "you might have meant to start a match arm after the match guard";
                     if self.eat(&token::CloseDelim(Delimiter::Brace)) {
-                        let applicability = if self.token.kind != token::FatArrow {
+                        let applicability = if self.token != token::FatArrow {
                             // We have high confidence that we indeed didn't have a struct
                             // literal in the match guard, but rather we had some operation
                             // that ended in a path, immediately followed by a block that was
@@ -3565,7 +3564,7 @@ impl<'a> Parser<'a> {
                         && self.look_ahead(1, |t| {
                             AssocOp::from_token(t).is_some()
                                 || matches!(t.kind, token::OpenDelim(_))
-                                || t.kind == token::Dot
+                                || *t == token::Dot
                         })
                     {
                         // Looks like they tried to write a shorthand, complex expression.
@@ -3850,11 +3849,11 @@ impl<'a> Parser<'a> {
         self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
             let res = f(this, attrs)?;
             let trailing = (this.restrictions.contains(Restrictions::STMT_EXPR)
-                 && this.token.kind == token::Semi)
+                 && this.token == token::Semi)
             // FIXME: pass an additional condition through from the place
             // where we know we need a comma, rather than assuming that
             // `#[attr] expr,` always captures a trailing comma.
-            || this.token.kind == token::Comma;
+            || this.token == token::Comma;
             Ok((res, trailing))
         })
     }
diff --git a/compiler/rustc_parse/src/parser/generics.rs b/compiler/rustc_parse/src/parser/generics.rs
index 9124c15707de5..f1bb7187e2f4b 100644
--- a/compiler/rustc_parse/src/parser/generics.rs
+++ b/compiler/rustc_parse/src/parser/generics.rs
@@ -393,7 +393,7 @@ impl<'a> Parser<'a> {
 
         if let Some(struct_) = struct_
             && self.may_recover()
-            && self.token.kind == token::OpenDelim(Delimiter::Parenthesis)
+            && self.token == token::OpenDelim(Delimiter::Parenthesis)
         {
             snapshot = Some((struct_, self.create_snapshot_for_diagnostic()));
         };
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 8775d792c3d2b..e34e82bcd7b2e 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -354,7 +354,7 @@ impl<'a> Parser<'a> {
     fn is_reuse_path_item(&mut self) -> bool {
         // no: `reuse ::path` for compatibility reasons with macro invocations
         self.token.is_keyword(kw::Reuse)
-            && self.look_ahead(1, |t| t.is_path_start() && t.kind != token::PathSep)
+            && self.look_ahead(1, |t| t.is_path_start() && *t != token::PathSep)
     }
 
     /// Are we sure this could not possibly be a macro invocation?
@@ -499,7 +499,7 @@ impl<'a> Parser<'a> {
         let mut err = self.dcx().struct_span_err(end.span, msg);
         if end.is_doc_comment() {
             err.span_label(end.span, "this doc comment doesn't document anything");
-        } else if self.token.kind == TokenKind::Semi {
+        } else if self.token == TokenKind::Semi {
             err.span_suggestion_verbose(
                 self.token.span,
                 "consider removing this semicolon",
@@ -777,12 +777,12 @@ impl<'a> Parser<'a> {
                         && self
                             .span_to_snippet(self.prev_token.span)
                             .is_ok_and(|snippet| snippet == "}")
-                        && self.token.kind == token::Semi;
+                        && self.token == token::Semi;
                     let mut semicolon_span = self.token.span;
                     if !is_unnecessary_semicolon {
                         // #105369, Detect spurious `;` before assoc fn body
                         is_unnecessary_semicolon = self.token == token::OpenDelim(Delimiter::Brace)
-                            && self.prev_token.kind == token::Semi;
+                            && self.prev_token == token::Semi;
                         semicolon_span = self.prev_token.span;
                     }
                     // We have to bail or we'll potentially never make progress.
@@ -1194,7 +1194,7 @@ impl<'a> Parser<'a> {
         // FIXME: This recovery should be tested better.
         if safety == Safety::Default
             && self.token.is_keyword(kw::Unsafe)
-            && self.look_ahead(1, |t| t.kind == token::OpenDelim(Delimiter::Brace))
+            && self.look_ahead(1, |t| *t == token::OpenDelim(Delimiter::Brace))
         {
             self.expect(&token::OpenDelim(Delimiter::Brace)).unwrap_err().emit();
             safety = Safety::Unsafe(self.token.span);
@@ -1258,7 +1258,7 @@ impl<'a> Parser<'a> {
             && self.is_keyword_ahead(1, &[kw::Extern])
             && self.look_ahead(
                 2 + self.look_ahead(2, |t| t.can_begin_string_literal() as usize),
-                |t| t.kind == token::OpenDelim(Delimiter::Brace),
+                |t| *t == token::OpenDelim(Delimiter::Brace),
             )
     }
 
@@ -1343,7 +1343,7 @@ impl<'a> Parser<'a> {
     ) -> PResult<'a, (Ident, StaticItem)> {
         let ident = self.parse_ident()?;
 
-        if self.token.kind == TokenKind::Lt && self.may_recover() {
+        if self.token == TokenKind::Lt && self.may_recover() {
             let generics = self.parse_generics()?;
             self.dcx().emit_err(errors::StaticWithGenerics { span: generics.span });
         }
@@ -1914,7 +1914,7 @@ impl<'a> Parser<'a> {
                 let mut err = self.dcx().struct_span_err(sp, msg);
 
                 if self.token.is_ident()
-                    || (self.token.kind == TokenKind::Pound
+                    || (self.token == TokenKind::Pound
                         && (self.look_ahead(1, |t| t == &token::OpenDelim(Delimiter::Bracket))))
                 {
                     // This is likely another field, TokenKind::Pound is used for `#[..]`
@@ -1937,8 +1937,8 @@ impl<'a> Parser<'a> {
     fn expect_field_ty_separator(&mut self) -> PResult<'a, ()> {
         if let Err(err) = self.expect(&token::Colon) {
             let sm = self.psess.source_map();
-            let eq_typo = self.token.kind == token::Eq && self.look_ahead(1, |t| t.is_path_start());
-            let semi_typo = self.token.kind == token::Semi
+            let eq_typo = self.token == token::Eq && self.look_ahead(1, |t| t.is_path_start());
+            let semi_typo = self.token == token::Semi
                 && self.look_ahead(1, |t| {
                     t.is_path_start()
                     // We check that we are in a situation like `foo; bar` to avoid bad suggestions
@@ -1974,7 +1974,7 @@ impl<'a> Parser<'a> {
         attrs: AttrVec,
     ) -> PResult<'a, FieldDef> {
         let name = self.parse_field_ident(adt_ty, lo)?;
-        if self.token.kind == token::Not {
+        if self.token == token::Not {
             if let Err(mut err) = self.unexpected() {
                 // Encounter the macro invocation
                 err.subdiagnostic(MacroExpandsToAdtField { adt_ty });
@@ -1983,10 +1983,10 @@ impl<'a> Parser<'a> {
         }
         self.expect_field_ty_separator()?;
         let ty = self.parse_ty_for_field_def()?;
-        if self.token.kind == token::Colon && self.look_ahead(1, |tok| tok.kind != token::Colon) {
+        if self.token == token::Colon && self.look_ahead(1, |t| *t != token::Colon) {
             self.dcx().emit_err(errors::SingleColonStructType { span: self.token.span });
         }
-        if self.token.kind == token::Eq {
+        if self.token == token::Eq {
             self.bump();
             let const_expr = self.parse_expr_anon_const()?;
             let sp = ty.span.shrink_to_hi().to(const_expr.value.span);
@@ -2064,7 +2064,7 @@ impl<'a> Parser<'a> {
                         .parse_ident_common(false)
                         // Cancel this error, we don't need it.
                         .map_err(|err| err.cancel())
-                    && self.token.kind == TokenKind::Colon
+                    && self.token == TokenKind::Colon
                 {
                     err.span_suggestion(
                         removal_span,
@@ -2367,12 +2367,12 @@ impl<'a> Parser<'a> {
         match self.expected_one_of_not_found(&[], expected) {
             Ok(error_guaranteed) => Ok(error_guaranteed),
             Err(mut err) => {
-                if self.token.kind == token::CloseDelim(Delimiter::Brace) {
+                if self.token == token::CloseDelim(Delimiter::Brace) {
                     // The enclosing `mod`, `trait` or `impl` is being closed, so keep the `fn` in
                     // the AST for typechecking.
                     err.span_label(ident_span, "while parsing this `fn`");
                     Ok(err.emit())
-                } else if self.token.kind == token::RArrow
+                } else if self.token == token::RArrow
                     && let Some(fn_params_end) = fn_params_end
                 {
                     // Instead of a function body, the parser has encountered a right arrow
@@ -2445,7 +2445,7 @@ impl<'a> Parser<'a> {
         fn_params_end: Option<Span>,
     ) -> PResult<'a, Option<P<Block>>> {
         let has_semi = if req_body {
-            self.token.kind == TokenKind::Semi
+            self.token == TokenKind::Semi
         } else {
             // Only include `;` in list of expected tokens if body is not required
             self.check(&TokenKind::Semi)
@@ -2458,7 +2458,7 @@ impl<'a> Parser<'a> {
         } else if self.check(&token::OpenDelim(Delimiter::Brace)) || self.token.is_whole_block() {
             self.parse_block_common(self.token.span, BlockCheckMode::Default, false)
                 .map(|(attrs, body)| (attrs, Some(body)))?
-        } else if self.token.kind == token::Eq {
+        } else if self.token == token::Eq {
             // Recover `fn foo() = $expr;`.
             self.bump(); // `=`
             let eq_sp = self.prev_token.span;
@@ -2761,7 +2761,7 @@ impl<'a> Parser<'a> {
     pub(super) fn parse_fn_params(&mut self, req_name: ReqName) -> PResult<'a, ThinVec<Param>> {
         let mut first_param = true;
         // Parse the arguments, starting out with `self` being allowed...
-        if self.token.kind != TokenKind::OpenDelim(Delimiter::Parenthesis)
+        if self.token != TokenKind::OpenDelim(Delimiter::Parenthesis)
         // might be typo'd trait impl, handled elsewhere
         && !self.token.is_keyword(kw::For)
         {
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 9b3b6d5f9add2..db74ea6279097 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -527,7 +527,7 @@ impl<'a> Parser<'a> {
         } else if inedible.contains(&self.token.kind) {
             // leave it in the input
             Ok(Recovered::No)
-        } else if self.token.kind != token::Eof
+        } else if self.token != token::Eof
             && self.last_unexpected_token_span == Some(self.token.span)
         {
             FatalError.raise();
@@ -756,7 +756,7 @@ impl<'a> Parser<'a> {
     /// compound tokens like multi-character operators in process.
     /// Returns `true` if the token was eaten.
     fn break_and_eat(&mut self, expected: TokenKind) -> bool {
-        if self.token.kind == expected {
+        if self.token == expected {
             self.bump();
             return true;
         }
@@ -882,7 +882,7 @@ impl<'a> Parser<'a> {
                             let token_str = pprust::token_kind_to_string(t);
 
                             match self.current_closure.take() {
-                                Some(closure_spans) if self.token.kind == TokenKind::Semi => {
+                                Some(closure_spans) if self.token == TokenKind::Semi => {
                                     // Finding a semicolon instead of a comma
                                     // after a closure body indicates that the
                                     // closure body may be a block but the user
@@ -910,7 +910,7 @@ impl<'a> Parser<'a> {
                             // If this was a missing `@` in a binding pattern
                             // bail with a suggestion
                             // https://github.com/rust-lang/rust/issues/72373
-                            if self.prev_token.is_ident() && self.token.kind == token::DotDot {
+                            if self.prev_token.is_ident() && self.token == token::DotDot {
                                 let msg = format!(
                                     "if you meant to bind the contents of the rest of the array \
                                      pattern into `{}`, use `@`",
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 5bfb8bdf776a0..089da1ffaf4a8 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -369,7 +369,7 @@ impl<'a> Parser<'a> {
                     .and_then(|(ident, _)| ident.name.as_str().chars().next())
                     .is_some_and(char::is_lowercase)
             })
-            && self.look_ahead(2, |tok| tok.kind == token::OpenDelim(Delimiter::Parenthesis));
+            && self.look_ahead(2, |t| *t == token::OpenDelim(Delimiter::Parenthesis));
 
         // Check for operators.
         // `|` is excluded as it is used in pattern alternatives and lambdas,
@@ -377,9 +377,9 @@ impl<'a> Parser<'a> {
         // `[` is included for indexing operations,
         // `[]` is excluded as `a[]` isn't an expression and should be recovered as `a, []` (cf. `tests/ui/parser/pat-lt-bracket-7.rs`)
         let has_trailing_operator = matches!(self.token.kind, token::BinOp(op) if op != BinOpToken::Or)
-            || self.token.kind == token::Question
-            || (self.token.kind == token::OpenDelim(Delimiter::Bracket)
-                && self.look_ahead(1, |tok| tok.kind != token::CloseDelim(Delimiter::Bracket)));
+            || self.token == token::Question
+            || (self.token == token::OpenDelim(Delimiter::Bracket)
+                && self.look_ahead(1, |t| *t != token::CloseDelim(Delimiter::Bracket)));
 
         if !has_trailing_method && !has_trailing_operator {
             // Nothing to recover here.
@@ -413,7 +413,7 @@ impl<'a> Parser<'a> {
                 let is_bound = is_end_bound
                     // is_start_bound: either `..` or `)..`
                     || self.token.is_range_separator()
-                    || self.token.kind == token::CloseDelim(Delimiter::Parenthesis)
+                    || self.token == token::CloseDelim(Delimiter::Parenthesis)
                         && self.look_ahead(1, Token::is_range_separator);
 
                 // Check that `parse_expr_assoc_with` didn't eat a rhs.
@@ -450,7 +450,7 @@ impl<'a> Parser<'a> {
             lo = self.token.span;
         }
 
-        let pat = if self.check(&token::BinOp(token::And)) || self.token.kind == token::AndAnd {
+        let pat = if self.check(&token::BinOp(token::And)) || self.token == token::AndAnd {
             self.parse_pat_deref(expected)?
         } else if self.check(&token::OpenDelim(Delimiter::Parenthesis)) {
             self.parse_pat_tuple_or_parens()?
@@ -625,7 +625,7 @@ impl<'a> Parser<'a> {
     ///
     /// [and]: https://docs.microsoft.com/en-us/dotnet/fsharp/language-reference/pattern-matching
     fn recover_intersection_pat(&mut self, lhs: P<Pat>) -> PResult<'a, P<Pat>> {
-        if self.token.kind != token::At {
+        if self.token != token::At {
             // Next token is not `@` so it's not going to be an intersection pattern.
             return Ok(lhs);
         }
@@ -958,14 +958,14 @@ impl<'a> Parser<'a> {
         self.check_inline_const(dist)
             || self.look_ahead(dist, |t| {
                 t.is_path_start() // e.g. `MY_CONST`;
-                || t.kind == token::Dot // e.g. `.5` for recovery;
+                || *t == token::Dot // e.g. `.5` for recovery;
                 || matches!(t.kind, token::Literal(..) | token::BinOp(token::Minus))
                 || t.is_bool_lit()
                 || t.is_whole_expr()
                 || t.is_lifetime() // recover `'a` instead of `'a'`
                 || (self.may_recover() // recover leading `(`
-                    && t.kind == token::OpenDelim(Delimiter::Parenthesis)
-                    && self.look_ahead(dist + 1, |t| t.kind != token::OpenDelim(Delimiter::Parenthesis))
+                    && *t == token::OpenDelim(Delimiter::Parenthesis)
+                    && self.look_ahead(dist + 1, |t| *t != token::OpenDelim(Delimiter::Parenthesis))
                     && self.is_pat_range_end_start(dist + 1))
             })
     }
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index 6f82d6b9826b5..007d760aba392 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -358,9 +358,9 @@ impl<'a> Parser<'a> {
                     })?;
                     let span = lo.to(self.prev_token.span);
                     AngleBracketedArgs { args, span }.into()
-                } else if self.token.kind == token::OpenDelim(Delimiter::Parenthesis)
+                } else if self.token == token::OpenDelim(Delimiter::Parenthesis)
                     // FIXME(return_type_notation): Could also recover `...` here.
-                    && self.look_ahead(1, |tok| tok.kind == token::DotDot)
+                    && self.look_ahead(1, |t| *t == token::DotDot)
                 {
                     self.bump(); // (
                     self.bump(); // ..
@@ -384,7 +384,7 @@ impl<'a> Parser<'a> {
                     let token_before_parsing = self.token.clone();
                     let mut snapshot = None;
                     if self.may_recover()
-                        && prev_token_before_parsing.kind == token::PathSep
+                        && prev_token_before_parsing == token::PathSep
                         && (style == PathStyle::Expr && self.token.can_begin_expr()
                             || style == PathStyle::Pat && self.token.can_begin_pattern())
                     {
@@ -393,7 +393,7 @@ impl<'a> Parser<'a> {
 
                     let (inputs, _) = match self.parse_paren_comma_seq(|p| p.parse_ty()) {
                         Ok(output) => output,
-                        Err(mut error) if prev_token_before_parsing.kind == token::PathSep => {
+                        Err(mut error) if prev_token_before_parsing == token::PathSep => {
                             error.span_label(
                                 prev_token_before_parsing.span.to(token_before_parsing.span),
                                 "while parsing this parenthesized list of type arguments starting here",
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index b206f134f0e28..c4fc0dfbaecf6 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -68,7 +68,7 @@ impl<'a> Parser<'a> {
             self.collect_tokens_trailing_token(attrs, force_collect, |this, attrs| {
                 this.expect_keyword(kw::Let)?;
                 let local = this.parse_local(attrs)?;
-                let trailing = capture_semi && this.token.kind == token::Semi;
+                let trailing = capture_semi && this.token == token::Semi;
                 Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), trailing))
             })?
         } else if self.is_kw_followed_by_ident(kw::Mut) && self.may_recover() {
@@ -760,7 +760,7 @@ impl<'a> Parser<'a> {
                                     )
                                 ),
                             );
-                            let suggest_eq = if self.token.kind == token::Dot
+                            let suggest_eq = if self.token == token::Dot
                                 && let _ = self.bump()
                                 && let mut snapshot = self.create_snapshot_for_diagnostic()
                                 && let Ok(_) = snapshot
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index 352ddd9eac4a5..a8e8270673afb 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -420,7 +420,7 @@ impl<'a> Parser<'a> {
         let mut trailing_plus = false;
         let (ts, trailing) = self.parse_paren_comma_seq(|p| {
             let ty = p.parse_ty()?;
-            trailing_plus = p.prev_token.kind == TokenKind::BinOp(token::Plus);
+            trailing_plus = p.prev_token == TokenKind::BinOp(token::Plus);
             Ok(ty)
         })?;
 
@@ -499,8 +499,8 @@ impl<'a> Parser<'a> {
         let elt_ty = match self.parse_ty() {
             Ok(ty) => ty,
             Err(err)
-                if self.look_ahead(1, |t| t.kind == token::CloseDelim(Delimiter::Bracket))
-                    | self.look_ahead(1, |t| t.kind == token::Semi) =>
+                if self.look_ahead(1, |t| *t == token::CloseDelim(Delimiter::Bracket))
+                    | self.look_ahead(1, |t| *t == token::Semi) =>
             {
                 // Recover from `[LIT; EXPR]` and `[LIT]`
                 self.bump();
@@ -601,7 +601,7 @@ impl<'a> Parser<'a> {
         let span_start = self.token.span;
         let ast::FnHeader { ext, safety, constness, coroutine_kind } =
             self.parse_fn_front_matter(&inherited_vis, Case::Sensitive)?;
-        if self.may_recover() && self.token.kind == TokenKind::Lt {
+        if self.may_recover() && self.token == TokenKind::Lt {
             self.recover_fn_ptr_with_generics(lo, &mut params, param_insertion_point)?;
         }
         let decl = self.parse_fn_decl(|_| false, AllowPlus::No, recover_return_sign)?;
@@ -681,7 +681,7 @@ impl<'a> Parser<'a> {
         // Always parse bounds greedily for better error recovery.
         let bounds = self.parse_generic_bounds()?;
 
-        *impl_dyn_multi = bounds.len() > 1 || self.prev_token.kind == TokenKind::BinOp(token::Plus);
+        *impl_dyn_multi = bounds.len() > 1 || self.prev_token == TokenKind::BinOp(token::Plus);
 
         Ok(TyKind::ImplTrait(ast::DUMMY_NODE_ID, bounds))
     }
@@ -727,8 +727,7 @@ impl<'a> Parser<'a> {
         self.check_keyword(kw::Dyn)
             && (self.token.uninterpolated_span().at_least_rust_2018()
                 || self.look_ahead(1, |t| {
-                    (can_begin_dyn_bound_in_edition_2015(t)
-                        || t.kind == TokenKind::BinOp(token::Star))
+                    (can_begin_dyn_bound_in_edition_2015(t) || *t == TokenKind::BinOp(token::Star))
                         && !can_continue_type_after_non_fn_ident(t)
                 }))
     }
@@ -750,7 +749,7 @@ impl<'a> Parser<'a> {
 
         // Always parse bounds greedily for better error recovery.
         let bounds = self.parse_generic_bounds()?;
-        *impl_dyn_multi = bounds.len() > 1 || self.prev_token.kind == TokenKind::BinOp(token::Plus);
+        *impl_dyn_multi = bounds.len() > 1 || self.prev_token == TokenKind::BinOp(token::Plus);
         Ok(TyKind::TraitObject(bounds, syntax))
     }
 
@@ -1060,7 +1059,7 @@ impl<'a> Parser<'a> {
         }
 
         let mut path = if self.token.is_keyword(kw::Fn)
-            && self.look_ahead(1, |tok| tok.kind == TokenKind::OpenDelim(Delimiter::Parenthesis))
+            && self.look_ahead(1, |t| *t == TokenKind::OpenDelim(Delimiter::Parenthesis))
             && let Some(path) = self.recover_path_from_fn()
         {
             path
diff --git a/src/tools/clippy/clippy_dev/src/new_lint.rs b/src/tools/clippy/clippy_dev/src/new_lint.rs
index de91233d196c8..87117832fb952 100644
--- a/src/tools/clippy/clippy_dev/src/new_lint.rs
+++ b/src/tools/clippy/clippy_dev/src/new_lint.rs
@@ -470,7 +470,7 @@ fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str>
     });
 
     // Find both the last lint declaration (declare_clippy_lint!) and the lint pass impl
-    while let Some(LintDeclSearchResult { content, .. }) = iter.find(|result| result.token_kind == TokenKind::Ident) {
+    while let Some(LintDeclSearchResult { content, .. }) = iter.find(|result| result.token == TokenKind::Ident) {
         let mut iter = iter
             .by_ref()
             .filter(|t| !matches!(t.token_kind, TokenKind::Whitespace | TokenKind::LineComment { .. }));
@@ -480,7 +480,7 @@ fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str>
                 // matches `!{`
                 match_tokens!(iter, Bang OpenBrace);
                 if let Some(LintDeclSearchResult { range, .. }) =
-                    iter.find(|result| result.token_kind == TokenKind::CloseBrace)
+                    iter.find(|result| result.token == TokenKind::CloseBrace)
                 {
                     last_decl_curly_offset = Some(range.end);
                 }
diff --git a/src/tools/rustfmt/src/parse/macros/mod.rs b/src/tools/rustfmt/src/parse/macros/mod.rs
index 60c827fd03bbb..8d5f7f90958f1 100644
--- a/src/tools/rustfmt/src/parse/macros/mod.rs
+++ b/src/tools/rustfmt/src/parse/macros/mod.rs
@@ -84,9 +84,7 @@ pub(crate) struct ParsedMacroArgs {
 fn check_keyword<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
     for &keyword in RUST_KW.iter() {
         if parser.token.is_keyword(keyword)
-            && parser.look_ahead(1, |t| {
-                t.kind == TokenKind::Eof || t.kind == TokenKind::Comma
-            })
+            && parser.look_ahead(1, |t| *t == TokenKind::Eof || *t == TokenKind::Comma)
         {
             parser.bump();
             return Some(MacroArg::Keyword(
@@ -131,7 +129,7 @@ pub(crate) fn parse_macro_args(
                                 Some(arg) => {
                                     args.push(arg);
                                     parser.bump();
-                                    if parser.token.kind == TokenKind::Eof && args.len() == 2 {
+                                    if parser.token == TokenKind::Eof && args.len() == 2 {
                                         vec_with_semi = true;
                                         break;
                                     }
@@ -150,7 +148,7 @@ pub(crate) fn parse_macro_args(
 
             parser.bump();
 
-            if parser.token.kind == TokenKind::Eof {
+            if parser.token == TokenKind::Eof {
                 trailing_comma = true;
                 break;
             }

From f72b3dbba217eff3b7292517944948311552eaab Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 9 Aug 2024 17:44:47 +1000
Subject: [PATCH 261/685] Use `impl PartialEq<TokenKind> for Token` more.

This lets us compare a `Token` with a `TokenKind`. It's used a lot, but
can be used even more, avoiding the need for some `.kind` uses.
---
 clippy_dev/src/new_lint.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_dev/src/new_lint.rs b/clippy_dev/src/new_lint.rs
index de91233d196c8..87117832fb952 100644
--- a/clippy_dev/src/new_lint.rs
+++ b/clippy_dev/src/new_lint.rs
@@ -470,7 +470,7 @@ fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str>
     });
 
     // Find both the last lint declaration (declare_clippy_lint!) and the lint pass impl
-    while let Some(LintDeclSearchResult { content, .. }) = iter.find(|result| result.token_kind == TokenKind::Ident) {
+    while let Some(LintDeclSearchResult { content, .. }) = iter.find(|result| result.token == TokenKind::Ident) {
         let mut iter = iter
             .by_ref()
             .filter(|t| !matches!(t.token_kind, TokenKind::Whitespace | TokenKind::LineComment { .. }));
@@ -480,7 +480,7 @@ fn setup_mod_file(path: &Path, lint: &LintData<'_>) -> io::Result<&'static str>
                 // matches `!{`
                 match_tokens!(iter, Bang OpenBrace);
                 if let Some(LintDeclSearchResult { range, .. }) =
-                    iter.find(|result| result.token_kind == TokenKind::CloseBrace)
+                    iter.find(|result| result.token == TokenKind::CloseBrace)
                 {
                     last_decl_curly_offset = Some(range.end);
                 }

From 3a02047d5212fa06f1dca8182d7cf9fb1d379ceb Mon Sep 17 00:00:00 2001
From: lcnr <rust@lcnr.de>
Date: Wed, 14 Aug 2024 09:36:53 +0200
Subject: [PATCH 262/685] if we have an `ocx`, use it

---
 .../src/traits/query/type_op/mod.rs           | 38 ++-----------------
 1 file changed, 3 insertions(+), 35 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs
index 2f64ed963f967..c5586d7d116d4 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs
@@ -170,44 +170,12 @@ where
         // collecting region constraints via `region_constraints`.
         let (mut output, _) = scrape_region_constraints(
             infcx,
-            |_ocx| {
-                let (output, ei, mut obligations, _) =
+            |ocx| {
+                let (output, ei, obligations, _) =
                     Q::fully_perform_into(self, infcx, &mut region_constraints, span)?;
                 error_info = ei;
 
-                // Typically, instantiating NLL query results does not
-                // create obligations. However, in some cases there
-                // are unresolved type variables, and unify them *can*
-                // create obligations. In that case, we have to go
-                // fulfill them. We do this via a (recursive) query.
-                while !obligations.is_empty() {
-                    trace!("{:#?}", obligations);
-                    let mut progress = false;
-                    for obligation in std::mem::take(&mut obligations) {
-                        let obligation = infcx.resolve_vars_if_possible(obligation);
-                        match ProvePredicate::fully_perform_into(
-                            obligation.param_env.and(ProvePredicate::new(obligation.predicate)),
-                            infcx,
-                            &mut region_constraints,
-                            span,
-                        ) {
-                            Ok(((), _, new, certainty)) => {
-                                obligations.extend(new);
-                                progress = true;
-                                if let Certainty::Ambiguous = certainty {
-                                    obligations.push(obligation);
-                                }
-                            }
-                            Err(_) => obligations.push(obligation),
-                        }
-                    }
-                    if !progress {
-                        infcx.dcx().span_bug(
-                            span,
-                            format!("ambiguity processing {obligations:?} from {self:?}"),
-                        );
-                    }
-                }
+                ocx.register_obligations(obligations);
                 Ok(output)
             },
             "fully_perform",

From e2ec11502d077c33650a288d255c3c056bb7232f Mon Sep 17 00:00:00 2001
From: Slanterns <slanterns.w@gmail.com>
Date: Wed, 14 Aug 2024 18:28:40 +0800
Subject: [PATCH 263/685] stabilize `is_none_or`

---
 compiler/rustc_const_eval/src/lib.rs | 1 -
 compiler/rustc_hir_typeck/src/lib.rs | 1 -
 library/core/src/option.rs           | 4 +---
 src/tools/miri/src/lib.rs            | 1 -
 4 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs
index 780404212c341..d825a47bfdf5d 100644
--- a/compiler/rustc_const_eval/src/lib.rs
+++ b/compiler/rustc_const_eval/src/lib.rs
@@ -6,7 +6,6 @@
 #![feature(box_patterns)]
 #![feature(decl_macro)]
 #![feature(if_let_guard)]
-#![feature(is_none_or)]
 #![feature(let_chains)]
 #![feature(never_type)]
 #![feature(rustdoc_internals)]
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 758a1cefe6341..9ec101196a43f 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -5,7 +5,6 @@
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
 #![feature(if_let_guard)]
-#![feature(is_none_or)]
 #![feature(let_chains)]
 #![feature(never_type)]
 #![feature(try_blocks)]
diff --git a/library/core/src/option.rs b/library/core/src/option.rs
index 6c89c81018038..9c6819bc58f32 100644
--- a/library/core/src/option.rs
+++ b/library/core/src/option.rs
@@ -656,8 +656,6 @@ impl<T> Option<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(is_none_or)]
-    ///
     /// let x: Option<u32> = Some(2);
     /// assert_eq!(x.is_none_or(|x| x > 1), true);
     ///
@@ -669,7 +667,7 @@ impl<T> Option<T> {
     /// ```
     #[must_use]
     #[inline]
-    #[unstable(feature = "is_none_or", issue = "126383")]
+    #[stable(feature = "is_none_or", since = "CURRENT_RUSTC_VERSION")]
     pub fn is_none_or(self, f: impl FnOnce(T) -> bool) -> bool {
         match self {
             None => true,
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 966d38508f612..7a11e353f9d98 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -12,7 +12,6 @@
 #![feature(let_chains)]
 #![feature(trait_upcasting)]
 #![feature(strict_overflow_ops)]
-#![feature(is_none_or)]
 // Configure clippy and other lints
 #![allow(
     clippy::collapsible_else_if,

From 607c4f51840c819abe191a29c8230111b40585a4 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Wed, 14 Aug 2024 18:45:29 +0800
Subject: [PATCH 264/685] Implement epoll shim

---
 src/tools/miri/src/helpers.rs                 |   8 +
 src/tools/miri/src/machine.rs                 |   5 +
 src/tools/miri/src/shims/mod.rs               |   2 +-
 src/tools/miri/src/shims/unix/fd.rs           | 107 +++-
 src/tools/miri/src/shims/unix/fs.rs           |   4 +
 src/tools/miri/src/shims/unix/linux/epoll.rs  | 382 ++++++++++--
 .../miri/src/shims/unix/linux/eventfd.rs      |  51 +-
 src/tools/miri/src/shims/unix/mod.rs          |   1 +
 src/tools/miri/src/shims/unix/socket.rs       |  91 ++-
 src/tools/miri/tests/fail-dep/tokio/sleep.rs  |   2 +-
 .../miri/tests/fail-dep/tokio/sleep.stderr    |   4 +-
 .../miri/tests/pass-dep/libc/libc-epoll.rs    | 552 ++++++++++++++++++
 12 files changed, 1134 insertions(+), 75 deletions(-)
 create mode 100644 src/tools/miri/tests/pass-dep/libc/libc-epoll.rs

diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index 1bdf9f06dcdb0..0483745621252 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -371,6 +371,14 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         path_ty_layout(this, &["std", "sys", "pal", "windows", "c", name])
     }
 
+    /// Helper function to get `TyAndLayout` of an array that consists of `libc` type.
+    fn libc_array_ty_layout(&self, name: &str, size: u64) -> TyAndLayout<'tcx> {
+        let this = self.eval_context_ref();
+        let elem_ty_layout = this.libc_ty_layout(name);
+        let array_ty = Ty::new_array(*this.tcx, elem_ty_layout.ty, size);
+        this.layout_of(array_ty).unwrap()
+    }
+
     /// Project to the given *named* field (which must be a struct or union type).
     fn project_field_named<P: Projectable<'tcx, Provenance>>(
         &self,
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 94598e7d2e3cc..2d8b8cb71ddd9 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -453,6 +453,9 @@ pub struct MiriMachine<'tcx> {
     /// The table of directory descriptors.
     pub(crate) dirs: shims::DirTable,
 
+    /// The list of all EpollEventInterest.
+    pub(crate) epoll_interests: shims::EpollInterestTable,
+
     /// This machine's monotone clock.
     pub(crate) clock: Clock,
 
@@ -647,6 +650,7 @@ impl<'tcx> MiriMachine<'tcx> {
             isolated_op: config.isolated_op,
             validation: config.validation,
             fds: shims::FdTable::init(config.mute_stdout_stderr),
+            epoll_interests: shims::EpollInterestTable::new(),
             dirs: Default::default(),
             layouts,
             threads,
@@ -785,6 +789,7 @@ impl VisitProvenance for MiriMachine<'_> {
             data_race,
             alloc_addresses,
             fds,
+            epoll_interests:_,
             tcx: _,
             isolated_op: _,
             validation: _,
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index a41a2883c9153..7d5349f26b127 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -17,7 +17,7 @@ pub mod panic;
 pub mod time;
 pub mod tls;
 
-pub use unix::{DirTable, FdTable};
+pub use unix::{DirTable, EpollInterestTable, FdTable};
 
 /// What needs to be done after emulating an item (a shim or an intrinsic) is done.
 pub enum EmulateItemResult {
diff --git a/src/tools/miri/src/shims/unix/fd.rs b/src/tools/miri/src/shims/unix/fd.rs
index 1b25ef05769b9..98a124b9a5620 100644
--- a/src/tools/miri/src/shims/unix/fd.rs
+++ b/src/tools/miri/src/shims/unix/fd.rs
@@ -6,9 +6,11 @@ use std::cell::{Ref, RefCell, RefMut};
 use std::collections::BTreeMap;
 use std::io::{self, ErrorKind, IsTerminal, Read, SeekFrom, Write};
 use std::rc::Rc;
+use std::rc::Weak;
 
 use rustc_target::abi::Size;
 
+use crate::shims::unix::linux::epoll::EpollReadyEvents;
 use crate::shims::unix::*;
 use crate::*;
 
@@ -27,6 +29,7 @@ pub trait FileDescription: std::fmt::Debug + Any {
     fn read<'tcx>(
         &mut self,
         _communicate_allowed: bool,
+        _fd_id: FdId,
         _bytes: &mut [u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -37,6 +40,7 @@ pub trait FileDescription: std::fmt::Debug + Any {
     fn write<'tcx>(
         &mut self,
         _communicate_allowed: bool,
+        _fd_id: FdId,
         _bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -80,6 +84,7 @@ pub trait FileDescription: std::fmt::Debug + Any {
     fn close<'tcx>(
         self: Box<Self>,
         _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<()>> {
         throw_unsup_format!("cannot close {}", self.name());
     }
@@ -97,6 +102,11 @@ pub trait FileDescription: std::fmt::Debug + Any {
         // so we use a default impl here.
         false
     }
+
+    /// Check the readiness of file description.
+    fn get_epoll_ready_events<'tcx>(&self) -> InterpResult<'tcx, EpollReadyEvents> {
+        throw_unsup_format!("{}: epoll does not support this file description", self.name());
+    }
 }
 
 impl dyn FileDescription {
@@ -119,6 +129,7 @@ impl FileDescription for io::Stdin {
     fn read<'tcx>(
         &mut self,
         communicate_allowed: bool,
+        _fd_id: FdId,
         bytes: &mut [u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -142,6 +153,7 @@ impl FileDescription for io::Stdout {
     fn write<'tcx>(
         &mut self,
         _communicate_allowed: bool,
+        _fd_id: FdId,
         bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -170,6 +182,7 @@ impl FileDescription for io::Stderr {
     fn write<'tcx>(
         &mut self,
         _communicate_allowed: bool,
+        _fd_id: FdId,
         bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -195,6 +208,7 @@ impl FileDescription for NullOutput {
     fn write<'tcx>(
         &mut self,
         _communicate_allowed: bool,
+        _fd_id: FdId,
         bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -203,36 +217,98 @@ impl FileDescription for NullOutput {
     }
 }
 
+/// Structure contains both the file description and its unique identifier.
+#[derive(Clone, Debug)]
+pub struct FileDescWithId<T: FileDescription + ?Sized> {
+    id: FdId,
+    file_description: RefCell<Box<T>>,
+}
+
 #[derive(Clone, Debug)]
-pub struct FileDescriptionRef(Rc<RefCell<Box<dyn FileDescription>>>);
+pub struct FileDescriptionRef(Rc<FileDescWithId<dyn FileDescription>>);
 
 impl FileDescriptionRef {
-    fn new(fd: impl FileDescription) -> Self {
-        FileDescriptionRef(Rc::new(RefCell::new(Box::new(fd))))
+    fn new(fd: impl FileDescription, id: FdId) -> Self {
+        FileDescriptionRef(Rc::new(FileDescWithId {
+            id,
+            file_description: RefCell::new(Box::new(fd)),
+        }))
     }
 
     pub fn borrow(&self) -> Ref<'_, dyn FileDescription> {
-        Ref::map(self.0.borrow(), |fd| fd.as_ref())
+        Ref::map(self.0.file_description.borrow(), |fd| fd.as_ref())
     }
 
     pub fn borrow_mut(&self) -> RefMut<'_, dyn FileDescription> {
-        RefMut::map(self.0.borrow_mut(), |fd| fd.as_mut())
+        RefMut::map(self.0.file_description.borrow_mut(), |fd| fd.as_mut())
     }
 
-    pub fn close<'ctx>(self, communicate_allowed: bool) -> InterpResult<'ctx, io::Result<()>> {
+    pub fn close<'tcx>(
+        self,
+        communicate_allowed: bool,
+        ecx: &mut MiriInterpCx<'tcx>,
+    ) -> InterpResult<'tcx, io::Result<()>> {
         // Destroy this `Rc` using `into_inner` so we can call `close` instead of
         // implicitly running the destructor of the file description.
+        let id = self.get_id();
         match Rc::into_inner(self.0) {
-            Some(fd) => RefCell::into_inner(fd).close(communicate_allowed),
+            Some(fd) => {
+                // Remove entry from the global epoll_event_interest table.
+                ecx.machine.epoll_interests.remove(id);
+
+                RefCell::into_inner(fd.file_description).close(communicate_allowed, ecx)
+            }
             None => Ok(Ok(())),
         }
     }
+
+    pub fn downgrade(&self) -> WeakFileDescriptionRef {
+        WeakFileDescriptionRef { weak_ref: Rc::downgrade(&self.0) }
+    }
+
+    pub fn get_id(&self) -> FdId {
+        self.0.id
+    }
+
+    /// Function used to retrieve the readiness events of a file description and insert
+    /// an `EpollEventInstance` into the ready list if the file description is ready.
+    pub(crate) fn check_and_update_readiness<'tcx>(
+        &self,
+        ecx: &mut InterpCx<'tcx, MiriMachine<'tcx>>,
+    ) -> InterpResult<'tcx, ()> {
+        use crate::shims::unix::linux::epoll::EvalContextExt;
+        ecx.check_and_update_readiness(self.get_id(), || self.borrow_mut().get_epoll_ready_events())
+    }
+}
+
+/// Holds a weak reference to the actual file description.
+#[derive(Clone, Debug, Default)]
+pub struct WeakFileDescriptionRef {
+    weak_ref: Weak<FileDescWithId<dyn FileDescription>>,
+}
+
+impl WeakFileDescriptionRef {
+    pub fn upgrade(&self) -> Option<FileDescriptionRef> {
+        if let Some(file_desc_with_id) = self.weak_ref.upgrade() {
+            return Some(FileDescriptionRef(file_desc_with_id));
+        }
+        None
+    }
 }
 
+/// A unique id for file descriptions. While we could use the address, considering that
+/// is definitely unique, the address would expose interpreter internal state when used
+/// for sorting things. So instead we generate a unique id per file description that stays
+/// the same even if a file descriptor is duplicated and gets a new integer file descriptor.
+#[derive(Debug, Copy, Clone, Default, Eq, PartialEq, Ord, PartialOrd)]
+pub struct FdId(usize);
+
 /// The file descriptor table
 #[derive(Debug)]
 pub struct FdTable {
-    fds: BTreeMap<i32, FileDescriptionRef>,
+    pub fds: BTreeMap<i32, FileDescriptionRef>,
+    /// Unique identifier for file description, used to differentiate between various file description.
+    next_file_description_id: FdId,
 }
 
 impl VisitProvenance for FdTable {
@@ -243,7 +319,7 @@ impl VisitProvenance for FdTable {
 
 impl FdTable {
     fn new() -> Self {
-        FdTable { fds: BTreeMap::new() }
+        FdTable { fds: BTreeMap::new(), next_file_description_id: FdId(0) }
     }
     pub(crate) fn init(mute_stdout_stderr: bool) -> FdTable {
         let mut fds = FdTable::new();
@@ -260,7 +336,8 @@ impl FdTable {
 
     /// Insert a new file description to the FdTable.
     pub fn insert_new(&mut self, fd: impl FileDescription) -> i32 {
-        let file_handle = FileDescriptionRef::new(fd);
+        let file_handle = FileDescriptionRef::new(fd, self.next_file_description_id);
+        self.next_file_description_id = FdId(self.next_file_description_id.0.strict_add(1));
         self.insert_ref_with_min_fd(file_handle, 0)
     }
 
@@ -337,7 +414,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             // If old_fd and new_fd point to the same description, then `dup_fd` ensures we keep the underlying file description alive.
             if let Some(file_description) = this.machine.fds.fds.insert(new_fd, dup_fd) {
                 // Ignore close error (not interpreter's) according to dup2() doc.
-                file_description.close(this.machine.communicate())?.ok();
+                file_description.close(this.machine.communicate(), this)?.ok();
             }
         }
         Ok(Scalar::from_i32(new_fd))
@@ -442,7 +519,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let Some(file_description) = this.machine.fds.remove(fd) else {
             return Ok(Scalar::from_i32(this.fd_not_found()?));
         };
-        let result = file_description.close(this.machine.communicate())?;
+        let result = file_description.close(this.machine.communicate(), this)?;
         // return `0` if close is successful
         let result = result.map(|()| 0i32);
         Ok(Scalar::from_i32(this.try_unwrap_io_result(result)?))
@@ -499,7 +576,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // `usize::MAX` because it is bounded by the host's `isize`.
         let mut bytes = vec![0; usize::try_from(count).unwrap()];
         let result = match offset {
-            None => fd.borrow_mut().read(communicate, &mut bytes, this),
+            None => fd.borrow_mut().read(communicate, fd.get_id(), &mut bytes, this),
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
                     let einval = this.eval_libc("EINVAL");
@@ -509,7 +586,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 fd.borrow_mut().pread(communicate, &mut bytes, offset, this)
             }
         };
-        drop(fd);
 
         // `File::read` never returns a value larger than `count`, so this cannot fail.
         match result?.map(|c| i64::try_from(c).unwrap()) {
@@ -558,7 +634,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         };
 
         let result = match offset {
-            None => fd.borrow_mut().write(communicate, &bytes, this),
+            None => fd.borrow_mut().write(communicate, fd.get_id(), &bytes, this),
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
                     let einval = this.eval_libc("EINVAL");
@@ -568,7 +644,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 fd.borrow_mut().pwrite(communicate, &bytes, offset, this)
             }
         };
-        drop(fd);
 
         let result = result?.map(|c| i64::try_from(c).unwrap());
         Ok(Scalar::from_target_isize(this.try_unwrap_io_result(result)?, this))
diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index d93374db8187f..9da36e64a0f99 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -12,6 +12,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_target::abi::Size;
 
 use crate::shims::os_str::bytes_to_os_str;
+use crate::shims::unix::fd::FdId;
 use crate::shims::unix::*;
 use crate::*;
 use shims::time::system_time_to_duration;
@@ -32,6 +33,7 @@ impl FileDescription for FileHandle {
     fn read<'tcx>(
         &mut self,
         communicate_allowed: bool,
+        _fd_id: FdId,
         bytes: &mut [u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -42,6 +44,7 @@ impl FileDescription for FileHandle {
     fn write<'tcx>(
         &mut self,
         communicate_allowed: bool,
+        _fd_id: FdId,
         bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -109,6 +112,7 @@ impl FileDescription for FileHandle {
     fn close<'tcx>(
         self: Box<Self>,
         communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<()>> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
         // We sync the file if it was opened in a mode different than read-only.
diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index 9127db3d00420..89616bd0d0723 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -1,32 +1,103 @@
+use std::cell::RefCell;
+use std::collections::BTreeMap;
 use std::io;
+use std::rc::{Rc, Weak};
 
-use rustc_data_structures::fx::FxHashMap;
-
+use crate::shims::unix::fd::FdId;
 use crate::shims::unix::*;
 use crate::*;
 
 /// An `Epoll` file descriptor connects file handles and epoll events
 #[derive(Clone, Debug, Default)]
 struct Epoll {
-    /// The file descriptors we are watching, and what we are watching for.
-    file_descriptors: FxHashMap<i32, EpollEvent>,
+    /// A map of EpollEventInterests registered under this epoll instance.
+    /// Each entry is differentiated using FdId and file descriptor value.
+    interest_list: BTreeMap<(FdId, i32), Rc<RefCell<EpollEventInterest>>>,
+    /// A map of EpollEventInstance that will be returned when `epoll_wait` is called.
+    /// Similar to interest_list, the entry is also differentiated using FdId
+    /// and file descriptor value.
+    // This is an Rc because EpollInterest need to hold a reference to update
+    // it.
+    ready_list: Rc<RefCell<BTreeMap<(FdId, i32), EpollEventInstance>>>,
 }
 
-/// Epoll Events associate events with data.
-/// These fields are currently unused by miri.
-/// This matches the `epoll_event` struct defined
+/// EpollEventInstance contains information that will be returned by epoll_wait.
+#[derive(Debug)]
+pub struct EpollEventInstance {
+    /// Xor-ed event types that happened to the file description.
+    events: u32,
+    /// Original data retrieved from `epoll_event` during `epoll_ctl`.
+    data: u64,
+}
+
+impl EpollEventInstance {
+    pub fn new(events: u32, data: u64) -> EpollEventInstance {
+        EpollEventInstance { events, data }
+    }
+}
+/// EpollEventInterest registers the file description information to an epoll
+/// instance during a successful `epoll_ctl` call. It also stores additional
+/// information needed to check and update readiness state for `epoll_wait`.
+///
+/// `events` and `data` field matches the `epoll_event` struct defined
 /// by the epoll_ctl man page. For more information
 /// see the man page:
 ///
 /// <https://man7.org/linux/man-pages/man2/epoll_ctl.2.html>
 #[derive(Clone, Debug)]
-struct EpollEvent {
-    #[allow(dead_code)]
+pub struct EpollEventInterest {
+    /// The file descriptor value of the file description registered.
+    file_descriptor: i32,
+    /// The events bitmask retrieved from `epoll_event`.
     events: u32,
-    /// `Scalar` is used to represent the
-    /// `epoll_data` type union.
-    #[allow(dead_code)]
-    data: Scalar,
+    /// The data retrieved from `epoll_event`.
+    /// libc's data field in epoll_event can store integer or pointer,
+    /// but only u64 is supported for now.
+    /// <https://man7.org/linux/man-pages/man3/epoll_event.3type.html>
+    data: u64,
+    /// Ready list of the epoll instance under which this EpollEventInterest is registered.
+    ready_list: Rc<RefCell<BTreeMap<(FdId, i32), EpollEventInstance>>>,
+}
+
+/// EpollReadyEvents reflects the readiness of a file description.
+pub struct EpollReadyEvents {
+    /// The associated file is available for read(2) operations.
+    pub epollin: bool,
+    /// The associated file is available for write(2) operations.
+    pub epollout: bool,
+    /// Stream socket peer closed connection, or shut down writing
+    /// half of connection.
+    pub epollrdhup: bool,
+}
+
+impl EpollReadyEvents {
+    pub fn new() -> Self {
+        EpollReadyEvents { epollin: false, epollout: false, epollrdhup: false }
+    }
+
+    pub fn get_event_bitmask<'tcx>(&self, ecx: &MiriInterpCx<'tcx>) -> u32 {
+        let epollin = ecx.eval_libc_u32("EPOLLIN");
+        let epollout = ecx.eval_libc_u32("EPOLLOUT");
+        let epollrdhup = ecx.eval_libc_u32("EPOLLRDHUP");
+
+        let mut bitmask = 0;
+        if self.epollin {
+            bitmask |= epollin;
+        }
+        if self.epollout {
+            bitmask |= epollout;
+        }
+        if self.epollrdhup {
+            bitmask |= epollrdhup;
+        }
+        bitmask
+    }
+}
+
+impl Epoll {
+    fn get_ready_list(&self) -> Rc<RefCell<BTreeMap<(FdId, i32), EpollEventInstance>>> {
+        Rc::clone(&self.ready_list)
+    }
 }
 
 impl FileDescription for Epoll {
@@ -37,11 +108,51 @@ impl FileDescription for Epoll {
     fn close<'tcx>(
         self: Box<Self>,
         _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<()>> {
         Ok(Ok(()))
     }
 }
 
+/// The table of all EpollEventInterest.
+/// The BTreeMap key is the FdId of an active file description registered with
+/// any epoll instance. The value is a list of EpollEventInterest associated
+/// with that file description.
+pub struct EpollInterestTable(BTreeMap<FdId, Vec<Weak<RefCell<EpollEventInterest>>>>);
+
+impl EpollInterestTable {
+    pub(crate) fn new() -> Self {
+        EpollInterestTable(BTreeMap::new())
+    }
+
+    pub fn insert_epoll_interest(&mut self, id: FdId, fd: Weak<RefCell<EpollEventInterest>>) {
+        match self.0.get_mut(&id) {
+            Some(fds) => {
+                fds.push(fd);
+            }
+            None => {
+                let vec = vec![fd];
+                self.0.insert(id, vec);
+            }
+        }
+    }
+
+    pub fn get_epoll_interest(&self, id: FdId) -> Option<&Vec<Weak<RefCell<EpollEventInterest>>>> {
+        self.0.get(&id)
+    }
+
+    pub fn get_epoll_interest_mut(
+        &mut self,
+        id: FdId,
+    ) -> Option<&mut Vec<Weak<RefCell<EpollEventInterest>>>> {
+        self.0.get_mut(&id)
+    }
+
+    pub fn remove(&mut self, id: FdId) {
+        self.0.remove(&id);
+    }
+}
+
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// This function returns a file descriptor referring to the new `Epoll` instance. This file
@@ -64,6 +175,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             );
         }
 
+        let mut epoll_instance = Epoll::default();
+        epoll_instance.ready_list = Rc::new(RefCell::new(BTreeMap::new()));
+
         let fd = this.machine.fds.insert_new(Epoll::default());
         Ok(Scalar::from_i32(fd))
     }
@@ -90,48 +204,143 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     ) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_mut();
 
-        let epfd = this.read_scalar(epfd)?.to_i32()?;
+        let epfd_value = this.read_scalar(epfd)?.to_i32()?;
         let op = this.read_scalar(op)?.to_i32()?;
         let fd = this.read_scalar(fd)?.to_i32()?;
-        let _event = this.read_scalar(event)?.to_pointer(this)?;
+        let event = this.deref_pointer_as(event, this.libc_ty_layout("epoll_event"))?;
 
         let epoll_ctl_add = this.eval_libc_i32("EPOLL_CTL_ADD");
         let epoll_ctl_mod = this.eval_libc_i32("EPOLL_CTL_MOD");
         let epoll_ctl_del = this.eval_libc_i32("EPOLL_CTL_DEL");
+        let epollin = this.eval_libc_u32("EPOLLIN");
+        let epollout = this.eval_libc_u32("EPOLLOUT");
+        let epollrdhup = this.eval_libc_u32("EPOLLRDHUP");
+        let epollet = this.eval_libc_u32("EPOLLET");
+
+        // Fail on unsupported operations.
+        if op & epoll_ctl_add != epoll_ctl_add
+            && op & epoll_ctl_mod != epoll_ctl_mod
+            && op & epoll_ctl_del != epoll_ctl_del
+        {
+            throw_unsup_format!("epoll_ctl: encountered unknown unsupported operation {:#x}", op);
+        }
+
+        // Check if epfd is a valid epoll file descriptor.
+        let Some(epfd) = this.machine.fds.get_ref(epfd_value) else {
+            return Ok(Scalar::from_i32(this.fd_not_found()?));
+        };
+        let mut binding = epfd.borrow_mut();
+        let epoll_file_description = &mut binding
+            .downcast_mut::<Epoll>()
+            .ok_or_else(|| err_unsup_format!("non-epoll FD passed to `epoll_ctl`"))?;
+
+        let interest_list = &mut epoll_file_description.interest_list;
+        let ready_list = &epoll_file_description.ready_list;
+
+        let Some(file_descriptor) = this.machine.fds.get_ref(fd) else {
+            return Ok(Scalar::from_i32(this.fd_not_found()?));
+        };
+        let id = file_descriptor.get_id();
 
         if op == epoll_ctl_add || op == epoll_ctl_mod {
-            let event = this.deref_pointer_as(event, this.libc_ty_layout("epoll_event"))?;
+            // Read event bitmask and data from epoll_event passed by caller.
+            let events = this.read_scalar(&this.project_field(&event, 0)?)?.to_u32()?;
+            let data = this.read_scalar(&this.project_field(&event, 1)?)?.to_u64()?;
 
-            let events = this.project_field(&event, 0)?;
-            let events = this.read_scalar(&events)?.to_u32()?;
-            let data = this.project_field(&event, 1)?;
-            let data = this.read_scalar(&data)?;
-            let event = EpollEvent { events, data };
+            // Unset the flag we support to discover if any unsupported flags are used.
+            let mut flags = events;
+            if events & epollet != epollet {
+                // We only support edge-triggered notification for now.
+                throw_unsup_format!("epoll_ctl: epollet flag must be included.");
+            } else {
+                flags &= !epollet;
+            }
+            if flags & epollin == epollin {
+                flags &= !epollin;
+            }
+            if flags & epollout == epollout {
+                flags &= !epollout;
+            }
+            if flags & epollrdhup == epollrdhup {
+                flags &= !epollrdhup;
+            }
+            if flags != 0 {
+                throw_unsup_format!(
+                    "epoll_ctl: encountered unknown unsupported flags {:#x}",
+                    flags
+                );
+            }
 
-            let Some(mut epfd) = this.machine.fds.get_mut(epfd) else {
-                return Ok(Scalar::from_i32(this.fd_not_found()?));
-            };
-            let epfd = epfd
-                .downcast_mut::<Epoll>()
-                .ok_or_else(|| err_unsup_format!("non-epoll FD passed to `epoll_ctl`"))?;
+            let epoll_key = (id, fd);
+
+            // Check the existence of fd in the interest list.
+            if op == epoll_ctl_add {
+                if interest_list.contains_key(&epoll_key) {
+                    let eexist = this.eval_libc("EEXIST");
+                    this.set_last_error(eexist)?;
+                    return Ok(Scalar::from_i32(-1));
+                }
+            } else {
+                if !interest_list.contains_key(&epoll_key) {
+                    let enoent = this.eval_libc("ENOENT");
+                    this.set_last_error(enoent)?;
+                    return Ok(Scalar::from_i32(-1));
+                }
+            }
+
+            let id = file_descriptor.get_id();
+            // Create an epoll_interest.
+            let interest = Rc::new(RefCell::new(EpollEventInterest {
+                file_descriptor: fd,
+                events,
+                data,
+                ready_list: Rc::clone(ready_list),
+            }));
+
+            if op == epoll_ctl_add {
+                // Insert an epoll_interest to global epoll_interest list.
+                this.machine.epoll_interests.insert_epoll_interest(id, Rc::downgrade(&interest));
+                interest_list.insert(epoll_key, interest);
+            } else {
+                // Directly modify the epoll_interest so the global epoll_event_interest table
+                // will be updated too.
+                let mut epoll_interest = interest_list.get_mut(&epoll_key).unwrap().borrow_mut();
+                epoll_interest.events = events;
+                epoll_interest.data = data;
+            }
+
+            // Readiness will be updated immediately when the epoll_event_interest is added or modified.
+            file_descriptor.check_and_update_readiness(this)?;
 
-            epfd.file_descriptors.insert(fd, event);
-            Ok(Scalar::from_i32(0))
+            return Ok(Scalar::from_i32(0));
         } else if op == epoll_ctl_del {
-            let Some(mut epfd) = this.machine.fds.get_mut(epfd) else {
-                return Ok(Scalar::from_i32(this.fd_not_found()?));
+            let epoll_key = (id, fd);
+
+            // Remove epoll_event_interest from interest_list.
+            let Some(epoll_interest) = interest_list.remove(&epoll_key) else {
+                let enoent = this.eval_libc("ENOENT");
+                this.set_last_error(enoent)?;
+                return Ok(Scalar::from_i32(-1));
             };
-            let epfd = epfd
-                .downcast_mut::<Epoll>()
-                .ok_or_else(|| err_unsup_format!("non-epoll FD passed to `epoll_ctl`"))?;
+            // All related Weak<EpollEventInterest> will fail to upgrade after the drop.
+            drop(epoll_interest);
 
-            epfd.file_descriptors.remove(&fd);
-            Ok(Scalar::from_i32(0))
-        } else {
-            let einval = this.eval_libc("EINVAL");
-            this.set_last_error(einval)?;
-            Ok(Scalar::from_i32(-1))
+            // Remove related epoll_interest from ready list.
+            ready_list.borrow_mut().remove(&epoll_key);
+
+            // Remove dangling EpollEventInterest from its global table.
+            // .unwrap() below should succeed because the file description id must have registered
+            // at least one epoll_interest, if not, it will fail when removing epoll_interest from
+            // interest list.
+            this.machine
+                .epoll_interests
+                .get_epoll_interest_mut(id)
+                .unwrap()
+                .retain(|event| event.upgrade().is_some());
+
+            return Ok(Scalar::from_i32(0));
         }
+        Ok(Scalar::from_i32(-1))
     }
 
     /// The `epoll_wait()` system call waits for events on the `Epoll`
@@ -166,25 +375,102 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn epoll_wait(
         &mut self,
         epfd: &OpTy<'tcx>,
-        events: &OpTy<'tcx>,
+        events_op: &OpTy<'tcx>,
         maxevents: &OpTy<'tcx>,
         timeout: &OpTy<'tcx>,
     ) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_mut();
 
         let epfd = this.read_scalar(epfd)?.to_i32()?;
-        let _events = this.read_scalar(events)?.to_pointer(this)?;
-        let _maxevents = this.read_scalar(maxevents)?.to_i32()?;
-        let _timeout = this.read_scalar(timeout)?.to_i32()?;
+        let maxevents = this.read_scalar(maxevents)?.to_i32()?;
+        let event = this.deref_pointer_as(
+            events_op,
+            this.libc_array_ty_layout("epoll_event", maxevents.try_into().unwrap()),
+        )?;
+        let timeout = this.read_scalar(timeout)?.to_i32()?;
 
-        let Some(mut epfd) = this.machine.fds.get_mut(epfd) else {
+        if epfd <= 0 {
+            let einval = this.eval_libc("EINVAL");
+            this.set_last_error(einval)?;
+            return Ok(Scalar::from_i32(-1));
+        }
+        // FIXME: Implement blocking support
+        if timeout != 0 {
+            throw_unsup_format!("epoll_wait: timeout value can only be 0");
+        }
+
+        let Some(epfd) = this.machine.fds.get_ref(epfd) else {
             return Ok(Scalar::from_i32(this.fd_not_found()?));
         };
-        let _epfd = epfd
+        let mut binding = epfd.borrow_mut();
+        let epoll_file_description = &mut binding
             .downcast_mut::<Epoll>()
             .ok_or_else(|| err_unsup_format!("non-epoll FD passed to `epoll_wait`"))?;
 
-        // FIXME return number of events ready when scheme for marking events ready exists
-        throw_unsup_format!("returning ready events from epoll_wait is not yet implemented");
+        let binding = epoll_file_description.get_ready_list();
+        let mut ready_list = binding.borrow_mut();
+        let mut num_of_events: i32 = 0;
+        let mut array_iter = this.project_array_fields(&event)?;
+
+        while let Some((epoll_key, epoll_return)) = ready_list.pop_first() {
+            // If the file description is fully close, the entry for corresponding FdID in the
+            // global epoll event interest table would be empty.
+            if this.machine.epoll_interests.get_epoll_interest(epoll_key.0).is_some() {
+                // Return notification to the caller if the file description is not fully closed.
+                if let Some(des) = array_iter.next(this)? {
+                    this.write_int_fields_named(
+                        &[
+                            ("events", epoll_return.events.into()),
+                            ("u64", epoll_return.data.into()),
+                        ],
+                        &des.1,
+                    )?;
+                    num_of_events = num_of_events.checked_add(1).unwrap();
+                } else {
+                    break;
+                }
+            }
+        }
+        Ok(Scalar::from_i32(num_of_events))
+    }
+
+    /// For a specific unique file descriptor id, get its ready events and update
+    /// the corresponding ready list. This function is called whenever a file description
+    /// is registered with epoll, or when read, write, or close operations are performed,
+    /// regardless of any changes in readiness.
+    ///
+    /// This is an internal helper function and is typically not meant to be used directly.
+    /// In most cases, `FileDescriptionRef::check_and_update_readiness` should be preferred.
+    fn check_and_update_readiness(
+        &self,
+        id: FdId,
+        get_ready_events: impl FnOnce() -> InterpResult<'tcx, EpollReadyEvents>,
+    ) -> InterpResult<'tcx, ()> {
+        let this = self.eval_context_ref();
+        // Get a list of EpollEventInterest that is associated to a specific file description.
+        if let Some(epoll_interests) = this.machine.epoll_interests.get_epoll_interest(id) {
+            let epoll_ready_events = get_ready_events()?;
+            // Get the bitmask of ready events.
+            let ready_events = epoll_ready_events.get_event_bitmask(this);
+
+            for weak_epoll_interest in epoll_interests {
+                if let Some(epoll_interest) = weak_epoll_interest.upgrade() {
+                    // This checks if any of the events specified in epoll_event_interest.events
+                    // match those in ready_events.
+                    let epoll_event_interest = epoll_interest.borrow();
+                    let flags = epoll_event_interest.events & ready_events;
+                    // If there is any event that we are interested in being specified as ready,
+                    // insert an epoll_return to the ready list.
+                    if flags != 0 {
+                        let epoll_key = (id, epoll_event_interest.file_descriptor);
+                        let ready_list = &mut epoll_event_interest.ready_list.borrow_mut();
+                        let event_instance =
+                            EpollEventInstance::new(flags, epoll_event_interest.data);
+                        ready_list.insert(epoll_key, event_instance);
+                    }
+                }
+            }
+        }
+        Ok(())
     }
 }
diff --git a/src/tools/miri/src/shims/unix/linux/eventfd.rs b/src/tools/miri/src/shims/unix/linux/eventfd.rs
index 4ab8760d9306a..8a11f225b2248 100644
--- a/src/tools/miri/src/shims/unix/linux/eventfd.rs
+++ b/src/tools/miri/src/shims/unix/linux/eventfd.rs
@@ -3,8 +3,10 @@ use std::io;
 use std::io::{Error, ErrorKind};
 use std::mem;
 
+use fd::FdId;
 use rustc_target::abi::Endian;
 
+use crate::shims::unix::linux::epoll::EpollReadyEvents;
 use crate::shims::unix::*;
 use crate::{concurrency::VClock, *};
 
@@ -35,9 +37,21 @@ impl FileDescription for Event {
         "event"
     }
 
+    fn get_epoll_ready_events<'tcx>(&self) -> InterpResult<'tcx, EpollReadyEvents> {
+        // We only check the status of EPOLLIN and EPOLLOUT flags for eventfd. If other event flags
+        // need to be supported in the future, the check should be added here.
+
+        Ok(EpollReadyEvents {
+            epollin: self.counter != 0,
+            epollout: self.counter != MAX_COUNTER,
+            ..EpollReadyEvents::new()
+        })
+    }
+
     fn close<'tcx>(
         self: Box<Self>,
         _communicate_allowed: bool,
+        _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<()>> {
         Ok(Ok(()))
     }
@@ -46,6 +60,7 @@ impl FileDescription for Event {
     fn read<'tcx>(
         &mut self,
         _communicate_allowed: bool,
+        fd_id: FdId,
         bytes: &mut [u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -70,6 +85,18 @@ impl FileDescription for Event {
                 Endian::Big => self.counter.to_be_bytes(),
             };
             self.counter = 0;
+            // When any of the event happened, we check and update the status of all supported event
+            // types for current file description.
+
+            // We have to use our own FdID in contrast to every other file descriptor out there, because
+            // we are updating ourselves when writing and reading. Technically `Event` is like socketpair, but
+            // it does not create two separate file descriptors. Thus we can't re-borrow ourselves via
+            // `FileDescriptionRef::check_and_update_readiness` while already being mutably borrowed for read/write.
+            crate::shims::unix::linux::epoll::EvalContextExt::check_and_update_readiness(
+                ecx,
+                fd_id,
+                || self.get_epoll_ready_events(),
+            )?;
             return Ok(Ok(U64_ARRAY_SIZE));
         }
     }
@@ -89,6 +116,7 @@ impl FileDescription for Event {
     fn write<'tcx>(
         &mut self,
         _communicate_allowed: bool,
+        fd_id: FdId,
         bytes: &[u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -124,6 +152,17 @@ impl FileDescription for Event {
                 }
             }
         };
+        // When any of the event happened, we check and update the status of all supported event
+        // types for current file description.
+
+        // Just like read() above, we use this internal method to not get the second borrow of the
+        // RefCell of this FileDescription. This is a special case, we should only use
+        // FileDescriptionRef::check_and_update_readiness in normal case.
+        crate::shims::unix::linux::epoll::EvalContextExt::check_and_update_readiness(
+            ecx,
+            fd_id,
+            || self.get_epoll_ready_events(),
+        )?;
         Ok(Ok(U64_ARRAY_SIZE))
     }
 }
@@ -178,11 +217,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             throw_unsup_format!("eventfd: encountered unknown unsupported flags {:#x}", flags);
         }
 
-        let fd = this.machine.fds.insert_new(Event {
-            counter: val.into(),
-            is_nonblock,
-            clock: VClock::default(),
-        });
-        Ok(Scalar::from_i32(fd))
+        let fds = &mut this.machine.fds;
+
+        let fd_value =
+            fds.insert_new(Event { counter: val.into(), is_nonblock, clock: VClock::default() });
+
+        Ok(Scalar::from_i32(fd_value))
     }
 }
diff --git a/src/tools/miri/src/shims/unix/mod.rs b/src/tools/miri/src/shims/unix/mod.rs
index dc9068fddde1e..8cfa659d90a34 100644
--- a/src/tools/miri/src/shims/unix/mod.rs
+++ b/src/tools/miri/src/shims/unix/mod.rs
@@ -17,6 +17,7 @@ mod solarish;
 pub use env::UnixEnvVars;
 pub use fd::{FdTable, FileDescription};
 pub use fs::DirTable;
+pub use linux::epoll::EpollInterestTable;
 // All the Unix-specific extension traits
 pub use env::EvalContextExt as _;
 pub use fd::EvalContextExt as _;
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index 455820a9e6e5a..0f40d9776bbb8 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -4,6 +4,8 @@ use std::io;
 use std::io::{Error, ErrorKind, Read};
 use std::rc::{Rc, Weak};
 
+use crate::shims::unix::fd::{FdId, WeakFileDescriptionRef};
+use crate::shims::unix::linux::epoll::EpollReadyEvents;
 use crate::shims::unix::*;
 use crate::{concurrency::VClock, *};
 
@@ -19,6 +21,11 @@ struct SocketPair {
     // gone, and trigger EPIPE as appropriate.
     writebuf: Weak<RefCell<Buffer>>,
     readbuf: Rc<RefCell<Buffer>>,
+    /// When a socketpair instance is created, two socketpair file descriptions are generated.
+    /// The peer_fd field holds a weak reference to the file description of peer socketpair.
+    // TODO: It might be possible to retrieve writebuf from peer_fd and remove the writebuf
+    // field above.
+    peer_fd: WeakFileDescriptionRef,
     is_nonblock: bool,
 }
 
@@ -37,21 +44,62 @@ impl FileDescription for SocketPair {
         "socketpair"
     }
 
+    fn get_epoll_ready_events<'tcx>(&self) -> InterpResult<'tcx, EpollReadyEvents> {
+        // We only check the status of EPOLLIN, EPOLLOUT and EPOLLRDHUP flags. If other event flags
+        // need to be supported in the future, the check should be added here.
+
+        let mut epoll_ready_events = EpollReadyEvents::new();
+        let readbuf = self.readbuf.borrow();
+
+        // Check if it is readable.
+        if !readbuf.buf.is_empty() {
+            epoll_ready_events.epollin = true;
+        }
+
+        // Check if is writable.
+        if let Some(writebuf) = self.writebuf.upgrade() {
+            let writebuf = writebuf.borrow();
+            let data_size = writebuf.buf.len();
+            let available_space = MAX_SOCKETPAIR_BUFFER_CAPACITY.strict_sub(data_size);
+            if available_space != 0 {
+                epoll_ready_events.epollout = true;
+            }
+        }
+
+        // Check if the peer_fd closed
+        if self.peer_fd.upgrade().is_none() {
+            epoll_ready_events.epollrdhup = true;
+            // This is an edge case. Whenever epollrdhup is triggered, epollin will be added
+            // even though there is no data in the buffer.
+            epoll_ready_events.epollin = true;
+        }
+        Ok(epoll_ready_events)
+    }
+
     fn close<'tcx>(
         self: Box<Self>,
         _communicate_allowed: bool,
+        ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<()>> {
         // This is used to signal socketfd of other side that there is no writer to its readbuf.
         // If the upgrade fails, there is no need to update as all read ends have been dropped.
         if let Some(writebuf) = self.writebuf.upgrade() {
             writebuf.borrow_mut().buf_has_writer = false;
         };
+
+        // Notify peer fd that closed has happened.
+        if let Some(peer_fd) = self.peer_fd.upgrade() {
+            // When any of the event happened, we check and update the status of all supported events
+            // types of peer fd.
+            peer_fd.check_and_update_readiness(ecx)?;
+        }
         Ok(Ok(()))
     }
 
     fn read<'tcx>(
         &mut self,
         _communicate_allowed: bool,
+        _fd_id: FdId,
         bytes: &mut [u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -88,15 +136,33 @@ impl FileDescription for SocketPair {
         // FIXME: this over-synchronizes; a more precise approach would be to
         // only sync with the writes whose data we will read.
         ecx.acquire_clock(&readbuf.clock);
+
         // Do full read / partial read based on the space available.
         // Conveniently, `read` exists on `VecDeque` and has exactly the desired behavior.
         let actual_read_size = readbuf.buf.read(bytes).unwrap();
+
+        // The readbuf needs to be explicitly dropped because it will cause panic when
+        // check_and_update_readiness borrows it again.
+        drop(readbuf);
+
+        // A notification should be provided for the peer file description even when it can
+        // only write 1 byte. This implementation is not compliant with the actual Linux kernel
+        // implementation. For optimization reasons, the kernel will only mark the file description
+        // as "writable" when it can write more than a certain number of bytes. Since we
+        // don't know what that *certain number* is, we will provide a notification every time
+        // a read is successful. This might result in our epoll emulation providing more
+        // notifications than the real system.
+        if let Some(peer_fd) = self.peer_fd.upgrade() {
+            peer_fd.check_and_update_readiness(ecx)?;
+        }
+
         return Ok(Ok(actual_read_size));
     }
 
     fn write<'tcx>(
         &mut self,
         _communicate_allowed: bool,
+        _fd_id: FdId,
         bytes: &[u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -131,6 +197,14 @@ impl FileDescription for SocketPair {
         // Do full write / partial write based on the space available.
         let actual_write_size = write_size.min(available_space);
         writebuf.buf.extend(&bytes[..actual_write_size]);
+
+        // The writebuf needs to be explicitly dropped because it will cause panic when
+        // check_and_update_readiness borrows it again.
+        drop(writebuf);
+        // Notification should be provided for peer fd as it became readable.
+        if let Some(peer_fd) = self.peer_fd.upgrade() {
+            peer_fd.check_and_update_readiness(ecx)?;
+        }
         return Ok(Ok(actual_write_size));
     }
 }
@@ -209,18 +283,33 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let socketpair_0 = SocketPair {
             writebuf: Rc::downgrade(&buffer1),
             readbuf: Rc::clone(&buffer2),
+            peer_fd: WeakFileDescriptionRef::default(),
             is_nonblock: is_sock_nonblock,
         };
-
         let socketpair_1 = SocketPair {
             writebuf: Rc::downgrade(&buffer2),
             readbuf: Rc::clone(&buffer1),
+            peer_fd: WeakFileDescriptionRef::default(),
             is_nonblock: is_sock_nonblock,
         };
 
+        // Insert the file description to the fd table.
         let fds = &mut this.machine.fds;
         let sv0 = fds.insert_new(socketpair_0);
         let sv1 = fds.insert_new(socketpair_1);
+
+        // Get weak file descriptor and file description id value.
+        let fd_ref0 = fds.get_ref(sv0).unwrap();
+        let fd_ref1 = fds.get_ref(sv1).unwrap();
+        let weak_fd_ref0 = fd_ref0.downgrade();
+        let weak_fd_ref1 = fd_ref1.downgrade();
+
+        // Update peer_fd and id field.
+        fd_ref1.borrow_mut().downcast_mut::<SocketPair>().unwrap().peer_fd = weak_fd_ref0;
+
+        fd_ref0.borrow_mut().downcast_mut::<SocketPair>().unwrap().peer_fd = weak_fd_ref1;
+
+        // Return socketpair file description value to the caller.
         let sv0 = Scalar::from_int(sv0, sv.layout.size);
         let sv1 = Scalar::from_int(sv1, sv.layout.size);
 
diff --git a/src/tools/miri/tests/fail-dep/tokio/sleep.rs b/src/tools/miri/tests/fail-dep/tokio/sleep.rs
index d96d778e6ca40..0fa5080d48460 100644
--- a/src/tools/miri/tests/fail-dep/tokio/sleep.rs
+++ b/src/tools/miri/tests/fail-dep/tokio/sleep.rs
@@ -1,6 +1,6 @@
 //@compile-flags: -Zmiri-permissive-provenance -Zmiri-backtrace=full
 //@only-target-x86_64-unknown-linux: support for tokio only on linux and x86
-//@error-in-other-file: returning ready events from epoll_wait is not yet implemented
+//@error-in-other-file: timeout value can only be 0
 //@normalize-stderr-test: " += note:.*\n" -> ""
 
 use tokio::time::{sleep, Duration, Instant};
diff --git a/src/tools/miri/tests/fail-dep/tokio/sleep.stderr b/src/tools/miri/tests/fail-dep/tokio/sleep.stderr
index 6d19faab90570..d5bf00fc17503 100644
--- a/src/tools/miri/tests/fail-dep/tokio/sleep.stderr
+++ b/src/tools/miri/tests/fail-dep/tokio/sleep.stderr
@@ -1,4 +1,4 @@
-error: unsupported operation: returning ready events from epoll_wait is not yet implemented
+error: unsupported operation: epoll_wait: timeout value can only be 0
   --> CARGO_REGISTRY/.../epoll.rs:LL:CC
    |
 LL | /         syscall!(epoll_wait(
@@ -7,7 +7,7 @@ LL | |             events.as_mut_ptr(),
 LL | |             events.capacity() as i32,
 LL | |             timeout,
 LL | |         ))
-   | |__________^ returning ready events from epoll_wait is not yet implemented
+   | |__________^ epoll_wait: timeout value can only be 0
    |
    = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
 
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
new file mode 100644
index 0000000000000..11a0257dc4e3d
--- /dev/null
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -0,0 +1,552 @@
+//@only-target-linux
+
+#![feature(exposed_provenance)] // Needed for fn test_pointer()
+use std::convert::TryInto;
+use std::mem::MaybeUninit;
+
+fn main() {
+    test_event_overwrite();
+    test_not_fully_closed_fd();
+    test_closed_fd();
+    test_epoll_socketpair_special_case();
+    test_two_epoll_instance();
+    test_epoll_ctl_mod();
+    test_epoll_socketpair();
+    test_epoll_eventfd();
+    test_epoll_ctl_del();
+    test_pointer();
+    test_two_same_fd_in_same_epoll_instance();
+    test_socketpair_read();
+}
+
+fn check_epoll_wait<const N: usize>(
+    epfd: i32,
+    mut expected_notifications: Vec<(u32, u64)>,
+) -> bool {
+    let epoll_event = libc::epoll_event { events: 0, u64: 0 };
+    let mut array: [libc::epoll_event; N] = [epoll_event; N];
+    let maxsize = N;
+    let array_ptr = array.as_mut_ptr();
+    let res = unsafe { libc::epoll_wait(epfd, array_ptr, maxsize.try_into().unwrap(), 0) };
+    assert_eq!(res, expected_notifications.len().try_into().unwrap());
+    let slice = unsafe { std::slice::from_raw_parts(array_ptr, res.try_into().unwrap()) };
+    let mut return_events = slice.iter();
+    while let Some(return_event) = return_events.next() {
+        if let Some(notification) = expected_notifications.pop() {
+            let event = return_event.events;
+            let data = return_event.u64;
+            assert_eq!(event, notification.0);
+            assert_eq!(data, notification.1);
+        } else {
+            return false;
+        }
+    }
+    if !expected_notifications.is_empty() {
+        return false;
+    }
+    return true;
+}
+
+fn test_epoll_socketpair() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let mut res =
+        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Write to fd[0]
+    let data = "abcde".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
+
+    // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET
+    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLRDHUP).unwrap() | epollet;
+    let mut ev = libc::epoll_event {
+        events: u32::try_from(flags).unwrap(),
+        u64: u64::try_from(fds[1]).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_ne!(res, -1);
+
+    // Check result from epoll_wait.
+    let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_value = u64::try_from(fds[1]).unwrap();
+    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+
+    // Close the peer socketpair.
+    let res = unsafe { libc::close(fds[0]) };
+    assert_eq!(res, 0);
+
+    // Check result from epoll_wait.
+    let expected_event = u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_value = u64::try_from(fds[1]).unwrap();
+    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+}
+
+fn test_epoll_ctl_mod() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let mut res =
+        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Write to fd[0].
+    let data = "abcde".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
+
+    // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET.
+    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
+    let epollet = libc::EPOLLET as u32;
+    let mut flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
+    let mut ev = libc::epoll_event {
+        events: u32::try_from(flags).unwrap(),
+        u64: u64::try_from(fds[1]).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_ne!(res, -1);
+
+    // Check result from epoll_wait.
+    let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_value = u64::try_from(fds[1]).unwrap();
+    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+
+    // Test EPOLLRDHUP.
+    flags |= u32::try_from(libc::EPOLLRDHUP).unwrap();
+    let mut ev = libc::epoll_event {
+        events: u32::try_from(flags).unwrap(),
+        u64: u64::try_from(fds[1]).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_MOD, fds[1], &mut ev) };
+    assert_ne!(res, -1);
+
+    // Close the other side of the socketpair to invoke EPOLLRDHUP.
+    let res = unsafe { libc::close(fds[0]) };
+    assert_eq!(res, 0);
+
+    // Check result from epoll_wait.
+    let expected_event = u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_value = u64::try_from(fds[1]).unwrap();
+    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+}
+
+fn test_epoll_ctl_del() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let mut res =
+        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Write to fd[0]
+    let data = "abcde".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
+
+    // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET
+    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
+    let mut ev = libc::epoll_event {
+        events: u32::try_from(flags).unwrap(),
+        u64: u64::try_from(fds[1]).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_ne!(res, -1);
+
+    // Test EPOLL_CTL_DEL.
+    assert!(check_epoll_wait::<0>(epfd, vec![]));
+}
+
+// This test is for one fd registered under two different epoll instance.
+fn test_two_epoll_instance() {
+    // Create two epoll instance.
+    let epfd1 = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd1, -1);
+    let epfd2 = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd2, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let mut res =
+        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Write to the socketpair.
+    let data = "abcde".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
+
+    // Register one side of the socketpair with EPOLLIN | EPOLLOUT | EPOLLET.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
+    let mut ev = libc::epoll_event {
+        events: u32::try_from(flags).unwrap(),
+        u64: u64::try_from(fds[1]).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd1, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_ne!(res, -1);
+    let res = unsafe { libc::epoll_ctl(epfd2, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_ne!(res, -1);
+
+    // Notification should be received from both instance of epoll.
+    let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_value = u64::try_from(fds[1]).unwrap();
+    assert!(check_epoll_wait::<8>(epfd1, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd2, vec![(expected_event, expected_value)]));
+}
+
+// This test is for two same file description registered under the same epoll instance through dup.
+// Notification should be provided for both.
+fn test_two_same_fd_in_same_epoll_instance() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Dup the fd.
+    let newfd = unsafe { libc::dup(fds[1]) };
+    assert_ne!(newfd, -1);
+
+    // Register both fd to the same epoll instance.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
+    let mut ev = libc::epoll_event { events: u32::try_from(flags).unwrap(), u64: 5 as u64 };
+    let mut res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_ne!(res, -1);
+    res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, newfd, &mut ev) };
+    assert_ne!(res, -1);
+
+    // Write to the socketpair.
+    let data = "abcde".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
+
+    //Two notification should be received.
+    let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_value = 5 as u64;
+    assert!(check_epoll_wait::<8>(
+        epfd,
+        vec![(expected_event, expected_value), (expected_event, expected_value)]
+    ));
+}
+
+fn test_epoll_eventfd() {
+    // Create an eventfd instance.
+    let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
+    let fd = unsafe { libc::eventfd(0, flags) };
+
+    // Write to the eventfd instance.
+    let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
+    let res: i32 = unsafe {
+        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
+    };
+    assert_eq!(res, 8);
+
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
+    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
+    let mut ev = libc::epoll_event {
+        events: u32::try_from(flags).unwrap(),
+        u64: u64::try_from(fd).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
+    assert_ne!(res, -1);
+
+    // Check result from epoll_wait.
+    let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_value = u64::try_from(fd).unwrap();
+    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+}
+
+fn test_pointer() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET
+    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLRDHUP).unwrap() | epollet;
+    let data = MaybeUninit::<u64>::uninit().as_ptr();
+    let mut ev = libc::epoll_event {
+        events: u32::try_from(flags).unwrap(),
+        u64: data.expose_provenance() as u64,
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_ne!(res, -1);
+}
+
+// When read/write happened on one side of the socketpair, only the other side will be notified.
+fn test_epoll_socketpair_special_case() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Register both fd to the same epoll instance.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
+    let mut ev = libc::epoll_event { events: u32::try_from(flags).unwrap(), u64: fds[0] as u64 };
+    let mut res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[0], &mut ev) };
+    assert_ne!(res, -1);
+    let mut ev = libc::epoll_event { events: u32::try_from(flags).unwrap(), u64: fds[1] as u64 };
+    res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_ne!(res, -1);
+
+    // Write to fds[1].
+    let data = "abcde".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
+
+    //Two notification should be received.
+    let expected_event0 = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_value0 = fds[0] as u64;
+    let expected_event1 = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value1 = fds[1] as u64;
+    assert!(check_epoll_wait::<8>(
+        epfd,
+        vec![(expected_event1, expected_value1), (expected_event0, expected_value0)]
+    ));
+
+    // Read from fds[0].
+    let mut buf: [u8; 5] = [0; 5];
+    res = unsafe {
+        libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+    };
+    assert_eq!(res, 5);
+    assert_eq!(buf, "abcde".as_bytes());
+
+    // Notification should be provided for fds[1].
+    let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value = fds[1] as u64;
+    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+}
+
+// When file description is fully closed, epoll_wait should not provide any notification for
+// that file description.
+fn test_closed_fd() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create an eventfd instance.
+    let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
+    let fd = unsafe { libc::eventfd(0, flags) };
+
+    // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
+    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
+    let mut ev = libc::epoll_event {
+        events: u32::try_from(flags).unwrap(),
+        u64: u64::try_from(fd).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
+    assert_ne!(res, -1);
+
+    // Write to the eventfd instance.
+    let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
+    let res: i32 = unsafe {
+        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
+    };
+    assert_eq!(res, 8);
+
+    // Close the eventfd.
+    let res = unsafe { libc::close(fd) };
+    assert_eq!(res, 0);
+
+    // No notification should be provided because the file description is closed.
+    assert!(check_epoll_wait::<8>(epfd, vec![]));
+}
+
+// When a certain file descriptor registered with epoll is closed, but the underlying file description
+// is not closed, notification should still be provided.
+//
+// This is a quirk of epoll being described in https://man7.org/linux/man-pages/man7/epoll.7.html
+// A file descriptor is removed from an interest list only after all the file descriptors
+// referring to the underlying open file description have been closed.
+fn test_not_fully_closed_fd() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create an eventfd instance.
+    let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
+    let fd = unsafe { libc::eventfd(0, flags) };
+
+    // Dup the fd.
+    let newfd = unsafe { libc::dup(fd) };
+    assert_ne!(newfd, -1);
+
+    // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
+    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
+    let mut ev = libc::epoll_event {
+        events: u32::try_from(flags).unwrap(),
+        u64: u64::try_from(fd).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
+    assert_ne!(res, -1);
+
+    // Close the original fd that being used to register with epoll.
+    let res = unsafe { libc::close(fd) };
+    assert_eq!(res, 0);
+
+    // Notification should still be provided because the file description is not closed.
+    let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value = fd as u64;
+    assert!(check_epoll_wait::<1>(epfd, vec![(expected_event, expected_value)]));
+
+    // Write to the eventfd instance to produce notification.
+    let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
+    let res: i32 = unsafe {
+        libc::write(newfd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
+    };
+    assert_eq!(res, 8);
+
+    // Close the dupped fd.
+    let res = unsafe { libc::close(newfd) };
+    assert_eq!(res, 0);
+
+    // No notification should be provided.
+    assert!(check_epoll_wait::<1>(epfd, vec![]));
+}
+
+// Each time a notification is provided, it should reflect the file description's readiness
+// at the moment the latest event occurred.
+fn test_event_overwrite() {
+    // Create an eventfd instance.
+    let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
+    let fd = unsafe { libc::eventfd(0, flags) };
+
+    // Write to the eventfd instance.
+    let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
+    let res: i32 = unsafe {
+        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
+    };
+    assert_eq!(res, 8);
+
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
+    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
+    let mut ev = libc::epoll_event {
+        events: u32::try_from(flags).unwrap(),
+        u64: u64::try_from(fd).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
+    assert_ne!(res, -1);
+
+    // Read from the eventfd instance.
+    let mut buf: [u8; 8] = [0; 8];
+    let res: i32 = unsafe { libc::read(fd, buf.as_mut_ptr().cast(), 8).try_into().unwrap() };
+    assert_eq!(res, 8);
+
+    // Check result from epoll_wait.
+    let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value = u64::try_from(fd).unwrap();
+    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+}
+
+// An epoll notification will be provided for every succesful read in a socketpair.
+// This behaviour differs from the real system.
+fn test_socketpair_read() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Register both fd to the same epoll instance.
+    let epollet = libc::EPOLLET as u32;
+    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
+    let mut ev = libc::epoll_event { events: u32::try_from(flags).unwrap(), u64: fds[0] as u64 };
+    let mut res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[0], &mut ev) };
+    assert_ne!(res, -1);
+    let mut ev = libc::epoll_event { events: u32::try_from(flags).unwrap(), u64: fds[1] as u64 };
+    res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_ne!(res, -1);
+
+    // Write 5 bytes to fds[1].
+    let data = "abcde".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
+
+    //Two notification should be received.
+    let expected_event0 = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_value0 = fds[0] as u64;
+    let expected_event1 = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value1 = fds[1] as u64;
+    assert!(check_epoll_wait::<8>(
+        epfd,
+        vec![(expected_event1, expected_value1), (expected_event0, expected_value0)]
+    ));
+
+    // Read 3 bytes from fds[0].
+    let mut buf: [u8; 3] = [0; 3];
+    res = unsafe {
+        libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+    };
+    assert_eq!(res, 3);
+    assert_eq!(buf, "abc".as_bytes());
+
+    // Notification will be provided.
+    // But in real system, no notification will be provided here.
+    let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value = fds[1] as u64;
+    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+
+    // Read until the buffer is empty.
+    let mut buf: [u8; 2] = [0; 2];
+    res = unsafe {
+        libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+    };
+    assert_eq!(res, 2);
+    assert_eq!(buf, "de".as_bytes());
+
+    // Notification will be provided.
+    // In real system, notification will be provided too.
+    let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value = fds[1] as u64;
+    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+}

From 5ae03863ded632b6cedeed29cc53e9c69fe5b56b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 4 Jun 2024 11:50:18 +0200
Subject: [PATCH 265/685] CommandExt::before_exec: deprecate safety in edition
 2024

---
 library/std/src/os/unix/process.rs              | 14 +++++++++++---
 .../rust-2024/unsafe-before_exec.e2024.stderr   | 11 +++++++++++
 tests/ui/rust-2024/unsafe-before_exec.rs        | 17 +++++++++++++++++
 3 files changed, 39 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/rust-2024/unsafe-before_exec.e2024.stderr
 create mode 100644 tests/ui/rust-2024/unsafe-before_exec.rs

diff --git a/library/std/src/os/unix/process.rs b/library/std/src/os/unix/process.rs
index c53423675bd00..46202441d4e38 100644
--- a/library/std/src/os/unix/process.rs
+++ b/library/std/src/os/unix/process.rs
@@ -109,13 +109,21 @@ pub trait CommandExt: Sealed {
     /// Schedules a closure to be run just before the `exec` function is
     /// invoked.
     ///
-    /// This method is stable and usable, but it should be unsafe. To fix
-    /// that, it got deprecated in favor of the unsafe [`pre_exec`].
+    /// `before_exec` used to be a safe method, but it needs to be unsafe since the closure may only
+    /// perform operations that are *async-signal-safe*. Hence it got deprecated in favor of the
+    /// unsafe [`pre_exec`]. Meanwhile, Rust gained the ability to make an existing safe method
+    /// fully unsafe in a new edition, which is how `before_exec` became `unsafe`. It still also
+    /// remains deprecated; `pre_exec` should be used instead.
     ///
     /// [`pre_exec`]: CommandExt::pre_exec
     #[stable(feature = "process_exec", since = "1.15.0")]
     #[deprecated(since = "1.37.0", note = "should be unsafe, use `pre_exec` instead")]
-    fn before_exec<F>(&mut self, f: F) -> &mut process::Command
+    #[cfg_attr(bootstrap, rustc_deprecated_safe_2024)]
+    #[cfg_attr(
+        not(bootstrap),
+        rustc_deprecated_safe_2024(audit_that = "the closure is async-signal-safe")
+    )]
+    unsafe fn before_exec<F>(&mut self, f: F) -> &mut process::Command
     where
         F: FnMut() -> io::Result<()> + Send + Sync + 'static,
     {
diff --git a/tests/ui/rust-2024/unsafe-before_exec.e2024.stderr b/tests/ui/rust-2024/unsafe-before_exec.e2024.stderr
new file mode 100644
index 0000000000000..2798ccdefd0c6
--- /dev/null
+++ b/tests/ui/rust-2024/unsafe-before_exec.e2024.stderr
@@ -0,0 +1,11 @@
+error[E0133]: call to unsafe function `before_exec` is unsafe and requires unsafe block
+  --> $DIR/unsafe-before_exec.rs:14:5
+   |
+LL |     cmd.before_exec(|| Ok(()));
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
+   |
+   = note: consult the function's documentation for information on how to avoid undefined behavior
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/rust-2024/unsafe-before_exec.rs b/tests/ui/rust-2024/unsafe-before_exec.rs
new file mode 100644
index 0000000000000..540394da80ef8
--- /dev/null
+++ b/tests/ui/rust-2024/unsafe-before_exec.rs
@@ -0,0 +1,17 @@
+//@ revisions: e2021 e2024
+//@ only-unix
+//@[e2021] edition: 2021
+//@[e2021] check-pass
+//@[e2024] edition: 2024
+//@[e2024] compile-flags: -Zunstable-options
+
+use std::process::Command;
+use std::os::unix::process::CommandExt;
+
+#[allow(deprecated)]
+fn main() {
+    let mut cmd = Command::new("sleep");
+    cmd.before_exec(|| Ok(()));
+    //[e2024]~^ ERROR call to unsafe function `before_exec` is unsafe
+    drop(cmd); // we don't actually run the command.
+}

From 6eaf531432147c0359fc1d3d959ee525851e7ced Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 14 Aug 2024 14:30:23 +0200
Subject: [PATCH 266/685] add Box::as_ptr and Box::as_mut_ptr methods

---
 library/alloc/src/boxed.rs   | 89 ++++++++++++++++++++++++++++++++++++
 library/alloc/src/vec/mod.rs |  3 +-
 2 files changed, 90 insertions(+), 2 deletions(-)

diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index 7de412595993a..0fe915bb838ca 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -1254,6 +1254,95 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
         unsafe { (Unique::from(&mut *ptr), alloc) }
     }
 
+    /// Returns a raw mutable pointer to the `Box`'s contents.
+    ///
+    /// The caller must ensure that the `Box` outlives the pointer this
+    /// function returns, or else it will end up dangling.
+    ///
+    /// This method guarantees that for the purpose of the aliasing model, this method
+    /// does not materialize a reference to the underlying memory, and thus the returned pointer
+    /// will remain valid when mixed with other calls to [`as_ptr`] and [`as_mut_ptr`].
+    /// Note that calling other methods that materialize references to the memory
+    /// may still invalidate this pointer.
+    /// See the example below for how this guarantee can be used.
+    ///
+    /// # Examples
+    ///
+    /// Due to the aliasing guarantee, the following code is legal:
+    ///
+    /// ```rust
+    /// #![feature(box_as_ptr)]
+    ///
+    /// unsafe {
+    ///     let mut b = Box::new(0);
+    ///     let ptr1 = Box::as_mut_ptr(&mut b);
+    ///     ptr1.write(1);
+    ///     let ptr2 = Box::as_mut_ptr(&mut b);
+    ///     ptr2.write(2);
+    ///     // Notably, the write to `ptr2` did *not* invalidate `ptr1`:
+    ///     ptr1.write(3);
+    /// }
+    /// ```
+    ///
+    /// [`as_mut_ptr`]: Self::as_mut_ptr
+    /// [`as_ptr`]: Self::as_ptr
+    #[unstable(feature = "box_as_ptr", issue = "129090")]
+    #[rustc_never_returns_null_ptr]
+    #[inline]
+    pub fn as_mut_ptr(b: &mut Self) -> *mut T {
+        // This is a primitive deref, not going through `DerefMut`, and therefore not materializing
+        // any references.
+        ptr::addr_of_mut!(**b)
+    }
+
+    /// Returns a raw pointer to the `Box`'s contents.
+    ///
+    /// The caller must ensure that the `Box` outlives the pointer this
+    /// function returns, or else it will end up dangling.
+    ///
+    /// The caller must also ensure that the memory the pointer (non-transitively) points to
+    /// is never written to (except inside an `UnsafeCell`) using this pointer or any pointer
+    /// derived from it. If you need to mutate the contents of the `Box`, use [`as_mut_ptr`].
+    ///
+    /// This method guarantees that for the purpose of the aliasing model, this method
+    /// does not materialize a reference to the underlying memory, and thus the returned pointer
+    /// will remain valid when mixed with other calls to [`as_ptr`] and [`as_mut_ptr`].
+    /// Note that calling other methods that materialize mutable references to the memory,
+    /// as well as writing to this memory, may still invalidate this pointer.
+    /// See the example below for how this guarantee can be used.
+    ///
+    /// # Examples
+    ///
+    /// Due to the aliasing guarantee, the following code is legal:
+    ///
+    /// ```rust
+    /// #![feature(box_as_ptr)]
+    ///
+    /// unsafe {
+    ///     let mut v = Box::new(0);
+    ///     let ptr1 = Box::as_ptr(&v);
+    ///     let ptr2 = Box::as_mut_ptr(&mut v);
+    ///     let _val = ptr2.read();
+    ///     // No write to this memory has happened yet, so `ptr1` is still valid.
+    ///     let _val = ptr1.read();
+    ///     // However, once we do a write...
+    ///     ptr2.write(1);
+    ///     // ... `ptr1` is no longer valid.
+    ///     // This would be UB: let _val = ptr1.read();
+    /// }
+    /// ```
+    ///
+    /// [`as_mut_ptr`]: Self::as_mut_ptr
+    /// [`as_ptr`]: Self::as_ptr
+    #[unstable(feature = "box_as_ptr", issue = "129090")]
+    #[rustc_never_returns_null_ptr]
+    #[inline]
+    pub fn as_ptr(b: &Self) -> *const T {
+        // This is a primitive deref, not going through `DerefMut`, and therefore not materializing
+        // any references.
+        ptr::addr_of!(**b)
+    }
+
     /// Returns a reference to the underlying allocator.
     ///
     /// Note: this is an associated function, which means that you have
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index b4e0bc5fcbe41..cfd2e4a15121a 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -1334,7 +1334,7 @@ impl<T, A: Allocator> Vec<T, A> {
         self.buf.ptr()
     }
 
-    /// Returns an unsafe mutable pointer to the vector's buffer, or a dangling
+    /// Returns a raw mutable pointer to the vector's buffer, or a dangling
     /// raw pointer valid for zero sized reads if the vector didn't allocate.
     ///
     /// The caller must ensure that the vector outlives the pointer this
@@ -1350,7 +1350,6 @@ impl<T, A: Allocator> Vec<T, A> {
     /// may still invalidate this pointer.
     /// See the second example below for how this guarantee can be used.
     ///
-    ///
     /// # Examples
     ///
     /// ```

From 58dcd1c2e6f020369e9e9c0d8ad76435cb34a6f3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 14 Aug 2024 14:32:17 +0200
Subject: [PATCH 267/685] use the new Box methods in the interpreter

---
 compiler/rustc_middle/src/lib.rs                      | 1 +
 compiler/rustc_middle/src/mir/interpret/allocation.rs | 6 ++----
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index 5bd7736a3f3cc..6886562d9b76d 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -34,6 +34,7 @@
 #![feature(allocator_api)]
 #![feature(array_windows)]
 #![feature(assert_matches)]
+#![feature(box_as_ptr)]
 #![feature(box_patterns)]
 #![feature(closure_track_caller)]
 #![feature(const_option)]
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs
index 665ab2797f21f..3e101c0c6354d 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation.rs
@@ -62,13 +62,11 @@ impl AllocBytes for Box<[u8]> {
     }
 
     fn as_mut_ptr(&mut self) -> *mut u8 {
-        // Carefully avoiding any intermediate references.
-        ptr::addr_of_mut!(**self).cast()
+        Box::as_mut_ptr(self).cast()
     }
 
     fn as_ptr(&self) -> *const u8 {
-        // Carefully avoiding any intermediate references.
-        ptr::addr_of!(**self).cast()
+        Box::as_ptr(self).cast()
     }
 }
 

From 5e04cefb01151aa8b09ef311d043cffde0a514ca Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Tue, 30 Jul 2024 14:20:16 -0400
Subject: [PATCH 268/685] rewrite min-global-align to rmake

---
 .../run-make-support/src/assertion_helpers.rs | 14 ++++++++++
 src/tools/run-make-support/src/lib.rs         |  2 +-
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 tests/run-make/min-global-align/Makefile      | 22 ---------------
 tests/run-make/min-global-align/rmake.rs      | 27 +++++++++++++++++++
 5 files changed, 42 insertions(+), 24 deletions(-)
 delete mode 100644 tests/run-make/min-global-align/Makefile
 create mode 100644 tests/run-make/min-global-align/rmake.rs

diff --git a/src/tools/run-make-support/src/assertion_helpers.rs b/src/tools/run-make-support/src/assertion_helpers.rs
index 6d256fc594d8e..b4da65aff4ab1 100644
--- a/src/tools/run-make-support/src/assertion_helpers.rs
+++ b/src/tools/run-make-support/src/assertion_helpers.rs
@@ -77,6 +77,20 @@ pub fn assert_not_contains_regex<H: AsRef<str>, N: AsRef<str>>(haystack: H, need
     }
 }
 
+/// Assert that `haystack` contains `needle` a `count` number of times.
+#[track_caller]
+pub fn assert_count_is<H: AsRef<str>, N: AsRef<str>>(count: usize, haystack: H, needle: N) {
+    let haystack = haystack.as_ref();
+    let needle = needle.as_ref();
+    if count != haystack.matches(needle).count() {
+        eprintln!("=== HAYSTACK ===");
+        eprintln!("{}", haystack);
+        eprintln!("=== NEEDLE ===");
+        eprintln!("{}", needle);
+        panic!("needle did not appear {count} times in haystack");
+    }
+}
+
 /// Assert that all files in `dir1` exist and have the same content in `dir2`
 pub fn assert_dirs_are_equal(dir1: impl AsRef<Path>, dir2: impl AsRef<Path>) {
     let dir2 = dir2.as_ref();
diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
index 4d0c1b0930ced..4bef4f0500784 100644
--- a/src/tools/run-make-support/src/lib.rs
+++ b/src/tools/run-make-support/src/lib.rs
@@ -87,7 +87,7 @@ pub use path_helpers::{
 pub use scoped_run::{run_in_tmpdir, test_while_readonly};
 
 pub use assertion_helpers::{
-    assert_contains, assert_contains_regex, assert_dirs_are_equal, assert_equals,
+    assert_contains, assert_contains_regex, assert_count_is, assert_dirs_are_equal, assert_equals,
     assert_not_contains, assert_not_contains_regex,
 };
 
diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 2d25de46f6e4a..3752e933f9960 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -13,7 +13,6 @@ run-make/libtest-json/Makefile
 run-make/libtest-junit/Makefile
 run-make/libtest-thread-limit/Makefile
 run-make/macos-deployment-target/Makefile
-run-make/min-global-align/Makefile
 run-make/native-link-modifier-bundle/Makefile
 run-make/no-alloc-shim/Makefile
 run-make/reproducible-build/Makefile
diff --git a/tests/run-make/min-global-align/Makefile b/tests/run-make/min-global-align/Makefile
deleted file mode 100644
index 82f38749e0092..0000000000000
--- a/tests/run-make/min-global-align/Makefile
+++ /dev/null
@@ -1,22 +0,0 @@
-include ../tools.mk
-
-# only-linux
-
-# This tests ensure that global variables respect the target minimum alignment.
-# The three bools `STATIC_BOOL`, `STATIC_MUT_BOOL`, and `CONST_BOOL` all have
-# type-alignment of 1, but some targets require greater global alignment.
-
-SRC = min_global_align.rs
-LL = $(TMPDIR)/min_global_align.ll
-
-all:
-# Most targets are happy with default alignment -- take i686 for example.
-ifeq ($(filter x86,$(LLVM_COMPONENTS)),x86)
-	$(RUSTC) --target=i686-unknown-linux-gnu --emit=llvm-ir $(SRC)
-	[ "$$(grep -c 'align 1' "$(LL)")" -eq "3" ]
-endif
-# SystemZ requires even alignment for PC-relative addressing.
-ifeq ($(filter systemz,$(LLVM_COMPONENTS)),systemz)
-	$(RUSTC) --target=s390x-unknown-linux-gnu --emit=llvm-ir $(SRC)
-	[ "$$(grep -c 'align 2' "$(LL)")" -eq "3" ]
-endif
diff --git a/tests/run-make/min-global-align/rmake.rs b/tests/run-make/min-global-align/rmake.rs
new file mode 100644
index 0000000000000..0db82b8340d42
--- /dev/null
+++ b/tests/run-make/min-global-align/rmake.rs
@@ -0,0 +1,27 @@
+// This tests ensure that global variables respect the target minimum alignment.
+// The three bools `STATIC_BOOL`, `STATIC_MUT_BOOL`, and `CONST_BOOL` all have
+// type-alignment of 1, but some targets require greater global alignment.
+// See https://github.com/rust-lang/rust/pull/44440
+
+//@ only-linux
+// Reason: this test is target-independent, considering compilation is targeted
+// towards linux architectures only.
+
+use run_make_support::{assert_count_is, llvm_components_contain, rfs, rustc};
+
+fn main() {
+    // Most targets are happy with default alignment -- take i686 for example.
+    if llvm_components_contain("x86") {
+        rustc().target("i686-unknown-linux-gnu").emit("llvm-ir").input("min_global_align.rs").run();
+        assert_count_is(3, rfs::read_to_string("min_global_align.ll"), "align 1");
+    }
+    // SystemZ requires even alignment for PC-relative addressing.
+    if llvm_components_contain("systemz") {
+        rustc()
+            .target("s390x-unknown-linux-gnu")
+            .emit("llvm-ir")
+            .input("min_global_align.rs")
+            .run();
+        assert_count_is(3, rfs::read_to_string("min_global_align.ll"), "align 2");
+    }
+}

From b85bedcb24e31636e47c724e0a1cbedf09d03158 Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Tue, 30 Jul 2024 14:39:11 -0400
Subject: [PATCH 269/685] rewrite no-alloc-shim to rmake

---
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 tests/run-make/min-global-align/rmake.rs      |  4 +-
 tests/run-make/no-alloc-shim/Makefile         | 24 --------
 tests/run-make/no-alloc-shim/rmake.rs         | 55 +++++++++++++++++++
 4 files changed, 57 insertions(+), 27 deletions(-)
 delete mode 100644 tests/run-make/no-alloc-shim/Makefile
 create mode 100644 tests/run-make/no-alloc-shim/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 3752e933f9960..cd232f5140848 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -14,7 +14,6 @@ run-make/libtest-junit/Makefile
 run-make/libtest-thread-limit/Makefile
 run-make/macos-deployment-target/Makefile
 run-make/native-link-modifier-bundle/Makefile
-run-make/no-alloc-shim/Makefile
 run-make/reproducible-build/Makefile
 run-make/rlib-format-packed-bundled-libs/Makefile
 run-make/split-debuginfo/Makefile
diff --git a/tests/run-make/min-global-align/rmake.rs b/tests/run-make/min-global-align/rmake.rs
index 0db82b8340d42..2adaaf172f470 100644
--- a/tests/run-make/min-global-align/rmake.rs
+++ b/tests/run-make/min-global-align/rmake.rs
@@ -1,10 +1,10 @@
-// This tests ensure that global variables respect the target minimum alignment.
+// This test checks that global variables respect the target minimum alignment.
 // The three bools `STATIC_BOOL`, `STATIC_MUT_BOOL`, and `CONST_BOOL` all have
 // type-alignment of 1, but some targets require greater global alignment.
 // See https://github.com/rust-lang/rust/pull/44440
 
 //@ only-linux
-// Reason: this test is target-independent, considering compilation is targeted
+// Reason: this test is specific to linux, considering compilation is targeted
 // towards linux architectures only.
 
 use run_make_support::{assert_count_is, llvm_components_contain, rfs, rustc};
diff --git a/tests/run-make/no-alloc-shim/Makefile b/tests/run-make/no-alloc-shim/Makefile
deleted file mode 100644
index 568e3f9ba1d68..0000000000000
--- a/tests/run-make/no-alloc-shim/Makefile
+++ /dev/null
@@ -1,24 +0,0 @@
-include ../tools.mk
-
-# ignore-cross-compile
-# ignore-msvc FIXME(bjorn3) can't figure out how to link with the MSVC toolchain
-
-TARGET_LIBDIR = $$($(RUSTC) --print target-libdir)
-
-all:
-	$(RUSTC) foo.rs --crate-type bin --emit obj -Cpanic=abort
-ifdef IS_MSVC
-	$(CC) $(CFLAGS) $(TMPDIR)/foo.o $(call OUT_EXE,foo) /link $(TARGET_LIBDIR)/liballoc-*.rlib $(TARGET_LIBDIR)/libcore-*.rlib $(TARGET_LIBDIR)/libcompiler_builtins-*.rlib
-	$(call OUT_EXE,foo)
-else
-	$(CC) $(CFLAGS) $(TMPDIR)/foo.o $(TARGET_LIBDIR)/liballoc-*.rlib $(TARGET_LIBDIR)/libcore-*.rlib $(TARGET_LIBDIR)/libcompiler_builtins-*.rlib -o $(call RUN_BINFILE,foo)
-	$(call RUN_BINFILE,foo)
-endif
-
-	# Check that linking without __rust_no_alloc_shim_is_unstable defined fails
-	$(RUSTC) foo.rs --crate-type bin --emit obj -Cpanic=abort --cfg check_feature_gate
-ifdef IS_MSVC
-	$(CC) $(CFLAGS) $(TMPDIR)/foo.o $(call OUT_EXE,foo) /link $(TARGET_LIBDIR)/liballoc-*.rlib $(TARGET_LIBDIR)/libcore-*.rlib $(TARGET_LIBDIR)/libcompiler_builtins-*.rlib || exit 0 && exit 1
-else
-	$(CC) $(CFLAGS) $(TMPDIR)/foo.o $(TARGET_LIBDIR)/liballoc-*.rlib $(TARGET_LIBDIR)/libcore-*.rlib $(TARGET_LIBDIR)/libcompiler_builtins-*.rlib -o $(call RUN_BINFILE,foo) || exit 0 && exit 1
-endif
diff --git a/tests/run-make/no-alloc-shim/rmake.rs b/tests/run-make/no-alloc-shim/rmake.rs
new file mode 100644
index 0000000000000..c398a3177df63
--- /dev/null
+++ b/tests/run-make/no-alloc-shim/rmake.rs
@@ -0,0 +1,55 @@
+// This test checks the compatibility of the interaction between `--emit obj` and
+// `#[global_allocator]`, as it is now possible to invoke the latter without the
+// allocator shim since #86844. As this feature is unstable, it should fail if
+// --cfg check_feature_gate is passed.
+// See https://github.com/rust-lang/rust/pull/86844
+
+//@ ignore-cross-compile
+// Reason: the compiled binary is executed
+
+//@ ignore-msvc
+//FIXME(Oneirical): Getting this to work on MSVC requires passing libcmt.lib to CC,
+// which is not trivial to do.
+// Tracking issue: https://github.com/rust-lang/rust/issues/128602
+// Discussion: https://github.com/rust-lang/rust/pull/128407#discussion_r1702439172
+
+use run_make_support::{cc, cwd, has_extension, has_prefix, run, rustc, shallow_find_files};
+
+fn main() {
+    rustc().input("foo.rs").crate_type("bin").emit("obj").panic("abort").run();
+    let libdir = rustc().print("target-libdir").run().stdout_utf8();
+    let libdir = libdir.trim();
+
+    let alloc_libs = shallow_find_files(&libdir, |path| {
+        has_prefix(path, "liballoc-") && has_extension(path, "rlib")
+    });
+    let core_libs = shallow_find_files(&libdir, |path| {
+        has_prefix(path, "libcore-") && has_extension(path, "rlib")
+    });
+    let compiler_builtins_libs = shallow_find_files(libdir, |path| {
+        has_prefix(path, "libcompiler_builtins") && has_extension(path, "rlib")
+    });
+
+    cc().input("foo.o")
+        .out_exe("foo")
+        .args(&alloc_libs)
+        .args(&core_libs)
+        .args(&compiler_builtins_libs)
+        .run();
+    run("foo");
+
+    // Check that linking without __rust_no_alloc_shim_is_unstable defined fails
+    rustc()
+        .input("foo.rs")
+        .crate_type("bin")
+        .emit("obj")
+        .panic("abort")
+        .cfg("check_feature_gate")
+        .run();
+    cc().input("foo.o")
+        .out_exe("foo")
+        .args(&alloc_libs)
+        .args(&core_libs)
+        .args(&compiler_builtins_libs)
+        .run_fail();
+}

From e29360ce4d42d7bd2c57bcb6d8ddfe93b3ae33ad Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Wed, 14 Aug 2024 08:09:38 -0700
Subject: [PATCH 270/685] Update Cargo.lock

---
 src/tools/rustbook/Cargo.lock | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/src/tools/rustbook/Cargo.lock b/src/tools/rustbook/Cargo.lock
index df051ed447e51..3b859fe98c5ab 100644
--- a/src/tools/rustbook/Cargo.lock
+++ b/src/tools/rustbook/Cargo.lock
@@ -303,6 +303,12 @@ dependencies = [
  "crypto-common",
 ]
 
+[[package]]
+name = "doc-comment"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+
 [[package]]
 name = "elasticlunr-rs"
 version = "3.0.2"
@@ -465,6 +471,21 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "html_parser"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f56db07b6612644f6f7719f8ef944f75fff9d6378fdf3d316fd32194184abd"
+dependencies = [
+ "doc-comment",
+ "pest",
+ "pest_derive",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "thiserror",
+]
+
 [[package]]
 name = "humantime"
 version = "2.1.0"
@@ -680,13 +701,13 @@ name = "mdbook-trpl-listing"
 version = "0.1.0"
 dependencies = [
  "clap",
+ "html_parser",
  "mdbook",
  "pulldown-cmark",
  "pulldown-cmark-to-cmark",
  "serde_json",
  "thiserror",
  "toml 0.8.14",
- "xmlparser",
 ]
 
 [[package]]
@@ -1767,12 +1788,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "xmlparser"
-version = "0.13.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
-
 [[package]]
 name = "yaml-rust"
 version = "0.4.5"

From 4d21c735a27533396da7e8f15bc042ef22b96130 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Wed, 14 Aug 2024 08:14:28 +0300
Subject: [PATCH 271/685] create `const BUILDER_CONFIG_FILENAME` for
 builder-config file

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/config/config.rs | 10 +++++++++-
 src/bootstrap/src/core/download.rs      |  3 ++-
 src/bootstrap/src/utils/tarball.rs      |  3 ++-
 3 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index b955593ecf64d..5f1d923b3f852 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -36,6 +36,14 @@ macro_rules! check_ci_llvm {
     };
 }
 
+/// This file is embedded in the overlay directory of the tarball sources. It is
+/// useful in scenarios where developers want to see how the tarball sources were
+/// generated.
+///
+/// We also use this file to compare the host's config.toml against the CI rustc builder
+/// configuration to detect any incompatible options.
+pub(crate) const BUILDER_CONFIG_FILENAME: &str = "builder-config";
+
 #[derive(Clone, Default)]
 pub enum DryRun {
     /// This isn't a dry run.
@@ -2322,7 +2330,7 @@ impl Config {
 
                     if let Some(config_path) = &self.config {
                         let builder_config_path =
-                            self.out.join(self.build.triple).join("ci-rustc/builder-config");
+                            self.out.join(self.build.triple).join("ci-rustc").join(BUILDER_CONFIG_FILENAME);
                         let ci_config_toml = Self::get_toml(&builder_config_path);
                         let current_config_toml = Self::get_toml(config_path);
 
diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index a88b4a33856cf..3c4e47bf4434d 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -9,6 +9,7 @@ use std::sync::OnceLock;
 use build_helper::ci::CiEnv;
 use xz2::bufread::XzDecoder;
 
+use crate::core::config::BUILDER_CONFIG_FILENAME;
 use crate::utils::exec::{command, BootstrapCommand};
 use crate::utils::helpers::{check_run, exe, hex_encode, move_file, program_out_of_date};
 use crate::{t, Config};
@@ -288,7 +289,7 @@ impl Config {
                 continue;
             }
             let mut short_path = t!(original_path.strip_prefix(directory_prefix));
-            let is_builder_config = short_path.to_str() == Some("builder-config");
+            let is_builder_config = short_path.to_str() == Some(BUILDER_CONFIG_FILENAME);
 
             if !short_path.starts_with(pattern) && (is_ci_rustc && !is_builder_config) {
                 continue;
diff --git a/src/bootstrap/src/utils/tarball.rs b/src/bootstrap/src/utils/tarball.rs
index 3f7f6214cf682..3c6c7a7fa180a 100644
--- a/src/bootstrap/src/utils/tarball.rs
+++ b/src/bootstrap/src/utils/tarball.rs
@@ -9,6 +9,7 @@ use std::path::{Path, PathBuf};
 
 use crate::core::build_steps::dist::distdir;
 use crate::core::builder::{Builder, Kind};
+use crate::core::config::BUILDER_CONFIG_FILENAME;
 use crate::utils::exec::BootstrapCommand;
 use crate::utils::helpers::{move_file, t};
 use crate::utils::{channel, helpers};
@@ -320,7 +321,7 @@ impl<'a> Tarball<'a> {
 
         // Add config file if present.
         if let Some(config) = &self.builder.config.config {
-            self.add_renamed_file(config, &self.overlay_dir, "builder-config");
+            self.add_renamed_file(config, &self.overlay_dir, BUILDER_CONFIG_FILENAME);
         }
 
         for file in self.overlay.legal_and_readme() {

From 4d13470834bb651362c9af0dd56419ebc83d6293 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Wed, 14 Aug 2024 08:29:47 +0300
Subject: [PATCH 272/685] fix the incorrect `unpack`ing logic

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

diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index 3c4e47bf4434d..ef178fb633437 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -291,7 +291,7 @@ impl Config {
             let mut short_path = t!(original_path.strip_prefix(directory_prefix));
             let is_builder_config = short_path.to_str() == Some(BUILDER_CONFIG_FILENAME);
 
-            if !short_path.starts_with(pattern) && (is_ci_rustc && !is_builder_config) {
+            if !(short_path.starts_with(pattern) || (is_ci_rustc && is_builder_config)) {
                 continue;
             }
             short_path = short_path.strip_prefix(pattern).unwrap_or(short_path);

From 151e8cd2f84894c62b76d1bffa2b50ddb0bfcd9b Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Wed, 14 Aug 2024 11:11:40 +0300
Subject: [PATCH 273/685] improve
 `config::check_incompatible_options_for_ci_rustc` logs

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/config/config.rs | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 5f1d923b3f852..00c564a0e29e8 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -2681,10 +2681,11 @@ fn check_incompatible_options_for_ci_rustc(
                 if Some(current) != $expected.as_ref() {
                     return Err(format!(
                         "ERROR: Setting `rust.{}` is incompatible with `rust.download-rustc`. \
-                        Current value: {:?}, Expected value(s): None/{:?}",
+                        Current value: {:?}, Expected value(s): {}{:?}",
                         stringify!($expected).replace("_", "-"),
                         $current,
-                        $expected
+                        if $expected.is_some() { "None/" } else { "" },
+                        $expected,
                     ));
                 };
             };
@@ -2693,11 +2694,15 @@ fn check_incompatible_options_for_ci_rustc(
 
     macro_rules! warn {
         ($current:expr, $expected:expr) => {
-            if let Some(current) = $current {
-                if Some(current) != $expected {
+            if let Some(current) = &$current {
+                if Some(current) != $expected.as_ref() {
                     println!(
-                        "WARNING: `rust.{}` has no effect with `rust.download-rustc`.",
-                        stringify!($expected).replace("_", "-")
+                        "WARNING: `rust.{}` has no effect with `rust.download-rustc`. \
+                        Current value: {:?}, Expected value(s): {}{:?}",
+                        stringify!($expected).replace("_", "-"),
+                        $current,
+                        if $expected.is_some() { "None/" } else { "" },
+                        $expected,
                     );
                 };
             };

From 0935c8660355c30e890b3c0782d5d57f2f3f240f Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Wed, 14 Aug 2024 11:16:26 +0300
Subject: [PATCH 274/685] leave a FIXME note for `--set` flags coverage

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

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 00c564a0e29e8..6564641f54012 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -2335,6 +2335,7 @@ impl Config {
                         let current_config_toml = Self::get_toml(config_path);
 
                         // Check the config compatibility
+                        // FIXME: this doesn't cover `--set` flags yet.
                         let res = check_incompatible_options_for_ci_rustc(
                             current_config_toml,
                             ci_config_toml,

From 469d5937bf392d79557dc2c6b0548a7d32ab6465 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Wed, 14 Aug 2024 16:55:19 +0300
Subject: [PATCH 275/685] disable download-rustc if CI rustc has unsupported
 options

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/config/config.rs | 46 ++++++++++++++++++-------
 src/bootstrap/src/core/config/tests.rs  | 11 +++---
 2 files changed, 38 insertions(+), 19 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 6564641f54012..dac1fd3e4a524 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -1200,19 +1200,19 @@ impl Config {
     }
 
     #[cfg(test)]
-    fn get_toml(_: &Path) -> TomlConfig {
-        TomlConfig::default()
+    fn get_toml(_: &Path) -> Result<TomlConfig, toml::de::Error> {
+        Ok(TomlConfig::default())
     }
 
     #[cfg(not(test))]
-    fn get_toml(file: &Path) -> TomlConfig {
+    fn get_toml(file: &Path) -> Result<TomlConfig, toml::de::Error> {
         let contents =
             t!(fs::read_to_string(file), format!("config file {} not found", file.display()));
         // Deserialize to Value and then TomlConfig to prevent the Deserialize impl of
         // TomlConfig and sub types to be monomorphized 5x by toml.
         toml::from_str(&contents)
             .and_then(|table: toml::Value| TomlConfig::deserialize(table))
-            .unwrap_or_else(|err| {
+            .inspect_err(|_| {
                 if let Ok(Some(changes)) = toml::from_str(&contents)
                     .and_then(|table: toml::Value| ChangeIdWrapper::deserialize(table))
                     .map(|change_id| change_id.inner.map(crate::find_recent_config_change_ids))
@@ -1224,9 +1224,6 @@ impl Config {
                         );
                     }
                 }
-
-                eprintln!("failed to parse TOML configuration '{}': {err}", file.display());
-                exit!(2);
             })
     }
 
@@ -1234,7 +1231,10 @@ impl Config {
         Self::parse_inner(flags, Self::get_toml)
     }
 
-    pub(crate) fn parse_inner(mut flags: Flags, get_toml: impl Fn(&Path) -> TomlConfig) -> Config {
+    pub(crate) fn parse_inner(
+        mut flags: Flags,
+        get_toml: impl Fn(&Path) -> Result<TomlConfig, toml::de::Error>,
+    ) -> Config {
         let mut config = Config::default_opts();
 
         // Set flags.
@@ -1342,7 +1342,10 @@ impl Config {
             } else {
                 toml_path.clone()
             });
-            get_toml(&toml_path)
+            get_toml(&toml_path).unwrap_or_else(|e| {
+                eprintln!("ERROR: Failed to parse '{}': {e}", toml_path.display());
+                exit!(2);
+            })
         } else {
             config.config = None;
             TomlConfig::default()
@@ -1373,7 +1376,13 @@ impl Config {
             include_path.push("bootstrap");
             include_path.push("defaults");
             include_path.push(format!("config.{include}.toml"));
-            let included_toml = get_toml(&include_path);
+            let included_toml = get_toml(&include_path).unwrap_or_else(|e| {
+                eprintln!(
+                    "ERROR: Failed to parse default config profile at '{}': {e}",
+                    include_path.display()
+                );
+                exit!(2);
+            });
             toml.merge(included_toml, ReplaceOpt::IgnoreDuplicate);
         }
 
@@ -2331,8 +2340,21 @@ impl Config {
                     if let Some(config_path) = &self.config {
                         let builder_config_path =
                             self.out.join(self.build.triple).join("ci-rustc").join(BUILDER_CONFIG_FILENAME);
-                        let ci_config_toml = Self::get_toml(&builder_config_path);
-                        let current_config_toml = Self::get_toml(config_path);
+
+                        let ci_config_toml = match Self::get_toml(&builder_config_path) {
+                            Ok(ci_config_toml) => ci_config_toml,
+                            Err(e) if e.to_string().contains("unknown field") => {
+                                println!("WARNING: CI rustc has some fields that are no longer supported in bootstrap; download-rustc will be disabled.");
+                                println!("HELP: Consider rebasing to a newer commit if available.");
+                                return None;
+                            },
+                            Err(e) => {
+                                eprintln!("ERROR: Failed to parse CI rustc config at '{}': {e}", builder_config_path.display());
+                                exit!(2);
+                            },
+                        };
+
+                        let current_config_toml = Self::get_toml(config_path).unwrap();
 
                         // Check the config compatibility
                         // FIXME: this doesn't cover `--set` flags yet.
diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index 40f3e5e7222fa..378d069672f5d 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -14,7 +14,7 @@ use crate::core::config::{LldMode, Target, TargetSelection, TomlConfig};
 fn parse(config: &str) -> Config {
     Config::parse_inner(
         Flags::parse(&["check".to_string(), "--config=/does/not/exist".to_string()]),
-        |&_| toml::from_str(&config).unwrap(),
+        |&_| toml::from_str(&config),
     )
 }
 
@@ -151,7 +151,6 @@ runner = "x86_64-runner"
 
                 "#,
             )
-            .unwrap()
         },
     );
     assert_eq!(config.change_id, Some(1), "setting top-level value");
@@ -208,13 +207,13 @@ fn override_toml_duplicate() {
             "--set=change-id=1".to_owned(),
             "--set=change-id=2".to_owned(),
         ]),
-        |&_| toml::from_str("change-id = 0").unwrap(),
+        |&_| toml::from_str("change-id = 0"),
     );
 }
 
 #[test]
 fn profile_user_dist() {
-    fn get_toml(file: &Path) -> TomlConfig {
+    fn get_toml(file: &Path) -> Result<TomlConfig, toml::de::Error> {
         let contents =
             if file.ends_with("config.toml") || env::var_os("RUST_BOOTSTRAP_CONFIG").is_some() {
                 "profile = \"user\"".to_owned()
@@ -223,9 +222,7 @@ fn profile_user_dist() {
                 std::fs::read_to_string(file).unwrap()
             };
 
-        toml::from_str(&contents)
-            .and_then(|table: toml::Value| TomlConfig::deserialize(table))
-            .unwrap()
+        toml::from_str(&contents).and_then(|table: toml::Value| TomlConfig::deserialize(table))
     }
     Config::parse_inner(Flags::parse(&["check".to_owned()]), get_toml);
 }

From 221701421066fc91eee4c7bde129b607088cf328 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 14 Aug 2024 16:44:05 +0000
Subject: [PATCH 276/685] Apply some suggestions to the test rmake file

---
 tests/run-make/staticlib-thin-archive/rmake.rs | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/tests/run-make/staticlib-thin-archive/rmake.rs b/tests/run-make/staticlib-thin-archive/rmake.rs
index f7e3e43d53581..955c50da2011c 100644
--- a/tests/run-make/staticlib-thin-archive/rmake.rs
+++ b/tests/run-make/staticlib-thin-archive/rmake.rs
@@ -3,21 +3,16 @@
 // archive support rustc would add emit object files to the staticlib and after
 // the object crate added thin archive support it would previously crash the
 // compiler due to a missing special case for thin archive members.
-use std::path::Path;
-
-use run_make_support::{llvm_ar, rust_lib_name, rustc, static_lib_name};
+use run_make_support::{llvm_ar, path, rfs, rust_lib_name, rustc, static_lib_name};
 
 fn main() {
-    std::fs::create_dir("archive").unwrap();
+    rfs::create_dir("archive");
 
     // Build a thin archive
     rustc().input("simple_obj.rs").emit("obj").output("archive/simple_obj.o").run();
     llvm_ar()
         .obj_to_thin_ar()
-        .output_input(
-            Path::new("archive").join(static_lib_name("thin_archive")),
-            "archive/simple_obj.o",
-        )
+        .output_input(path("archive").join(static_lib_name("thin_archive")), "archive/simple_obj.o")
         .run();
 
     // Build an rlib which includes the members of this thin archive

From 9de0d147f479f94c7cb49f1573e90fc529cda476 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 14 Aug 2024 16:50:48 +0000
Subject: [PATCH 277/685] Unconditionally use the LLVM symbol reader

This may fix a linker error on MSVC
---
 .../rustc_codegen_llvm/src/back/archive.rs    | 22 -------------------
 1 file changed, 22 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/back/archive.rs b/compiler/rustc_codegen_llvm/src/back/archive.rs
index 60e6346254877..2120fc1815cd8 100644
--- a/compiler/rustc_codegen_llvm/src/back/archive.rs
+++ b/compiler/rustc_codegen_llvm/src/back/archive.rs
@@ -200,25 +200,11 @@ static LLVM_OBJECT_READER: ObjectReader = ObjectReader {
     get_xcoff_member_alignment: DEFAULT_OBJECT_READER.get_xcoff_member_alignment,
 };
 
-fn should_use_llvm_reader(buf: &[u8]) -> bool {
-    let is_bitcode = unsafe { llvm::LLVMRustIsBitcode(buf.as_ptr(), buf.len()) };
-
-    // COFF bigobj file, msvc LTO file or import library. See
-    // https://github.com/llvm/llvm-project/blob/453f27bc9/llvm/lib/BinaryFormat/Magic.cpp#L38-L51
-    let is_unsupported_windows_obj_file = buf.get(0..4) == Some(b"\0\0\xFF\xFF");
-
-    is_bitcode || is_unsupported_windows_obj_file
-}
-
 #[deny(unsafe_op_in_unsafe_fn)]
 fn get_llvm_object_symbols(
     buf: &[u8],
     f: &mut dyn FnMut(&[u8]) -> io::Result<()>,
 ) -> io::Result<bool> {
-    if !should_use_llvm_reader(buf) {
-        return (DEFAULT_OBJECT_READER.get_symbols)(buf, f);
-    }
-
     let mut state = Box::new(f);
 
     let err = unsafe {
@@ -255,18 +241,10 @@ fn get_llvm_object_symbols(
 }
 
 fn llvm_is_64_bit_object_file(buf: &[u8]) -> bool {
-    if !should_use_llvm_reader(buf) {
-        return (DEFAULT_OBJECT_READER.is_64_bit_object_file)(buf);
-    }
-
     unsafe { llvm::LLVMRustIs64BitSymbolicFile(buf.as_ptr(), buf.len()) }
 }
 
 fn llvm_is_ec_object_file(buf: &[u8]) -> bool {
-    if !should_use_llvm_reader(buf) {
-        return (DEFAULT_OBJECT_READER.is_ec_object_file)(buf);
-    }
-
     unsafe { llvm::LLVMRustIsECObject(buf.as_ptr(), buf.len()) }
 }
 

From 4a2d0d9233b8abde6faa00b6e04636d43493269c Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Wed, 14 Aug 2024 09:57:14 -0700
Subject: [PATCH 278/685] Fix dependencies cron job

---
 .github/workflows/dependencies.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/dependencies.yml b/.github/workflows/dependencies.yml
index b137497594f2b..5e54ceea3d7f8 100644
--- a/.github/workflows/dependencies.yml
+++ b/.github/workflows/dependencies.yml
@@ -67,7 +67,7 @@ jobs:
       - name: cargo update rustbook
         run: |
           echo -e "\nrustbook dependencies:" >> cargo_update.log
-          cargo update --manifest-path src/tools/rustbook 2>&1 | sed '/crates.io index/d' | tee -a cargo_update.log
+          cargo update --manifest-path src/tools/rustbook/Cargo.toml 2>&1 | sed '/crates.io index/d' | tee -a cargo_update.log
       - name: upload Cargo.lock artifact for use in PR
         uses: actions/upload-artifact@v4
         with:

From 14ac0a38db036fbe3620534ee1c142f7092364e5 Mon Sep 17 00:00:00 2001
From: Slanterns <slanterns.w@gmail.com>
Date: Thu, 15 Aug 2024 01:22:42 +0800
Subject: [PATCH 279/685] fix r-a

---
 src/tools/rust-analyzer/crates/hir-ty/src/display.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
index a433ecfd778b9..f6f90faa4ef73 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/display.rs
@@ -1462,7 +1462,7 @@ fn generic_args_sans_defaults<'ga>(
                     // otherwise, if the arg is equal to the param default, hide it (unless the
                     // default is an error which can happen for the trait Self type)
                     #[allow(unstable_name_collisions)]
-                    default_parameters.get(i).is_none_or(|default_parameter| {
+                    IsNoneOr::is_none_or(default_parameters.get(i), |default_parameter| {
                         // !is_err(default_parameter.skip_binders())
                         //     &&
                         arg != &default_parameter.clone().substitute(Interner, &parameters)

From 1e1d8393881f60781ac6b13e2d7667afaee2d764 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 14 Aug 2024 12:55:11 -0400
Subject: [PATCH 280/685] Fix projections when parent capture is by-ref

---
 .../src/coroutine/by_move_body.rs             | 54 ++++++++++++++-----
 .../async-closures/move-out-of-ref.rs         | 16 ++++++
 .../async-closures/move-out-of-ref.stderr     | 18 +++++++
 3 files changed, 74 insertions(+), 14 deletions(-)
 create mode 100644 tests/ui/async-await/async-closures/move-out-of-ref.rs
 create mode 100644 tests/ui/async-await/async-closures/move-out-of-ref.stderr

diff --git a/compiler/rustc_mir_transform/src/coroutine/by_move_body.rs b/compiler/rustc_mir_transform/src/coroutine/by_move_body.rs
index 69d21a63f557b..7ea36f08232e2 100644
--- a/compiler/rustc_mir_transform/src/coroutine/by_move_body.rs
+++ b/compiler/rustc_mir_transform/src/coroutine/by_move_body.rs
@@ -78,6 +78,8 @@ use rustc_middle::mir::{self, dump_mir, MirPass};
 use rustc_middle::ty::{self, InstanceKind, Ty, TyCtxt, TypeVisitableExt};
 use rustc_target::abi::{FieldIdx, VariantIdx};
 
+use crate::pass_manager::validate_body;
+
 pub struct ByMoveBody;
 
 impl<'tcx> MirPass<'tcx> for ByMoveBody {
@@ -131,20 +133,40 @@ impl<'tcx> MirPass<'tcx> for ByMoveBody {
             |(parent_field_idx, parent_capture), (child_field_idx, child_capture)| {
                 // Store this set of additional projections (fields and derefs).
                 // We need to re-apply them later.
-                let child_precise_captures =
-                    &child_capture.place.projections[parent_capture.place.projections.len()..];
+                let mut child_precise_captures = child_capture.place.projections
+                    [parent_capture.place.projections.len()..]
+                    .to_vec();
 
-                // If the parent captures by-move, and the child captures by-ref, then we
-                // need to peel an additional `deref` off of the body of the child.
-                let needs_deref = child_capture.is_by_ref() && !parent_capture.is_by_ref();
-                if needs_deref {
-                    assert_ne!(
-                        coroutine_kind,
-                        ty::ClosureKind::FnOnce,
+                // If the parent capture is by-ref, then we need to apply an additional
+                // deref before applying any further projections to this place.
+                if parent_capture.is_by_ref() {
+                    child_precise_captures.insert(
+                        0,
+                        Projection { ty: parent_capture.place.ty(), kind: ProjectionKind::Deref },
+                    );
+                }
+                // If the child capture is by-ref, then we need to apply a "ref"
+                // projection (i.e. `&`) at the end. But wait! We don't have that
+                // as a projection kind. So instead, we can apply its dual and
+                // *peel* a deref off of the place when it shows up in the MIR body.
+                // Luckily, by construction this is always possible.
+                let peel_deref = if child_capture.is_by_ref() {
+                    assert!(
+                        parent_capture.is_by_ref() || coroutine_kind != ty::ClosureKind::FnOnce,
                         "`FnOnce` coroutine-closures return coroutines that capture from \
                         their body; it will always result in a borrowck error!"
                     );
-                }
+                    true
+                } else {
+                    false
+                };
+
+                // Regarding the behavior above, you may think that it's redundant to both
+                // insert a deref and then peel a deref if the parent and child are both
+                // captured by-ref. This would be correct, except for the case where we have
+                // precise capturing projections, since the inserted deref is to the *beginning*
+                // and the peeled deref is at the *end*. I cannot seem to actually find a
+                // case where this happens, though, but let's keep this code flexible.
 
                 // Finally, store the type of the parent's captured place. We need
                 // this when building the field projection in the MIR body later on.
@@ -164,7 +186,7 @@ impl<'tcx> MirPass<'tcx> for ByMoveBody {
                     (
                         FieldIdx::from_usize(parent_field_idx + num_args),
                         parent_capture_ty,
-                        needs_deref,
+                        peel_deref,
                         child_precise_captures,
                     ),
                 )
@@ -192,6 +214,10 @@ impl<'tcx> MirPass<'tcx> for ByMoveBody {
         let mut by_move_body = body.clone();
         MakeByMoveBody { tcx, field_remapping, by_move_coroutine_ty }.visit_body(&mut by_move_body);
         dump_mir(tcx, false, "coroutine_by_move", &0, &by_move_body, |_, _| Ok(()));
+
+        // Let's just always validate this body.
+        validate_body(tcx, &mut by_move_body, "Initial coroutine_by_move body".to_string());
+
         // FIXME: use query feeding to generate the body right here and then only store the `DefId` of the new body.
         by_move_body.source = mir::MirSource::from_instance(InstanceKind::CoroutineKindShim {
             coroutine_def_id: coroutine_def_id.to_def_id(),
@@ -202,7 +228,7 @@ impl<'tcx> MirPass<'tcx> for ByMoveBody {
 
 struct MakeByMoveBody<'tcx> {
     tcx: TyCtxt<'tcx>,
-    field_remapping: UnordMap<FieldIdx, (FieldIdx, Ty<'tcx>, bool, &'tcx [Projection<'tcx>])>,
+    field_remapping: UnordMap<FieldIdx, (FieldIdx, Ty<'tcx>, bool, Vec<Projection<'tcx>>)>,
     by_move_coroutine_ty: Ty<'tcx>,
 }
 
@@ -223,14 +249,14 @@ impl<'tcx> MutVisitor<'tcx> for MakeByMoveBody<'tcx> {
         if place.local == ty::CAPTURE_STRUCT_LOCAL
             && let Some((&mir::ProjectionElem::Field(idx, _), projection)) =
                 place.projection.split_first()
-            && let Some(&(remapped_idx, remapped_ty, needs_deref, bridging_projections)) =
+            && let Some(&(remapped_idx, remapped_ty, peel_deref, ref bridging_projections)) =
                 self.field_remapping.get(&idx)
         {
             // As noted before, if the parent closure captures a field by value, and
             // the child captures a field by ref, then for the by-move body we're
             // generating, we also are taking that field by value. Peel off a deref,
             // since a layer of ref'ing has now become redundant.
-            let final_projections = if needs_deref {
+            let final_projections = if peel_deref {
                 let Some((mir::ProjectionElem::Deref, projection)) = projection.split_first()
                 else {
                     bug!(
diff --git a/tests/ui/async-await/async-closures/move-out-of-ref.rs b/tests/ui/async-await/async-closures/move-out-of-ref.rs
new file mode 100644
index 0000000000000..a05447232f62b
--- /dev/null
+++ b/tests/ui/async-await/async-closures/move-out-of-ref.rs
@@ -0,0 +1,16 @@
+//@ compile-flags: -Zvalidate-mir
+//@ edition: 2021
+
+#![feature(async_closure)]
+
+// NOT copy.
+struct Ty;
+
+fn hello(x: &Ty) {
+    let c = async || {
+        *x;
+        //~^ ERROR cannot move out of `*x` which is behind a shared reference
+    };
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/async-closures/move-out-of-ref.stderr b/tests/ui/async-await/async-closures/move-out-of-ref.stderr
new file mode 100644
index 0000000000000..294905a481d65
--- /dev/null
+++ b/tests/ui/async-await/async-closures/move-out-of-ref.stderr
@@ -0,0 +1,18 @@
+error[E0507]: cannot move out of `*x` which is behind a shared reference
+  --> $DIR/move-out-of-ref.rs:11:9
+   |
+LL |         *x;
+   |         ^^ move occurs because `*x` has type `Ty`, which does not implement the `Copy` trait
+   |
+note: if `Ty` implemented `Clone`, you could clone the value
+  --> $DIR/move-out-of-ref.rs:7:1
+   |
+LL | struct Ty;
+   | ^^^^^^^^^ consider implementing `Clone` for this type
+...
+LL |         *x;
+   |         -- you could clone this value
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0507`.

From f264e5d0112f45e00c548d04d2ead8a072f34f5c Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 14 Aug 2024 14:12:44 -0400
Subject: [PATCH 281/685] Remove redundant type ops

---
 compiler/rustc_middle/src/query/mod.rs        | 27 ++-------------
 .../src/traits/query/type_op/eq.rs            | 33 -------------------
 .../src/traits/query/type_op/mod.rs           |  2 --
 .../src/traits/query/type_op/subtype.rs       | 30 -----------------
 compiler/rustc_traits/src/type_op.rs          | 24 --------------
 5 files changed, 3 insertions(+), 113 deletions(-)
 delete mode 100644 compiler/rustc_trait_selection/src/traits/query/type_op/eq.rs
 delete mode 100644 compiler/rustc_trait_selection/src/traits/query/type_op/subtype.rs

diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 075eae029041e..92c8d265c09ec 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -65,10 +65,9 @@ use crate::query::plumbing::{
 };
 use crate::traits::query::{
     CanonicalAliasGoal, CanonicalPredicateGoal, CanonicalTyGoal,
-    CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpNormalizeGoal,
-    CanonicalTypeOpProvePredicateGoal, CanonicalTypeOpSubtypeGoal, DropckConstraint,
-    DropckOutlivesResult, MethodAutoderefStepsResult, NoSolution, NormalizationResult,
-    OutlivesBound,
+    CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpNormalizeGoal,
+    CanonicalTypeOpProvePredicateGoal, DropckConstraint, DropckOutlivesResult,
+    MethodAutoderefStepsResult, NoSolution, NormalizationResult, OutlivesBound,
 };
 use crate::traits::{
     specialization_graph, CodegenObligationError, EvaluationResult, ImplSource,
@@ -2090,26 +2089,6 @@ rustc_queries! {
         desc { "evaluating `type_op_ascribe_user_type` `{:?}`", goal.value.value }
     }
 
-    /// Do not call this query directly: part of the `Eq` type-op
-    query type_op_eq(
-        goal: CanonicalTypeOpEqGoal<'tcx>
-    ) -> Result<
-        &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ()>>,
-        NoSolution,
-    > {
-        desc { "evaluating `type_op_eq` `{:?}`", goal.value.value }
-    }
-
-    /// Do not call this query directly: part of the `Subtype` type-op
-    query type_op_subtype(
-        goal: CanonicalTypeOpSubtypeGoal<'tcx>
-    ) -> Result<
-        &'tcx Canonical<'tcx, canonical::QueryResponse<'tcx, ()>>,
-        NoSolution,
-    > {
-        desc { "evaluating `type_op_subtype` `{:?}`", goal.value.value }
-    }
-
     /// Do not call this query directly: part of the `ProvePredicate` type-op
     query type_op_prove_predicate(
         goal: CanonicalTypeOpProvePredicateGoal<'tcx>
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/eq.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/eq.rs
deleted file mode 100644
index 656130cda19eb..0000000000000
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/eq.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-pub use rustc_middle::traits::query::type_op::Eq;
-use rustc_middle::traits::query::NoSolution;
-use rustc_middle::traits::ObligationCause;
-use rustc_middle::ty::{ParamEnvAnd, TyCtxt};
-
-use crate::infer::canonical::{Canonical, CanonicalQueryResponse};
-use crate::traits::ObligationCtxt;
-
-impl<'tcx> super::QueryTypeOp<'tcx> for Eq<'tcx> {
-    type QueryResponse = ();
-
-    fn try_fast_path(
-        _tcx: TyCtxt<'tcx>,
-        key: &ParamEnvAnd<'tcx, Eq<'tcx>>,
-    ) -> Option<Self::QueryResponse> {
-        if key.value.a == key.value.b { Some(()) } else { None }
-    }
-
-    fn perform_query(
-        tcx: TyCtxt<'tcx>,
-        canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Self>>,
-    ) -> Result<CanonicalQueryResponse<'tcx, ()>, NoSolution> {
-        tcx.type_op_eq(canonicalized)
-    }
-
-    fn perform_locally_with_next_solver(
-        ocx: &ObligationCtxt<'_, 'tcx>,
-        key: ParamEnvAnd<'tcx, Self>,
-    ) -> Result<Self::QueryResponse, NoSolution> {
-        ocx.eq(&ObligationCause::dummy(), key.param_env, key.value.a, key.value.b)?;
-        Ok(())
-    }
-}
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs
index 2f64ed963f967..791424065d1c9 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/mod.rs
@@ -16,12 +16,10 @@ use crate::traits::{ObligationCause, ObligationCtxt};
 
 pub mod ascribe_user_type;
 pub mod custom;
-pub mod eq;
 pub mod implied_outlives_bounds;
 pub mod normalize;
 pub mod outlives;
 pub mod prove_predicate;
-pub mod subtype;
 
 pub use rustc_middle::traits::query::type_op::*;
 
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/subtype.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/subtype.rs
deleted file mode 100644
index 892c2a1f11309..0000000000000
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/subtype.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-pub use rustc_middle::traits::query::type_op::Subtype;
-use rustc_middle::traits::query::NoSolution;
-use rustc_middle::traits::ObligationCause;
-use rustc_middle::ty::{ParamEnvAnd, TyCtxt};
-
-use crate::infer::canonical::{Canonical, CanonicalQueryResponse};
-use crate::traits::ObligationCtxt;
-
-impl<'tcx> super::QueryTypeOp<'tcx> for Subtype<'tcx> {
-    type QueryResponse = ();
-
-    fn try_fast_path(_tcx: TyCtxt<'tcx>, key: &ParamEnvAnd<'tcx, Self>) -> Option<()> {
-        if key.value.sub == key.value.sup { Some(()) } else { None }
-    }
-
-    fn perform_query(
-        tcx: TyCtxt<'tcx>,
-        canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Self>>,
-    ) -> Result<CanonicalQueryResponse<'tcx, ()>, NoSolution> {
-        tcx.type_op_subtype(canonicalized)
-    }
-
-    fn perform_locally_with_next_solver(
-        ocx: &ObligationCtxt<'_, 'tcx>,
-        key: ParamEnvAnd<'tcx, Self>,
-    ) -> Result<Self::QueryResponse, NoSolution> {
-        ocx.sub(&ObligationCause::dummy(), key.param_env, key.value.sub, key.value.sup)?;
-        Ok(())
-    }
-}
diff --git a/compiler/rustc_traits/src/type_op.rs b/compiler/rustc_traits/src/type_op.rs
index 5affadaac38c3..f34adf8575565 100644
--- a/compiler/rustc_traits/src/type_op.rs
+++ b/compiler/rustc_traits/src/type_op.rs
@@ -10,18 +10,14 @@ use rustc_trait_selection::traits::query::normalize::QueryNormalizeExt;
 use rustc_trait_selection::traits::query::type_op::ascribe_user_type::{
     type_op_ascribe_user_type_with_span, AscribeUserType,
 };
-use rustc_trait_selection::traits::query::type_op::eq::Eq;
 use rustc_trait_selection::traits::query::type_op::normalize::Normalize;
 use rustc_trait_selection::traits::query::type_op::prove_predicate::ProvePredicate;
-use rustc_trait_selection::traits::query::type_op::subtype::Subtype;
 use rustc_trait_selection::traits::{Normalized, Obligation, ObligationCause, ObligationCtxt};
 
 pub(crate) fn provide(p: &mut Providers) {
     *p = Providers {
         type_op_ascribe_user_type,
-        type_op_eq,
         type_op_prove_predicate,
-        type_op_subtype,
         type_op_normalize_ty,
         type_op_normalize_clause,
         type_op_normalize_fn_sig,
@@ -39,16 +35,6 @@ fn type_op_ascribe_user_type<'tcx>(
     })
 }
 
-fn type_op_eq<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Eq<'tcx>>>,
-) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution> {
-    tcx.infer_ctxt().enter_canonical_trait_query(&canonicalized, |ocx, key| {
-        let (param_env, Eq { a, b }) = key.into_parts();
-        Ok(ocx.eq(&ObligationCause::dummy(), param_env, a, b)?)
-    })
-}
-
 fn type_op_normalize<'tcx, T>(
     ocx: &ObligationCtxt<'_, 'tcx>,
     key: ParamEnvAnd<'tcx, Normalize<T>>,
@@ -91,16 +77,6 @@ fn type_op_normalize_poly_fn_sig<'tcx>(
     tcx.infer_ctxt().enter_canonical_trait_query(&canonicalized, type_op_normalize)
 }
 
-fn type_op_subtype<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Subtype<'tcx>>>,
-) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution> {
-    tcx.infer_ctxt().enter_canonical_trait_query(&canonicalized, |ocx, key| {
-        let (param_env, Subtype { sub, sup }) = key.into_parts();
-        Ok(ocx.sup(&ObligationCause::dummy(), param_env, sup, sub)?)
-    })
-}
-
 fn type_op_prove_predicate<'tcx>(
     tcx: TyCtxt<'tcx>,
     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, ProvePredicate<'tcx>>>,

From bb84372e436dfeba61ad1b4deef408a3cf9a12c5 Mon Sep 17 00:00:00 2001
From: Nadrieril <nadrieril+git@gmail.com>
Date: Sat, 10 Aug 2024 14:49:26 +0200
Subject: [PATCH 282/685] rust-analyzer: use in-tree pattern_analysis crate

---
 src/tools/rust-analyzer/crates/hir-ty/src/lib.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
index 4c9e0a1e11836..21c84511dc35e 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/lib.rs
@@ -15,8 +15,10 @@ extern crate rustc_abi;
 #[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_abi as rustc_abi;
 
-// Use the crates.io version unconditionally until the API settles enough that we can switch to
-// using the in-tree one.
+#[cfg(feature = "in-rust-tree")]
+extern crate rustc_pattern_analysis;
+
+#[cfg(not(feature = "in-rust-tree"))]
 extern crate ra_ap_rustc_pattern_analysis as rustc_pattern_analysis;
 
 mod builder;

From 7c972d75dca7d1ef0e5a7d356cdc4d61afcd739f Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 14 Aug 2024 19:21:44 +0000
Subject: [PATCH 283/685] Use toString instead of raw_svector_ostream for error
 messages

---
 compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp
index ccf1a5429e2b5..d119a995c61b5 100644
--- a/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp
@@ -77,11 +77,7 @@ LLVMRustGetSymbols(char *BufPtr, size_t BufLen, void *State,
   Expected<std::unique_ptr<object::SymbolicFile>> ObjOrErr =
       getSymbolicFile(Buf->getMemBufferRef(), Context);
   if (!ObjOrErr) {
-    Error E = ObjOrErr.takeError();
-    SmallString<0> ErrorBuf;
-    auto Error = raw_svector_ostream(ErrorBuf);
-    Error << E << '\0';
-    return ErrorCallback(Error.str().data());
+    return ErrorCallback(toString(ObjOrErr.takeError()).c_str());
   }
   std::unique_ptr<object::SymbolicFile> Obj = std::move(*ObjOrErr);
 
@@ -89,10 +85,7 @@ LLVMRustGetSymbols(char *BufPtr, size_t BufLen, void *State,
     if (!isArchiveSymbol(S))
       continue;
     if (Error E = S.printName(SymName)) {
-      SmallString<0> ErrorBuf;
-      auto Error = raw_svector_ostream(ErrorBuf);
-      Error << E << '\0';
-      return ErrorCallback(Error.str().data());
+      return ErrorCallback(toString(std::move(E)).c_str());
     }
     SymName << '\0';
     if (void *E = Callback(State, SymNameBuf.str().data())) {

From 4290943fb35b1e0472d6ee4888c5ab106abe1311 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Tue, 13 Aug 2024 23:28:08 -0400
Subject: [PATCH 284/685] Infer async closure args from Fn bound even if there
 is no corresponding Future bound

---
 compiler/rustc_hir_typeck/src/closure.rs      | 45 ++++++++++++-----
 .../async-closures/sig-from-bare-fn.rs        | 49 +++++++++++++++++++
 2 files changed, 83 insertions(+), 11 deletions(-)
 create mode 100644 tests/ui/async-await/async-closures/sig-from-bare-fn.rs

diff --git a/compiler/rustc_hir_typeck/src/closure.rs b/compiler/rustc_hir_typeck/src/closure.rs
index a7953acc95c80..3d176b7819307 100644
--- a/compiler/rustc_hir_typeck/src/closure.rs
+++ b/compiler/rustc_hir_typeck/src/closure.rs
@@ -14,7 +14,7 @@ use rustc_middle::span_bug;
 use rustc_middle::ty::visit::{TypeVisitable, TypeVisitableExt};
 use rustc_middle::ty::{self, GenericArgs, Ty, TyCtxt, TypeSuperVisitable, TypeVisitor};
 use rustc_span::def_id::LocalDefId;
-use rustc_span::Span;
+use rustc_span::{Span, DUMMY_SP};
 use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::error_reporting::traits::ArgKind;
 use rustc_trait_selection::traits;
@@ -539,6 +539,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// we identify the `FnOnce<Args, Output = ?Fut>` bound, and if the output type is
     /// an inference variable `?Fut`, we check if that is bounded by a `Future<Output = Ty>`
     /// projection.
+    ///
+    /// This function is actually best-effort with the return type; if we don't find a
+    /// `Future` projection, we still will return arguments that we extracted from the `FnOnce`
+    /// projection, and the output will be an unconstrained type variable instead.
     fn extract_sig_from_projection_and_future_bound(
         &self,
         cause_span: Option<Span>,
@@ -564,24 +568,43 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         };
 
         // FIXME: We may want to elaborate here, though I assume this will be exceedingly rare.
+        let mut return_ty = None;
         for bound in self.obligations_for_self_ty(return_vid) {
             if let Some(ret_projection) = bound.predicate.as_projection_clause()
                 && let Some(ret_projection) = ret_projection.no_bound_vars()
                 && self.tcx.is_lang_item(ret_projection.def_id(), LangItem::FutureOutput)
             {
-                let sig = projection.rebind(self.tcx.mk_fn_sig(
-                    input_tys,
-                    ret_projection.term.expect_type(),
-                    false,
-                    hir::Safety::Safe,
-                    Abi::Rust,
-                ));
-
-                return Some(ExpectedSig { cause_span, sig });
+                return_ty = Some(ret_projection.term.expect_type());
+                break;
             }
         }
 
-        None
+        // SUBTLE: If we didn't find a `Future<Output = ...>` bound for the return
+        // vid, we still want to attempt to provide inference guidance for the async
+        // closure's arguments. Instantiate a new vid to plug into the output type.
+        //
+        // You may be wondering, what if it's higher-ranked? Well, given that we
+        // found a type variable for the `FnOnce::Output` projection above, we know
+        // that the output can't mention any of the vars.
+        //
+        // Also note that we use a fresh var here for the signature since the signature
+        // records the output of the *future*, and `return_vid` above is the type
+        // variable of the future, not its output.
+        //
+        // FIXME: We probably should store this signature inference output in a way
+        // that does not misuse a `FnSig` type, but that can be done separately.
+        let return_ty =
+            return_ty.unwrap_or_else(|| self.next_ty_var(cause_span.unwrap_or(DUMMY_SP)));
+
+        let sig = projection.rebind(self.tcx.mk_fn_sig(
+            input_tys,
+            return_ty,
+            false,
+            hir::Safety::Safe,
+            Abi::Rust,
+        ));
+
+        return Some(ExpectedSig { cause_span, sig });
     }
 
     fn sig_of_closure(
diff --git a/tests/ui/async-await/async-closures/sig-from-bare-fn.rs b/tests/ui/async-await/async-closures/sig-from-bare-fn.rs
new file mode 100644
index 0000000000000..a679471a3b3d0
--- /dev/null
+++ b/tests/ui/async-await/async-closures/sig-from-bare-fn.rs
@@ -0,0 +1,49 @@
+//@ check-pass
+//@ edition: 2021
+
+// Make sure that we infer the args of an async closure even if it's passed to
+// a function that requires the async closure implement `Fn*` but does *not* have
+// a `Future` bound on the return type.
+
+#![feature(async_closure)]
+
+use std::future::Future;
+
+trait TryStream {
+    type Ok;
+    type Err;
+}
+
+trait TryFuture {
+    type Ok;
+    type Err;
+}
+
+impl<F, T, E> TryFuture for F where F: Future<Output = Result<T, E>> {
+    type Ok = T;
+    type Err = E;
+}
+
+trait TryStreamExt: TryStream {
+    fn try_for_each<F, Fut>(&self, f: F)
+    where
+        F: FnMut(Self::Ok) -> Fut,
+        Fut: TryFuture<Ok = (), Err = Self::Err>;
+}
+
+impl<S> TryStreamExt for S where S: TryStream {
+    fn try_for_each<F, Fut>(&self, f: F)
+    where
+        F: FnMut(Self::Ok) -> Fut,
+        Fut: TryFuture<Ok = (), Err = Self::Err>,
+    { }
+}
+
+fn test(stream: impl TryStream<Ok = &'static str, Err = ()>) {
+    stream.try_for_each(async |s| {
+        s.trim(); // Make sure we know the type of `s` at this point.
+        Ok(())
+    });
+}
+
+fn main() {}

From 901c9daa05ec817c3a0f7aad87a928cfcfe00ce2 Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Wed, 14 Aug 2024 19:37:14 +0000
Subject: [PATCH 285/685] Fix null pointer dereference when a file is not an
 object file

---
 compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp
index d119a995c61b5..d625935d92594 100644
--- a/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/SymbolWrapper.cpp
@@ -80,6 +80,9 @@ LLVMRustGetSymbols(char *BufPtr, size_t BufLen, void *State,
     return ErrorCallback(toString(ObjOrErr.takeError()).c_str());
   }
   std::unique_ptr<object::SymbolicFile> Obj = std::move(*ObjOrErr);
+  if (Obj == nullptr) {
+    return 0;
+  }
 
   for (const object::BasicSymbolRef &S : Obj->symbols()) {
     if (!isArchiveSymbol(S))

From 99aad72af55e9cfd77adeeca0f9b403758201d42 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Thu, 15 Aug 2024 09:46:21 +1000
Subject: [PATCH 286/685] Add a comment explaining the return type of
 `Ty::kind`.

---
 compiler/rustc_middle/src/ty/sty.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 0a277fea49c12..d60bfb9faa1aa 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -970,6 +970,10 @@ impl<'tcx> rustc_type_ir::inherent::Ty<TyCtxt<'tcx>> for Ty<'tcx> {
 
 /// Type utilities
 impl<'tcx> Ty<'tcx> {
+    // It would be nicer if this returned the value instead of a reference,
+    // like how `Predicate::kind` and `Region::kind` do. (It would result in
+    // many fewer subsequent dereferences.) But that gives a small but
+    // noticeable performance hit. See #126069 for details.
     #[inline(always)]
     pub fn kind(self) -> &'tcx TyKind<'tcx> {
         self.0.0

From 8b990e35f423907d22cb7f386d40acc1599377ad Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 14 Aug 2024 14:41:10 +1000
Subject: [PATCH 287/685] Port the `sysroot-crates-are-unstable` Python script
 to rmake

---
 .../sysroot-crates-are-unstable/rmake.rs      | 101 +++++++++++++++++-
 .../sysroot-crates-are-unstable/test.py       |  75 -------------
 2 files changed, 99 insertions(+), 77 deletions(-)
 delete mode 100644 tests/run-make/sysroot-crates-are-unstable/test.py

diff --git a/tests/run-make/sysroot-crates-are-unstable/rmake.rs b/tests/run-make/sysroot-crates-are-unstable/rmake.rs
index 24da387eb8016..2240d87237b1a 100644
--- a/tests/run-make/sysroot-crates-are-unstable/rmake.rs
+++ b/tests/run-make/sysroot-crates-are-unstable/rmake.rs
@@ -1,5 +1,102 @@
-use run_make_support::python_command;
+// Check that crates in the sysroot are treated as unstable, unless they are
+// on a list of known-stable sysroot crates.
+
+use std::path::{Path, PathBuf};
+use std::str;
+
+use run_make_support::{rfs, rustc, target};
+
+fn is_stable_crate(name: &str) -> bool {
+    matches!(name, "std" | "alloc" | "core" | "proc_macro")
+}
 
 fn main() {
-    python_command().arg("test.py").run();
+    for cr in get_unstable_sysroot_crates() {
+        check_crate_is_unstable(&cr);
+    }
+    println!("Done");
+}
+
+#[derive(Debug)]
+struct Crate {
+    name: String,
+    path: PathBuf,
+}
+
+fn check_crate_is_unstable(cr: &Crate) {
+    let Crate { name, path } = cr;
+
+    print!("- Verifying that sysroot crate '{name}' is an unstable crate ...");
+
+    // Trying to use this crate from a user program should fail.
+    let output = rustc()
+        .crate_type("rlib")
+        .target(target())
+        .extern_(name, path)
+        .input("-")
+        .stdin(format!("extern crate {name};"))
+        .run_fail();
+
+    // Make sure it failed for the intended reason, not some other reason.
+    // (The actual feature required varies between crates.)
+    output.assert_stderr_contains("use of unstable library feature");
+
+    println!(" OK");
+}
+
+fn get_unstable_sysroot_crates() -> Vec<Crate> {
+    let sysroot = PathBuf::from(rustc().print("sysroot").run().stdout_utf8().trim());
+    let sysroot_libs_dir = sysroot.join("lib").join("rustlib").join(target()).join("lib");
+    println!("Sysroot libs dir: {sysroot_libs_dir:?}");
+
+    // Generate a list of all library crates in the sysroot.
+    let sysroot_crates = get_all_crates_in_dir(&sysroot_libs_dir);
+    println!(
+        "Found {} sysroot crates: {:?}",
+        sysroot_crates.len(),
+        sysroot_crates.iter().map(|cr| &cr.name).collect::<Vec<_>>()
+    );
+
+    // Self-check: If we didn't find `core`, we probably checked the wrong directory.
+    assert!(
+        sysroot_crates.iter().any(|cr| cr.name == "core"),
+        "Couldn't find `core` in {sysroot_libs_dir:?}"
+    );
+
+    let unstable_sysroot_crates =
+        sysroot_crates.into_iter().filter(|cr| !is_stable_crate(&cr.name)).collect::<Vec<_>>();
+    // Self-check: There should be at least one unstable crate in the directory.
+    assert!(
+        !unstable_sysroot_crates.is_empty(),
+        "Couldn't find any unstable crates in {sysroot_libs_dir:?}"
+    );
+    unstable_sysroot_crates
+}
+
+fn get_all_crates_in_dir(libs_dir: &Path) -> Vec<Crate> {
+    let mut libs = vec![];
+    rfs::read_dir_entries(libs_dir, |path| {
+        if !path.is_file() {
+            return;
+        }
+        if let Some(name) = crate_name_from_path(path) {
+            libs.push(Crate { name, path: path.to_owned() });
+        }
+    });
+    libs.sort_by(|a, b| a.name.cmp(&b.name));
+    libs
+}
+
+/// Treat a file as a crate if its name begins with `lib` and ends with `.rlib`.
+/// The crate name is the part before the first hyphen (if any).
+fn crate_name_from_path(path: &Path) -> Option<String> {
+    let name = path
+        .file_name()?
+        .to_str()?
+        .strip_prefix("lib")?
+        .strip_suffix(".rlib")?
+        .split('-')
+        .next()
+        .expect("split always yields at least one string");
+    Some(name.to_owned())
 }
diff --git a/tests/run-make/sysroot-crates-are-unstable/test.py b/tests/run-make/sysroot-crates-are-unstable/test.py
deleted file mode 100644
index 45cfdd195b4e2..0000000000000
--- a/tests/run-make/sysroot-crates-are-unstable/test.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import sys
-import os
-from os import listdir
-from os.path import isfile, join
-from subprocess import PIPE, Popen
-
-
-# This is n list of files which are stable crates or simply are not crates,
-# we don't check for the instability of these crates as they're all stable!
-STABLE_CRATES = ['std', 'alloc', 'core', 'proc_macro',
-                 'rsbegin.o', 'rsend.o', 'dllcrt2.o', 'crt2.o', 'clang_rt']
-
-
-def convert_to_string(s):
-    if s.__class__.__name__ == 'bytes':
-        return s.decode('utf-8')
-    return s
-
-
-def set_ld_lib_path():
-    var = os.environ.get("LD_LIB_PATH_ENVVAR")
-    rpath = os.environ.get("HOST_RPATH_DIR")
-    if var and rpath:
-        path = os.environ.get(var)
-        if path:
-            os.environ[var] = rpath + os.pathsep + path
-        else:
-            os.environ[var] = rpath
-
-
-def exec_command(command, to_input=None):
-    child = None
-    if to_input is None:
-        child = Popen(command, stdout=PIPE, stderr=PIPE)
-    else:
-        child = Popen(command, stdout=PIPE, stderr=PIPE, stdin=PIPE)
-    stdout, stderr = child.communicate(input=to_input)
-    return (convert_to_string(stdout), convert_to_string(stderr))
-
-
-def check_lib(lib):
-    if lib['name'] in STABLE_CRATES:
-        return True
-    print('verifying if {} is an unstable crate'.format(lib['name']))
-    stdout, stderr = exec_command([os.environ['RUSTC'], '-', '--crate-type', 'rlib',
-                                   '--target', os.environ['TARGET'],
-                                   '--extern', '{}={}'.format(lib['name'], lib['path'])],
-                                  to_input=('extern crate {};'.format(lib['name'])).encode('utf-8'))
-    if 'use of unstable library feature' not in '{}{}'.format(stdout, stderr):
-        print('crate {} "{}" is not unstable'.format(lib['name'], lib['path']))
-        print('{}{}'.format(stdout, stderr))
-        print('')
-        return False
-    return True
-
-# Generate a list of all crates in the sysroot. To do this we list all files in
-# rustc's sysroot, look at the filename, strip everything after the `-`, and
-# strip the leading `lib` (if present)
-def get_all_libs(dir_path):
-    return [{ 'path': join(dir_path, f), 'name': f[3:].split('-')[0] }
-            for f in listdir(dir_path)
-            if isfile(join(dir_path, f)) and f.endswith('.rlib') and f not in STABLE_CRATES]
-
-
-set_ld_lib_path()
-sysroot = exec_command([os.environ['RUSTC'], '--print', 'sysroot'])[0].replace('\n', '')
-assert sysroot, "Could not read the rustc sysroot!"
-libs = get_all_libs(join(sysroot, 'lib/rustlib/{}/lib'.format(os.environ['TARGET'])))
-
-ret = 0
-for lib in libs:
-    if not check_lib(lib):
-        # We continue so users can see all the not unstable crates.
-        ret = 1
-sys.exit(ret)

From 35785ef39fa01250f6c4db6bb08e239f55c308ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?=
 <jieyouxu@outlook.com>
Date: Thu, 15 Aug 2024 05:13:05 +0000
Subject: [PATCH 288/685] tests: re-enable `dump-ice-to-disk` for Windows

This test was previously flakey on `i686-mingw`, but since some
modifications I could no longer make it fail on `i686-mingw`.

See <https://github.com/rust-lang/rust/pull/128958> for multiple try
job runs.
---
 tests/run-make/dump-ice-to-disk/rmake.rs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/tests/run-make/dump-ice-to-disk/rmake.rs b/tests/run-make/dump-ice-to-disk/rmake.rs
index 48b4071e06541..08767246b90d0 100644
--- a/tests/run-make/dump-ice-to-disk/rmake.rs
+++ b/tests/run-make/dump-ice-to-disk/rmake.rs
@@ -14,11 +14,14 @@
 //!       that `RUSTC_ICE_PATH` takes precedence and no ICE dump is emitted under `METRICS_PATH`.
 //!
 //! See <https://github.com/rust-lang/rust/pull/108714>.
-
-//@ ignore-windows
-// FIXME(#128911): @jieyouxu: This test is sometimes for whatever forsaken reason flakey in
-// `i686-mingw`, and I cannot reproduce it locally. The error messages upon assertion failure in
-// this test is intentionally extremely verbose to aid debugging that issue.
+//!
+//! # Test history
+//!
+//! - The previous rmake.rs iteration of this test was flakey for unknown reason on `i686-mingw`
+//!   *specifically*, so assertion failures in this test was made extremely verbose to help
+//!   diagnose why the ICE messages was different *specifically* on `i686-mingw`.
+//! - An attempt is made to re-enable this test on `i686-mingw` (by removing `ignore-windows`). If
+//!   this test is still flakey, please restore the `ignore-windows` directive.
 
 use std::cell::OnceCell;
 use std::path::{Path, PathBuf};

From 320be47410e2a826c47097790b790b3a1826d073 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 15 Aug 2024 14:55:40 +1000
Subject: [PATCH 289/685] Include a copy of `compiler-rt` source in the
 `download-ci-llvm` tarball

---
 src/bootstrap/download-ci-llvm-stamp       |  2 +-
 src/bootstrap/src/core/build_steps/dist.rs | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/download-ci-llvm-stamp b/src/bootstrap/download-ci-llvm-stamp
index 11316004412e6..909015305015b 100644
--- a/src/bootstrap/download-ci-llvm-stamp
+++ b/src/bootstrap/download-ci-llvm-stamp
@@ -1,4 +1,4 @@
 Change this file to make users of the `download-ci-llvm` configuration download
 a new version of LLVM from CI, even if the LLVM submodule hasn’t changed.
 
-Last change is for: https://github.com/rust-lang/rust/pull/125642
+Last change is for: https://github.com/rust-lang/rust/pull/129116
diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index 530eb9b446a43..24894251017ae 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -2322,6 +2322,19 @@ impl Step for RustDev {
         let link_type = if builder.llvm_link_shared() { "dynamic" } else { "static" };
         t!(std::fs::write(tarball.image_dir().join("link-type.txt"), link_type), dst_libdir);
 
+        // Copy the `compiler-rt` source, so that `library/profiler_builtins`
+        // can potentially use it to build the profiler runtime without needing
+        // to check out the LLVM submodule.
+        copy_src_dirs(
+            builder,
+            &builder.src.join("src").join("llvm-project"),
+            &["compiler-rt"],
+            // The test subdirectory is much larger than the rest of the source,
+            // and we currently don't use these test files anyway.
+            &["compiler-rt/test"],
+            tarball.image_dir(),
+        );
+
         Some(tarball.generate())
     }
 }

From 9028b5381b2867bcd4d9cd0ba95ff97607deaaf3 Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Thu, 15 Aug 2024 13:12:11 +0000
Subject: [PATCH 290/685] rustdoc-json: Use FxHashMap from rustdoc_json_types

---
 src/librustdoc/json/mod.rs    | 10 +++++-----
 src/rustdoc-json-types/lib.rs |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs
index 860672443f2e8..a424faaf99986 100644
--- a/src/librustdoc/json/mod.rs
+++ b/src/librustdoc/json/mod.rs
@@ -13,12 +13,15 @@ use std::io::{stdout, BufWriter, Write};
 use std::path::PathBuf;
 use std::rc::Rc;
 
-use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::{DefId, DefIdSet};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
 use rustc_span::def_id::LOCAL_CRATE;
 use rustdoc_json_types as types;
+// It's important to use the FxHashMap from rustdoc_json_types here, instead of
+// the one from rustc_data_structures, as they're different types due to sysroots.
+// See #110051 and #127456 for details
+use rustdoc_json_types::FxHashMap;
 
 use crate::clean::types::{ExternalCrate, ExternalLocation};
 use crate::clean::ItemKind;
@@ -234,14 +237,11 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
         let index = (*self.index).clone().into_inner();
 
         debug!("Constructing Output");
-        // This needs to be the default HashMap for compatibility with the public interface for
-        // rustdoc-json-types
-        #[allow(rustc::default_hash_types)]
         let output = types::Crate {
             root: types::Id(format!("0:0:{}", e.name(self.tcx).as_u32())),
             crate_version: self.cache.crate_version.clone(),
             includes_private: self.cache.document_private,
-            index: index.into_iter().collect(),
+            index,
             paths: self
                 .cache
                 .paths
diff --git a/src/rustdoc-json-types/lib.rs b/src/rustdoc-json-types/lib.rs
index 999134a40909d..40a90c1a56504 100644
--- a/src/rustdoc-json-types/lib.rs
+++ b/src/rustdoc-json-types/lib.rs
@@ -5,7 +5,7 @@
 
 use std::path::PathBuf;
 
-use rustc_hash::FxHashMap;
+pub use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 
 /// The version of JSON output that this crate represents.

From a19a8f8e52364b4ce5ade2899b57260dd347c93c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 15 Aug 2024 14:44:38 +0200
Subject: [PATCH 291/685] Remove duplicated `Rustdoc::output` method from
 `run-make-support` lib

---
 src/tools/run-make-support/src/external_deps/rustdoc.rs | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/tools/run-make-support/src/external_deps/rustdoc.rs b/src/tools/run-make-support/src/external_deps/rustdoc.rs
index 96c2218a563e6..96b1c719e2e3e 100644
--- a/src/tools/run-make-support/src/external_deps/rustdoc.rs
+++ b/src/tools/run-make-support/src/external_deps/rustdoc.rs
@@ -71,14 +71,8 @@ impl Rustdoc {
         self
     }
 
-    /// Specify path to the output folder.
-    pub fn output<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
-        self.cmd.arg("-o");
-        self.cmd.arg(path.as_ref());
-        self
-    }
-
     /// Specify output directory.
+    #[doc(alias = "output")]
     pub fn out_dir<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
         self.cmd.arg("--out-dir").arg(path.as_ref());
         self

From d562a4a5108d0b67ba2a648530aab2b15224a615 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 15 Aug 2024 14:44:48 +0200
Subject: [PATCH 292/685] About rmake tests

---
 tests/run-make/deref-impl-rustdoc-ice/rmake.rs         | 2 +-
 tests/run-make/emit-shared-files/rmake.rs              | 6 +++---
 tests/run-make/exit-code/rmake.rs                      | 2 +-
 tests/run-make/rustdoc-determinism/rmake.rs            | 8 ++++----
 tests/run-make/rustdoc-io-error/rmake.rs               | 2 +-
 tests/run-make/rustdoc-map-file/rmake.rs               | 2 +-
 tests/run-make/rustdoc-output-path/rmake.rs            | 2 +-
 tests/run-make/rustdoc-output-stdout/rmake.rs          | 2 +-
 tests/run-make/rustdoc-scrape-examples-macros/rmake.rs | 4 ++--
 tests/run-make/rustdoc-scrape-examples-remap/scrape.rs | 4 ++--
 tests/run-make/rustdoc-target-spec-json-path/rmake.rs  | 2 +-
 tests/run-make/rustdoc-themes/rmake.rs                 | 2 +-
 tests/run-make/rustdoc-with-out-dir-option/rmake.rs    | 2 +-
 13 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/tests/run-make/deref-impl-rustdoc-ice/rmake.rs b/tests/run-make/deref-impl-rustdoc-ice/rmake.rs
index 91fc0a9025fad..0ad5934f62e18 100644
--- a/tests/run-make/deref-impl-rustdoc-ice/rmake.rs
+++ b/tests/run-make/deref-impl-rustdoc-ice/rmake.rs
@@ -12,5 +12,5 @@ use run_make_support::{cwd, rustc, rustdoc};
 fn main() {
     rustc().input("foo.rs").run();
     rustc().input("bar.rs").run();
-    rustdoc().input("baz.rs").library_search_path(cwd()).output(cwd()).run();
+    rustdoc().input("baz.rs").library_search_path(cwd()).out_dir(cwd()).run();
 }
diff --git a/tests/run-make/emit-shared-files/rmake.rs b/tests/run-make/emit-shared-files/rmake.rs
index 8ac9073e993ba..e5482af10bb94 100644
--- a/tests/run-make/emit-shared-files/rmake.rs
+++ b/tests/run-make/emit-shared-files/rmake.rs
@@ -13,7 +13,7 @@ fn main() {
     rustdoc()
         .arg("-Zunstable-options")
         .arg("--emit=invocation-specific")
-        .output("invocation-only")
+        .out_dir("invocation-only")
         .arg("--resource-suffix=-xxx")
         .args(&["--theme", "y.css"])
         .args(&["--extend-css", "z.css"])
@@ -34,7 +34,7 @@ fn main() {
     rustdoc()
         .arg("-Zunstable-options")
         .arg("--emit=toolchain-shared-resources")
-        .output("toolchain-only")
+        .out_dir("toolchain-only")
         .arg("--resource-suffix=-xxx")
         .args(&["--extend-css", "z.css"])
         .input("x.rs")
@@ -68,7 +68,7 @@ fn main() {
     rustdoc()
         .arg("-Zunstable-options")
         .arg("--emit=toolchain-shared-resources,unversioned-shared-resources")
-        .output("all-shared")
+        .out_dir("all-shared")
         .arg("--resource-suffix=-xxx")
         .args(&["--extend-css", "z.css"])
         .input("x.rs")
diff --git a/tests/run-make/exit-code/rmake.rs b/tests/run-make/exit-code/rmake.rs
index f290554831db7..d3dcc04428cb6 100644
--- a/tests/run-make/exit-code/rmake.rs
+++ b/tests/run-make/exit-code/rmake.rs
@@ -16,7 +16,7 @@ fn main() {
         .run_fail()
         .assert_exit_code(101);
 
-    rustdoc().arg("success.rs").output("exit-code").run();
+    rustdoc().arg("success.rs").out_dir("exit-code").run();
 
     rustdoc().arg("--invalid-arg-foo").run_fail().assert_exit_code(1);
 
diff --git a/tests/run-make/rustdoc-determinism/rmake.rs b/tests/run-make/rustdoc-determinism/rmake.rs
index aa8090174d9c3..ce0885081783b 100644
--- a/tests/run-make/rustdoc-determinism/rmake.rs
+++ b/tests/run-make/rustdoc-determinism/rmake.rs
@@ -7,12 +7,12 @@ use run_make_support::{diff, rustdoc};
 
 fn main() {
     let foo_first = Path::new("foo_first");
-    rustdoc().input("foo.rs").output(&foo_first).run();
-    rustdoc().input("bar.rs").output(&foo_first).run();
+    rustdoc().input("foo.rs").out_dir(&foo_first).run();
+    rustdoc().input("bar.rs").out_dir(&foo_first).run();
 
     let bar_first = Path::new("bar_first");
-    rustdoc().input("bar.rs").output(&bar_first).run();
-    rustdoc().input("foo.rs").output(&bar_first).run();
+    rustdoc().input("bar.rs").out_dir(&bar_first).run();
+    rustdoc().input("foo.rs").out_dir(&bar_first).run();
 
     diff()
         .expected_file(foo_first.join("search-index.js"))
diff --git a/tests/run-make/rustdoc-io-error/rmake.rs b/tests/run-make/rustdoc-io-error/rmake.rs
index a5fae36e733da..31441d7ebc5c7 100644
--- a/tests/run-make/rustdoc-io-error/rmake.rs
+++ b/tests/run-make/rustdoc-io-error/rmake.rs
@@ -25,7 +25,7 @@ fn main() {
     permissions.set_readonly(true);
     rfs::set_permissions(&out_dir, permissions);
 
-    let output = rustdoc().input("foo.rs").output(&out_dir).env("RUST_BACKTRACE", "1").run_fail();
+    let output = rustdoc().input("foo.rs").out_dir(&out_dir).env("RUST_BACKTRACE", "1").run_fail();
 
     rfs::set_permissions(&out_dir, original_permissions);
 
diff --git a/tests/run-make/rustdoc-map-file/rmake.rs b/tests/run-make/rustdoc-map-file/rmake.rs
index 08f9595ef9f6a..a4485165fd277 100644
--- a/tests/run-make/rustdoc-map-file/rmake.rs
+++ b/tests/run-make/rustdoc-map-file/rmake.rs
@@ -6,7 +6,7 @@ fn main() {
         .input("foo.rs")
         .arg("-Zunstable-options")
         .arg("--generate-redirect-map")
-        .output(&out_dir)
+        .out_dir(&out_dir)
         .run();
     // FIXME (GuillaumeGomez): Port the python script to Rust as well.
     python_command().arg("validate_json.py").arg(&out_dir).run();
diff --git a/tests/run-make/rustdoc-output-path/rmake.rs b/tests/run-make/rustdoc-output-path/rmake.rs
index 3c1ccd3a06936..181239eac4dd3 100644
--- a/tests/run-make/rustdoc-output-path/rmake.rs
+++ b/tests/run-make/rustdoc-output-path/rmake.rs
@@ -6,6 +6,6 @@ use run_make_support::rustdoc;
 
 fn main() {
     let out_dir = Path::new("foo/bar/doc");
-    rustdoc().input("foo.rs").output(&out_dir).run();
+    rustdoc().input("foo.rs").out_dir(&out_dir).run();
     assert!(out_dir.exists());
 }
diff --git a/tests/run-make/rustdoc-output-stdout/rmake.rs b/tests/run-make/rustdoc-output-stdout/rmake.rs
index e7dfb66602cf3..dbc9892f3f59a 100644
--- a/tests/run-make/rustdoc-output-stdout/rmake.rs
+++ b/tests/run-make/rustdoc-output-stdout/rmake.rs
@@ -10,7 +10,7 @@ fn main() {
     // First we check that we generate the JSON in the stdout.
     rustdoc()
         .input("foo.rs")
-        .output("-")
+        .out_dir("-")
         .arg("-Zunstable-options")
         .output_format("json")
         .run()
diff --git a/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs b/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs
index b77df7adc8d9e..546a0685b4ee5 100644
--- a/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs
+++ b/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs
@@ -35,7 +35,7 @@ fn main() {
         .input("examples/ex.rs")
         .crate_name("ex")
         .crate_type("bin")
-        .output(&out_dir)
+        .out_dir(&out_dir)
         .extern_(crate_name, rust_lib_name(crate_name))
         .extern_(proc_crate_name, dylib_name.trim())
         .arg("-Zunstable-options")
@@ -49,7 +49,7 @@ fn main() {
         .input("src/lib.rs")
         .crate_name(crate_name)
         .crate_type("lib")
-        .output(&out_dir)
+        .out_dir(&out_dir)
         .arg("-Zunstable-options")
         .arg("--with-examples")
         .arg(&ex_dir)
diff --git a/tests/run-make/rustdoc-scrape-examples-remap/scrape.rs b/tests/run-make/rustdoc-scrape-examples-remap/scrape.rs
index eca07043b557c..c4d7814c3c831 100644
--- a/tests/run-make/rustdoc-scrape-examples-remap/scrape.rs
+++ b/tests/run-make/rustdoc-scrape-examples-remap/scrape.rs
@@ -20,7 +20,7 @@ pub fn scrape(extra_args: &[&str]) {
             .input(&dep)
             .crate_name(&dep_stem)
             .crate_type("bin")
-            .output(&out_dir)
+            .out_dir(&out_dir)
             .extern_(crate_name, format!("lib{crate_name}.rmeta"))
             .arg("-Zunstable-options")
             .arg("--scrape-examples-output-path")
@@ -35,7 +35,7 @@ pub fn scrape(extra_args: &[&str]) {
     let mut rustdoc = rustdoc();
     rustdoc
         .input("src/lib.rs")
-        .output(&out_dir)
+        .out_dir(&out_dir)
         .crate_name(crate_name)
         .crate_type("lib")
         .arg("-Zunstable-options");
diff --git a/tests/run-make/rustdoc-target-spec-json-path/rmake.rs b/tests/run-make/rustdoc-target-spec-json-path/rmake.rs
index 3246fc5650646..fe9587f502228 100644
--- a/tests/run-make/rustdoc-target-spec-json-path/rmake.rs
+++ b/tests/run-make/rustdoc-target-spec-json-path/rmake.rs
@@ -7,7 +7,7 @@ fn main() {
     rustc().crate_type("lib").input("dummy_core.rs").target("target.json").run();
     rustdoc()
         .input("my_crate.rs")
-        .output(out_dir)
+        .out_dir(out_dir)
         .library_search_path(cwd())
         .target("target.json")
         .run();
diff --git a/tests/run-make/rustdoc-themes/rmake.rs b/tests/run-make/rustdoc-themes/rmake.rs
index 8a961beb9f742..4577e47d47e72 100644
--- a/tests/run-make/rustdoc-themes/rmake.rs
+++ b/tests/run-make/rustdoc-themes/rmake.rs
@@ -27,6 +27,6 @@ fn main() {
     rfs::create_dir_all(&out_dir);
     rfs::write(&test_css, test_content);
 
-    rustdoc().output(&out_dir).input("foo.rs").arg("--theme").arg(&test_css).run();
+    rustdoc().out_dir(&out_dir).input("foo.rs").arg("--theme").arg(&test_css).run();
     htmldocck().arg(out_dir).arg("foo.rs").run();
 }
diff --git a/tests/run-make/rustdoc-with-out-dir-option/rmake.rs b/tests/run-make/rustdoc-with-out-dir-option/rmake.rs
index ded89c9ae7913..a82a1965a9c9d 100644
--- a/tests/run-make/rustdoc-with-out-dir-option/rmake.rs
+++ b/tests/run-make/rustdoc-with-out-dir-option/rmake.rs
@@ -2,6 +2,6 @@ use run_make_support::{htmldocck, rustdoc};
 
 fn main() {
     let out_dir = "rustdoc";
-    rustdoc().input("src/lib.rs").crate_name("foobar").crate_type("lib").output(&out_dir).run();
+    rustdoc().input("src/lib.rs").crate_name("foobar").crate_type("lib").out_dir(&out_dir).run();
     htmldocck().arg(out_dir).arg("src/lib.rs").run();
 }

From 7c4d56102a869ec37e74d2874d33f130d81775ef Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Wed, 7 Aug 2024 11:17:54 -0400
Subject: [PATCH 293/685] coalesce dep-info-spaces and dep-info-doesnt-run-much
 into dep-info

---
 .../tidy/src/allowed_run_make_makefiles.txt   |  3 --
 .../dep-info-doesnt-run-much/Makefile         |  4 --
 tests/run-make/dep-info-spaces/Makefile       | 19 ----------
 tests/run-make/dep-info-spaces/Makefile.foo   |  7 ----
 tests/run-make/dep-info-spaces/bar.rs         |  1 -
 tests/run-make/dep-info/Makefile              | 25 -------------
 tests/run-make/dep-info/Makefile.foo          |  7 ----
 .../foo.rs => dep-info/erroneous.rs}          |  0
 .../{dep-info-spaces => dep-info}/foo foo.rs  |  0
 .../lib.rs => dep-info/lib_foofoo.rs}         |  0
 tests/run-make/dep-info/rmake.rs              | 37 +++++++++++++++++++
 11 files changed, 37 insertions(+), 66 deletions(-)
 delete mode 100644 tests/run-make/dep-info-doesnt-run-much/Makefile
 delete mode 100644 tests/run-make/dep-info-spaces/Makefile
 delete mode 100644 tests/run-make/dep-info-spaces/Makefile.foo
 delete mode 100644 tests/run-make/dep-info-spaces/bar.rs
 delete mode 100644 tests/run-make/dep-info/Makefile
 delete mode 100644 tests/run-make/dep-info/Makefile.foo
 rename tests/run-make/{dep-info-doesnt-run-much/foo.rs => dep-info/erroneous.rs} (100%)
 rename tests/run-make/{dep-info-spaces => dep-info}/foo foo.rs (100%)
 rename tests/run-make/{dep-info-spaces/lib.rs => dep-info/lib_foofoo.rs} (100%)
 create mode 100644 tests/run-make/dep-info/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index ce8a4030130b5..6f0fb8959b77f 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -1,8 +1,5 @@
 run-make/branch-protection-check-IBT/Makefile
 run-make/cat-and-grep-sanity-check/Makefile
-run-make/dep-info-doesnt-run-much/Makefile
-run-make/dep-info-spaces/Makefile
-run-make/dep-info/Makefile
 run-make/emit-to-stdout/Makefile
 run-make/extern-fn-reachable/Makefile
 run-make/incr-add-rust-src-component/Makefile
diff --git a/tests/run-make/dep-info-doesnt-run-much/Makefile b/tests/run-make/dep-info-doesnt-run-much/Makefile
deleted file mode 100644
index b4dc44ad2be84..0000000000000
--- a/tests/run-make/dep-info-doesnt-run-much/Makefile
+++ /dev/null
@@ -1,4 +0,0 @@
-include ../tools.mk
-
-all:
-	$(RUSTC) foo.rs --emit dep-info
diff --git a/tests/run-make/dep-info-spaces/Makefile b/tests/run-make/dep-info-spaces/Makefile
deleted file mode 100644
index 0cfe513e490a7..0000000000000
--- a/tests/run-make/dep-info-spaces/Makefile
+++ /dev/null
@@ -1,19 +0,0 @@
-include ../tools.mk
-
-# ignore-windows
-# ignore-freebsd
-# FIXME: (windows: see `../dep-info/Makefile`)
-
-all:
-	cp lib.rs $(TMPDIR)/
-	cp 'foo foo.rs' $(TMPDIR)/
-	cp bar.rs $(TMPDIR)/
-	$(RUSTC) --emit link,dep-info --crate-type=lib $(TMPDIR)/lib.rs
-	sleep 1
-	touch $(TMPDIR)/'foo foo.rs'
-	-rm -f $(TMPDIR)/done
-	$(MAKE) -drf Makefile.foo
-	rm $(TMPDIR)/done
-	pwd
-	$(MAKE) -drf Makefile.foo
-	rm $(TMPDIR)/done && exit 1 || exit 0
diff --git a/tests/run-make/dep-info-spaces/Makefile.foo b/tests/run-make/dep-info-spaces/Makefile.foo
deleted file mode 100644
index 80a5d4333cdc2..0000000000000
--- a/tests/run-make/dep-info-spaces/Makefile.foo
+++ /dev/null
@@ -1,7 +0,0 @@
-LIB := $(shell $(RUSTC) --print file-names --crate-type=lib $(TMPDIR)/lib.rs)
-
-$(TMPDIR)/$(LIB):
-	$(RUSTC) --emit link,dep-info --crate-type=lib $(TMPDIR)/lib.rs
-	touch $(TMPDIR)/done
-
--include $(TMPDIR)/lib.d
diff --git a/tests/run-make/dep-info-spaces/bar.rs b/tests/run-make/dep-info-spaces/bar.rs
deleted file mode 100644
index c5c0bc606cd69..0000000000000
--- a/tests/run-make/dep-info-spaces/bar.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub fn bar() {}
diff --git a/tests/run-make/dep-info/Makefile b/tests/run-make/dep-info/Makefile
deleted file mode 100644
index c76f43a8eed51..0000000000000
--- a/tests/run-make/dep-info/Makefile
+++ /dev/null
@@ -1,25 +0,0 @@
-include ../tools.mk
-
-# ignore-windows
-# ignore-freebsd
-# FIXME: on windows `rustc --dep-info` produces Makefile dependency with
-# windows native paths (e.g. `c:\path\to\libfoo.a`)
-# but msys make seems to fail to recognize such paths, so test fails.
-
-all:
-	cp *.rs $(TMPDIR)
-	$(RUSTC) --emit dep-info,link --crate-type=lib $(TMPDIR)/lib.rs
-	sleep 2
-	touch $(TMPDIR)/foo.rs
-	-rm -f $(TMPDIR)/done
-	$(MAKE) -drf Makefile.foo
-	sleep 2
-	rm $(TMPDIR)/done
-	pwd
-	$(MAKE) -drf Makefile.foo
-	rm $(TMPDIR)/done && exit 1 || exit 0
-
-	# When a source file is deleted `make` should still work
-	rm $(TMPDIR)/bar.rs
-	cp $(TMPDIR)/lib2.rs $(TMPDIR)/lib.rs
-	$(MAKE) -drf Makefile.foo
diff --git a/tests/run-make/dep-info/Makefile.foo b/tests/run-make/dep-info/Makefile.foo
deleted file mode 100644
index e5df31f88c1e1..0000000000000
--- a/tests/run-make/dep-info/Makefile.foo
+++ /dev/null
@@ -1,7 +0,0 @@
-LIB := $(shell $(RUSTC) --print file-names --crate-type=lib lib.rs)
-
-$(TMPDIR)/$(LIB):
-	$(RUSTC) --emit dep-info,link --crate-type=lib lib.rs
-	touch $(TMPDIR)/done
-
--include $(TMPDIR)/foo.d
diff --git a/tests/run-make/dep-info-doesnt-run-much/foo.rs b/tests/run-make/dep-info/erroneous.rs
similarity index 100%
rename from tests/run-make/dep-info-doesnt-run-much/foo.rs
rename to tests/run-make/dep-info/erroneous.rs
diff --git a/tests/run-make/dep-info-spaces/foo foo.rs b/tests/run-make/dep-info/foo foo.rs
similarity index 100%
rename from tests/run-make/dep-info-spaces/foo foo.rs
rename to tests/run-make/dep-info/foo foo.rs
diff --git a/tests/run-make/dep-info-spaces/lib.rs b/tests/run-make/dep-info/lib_foofoo.rs
similarity index 100%
rename from tests/run-make/dep-info-spaces/lib.rs
rename to tests/run-make/dep-info/lib_foofoo.rs
diff --git a/tests/run-make/dep-info/rmake.rs b/tests/run-make/dep-info/rmake.rs
new file mode 100644
index 0000000000000..508569b7671c1
--- /dev/null
+++ b/tests/run-make/dep-info/rmake.rs
@@ -0,0 +1,37 @@
+// This is a simple smoke test for rustc's `--emit dep-info` feature. It prints out
+// information about dependencies in a Makefile-compatible format, as a `.d` file.
+// Note that this test does not check that the `.d` file is Makefile-compatible.
+
+// This test first checks that emitting dep-info disables static analysis, preventing
+// compilation of `erroneous.rs` from causing a compilation failure.
+// Then, it checks that compilation using the flag is successful in general, even with
+// empty source files or source files that contain a whitespace character.
+
+// Finally, it removes one dependency and checks that compilation is still successful.
+// See https://github.com/rust-lang/rust/pull/10698
+
+use run_make_support::{rfs, rustc};
+
+fn main() {
+    // We're only emitting dep info, so we shouldn't be running static analysis to
+    // figure out that this program is erroneous.
+    rustc().input("erroneous.rs").emit("dep-info").run();
+
+    rustc().input("lib.rs").emit("dep-info,link").crate_type("lib").run();
+    rfs::remove_file("foo.rs");
+    rfs::create_file("foo.rs");
+    // Compilation should succeed even if `foo.rs` is empty.
+    rustc().input("lib.rs").emit("dep-info,link").crate_type("lib").run();
+
+    // Again, with a space in the filename this time around.
+    rustc().input("lib_foofoo.rs").emit("dep-info,link").crate_type("lib").run();
+    rfs::remove_file("foo foo.rs");
+    rfs::create_file("foo foo.rs");
+    // Compilation should succeed even if `foo foo.rs` is empty.
+    rustc().input("lib_foofoo.rs").emit("dep-info,link").crate_type("lib").run();
+
+    // When a source file is deleted, compilation should still succeed if the library
+    // also loses this source file dependency.
+    rfs::remove_file("bar.rs");
+    rustc().input("lib2.rs").emit("dep-info,link").crate_type("lib").run();
+}

From 2e4d5bbba7b4efe27b8afca47fef98a2254e684b Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Mon, 12 Aug 2024 13:26:25 -0400
Subject: [PATCH 294/685] rewrite rlib-format-packed-bundled-libs to rmake

---
 .../src/external_deps/llvm.rs                 |  6 ++
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 .../rlib-format-packed-bundled-libs/Makefile  | 39 ---------
 .../rlib-format-packed-bundled-libs/rmake.rs  | 81 +++++++++++++++++++
 4 files changed, 87 insertions(+), 40 deletions(-)
 delete mode 100644 tests/run-make/rlib-format-packed-bundled-libs/Makefile
 create mode 100644 tests/run-make/rlib-format-packed-bundled-libs/rmake.rs

diff --git a/src/tools/run-make-support/src/external_deps/llvm.rs b/src/tools/run-make-support/src/external_deps/llvm.rs
index 7af79443affd6..021858dea7a27 100644
--- a/src/tools/run-make-support/src/external_deps/llvm.rs
+++ b/src/tools/run-make-support/src/external_deps/llvm.rs
@@ -291,6 +291,12 @@ impl LlvmAr {
         self
     }
 
+    /// Print the table of contents.
+    pub fn table_of_contents(&mut self) -> &mut Self {
+        self.cmd.arg("t");
+        self
+    }
+
     /// Provide an output, then an input file. Bundled in one function, as llvm-ar has
     /// no "--output"-style flag.
     pub fn output_input(&mut self, out: impl AsRef<Path>, input: impl AsRef<Path>) -> &mut Self {
diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index bc4465557738e..34008623a4c39 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -15,7 +15,6 @@ run-make/libtest-thread-limit/Makefile
 run-make/macos-deployment-target/Makefile
 run-make/native-link-modifier-bundle/Makefile
 run-make/reproducible-build/Makefile
-run-make/rlib-format-packed-bundled-libs/Makefile
 run-make/split-debuginfo/Makefile
 run-make/symbol-mangling-hashed/Makefile
 run-make/translation/Makefile
diff --git a/tests/run-make/rlib-format-packed-bundled-libs/Makefile b/tests/run-make/rlib-format-packed-bundled-libs/Makefile
deleted file mode 100644
index f454da67893d0..0000000000000
--- a/tests/run-make/rlib-format-packed-bundled-libs/Makefile
+++ /dev/null
@@ -1,39 +0,0 @@
-include ../tools.mk
-
-# ignore-cross-compile
-
-# Make sure rlib format with -Zpacked_bundled_libs is correct.
-
-# We're using the llvm-nm instead of the system nm to ensure it is compatible
-# with the LLVM bitcode generated by rustc.
-# Except on Windows where piping/IO redirection under MSYS2 is wonky with llvm-nm.
-ifndef IS_WINDOWS
-NM = "$(LLVM_BIN_DIR)"/llvm-nm
-else
-NM = nm
-endif
-
-all: $(call NATIVE_STATICLIB,native_dep_1) $(call NATIVE_STATICLIB,native_dep_2) $(call NATIVE_STATICLIB,native_dep_3)
-	$(RUSTC) rust_dep_up.rs --crate-type=rlib -Zpacked_bundled_libs
-	$(NM) $(TMPDIR)/librust_dep_up.rlib | $(CGREP) -e "U.*native_f2"
-	$(NM) $(TMPDIR)/librust_dep_up.rlib | $(CGREP) -e "U.*native_f3"
-	$(NM) $(TMPDIR)/librust_dep_up.rlib | $(CGREP) -e "T.*rust_dep_up"
-	$(AR) t $(TMPDIR)/librust_dep_up.rlib | $(CGREP) "native_dep_2"
-	$(AR) t $(TMPDIR)/librust_dep_up.rlib | $(CGREP) "native_dep_3"
-	$(RUSTC) rust_dep_local.rs --extern rlib=$(TMPDIR)/librust_dep_up.rlib -Zpacked_bundled_libs --crate-type=rlib
-	$(NM) $(TMPDIR)/librust_dep_local.rlib | $(CGREP) -e "U.*native_f1"
-	$(NM) $(TMPDIR)/librust_dep_local.rlib | $(CGREP) -e "T.*rust_dep_local"
-	$(AR) t $(TMPDIR)/librust_dep_local.rlib | $(CGREP) "native_dep_1"
-
-	# Make sure compiler doesn't use files, that it shouldn't know about.
-	rm $(TMPDIR)/*native_dep_*
-
-	$(RUSTC) main.rs --extern lib=$(TMPDIR)/librust_dep_local.rlib -o $(TMPDIR)/main.exe -Zpacked_bundled_libs --print link-args | $(CGREP) -e "native_dep_1.*native_dep_2.*native_dep_3"
-
-ifndef IS_MSVC
-	$(NM) $(TMPDIR)/main.exe | $(CGREP) -e "T.*native_f1"
-	$(NM) $(TMPDIR)/main.exe | $(CGREP) -e "T.*native_f2"
-	$(NM) $(TMPDIR)/main.exe | $(CGREP) -e "T.*native_f3"
-	$(NM) $(TMPDIR)/main.exe | $(CGREP) -e "T.*rust_dep_local"
-	$(NM) $(TMPDIR)/main.exe | $(CGREP) -e "T.*rust_dep_up"
-endif
diff --git a/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs b/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs
new file mode 100644
index 0000000000000..7cd0932ecf342
--- /dev/null
+++ b/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs
@@ -0,0 +1,81 @@
+// `-Z packed_bundled_libs` is an unstable rustc flag that makes the compiler
+// only require a native library and no supplementary object files to compile.
+// Output files compiled with this flag should still contain all expected symbols -
+// that is what this test checks.
+// See https://github.com/rust-lang/rust/pull/100101
+
+// FIXME(Oneirical): MSVC and cross-compile
+
+use run_make_support::{
+    bin_name, build_native_static_lib, cwd, filename_contains, llvm_ar, llvm_nm, rfs,
+    rust_lib_name, rustc, shallow_find_files,
+};
+
+fn main() {
+    build_native_static_lib("native_dep_1");
+    build_native_static_lib("native_dep_2");
+    build_native_static_lib("native_dep_3");
+    rustc().input("rust_dep_up.rs").crate_type("rlib").arg("-Zpacked_bundled_libs").run();
+    llvm_nm()
+        .input(rust_lib_name("rust_dep_up"))
+        .run()
+        .assert_stdout_contains_regex("U.*native_f2");
+    llvm_nm()
+        .input(rust_lib_name("rust_dep_up"))
+        .run()
+        .assert_stdout_contains_regex("U.*native_f3");
+    llvm_nm()
+        .input(rust_lib_name("rust_dep_up"))
+        .run()
+        .assert_stdout_contains_regex("T.*rust_dep_up");
+    llvm_ar()
+        .table_of_contents()
+        .arg(rust_lib_name("rust_dep_up"))
+        .run()
+        .assert_stdout_contains("native_dep_2");
+    llvm_ar()
+        .table_of_contents()
+        .arg(rust_lib_name("rust_dep_up"))
+        .run()
+        .assert_stdout_contains("native_dep_3");
+    rustc()
+        .input("rust_dep_local.rs")
+        .extern_("rlib", rust_lib_name("rust_dep_up"))
+        .arg("-Zpacked_bundled_libs")
+        .crate_type("rlib")
+        .run();
+    llvm_nm()
+        .input(rust_lib_name("rust_dep_local"))
+        .run()
+        .assert_stdout_contains_regex("U.*native_f1");
+    llvm_nm()
+        .input(rust_lib_name("rust_dep_local"))
+        .run()
+        .assert_stdout_contains_regex("T.*rust_dep_local");
+    llvm_ar()
+        .table_of_contents()
+        .arg(rust_lib_name("rust_dep_local"))
+        .run()
+        .assert_stdout_contains("native_dep_1");
+
+    // Ensure the compiler will not use files it should not know about.
+    for file in shallow_find_files(cwd(), |path| filename_contains(path, "native_dep_")) {
+        rfs::remove_file(file);
+    }
+
+    rustc()
+        .input("main.rs")
+        .extern_("lib", rust_lib_name("rust_dep_local"))
+        .output(bin_name("main"))
+        .arg("-Zpacked_bundled_libs")
+        .print("link-args")
+        .run()
+        .assert_stdout_contains_regex("native_dep_1.*native_dep_2.*native_dep_3");
+
+    //FIXME(Oneirical): This part will apparently fail on MSVC
+    llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f1");
+    llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f2");
+    llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f3");
+    llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*rust_dep_local");
+    llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*rust_dep_up");
+}

From 51628fb6662128306b4f5aa852729fff6b7f8e00 Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Mon, 12 Aug 2024 13:45:38 -0400
Subject: [PATCH 295/685] rewrite native-link-modifier-bundle to rmake

---
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 .../native-link-modifier-bundle/Makefile      | 38 --------
 .../native-link-modifier-bundle/rmake.rs      | 90 +++++++++++++++++++
 .../rlib-format-packed-bundled-libs/rmake.rs  | 19 ++--
 4 files changed, 101 insertions(+), 47 deletions(-)
 delete mode 100644 tests/run-make/native-link-modifier-bundle/Makefile
 create mode 100644 tests/run-make/native-link-modifier-bundle/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 34008623a4c39..dd0dbe7cb4b02 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -13,7 +13,6 @@ run-make/libtest-json/Makefile
 run-make/libtest-junit/Makefile
 run-make/libtest-thread-limit/Makefile
 run-make/macos-deployment-target/Makefile
-run-make/native-link-modifier-bundle/Makefile
 run-make/reproducible-build/Makefile
 run-make/split-debuginfo/Makefile
 run-make/symbol-mangling-hashed/Makefile
diff --git a/tests/run-make/native-link-modifier-bundle/Makefile b/tests/run-make/native-link-modifier-bundle/Makefile
deleted file mode 100644
index 527720922fe58..0000000000000
--- a/tests/run-make/native-link-modifier-bundle/Makefile
+++ /dev/null
@@ -1,38 +0,0 @@
-# ignore-cross-compile
-# ignore-windows-msvc
-
-include ../tools.mk
-
-# We're using the llvm-nm instead of the system nm to ensure it is compatible
-# with the LLVM bitcode generated by rustc.
-# Except on Windows where piping/IO redirection under MSYS2 is wonky with llvm-nm.
-ifndef IS_WINDOWS
-NM = "$(LLVM_BIN_DIR)"/llvm-nm
-else
-NM = nm
-endif
-
-all: $(call NATIVE_STATICLIB,native-staticlib)
-	# Build a staticlib and a rlib, the `native_func` symbol will be bundled into them
-	$(RUSTC) bundled.rs --crate-type=staticlib --crate-type=rlib
-	$(NM) $(TMPDIR)/libbundled.a | $(CGREP) -e "T _*native_func"
-	$(NM) $(TMPDIR)/libbundled.a | $(CGREP) -e "U _*native_func"
-	$(NM) $(TMPDIR)/libbundled.rlib | $(CGREP) -e "T _*native_func"
-	$(NM) $(TMPDIR)/libbundled.rlib | $(CGREP) -e "U _*native_func"
-
-	# Build a staticlib and a rlib, the `native_func` symbol will not be bundled into it
-	$(RUSTC) non-bundled.rs --crate-type=staticlib --crate-type=rlib
-	$(NM) $(TMPDIR)/libnon_bundled.a | $(CGREP) -ve "T _*native_func"
-	$(NM) $(TMPDIR)/libnon_bundled.a | $(CGREP) -e "U _*native_func"
-	$(NM) $(TMPDIR)/libnon_bundled.rlib | $(CGREP) -ve "T _*native_func"
-	$(NM) $(TMPDIR)/libnon_bundled.rlib | $(CGREP) -e "U _*native_func"
-
-	# Build a cdylib, `native-staticlib` will not appear on the linker line because it was bundled previously
-	# The cdylib will contain the `native_func` symbol in the end
-	$(RUSTC) cdylib-bundled.rs --crate-type=cdylib --print link-args | $(CGREP) -ve '-l[" ]*native-staticlib'
-	$(NM) $(call DYLIB,cdylib_bundled) | $(CGREP) -e "[Tt] _*native_func"
-
-	# Build a cdylib, `native-staticlib` will appear on the linker line because it was not bundled previously
-	# The cdylib will contain the `native_func` symbol in the end
-	$(RUSTC) cdylib-non-bundled.rs --crate-type=cdylib --print link-args | $(CGREP) -e '-l[" ]*native-staticlib'
-	$(NM) $(call DYLIB,cdylib_non_bundled) | $(CGREP) -e "[Tt] _*native_func"
diff --git a/tests/run-make/native-link-modifier-bundle/rmake.rs b/tests/run-make/native-link-modifier-bundle/rmake.rs
new file mode 100644
index 0000000000000..058b66b15f12f
--- /dev/null
+++ b/tests/run-make/native-link-modifier-bundle/rmake.rs
@@ -0,0 +1,90 @@
+// This test exercises the `bundle` link argument, which can be turned on or off.
+
+// When building a rlib or staticlib, +bundle means that all object files from the native static
+// library will be added to the rlib or staticlib archive, and then used from it during linking of
+// the final binary.
+
+// When building a rlib -bundle means that the native static library is registered as a dependency
+// of that rlib "by name", and object files from it are included only during linking of the final
+// binary, the file search by that name is also performed during final linking.
+// When building a staticlib -bundle means that the native static library is simply not included
+// into the archive and some higher level build system will need to add it later during linking of
+// the final binary.
+
+// This modifier has no effect when building other targets like executables or dynamic libraries.
+
+// The default for this modifier is +bundle.
+// See https://github.com/rust-lang/rust/pull/95818
+
+//@ ignore-cross-compile
+// Reason: cross-compilation fails to export native symbols
+
+use run_make_support::{
+    build_native_static_lib, dynamic_lib_name, is_msvc, llvm_nm, rust_lib_name, rustc,
+    static_lib_name,
+};
+
+fn main() {
+    build_native_static_lib("native-staticlib");
+    // Build a staticlib and a rlib, the `native_func` symbol will be bundled into them
+    rustc().input("bundled.rs").crate_type("staticlib").crate_type("rlib").run();
+    llvm_nm()
+        .input(static_lib_name("bundled"))
+        .run()
+        .assert_stdout_contains_regex("T _*native_func");
+    llvm_nm()
+        .input(static_lib_name("bundled"))
+        .run()
+        .assert_stdout_contains_regex("U _*native_func");
+    llvm_nm().input(rust_lib_name("bundled")).run().assert_stdout_contains_regex("T _*native_func");
+    llvm_nm().input(rust_lib_name("bundled")).run().assert_stdout_contains_regex("U _*native_func");
+
+    // Build a staticlib and a rlib, the `native_func` symbol will not be bundled into it
+    build_native_static_lib("native-staticlib");
+    rustc().input("non-bundled.rs").crate_type("staticlib").crate_type("rlib").run();
+    llvm_nm()
+        .input(static_lib_name("non_bundled"))
+        .run()
+        .assert_stdout_not_contains_regex("T _*native_func");
+    llvm_nm()
+        .input(static_lib_name("non_bundled"))
+        .run()
+        .assert_stdout_contains_regex("U _*native_func");
+    llvm_nm()
+        .input(rust_lib_name("non_bundled"))
+        .run()
+        .assert_stdout_not_contains_regex("T _*native_func");
+    llvm_nm()
+        .input(rust_lib_name("non_bundled"))
+        .run()
+        .assert_stdout_contains_regex("U _*native_func");
+
+    // This part of the test does not function on Windows MSVC - no symbols are printed.
+    if !is_msvc() {
+        // Build a cdylib, `native-staticlib` will not appear on the linker line because it was
+        // bundled previously. The cdylib will contain the `native_func` symbol in the end.
+        rustc()
+            .input("cdylib-bundled.rs")
+            .crate_type("cdylib")
+            .print("link-args")
+            .run()
+            .assert_stdout_not_contains(r#"-l[" ]*native-staticlib"#);
+        llvm_nm()
+            .input(dynamic_lib_name("cdylib_bundled"))
+            .run()
+            .assert_stdout_contains_regex("[Tt] _*native_func");
+
+        // Build a cdylib, `native-staticlib` will appear on the linker line because it was not
+        // bundled previously. The cdylib will contain the `native_func` symbol in the end
+        rustc()
+            .input("cdylib-non-bundled.rs")
+            .crate_type("cdylib")
+            .print("link-args")
+            .run()
+            .assert_stdout_contains_regex(r#"-l[" ]*native-staticlib"#);
+        llvm_nm()
+            .input(dynamic_lib_name("cdylib_non_bundled"))
+            .run()
+            .assert_stdout_contains_regex("[Tt] _*native_func");
+    }
+}
diff --git a/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs b/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs
index 7cd0932ecf342..ff0438a6b72be 100644
--- a/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs
+++ b/tests/run-make/rlib-format-packed-bundled-libs/rmake.rs
@@ -4,10 +4,11 @@
 // that is what this test checks.
 // See https://github.com/rust-lang/rust/pull/100101
 
-// FIXME(Oneirical): MSVC and cross-compile
+//@ ignore-cross-compile
+// Reason: cross-compilation fails to export native symbols
 
 use run_make_support::{
-    bin_name, build_native_static_lib, cwd, filename_contains, llvm_ar, llvm_nm, rfs,
+    bin_name, build_native_static_lib, cwd, filename_contains, is_msvc, llvm_ar, llvm_nm, rfs,
     rust_lib_name, rustc, shallow_find_files,
 };
 
@@ -72,10 +73,12 @@ fn main() {
         .run()
         .assert_stdout_contains_regex("native_dep_1.*native_dep_2.*native_dep_3");
 
-    //FIXME(Oneirical): This part will apparently fail on MSVC
-    llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f1");
-    llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f2");
-    llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f3");
-    llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*rust_dep_local");
-    llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*rust_dep_up");
+    // The binary "main" will not contain any symbols on MSVC.
+    if !is_msvc() {
+        llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f1");
+        llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f2");
+        llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*native_f3");
+        llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*rust_dep_local");
+        llvm_nm().input(bin_name("main")).run().assert_stdout_contains_regex("T.*rust_dep_up");
+    }
 }

From 9a95573c2bb3e76643f0c1c4deb5eea24c37ec5c Mon Sep 17 00:00:00 2001
From: Ian Jackson <ijackson@chiark.greenend.org.uk>
Date: Mon, 5 Aug 2024 17:25:00 +0100
Subject: [PATCH 296/685] Add cautionary paragraph about noop wakers.

Based on a suggestion from @kpreid, with some further editing.
---
 library/core/src/task/wake.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/library/core/src/task/wake.rs b/library/core/src/task/wake.rs
index baa8a956f8af1..4d2de6be025bc 100644
--- a/library/core/src/task/wake.rs
+++ b/library/core/src/task/wake.rs
@@ -539,6 +539,10 @@ impl Waker {
     /// some futures, but are not expecting those futures to wake the waker or
     /// do not need to do anything specific if it happens.
     ///
+    /// More generally, using `Waker::noop()` to poll a future
+    /// means discarding the notification of when the future should be polled again.
+    /// So it should only be used when such a notification will not be needed to make progress.
+    ///
     /// If an owned `Waker` is needed, `clone()` this one.
     ///
     /// # Examples
@@ -796,6 +800,10 @@ impl LocalWaker {
     /// some futures, but are not expecting those futures to wake the waker or
     /// do not need to do anything specific if it happens.
     ///
+    /// More generally, using `LocalWaker::noop()` to poll a future
+    /// means discarding the notification of when the future should be polled again,
+    /// So it should only be used when such a notification will not be needed to make progress.
+    ///
     /// If an owned `LocalWaker` is needed, `clone()` this one.
     ///
     /// # Examples

From 478d42bdc2ba3753c9177fb4de62c0b64c806e6c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <jakub.beranek@vsb.cz>
Date: Wed, 14 Aug 2024 16:11:46 +0200
Subject: [PATCH 297/685] Print more verbose error for commands that capture
 output

---
 src/bootstrap/src/lib.rs        | 26 ++++++++++++++++++++++----
 src/bootstrap/src/utils/exec.rs | 10 ++++++++++
 2 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index bfd0e42acfd32..1e2e90105a9a9 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -1056,11 +1056,29 @@ Executed at: {executed_at}"#,
             }
         };
 
-        let fail = |message: &str| {
+        let fail = |message: &str, output: CommandOutput| -> ! {
             if self.is_verbose() {
                 println!("{message}");
             } else {
-                println!("Command has failed. Rerun with -v to see more details.");
+                let (stdout, stderr) = (output.stdout_if_present(), output.stderr_if_present());
+                // If the command captures output, the user would not see any indication that
+                // it has failed. In this case, print a more verbose error, since to provide more
+                // context.
+                if stdout.is_some() || stderr.is_some() {
+                    if let Some(stdout) =
+                        output.stdout_if_present().take_if(|s| !s.trim().is_empty())
+                    {
+                        println!("STDOUT:\n{stdout}\n");
+                    }
+                    if let Some(stderr) =
+                        output.stderr_if_present().take_if(|s| !s.trim().is_empty())
+                    {
+                        println!("STDERR:\n{stderr}\n");
+                    }
+                    println!("Command {command:?} has failed. Rerun with -v to see more details.");
+                } else {
+                    println!("Command has failed. Rerun with -v to see more details.");
+                }
             }
             exit!(1);
         };
@@ -1069,14 +1087,14 @@ Executed at: {executed_at}"#,
             match command.failure_behavior {
                 BehaviorOnFailure::DelayFail => {
                     if self.fail_fast {
-                        fail(&message);
+                        fail(&message, output);
                     }
 
                     let mut failures = self.delayed_failures.borrow_mut();
                     failures.push(message);
                 }
                 BehaviorOnFailure::Exit => {
-                    fail(&message);
+                    fail(&message, output);
                 }
                 BehaviorOnFailure::Ignore => {
                     // If failures are allowed, either the error has been printed already
diff --git a/src/bootstrap/src/utils/exec.rs b/src/bootstrap/src/utils/exec.rs
index 9f0d0b7e9691f..530d760a584c8 100644
--- a/src/bootstrap/src/utils/exec.rs
+++ b/src/bootstrap/src/utils/exec.rs
@@ -291,6 +291,11 @@ impl CommandOutput {
         .expect("Cannot parse process stdout as UTF-8")
     }
 
+    #[must_use]
+    pub fn stdout_if_present(&self) -> Option<String> {
+        self.stdout.as_ref().and_then(|s| String::from_utf8(s.clone()).ok())
+    }
+
     #[must_use]
     pub fn stdout_if_ok(&self) -> Option<String> {
         if self.is_success() { Some(self.stdout()) } else { None }
@@ -303,6 +308,11 @@ impl CommandOutput {
         )
         .expect("Cannot parse process stderr as UTF-8")
     }
+
+    #[must_use]
+    pub fn stderr_if_present(&self) -> Option<String> {
+        self.stderr.as_ref().and_then(|s| String::from_utf8(s.clone()).ok())
+    }
 }
 
 impl Default for CommandOutput {

From f3e00339a7009e735dcc280eba62e8f5f30c4c98 Mon Sep 17 00:00:00 2001
From: Philipp Krones <hello@philkrones.com>
Date: Thu, 15 Aug 2024 21:09:17 +0200
Subject: [PATCH 298/685] flip1995: 2 week vacation

---
 triagebot.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/triagebot.toml b/triagebot.toml
index dcf00e4e384b0..99b3560a06427 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -20,6 +20,7 @@ new_pr = true
 [assign]
 contributing_url = "https://github.com/rust-lang/rust-clippy/blob/master/CONTRIBUTING.md"
 users_on_vacation = [
+    "flip1995",
     "matthiaskrgr",
     "giraffate",
 ]

From 7d99549073b8785feec85c9ed25eb29bb09daa29 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Thu, 15 Aug 2024 22:44:16 +0200
Subject: [PATCH 299/685] crashes: more tests

---
 tests/crashes/128695.rs | 11 +++++++++++
 tests/crashes/128810.rs | 25 +++++++++++++++++++++++++
 tests/crashes/128848.rs |  5 +++++
 tests/crashes/128870.rs | 18 ++++++++++++++++++
 tests/crashes/129075.rs | 16 ++++++++++++++++
 tests/crashes/129095.rs | 10 ++++++++++
 tests/crashes/129099.rs | 15 +++++++++++++++
 tests/crashes/129109.rs | 10 ++++++++++
 tests/crashes/129127.rs | 21 +++++++++++++++++++++
 9 files changed, 131 insertions(+)
 create mode 100644 tests/crashes/128695.rs
 create mode 100644 tests/crashes/128810.rs
 create mode 100644 tests/crashes/128848.rs
 create mode 100644 tests/crashes/128870.rs
 create mode 100644 tests/crashes/129075.rs
 create mode 100644 tests/crashes/129095.rs
 create mode 100644 tests/crashes/129099.rs
 create mode 100644 tests/crashes/129109.rs
 create mode 100644 tests/crashes/129127.rs

diff --git a/tests/crashes/128695.rs b/tests/crashes/128695.rs
new file mode 100644
index 0000000000000..661f427dc0e99
--- /dev/null
+++ b/tests/crashes/128695.rs
@@ -0,0 +1,11 @@
+//@ known-bug: rust-lang/rust#128695
+//@ edition: 2021
+
+use core::pin::{pin, Pin};
+
+fn main() {
+    let fut = pin!(async {
+        let async_drop_fut = pin!(core::future::async_drop(async {}));
+        (async_drop_fut).await;
+    });
+}
diff --git a/tests/crashes/128810.rs b/tests/crashes/128810.rs
new file mode 100644
index 0000000000000..68214ff010c99
--- /dev/null
+++ b/tests/crashes/128810.rs
@@ -0,0 +1,25 @@
+//@ known-bug: rust-lang/rust#128810
+
+#![feature(fn_delegation)]
+
+use std::marker::PhantomData;
+
+pub struct InvariantRef<'a, T: ?Sized>(&'a T, PhantomData<&'a mut &'a T>);
+
+impl<'a> InvariantRef<'a, ()> {
+    pub const NEW: Self = InvariantRef::new(&());
+}
+
+trait Trait {
+    fn foo(&self) -> u8 { 0 }
+    fn bar(&self) -> u8 { 1 }
+    fn meh(&self) -> u8 { 2 }
+}
+
+struct Z(u8);
+
+impl Trait for Z {
+    reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+}
+
+fn main() { }
diff --git a/tests/crashes/128848.rs b/tests/crashes/128848.rs
new file mode 100644
index 0000000000000..636811fc6b504
--- /dev/null
+++ b/tests/crashes/128848.rs
@@ -0,0 +1,5 @@
+//@ known-bug: rust-lang/rust#128848
+
+fn f<T>(a: T, b: T, c: T)  {
+    f.call_once()
+}
diff --git a/tests/crashes/128870.rs b/tests/crashes/128870.rs
new file mode 100644
index 0000000000000..2b7319621440c
--- /dev/null
+++ b/tests/crashes/128870.rs
@@ -0,0 +1,18 @@
+//@ known-bug: rust-lang/rust#128870
+//@ compile-flags: -Zvalidate-mir
+
+#[repr(packed)]
+#[repr(u32)]
+enum E {
+    A,
+    B,
+    C,
+}
+
+fn main() {
+    union InvalidTag {
+        int: u32,
+        e: E,
+    }
+    let _invalid_tag = InvalidTag { int: 4 };
+}
diff --git a/tests/crashes/129075.rs b/tests/crashes/129075.rs
new file mode 100644
index 0000000000000..4a0e920914cc5
--- /dev/null
+++ b/tests/crashes/129075.rs
@@ -0,0 +1,16 @@
+//@ known-bug: rust-lang/rust#129075
+//@ compile-flags: -Zvalidate-mir -Zinline-mir=yes
+
+struct Foo<T>([T; 2]);
+
+impl<T: Default + Copy> Default for Foo<T> {
+    fn default(&mut self) -> Self {
+        Foo([Default::default(); 2])
+    }
+}
+
+fn field_array() {
+    let a: i32;
+    let b;
+    Foo([a, b]) = Default::default();
+}
diff --git a/tests/crashes/129095.rs b/tests/crashes/129095.rs
new file mode 100644
index 0000000000000..ea70c0565fc36
--- /dev/null
+++ b/tests/crashes/129095.rs
@@ -0,0 +1,10 @@
+//@ known-bug: rust-lang/rust#129095
+//@ compile-flags: -Zmir-opt-level=5 -Zvalidate-mir
+
+pub fn function_with_bytes<const BYTES: &'static [u8; 4]>() -> &'static [u8] {
+    BYTES
+}
+
+pub fn main() {
+    assert_eq!(function_with_bytes::<b"AAAAb">(), &[0x41, 0x41, 0x41, 0x41]);
+}
diff --git a/tests/crashes/129099.rs b/tests/crashes/129099.rs
new file mode 100644
index 0000000000000..9aaab756b5b8d
--- /dev/null
+++ b/tests/crashes/129099.rs
@@ -0,0 +1,15 @@
+//@ known-bug: rust-lang/rust#129099
+
+#![feature(type_alias_impl_trait)]
+
+fn dyn_hoops<T: Sized>() -> dyn for<'a> Iterator<Item = impl Captures<'a>> {
+    loop {}
+}
+
+pub fn main() {
+    type Opaque = impl Sized;
+    fn define() -> Opaque {
+        let x: Opaque = dyn_hoops::<()>(0);
+        x
+    }
+}
diff --git a/tests/crashes/129109.rs b/tests/crashes/129109.rs
new file mode 100644
index 0000000000000..8b9ebdf03c779
--- /dev/null
+++ b/tests/crashes/129109.rs
@@ -0,0 +1,10 @@
+//@ known-bug: rust-lang/rust#129109
+//@ compile-flags: -Zmir-opt-level=5 -Zvalidate-mir
+
+extern "C" {
+    pub static mut symbol: [i8];
+}
+
+fn main() {
+    println!("C", unsafe { &symbol });
+}
diff --git a/tests/crashes/129127.rs b/tests/crashes/129127.rs
new file mode 100644
index 0000000000000..8ec848dbd0578
--- /dev/null
+++ b/tests/crashes/129127.rs
@@ -0,0 +1,21 @@
+//@ known-bug: rust-lang/rust#129127
+//@ compile-flags: -Zmir-opt-level=5 -Zvalidate-mir -Zcross-crate-inline-threshold=always
+
+
+
+
+pub struct Rows<'a>();
+
+impl<'a> Iterator for Rows<'a> {
+    type Item = ();
+
+    fn next() -> Option<Self::Item> {
+        let mut rows = Rows();
+        rows.map(|row| row).next()
+    }
+}
+
+fn main() {
+    let mut rows = Rows();
+    rows.next();
+}

From 293be4611db92ec26f4d631794cb4828bb487aa7 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Thu, 15 Aug 2024 22:45:10 +0200
Subject: [PATCH 300/685] add 'project' process guidlines for larger
 contributions

---
 src/tools/miri/CONTRIBUTING.md | 35 +++++++++++++++++++++++++++++++++-
 1 file changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/CONTRIBUTING.md b/src/tools/miri/CONTRIBUTING.md
index 1c76354eaeea4..ca03a9b16e36e 100644
--- a/src/tools/miri/CONTRIBUTING.md
+++ b/src/tools/miri/CONTRIBUTING.md
@@ -8,10 +8,43 @@ find useful.
 Check out the issues on this GitHub repository for some ideas. In particular,
 look for the green `E-*` labels which mark issues that should be rather
 well-suited for onboarding. For more ideas or help with hacking on Miri, you can
-contact us (`oli-obk` and `RalfJ`) on the [Rust Zulip].
+contact us on the [Rust Zulip]. See the [Rust website](https://www.rust-lang.org/governance/teams/compiler#team-miri)
+for a list of Miri maintainers.
 
 [Rust Zulip]: https://rust-lang.zulipchat.com
 
+### Larger-scale contributions
+
+If you are thinking about making a larger-scale contribution -- in particular anything that needs
+more than can reasonably fit in a single PR to be feature-complete -- then please talk to us before
+writing significant amounts of code. Generally, we will ask that you follow a three-step "project"
+process for such contributions:
+
+1. Clearly define the **goal** of the project. This defines the scope of the project, i.e. which
+   part of which APIs should be supported. If this involves functions that expose a big API surface
+   with lots of flags, the project may want to support only a tiny subset of flags; that should be
+   documented. A good way to express the goal is with one or more test cases that Miri should be
+   able to successfully execute when the project is completed. It is a good idea to get feedback
+   from team members already at this stage to ensure that the project is reasonably scoped and
+   aligns with our interests.
+2. Make a **design** for how to realize the goal. A larger project will likely have to do global
+   changes to Miri, like adding new global state to the `Machine` type or new methods to the
+   `FileDescription` trait. Often we have to iterate on those changes, which can quite substantially
+   change how the final implementation looks like.
+
+    The design should be reasonably concrete, i.e. for new global state or methods the corresponding
+   Rust types and method signatures should be spelled out. We realize that it can be hard to make a
+   design without doing implementation work, in particular if you are not yet familiar with the
+   codebase. Doing draft implementations in phase 2 of this process is perfectly fine, just please
+   be aware that we might request fundamental changes that can require significantly reworking what
+   you already did. If you open a PR in this stage, please clearly indicate that this project is
+   still in the design stage.
+
+3. Finish the **implementation** and have it reviewed.
+
+This process is largely informal, and its primary goal is to more clearly communicate expectations.
+Please get in touch with us if you have any questions!
+
 ## Preparing the build environment
 
 Miri heavily relies on internal and unstable rustc interfaces to execute MIR,

From 23273e03d7a9d6b22953be450a1fb86bdca25a98 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Thu, 15 Aug 2024 17:04:26 -0400
Subject: [PATCH 301/685] Disable macro-stepping on current lldb

---
 tests/debuginfo/macro-stepping.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/debuginfo/macro-stepping.rs b/tests/debuginfo/macro-stepping.rs
index d469cbb761fcb..3edac3c7832f9 100644
--- a/tests/debuginfo/macro-stepping.rs
+++ b/tests/debuginfo/macro-stepping.rs
@@ -1,7 +1,7 @@
 //@ ignore-windows
 //@ ignore-android
 //@ ignore-aarch64
-//@ min-lldb-version: 310
+//@ min-lldb-version: 1800
 //@ min-gdb-version: 13.0
 
 //@ aux-build:macro-stepping.rs
@@ -12,6 +12,7 @@
 extern crate macro_stepping; // exports new_scope!()
 
 //@ compile-flags:-g -Zmir-enable-passes=-SingleUseConsts
+// SingleUseConsts shouldn't need to be disabled, see #128945
 
 // === GDB TESTS ===================================================================================
 

From 194489473d6edf6d421d657b5716996f02230928 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 11 Jun 2024 10:27:44 +1000
Subject: [PATCH 302/685] Add `warn(unreachable_pub)` to several crates.

It requires no additonal changes to these crates, but will prevent
unnecessary `pub`s in the future.
---
 compiler/rustc_abi/src/lib.rs    | 1 +
 compiler/rustc_ast/src/lib.rs    | 1 +
 compiler/rustc_ast_ir/src/lib.rs | 1 +
 3 files changed, 3 insertions(+)

diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index 3dc548c4554a3..ea634d7485ef7 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -3,6 +3,7 @@
 #![cfg_attr(feature = "nightly", doc(rust_logo))]
 #![cfg_attr(feature = "nightly", feature(rustdoc_internals))]
 #![cfg_attr(feature = "nightly", feature(step_trait))]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 use std::fmt;
diff --git a/compiler/rustc_ast/src/lib.rs b/compiler/rustc_ast/src/lib.rs
index 27e9f3d137ffd..7730d0b4b78df 100644
--- a/compiler/rustc_ast/src/lib.rs
+++ b/compiler/rustc_ast/src/lib.rs
@@ -19,6 +19,7 @@
 #![feature(never_type)]
 #![feature(rustdoc_internals)]
 #![feature(stmt_expr_attributes)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 pub mod util {
diff --git a/compiler/rustc_ast_ir/src/lib.rs b/compiler/rustc_ast_ir/src/lib.rs
index 1d0c76f6ceae8..eeed5d3615139 100644
--- a/compiler/rustc_ast_ir/src/lib.rs
+++ b/compiler/rustc_ast_ir/src/lib.rs
@@ -2,6 +2,7 @@
 #![cfg_attr(feature = "nightly", allow(internal_features))]
 #![cfg_attr(feature = "nightly", feature(never_type))]
 #![cfg_attr(feature = "nightly", feature(rustc_attrs))]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 #[cfg(feature = "nightly")]

From f839309c74d08a2cc8fb0a6db5089bb6f70f669b Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 11 Jun 2024 10:40:10 +1000
Subject: [PATCH 303/685] Add `warn(unreachable_pub)` to `rustc_arena`.

---
 compiler/rustc_arena/src/lib.rs   |  1 +
 compiler/rustc_arena/src/tests.rs | 22 +++++++++++-----------
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_arena/src/lib.rs b/compiler/rustc_arena/src/lib.rs
index f5f01348e4612..8493354014734 100644
--- a/compiler/rustc_arena/src/lib.rs
+++ b/compiler/rustc_arena/src/lib.rs
@@ -25,6 +25,7 @@
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
 #![feature(strict_provenance)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 use std::alloc::Layout;
diff --git a/compiler/rustc_arena/src/tests.rs b/compiler/rustc_arena/src/tests.rs
index 9eaa292e9893c..bfde8abd5893a 100644
--- a/compiler/rustc_arena/src/tests.rs
+++ b/compiler/rustc_arena/src/tests.rs
@@ -32,7 +32,7 @@ impl<T> TypedArena<T> {
 }
 
 #[test]
-pub fn test_unused() {
+fn test_unused() {
     let arena: TypedArena<Point> = TypedArena::default();
     assert!(arena.chunks.borrow().is_empty());
 }
@@ -75,7 +75,7 @@ fn test_arena_alloc_nested() {
 }
 
 #[test]
-pub fn test_copy() {
+fn test_copy() {
     let arena = TypedArena::default();
     #[cfg(not(miri))]
     const N: usize = 100000;
@@ -87,13 +87,13 @@ pub fn test_copy() {
 }
 
 #[bench]
-pub fn bench_copy(b: &mut Bencher) {
+fn bench_copy(b: &mut Bencher) {
     let arena = TypedArena::default();
     b.iter(|| arena.alloc(Point { x: 1, y: 2, z: 3 }))
 }
 
 #[bench]
-pub fn bench_copy_nonarena(b: &mut Bencher) {
+fn bench_copy_nonarena(b: &mut Bencher) {
     b.iter(|| {
         let _: Box<_> = Box::new(Point { x: 1, y: 2, z: 3 });
     })
@@ -106,7 +106,7 @@ struct Noncopy {
 }
 
 #[test]
-pub fn test_noncopy() {
+fn test_noncopy() {
     let arena = TypedArena::default();
     #[cfg(not(miri))]
     const N: usize = 100000;
@@ -118,7 +118,7 @@ pub fn test_noncopy() {
 }
 
 #[test]
-pub fn test_typed_arena_zero_sized() {
+fn test_typed_arena_zero_sized() {
     let arena = TypedArena::default();
     #[cfg(not(miri))]
     const N: usize = 100000;
@@ -130,7 +130,7 @@ pub fn test_typed_arena_zero_sized() {
 }
 
 #[test]
-pub fn test_typed_arena_clear() {
+fn test_typed_arena_clear() {
     let mut arena = TypedArena::default();
     for _ in 0..10 {
         arena.clear();
@@ -145,7 +145,7 @@ pub fn test_typed_arena_clear() {
 }
 
 #[bench]
-pub fn bench_typed_arena_clear(b: &mut Bencher) {
+fn bench_typed_arena_clear(b: &mut Bencher) {
     let mut arena = TypedArena::default();
     b.iter(|| {
         arena.alloc(Point { x: 1, y: 2, z: 3 });
@@ -154,7 +154,7 @@ pub fn bench_typed_arena_clear(b: &mut Bencher) {
 }
 
 #[bench]
-pub fn bench_typed_arena_clear_100(b: &mut Bencher) {
+fn bench_typed_arena_clear_100(b: &mut Bencher) {
     let mut arena = TypedArena::default();
     b.iter(|| {
         for _ in 0..100 {
@@ -230,7 +230,7 @@ fn test_typed_arena_drop_small_count() {
 }
 
 #[bench]
-pub fn bench_noncopy(b: &mut Bencher) {
+fn bench_noncopy(b: &mut Bencher) {
     let arena = TypedArena::default();
     b.iter(|| {
         arena.alloc(Noncopy { string: "hello world".to_string(), array: vec![1, 2, 3, 4, 5] })
@@ -238,7 +238,7 @@ pub fn bench_noncopy(b: &mut Bencher) {
 }
 
 #[bench]
-pub fn bench_noncopy_nonarena(b: &mut Bencher) {
+fn bench_noncopy_nonarena(b: &mut Bencher) {
     b.iter(|| {
         let _: Box<_> =
             Box::new(Noncopy { string: "hello world".to_string(), array: vec![1, 2, 3, 4, 5] });

From ea014b4d75d63c2c9d19a67abae5309790186525 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 11 Jun 2024 10:46:06 +1000
Subject: [PATCH 304/685] Add `warn(unreachable_pub)` to `rustc_ast_lowering`.

---
 compiler/rustc_ast_lowering/src/errors.rs | 80 +++++++++++------------
 compiler/rustc_ast_lowering/src/item.rs   |  2 +-
 compiler/rustc_ast_lowering/src/lib.rs    |  1 +
 3 files changed, 42 insertions(+), 41 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs
index 7a6c9d8d0d375..18019b3da9206 100644
--- a/compiler/rustc_ast_lowering/src/errors.rs
+++ b/compiler/rustc_ast_lowering/src/errors.rs
@@ -6,7 +6,7 @@ use rustc_span::{Span, Symbol};
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_generic_type_with_parentheses, code = E0214)]
-pub struct GenericTypeWithParentheses {
+pub(crate) struct GenericTypeWithParentheses {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -16,7 +16,7 @@ pub struct GenericTypeWithParentheses {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(ast_lowering_use_angle_brackets, applicability = "maybe-incorrect")]
-pub struct UseAngleBrackets {
+pub(crate) struct UseAngleBrackets {
     #[suggestion_part(code = "<")]
     pub open_param: Span,
     #[suggestion_part(code = ">")]
@@ -26,7 +26,7 @@ pub struct UseAngleBrackets {
 #[derive(Diagnostic)]
 #[diag(ast_lowering_invalid_abi, code = E0703)]
 #[note]
-pub struct InvalidAbi {
+pub(crate) struct InvalidAbi {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -38,7 +38,7 @@ pub struct InvalidAbi {
     pub suggestion: Option<InvalidAbiSuggestion>,
 }
 
-pub struct InvalidAbiReason(pub &'static str);
+pub(crate) struct InvalidAbiReason(pub &'static str);
 
 impl Subdiagnostic for InvalidAbiReason {
     fn add_to_diag_with<G: EmissionGuarantee, F: SubdiagMessageOp<G>>(
@@ -57,7 +57,7 @@ impl Subdiagnostic for InvalidAbiReason {
     code = "{suggestion}",
     applicability = "maybe-incorrect"
 )]
-pub struct InvalidAbiSuggestion {
+pub(crate) struct InvalidAbiSuggestion {
     #[primary_span]
     pub span: Span,
     pub suggestion: String,
@@ -65,7 +65,7 @@ pub struct InvalidAbiSuggestion {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_assoc_ty_parentheses)]
-pub struct AssocTyParentheses {
+pub(crate) struct AssocTyParentheses {
     #[primary_span]
     pub span: Span,
     #[subdiagnostic]
@@ -73,7 +73,7 @@ pub struct AssocTyParentheses {
 }
 
 #[derive(Subdiagnostic)]
-pub enum AssocTyParenthesesSub {
+pub(crate) enum AssocTyParenthesesSub {
     #[multipart_suggestion(ast_lowering_remove_parentheses)]
     Empty {
         #[suggestion_part(code = "")]
@@ -91,7 +91,7 @@ pub enum AssocTyParenthesesSub {
 #[derive(Diagnostic)]
 #[diag(ast_lowering_misplaced_impl_trait, code = E0562)]
 #[note]
-pub struct MisplacedImplTrait<'a> {
+pub(crate) struct MisplacedImplTrait<'a> {
     #[primary_span]
     pub span: Span,
     pub position: DiagArgFromDisplay<'a>,
@@ -99,7 +99,7 @@ pub struct MisplacedImplTrait<'a> {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_assoc_ty_binding_in_dyn)]
-pub struct MisplacedAssocTyBinding {
+pub(crate) struct MisplacedAssocTyBinding {
     #[primary_span]
     pub span: Span,
     #[suggestion(code = " = impl", applicability = "maybe-incorrect", style = "verbose")]
@@ -108,7 +108,7 @@ pub struct MisplacedAssocTyBinding {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_underscore_expr_lhs_assign)]
-pub struct UnderscoreExprLhsAssign {
+pub(crate) struct UnderscoreExprLhsAssign {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -116,7 +116,7 @@ pub struct UnderscoreExprLhsAssign {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_base_expression_double_dot, code = E0797)]
-pub struct BaseExpressionDoubleDot {
+pub(crate) struct BaseExpressionDoubleDot {
     #[primary_span]
     #[suggestion(code = "/* expr */", applicability = "has-placeholders", style = "verbose")]
     pub span: Span,
@@ -124,7 +124,7 @@ pub struct BaseExpressionDoubleDot {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_await_only_in_async_fn_and_blocks, code = E0728)]
-pub struct AwaitOnlyInAsyncFnAndBlocks {
+pub(crate) struct AwaitOnlyInAsyncFnAndBlocks {
     #[primary_span]
     #[label]
     pub await_kw_span: Span,
@@ -134,21 +134,21 @@ pub struct AwaitOnlyInAsyncFnAndBlocks {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_coroutine_too_many_parameters, code = E0628)]
-pub struct CoroutineTooManyParameters {
+pub(crate) struct CoroutineTooManyParameters {
     #[primary_span]
     pub fn_decl_span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_closure_cannot_be_static, code = E0697)]
-pub struct ClosureCannotBeStatic {
+pub(crate) struct ClosureCannotBeStatic {
     #[primary_span]
     pub fn_decl_span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_functional_record_update_destructuring_assignment)]
-pub struct FunctionalRecordUpdateDestructuringAssignment {
+pub(crate) struct FunctionalRecordUpdateDestructuringAssignment {
     #[primary_span]
     #[suggestion(code = "", applicability = "machine-applicable")]
     pub span: Span,
@@ -156,28 +156,28 @@ pub struct FunctionalRecordUpdateDestructuringAssignment {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_async_coroutines_not_supported, code = E0727)]
-pub struct AsyncCoroutinesNotSupported {
+pub(crate) struct AsyncCoroutinesNotSupported {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_inline_asm_unsupported_target, code = E0472)]
-pub struct InlineAsmUnsupportedTarget {
+pub(crate) struct InlineAsmUnsupportedTarget {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_att_syntax_only_x86)]
-pub struct AttSyntaxOnlyX86 {
+pub(crate) struct AttSyntaxOnlyX86 {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_abi_specified_multiple_times)]
-pub struct AbiSpecifiedMultipleTimes {
+pub(crate) struct AbiSpecifiedMultipleTimes {
     #[primary_span]
     pub abi_span: Span,
     pub prev_name: Symbol,
@@ -189,7 +189,7 @@ pub struct AbiSpecifiedMultipleTimes {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_clobber_abi_not_supported)]
-pub struct ClobberAbiNotSupported {
+pub(crate) struct ClobberAbiNotSupported {
     #[primary_span]
     pub abi_span: Span,
 }
@@ -197,7 +197,7 @@ pub struct ClobberAbiNotSupported {
 #[derive(Diagnostic)]
 #[note]
 #[diag(ast_lowering_invalid_abi_clobber_abi)]
-pub struct InvalidAbiClobberAbi {
+pub(crate) struct InvalidAbiClobberAbi {
     #[primary_span]
     pub abi_span: Span,
     pub supported_abis: String,
@@ -205,7 +205,7 @@ pub struct InvalidAbiClobberAbi {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_invalid_register)]
-pub struct InvalidRegister<'a> {
+pub(crate) struct InvalidRegister<'a> {
     #[primary_span]
     pub op_span: Span,
     pub reg: Symbol,
@@ -214,7 +214,7 @@ pub struct InvalidRegister<'a> {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_invalid_register_class)]
-pub struct InvalidRegisterClass<'a> {
+pub(crate) struct InvalidRegisterClass<'a> {
     #[primary_span]
     pub op_span: Span,
     pub reg_class: Symbol,
@@ -223,7 +223,7 @@ pub struct InvalidRegisterClass<'a> {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_invalid_asm_template_modifier_reg_class)]
-pub struct InvalidAsmTemplateModifierRegClass {
+pub(crate) struct InvalidAsmTemplateModifierRegClass {
     #[primary_span]
     #[label(ast_lowering_template_modifier)]
     pub placeholder_span: Span,
@@ -234,7 +234,7 @@ pub struct InvalidAsmTemplateModifierRegClass {
 }
 
 #[derive(Subdiagnostic)]
-pub enum InvalidAsmTemplateModifierRegClassSub {
+pub(crate) enum InvalidAsmTemplateModifierRegClassSub {
     #[note(ast_lowering_support_modifiers)]
     SupportModifier { class_name: Symbol, modifiers: String },
     #[note(ast_lowering_does_not_support_modifiers)]
@@ -243,7 +243,7 @@ pub enum InvalidAsmTemplateModifierRegClassSub {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_invalid_asm_template_modifier_const)]
-pub struct InvalidAsmTemplateModifierConst {
+pub(crate) struct InvalidAsmTemplateModifierConst {
     #[primary_span]
     #[label(ast_lowering_template_modifier)]
     pub placeholder_span: Span,
@@ -253,7 +253,7 @@ pub struct InvalidAsmTemplateModifierConst {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_invalid_asm_template_modifier_sym)]
-pub struct InvalidAsmTemplateModifierSym {
+pub(crate) struct InvalidAsmTemplateModifierSym {
     #[primary_span]
     #[label(ast_lowering_template_modifier)]
     pub placeholder_span: Span,
@@ -263,7 +263,7 @@ pub struct InvalidAsmTemplateModifierSym {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_invalid_asm_template_modifier_label)]
-pub struct InvalidAsmTemplateModifierLabel {
+pub(crate) struct InvalidAsmTemplateModifierLabel {
     #[primary_span]
     #[label(ast_lowering_template_modifier)]
     pub placeholder_span: Span,
@@ -273,7 +273,7 @@ pub struct InvalidAsmTemplateModifierLabel {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_register_class_only_clobber)]
-pub struct RegisterClassOnlyClobber {
+pub(crate) struct RegisterClassOnlyClobber {
     #[primary_span]
     pub op_span: Span,
     pub reg_class_name: Symbol,
@@ -281,7 +281,7 @@ pub struct RegisterClassOnlyClobber {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_register_conflict)]
-pub struct RegisterConflict<'a> {
+pub(crate) struct RegisterConflict<'a> {
     #[primary_span]
     #[label(ast_lowering_register1)]
     pub op_span1: Span,
@@ -296,7 +296,7 @@ pub struct RegisterConflict<'a> {
 #[derive(Diagnostic)]
 #[help]
 #[diag(ast_lowering_sub_tuple_binding)]
-pub struct SubTupleBinding<'a> {
+pub(crate) struct SubTupleBinding<'a> {
     #[primary_span]
     #[label]
     #[suggestion(
@@ -313,7 +313,7 @@ pub struct SubTupleBinding<'a> {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_extra_double_dot)]
-pub struct ExtraDoubleDot<'a> {
+pub(crate) struct ExtraDoubleDot<'a> {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -325,21 +325,21 @@ pub struct ExtraDoubleDot<'a> {
 #[derive(Diagnostic)]
 #[note]
 #[diag(ast_lowering_misplaced_double_dot)]
-pub struct MisplacedDoubleDot {
+pub(crate) struct MisplacedDoubleDot {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_misplaced_relax_trait_bound)]
-pub struct MisplacedRelaxTraitBound {
+pub(crate) struct MisplacedRelaxTraitBound {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_match_arm_with_no_body)]
-pub struct MatchArmWithNoBody {
+pub(crate) struct MatchArmWithNoBody {
     #[primary_span]
     pub span: Span,
     #[suggestion(code = " => todo!(),", applicability = "has-placeholders")]
@@ -348,7 +348,7 @@ pub struct MatchArmWithNoBody {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_never_pattern_with_body)]
-pub struct NeverPatternWithBody {
+pub(crate) struct NeverPatternWithBody {
     #[primary_span]
     #[label]
     #[suggestion(code = "", applicability = "maybe-incorrect")]
@@ -357,7 +357,7 @@ pub struct NeverPatternWithBody {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_never_pattern_with_guard)]
-pub struct NeverPatternWithGuard {
+pub(crate) struct NeverPatternWithGuard {
     #[primary_span]
     #[suggestion(code = "", applicability = "maybe-incorrect")]
     pub span: Span,
@@ -365,7 +365,7 @@ pub struct NeverPatternWithGuard {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_arbitrary_expression_in_pattern)]
-pub struct ArbitraryExpressionInPattern {
+pub(crate) struct ArbitraryExpressionInPattern {
     #[primary_span]
     pub span: Span,
     #[note(ast_lowering_pattern_from_macro_note)]
@@ -374,13 +374,13 @@ pub struct ArbitraryExpressionInPattern {
 
 #[derive(Diagnostic)]
 #[diag(ast_lowering_inclusive_range_with_no_end)]
-pub struct InclusiveRangeWithNoEnd {
+pub(crate) struct InclusiveRangeWithNoEnd {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-pub enum BadReturnTypeNotation {
+pub(crate) enum BadReturnTypeNotation {
     #[diag(ast_lowering_bad_return_type_notation_inputs)]
     Inputs {
         #[primary_span]
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 7af3945d3f99d..46ea7e6acb724 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -1182,7 +1182,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     /// into the body. This is to make sure that the future actually owns the
     /// arguments that are passed to the function, and to ensure things like
     /// drop order are stable.
-    pub fn lower_coroutine_body_with_moved_arguments(
+    pub(crate) fn lower_coroutine_body_with_moved_arguments(
         &mut self,
         decl: &FnDecl,
         lower_body: impl FnOnce(&mut LoweringContext<'_, 'hir>) -> hir::Expr<'hir>,
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 81d17a9dec205..43b56d7a91b12 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -37,6 +37,7 @@
 #![feature(box_patterns)]
 #![feature(let_chains)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 use std::collections::hash_map::Entry;

From a6b2880d5a3f8faec20b96014792b21ae2c5bfbb Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Sat, 6 Jul 2024 21:19:05 +1000
Subject: [PATCH 305/685] Add `warn(unreachable_pub)` to `rustc_ast_passes`.

---
 compiler/rustc_ast_passes/src/errors.rs | 164 ++++++++++++------------
 compiler/rustc_ast_passes/src/lib.rs    |   1 +
 2 files changed, 83 insertions(+), 82 deletions(-)

diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 9e40368083729..d2c127a7bbb0d 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -11,7 +11,7 @@ use crate::fluent_generated as fluent;
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_visibility_not_permitted, code = E0449)]
-pub struct VisibilityNotPermitted {
+pub(crate) struct VisibilityNotPermitted {
     #[primary_span]
     pub span: Span,
     #[subdiagnostic]
@@ -25,7 +25,7 @@ pub struct VisibilityNotPermitted {
 }
 
 #[derive(Subdiagnostic)]
-pub enum VisibilityNotPermittedNote {
+pub(crate) enum VisibilityNotPermittedNote {
     #[note(ast_passes_enum_variant)]
     EnumVariant,
     #[note(ast_passes_trait_impl)]
@@ -38,7 +38,7 @@ pub enum VisibilityNotPermittedNote {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_trait_fn_const, code = E0379)]
-pub struct TraitFnConst {
+pub(crate) struct TraitFnConst {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -64,21 +64,21 @@ pub struct TraitFnConst {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_forbidden_bound)]
-pub struct ForbiddenBound {
+pub(crate) struct ForbiddenBound {
     #[primary_span]
     pub spans: Vec<Span>,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_forbidden_const_param)]
-pub struct ForbiddenConstParam {
+pub(crate) struct ForbiddenConstParam {
     #[primary_span]
     pub const_param_spans: Vec<Span>,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_fn_param_too_many)]
-pub struct FnParamTooMany {
+pub(crate) struct FnParamTooMany {
     #[primary_span]
     pub span: Span,
     pub max_num_args: usize,
@@ -86,14 +86,14 @@ pub struct FnParamTooMany {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_fn_param_c_var_args_not_last)]
-pub struct FnParamCVarArgsNotLast {
+pub(crate) struct FnParamCVarArgsNotLast {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_fn_param_doc_comment)]
-pub struct FnParamDocComment {
+pub(crate) struct FnParamDocComment {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -101,7 +101,7 @@ pub struct FnParamDocComment {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_fn_param_forbidden_attr)]
-pub struct FnParamForbiddenAttr {
+pub(crate) struct FnParamForbiddenAttr {
     #[primary_span]
     pub span: Span,
 }
@@ -109,7 +109,7 @@ pub struct FnParamForbiddenAttr {
 #[derive(Diagnostic)]
 #[diag(ast_passes_fn_param_forbidden_self)]
 #[note]
-pub struct FnParamForbiddenSelf {
+pub(crate) struct FnParamForbiddenSelf {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -117,7 +117,7 @@ pub struct FnParamForbiddenSelf {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_forbidden_default)]
-pub struct ForbiddenDefault {
+pub(crate) struct ForbiddenDefault {
     #[primary_span]
     pub span: Span,
     #[label]
@@ -126,7 +126,7 @@ pub struct ForbiddenDefault {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_assoc_const_without_body)]
-pub struct AssocConstWithoutBody {
+pub(crate) struct AssocConstWithoutBody {
     #[primary_span]
     pub span: Span,
     #[suggestion(code = " = <expr>;", applicability = "has-placeholders")]
@@ -135,7 +135,7 @@ pub struct AssocConstWithoutBody {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_assoc_fn_without_body)]
-pub struct AssocFnWithoutBody {
+pub(crate) struct AssocFnWithoutBody {
     #[primary_span]
     pub span: Span,
     #[suggestion(code = " {{ <body> }}", applicability = "has-placeholders")]
@@ -144,7 +144,7 @@ pub struct AssocFnWithoutBody {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_assoc_type_without_body)]
-pub struct AssocTypeWithoutBody {
+pub(crate) struct AssocTypeWithoutBody {
     #[primary_span]
     pub span: Span,
     #[suggestion(code = " = <type>;", applicability = "has-placeholders")]
@@ -153,7 +153,7 @@ pub struct AssocTypeWithoutBody {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_const_without_body)]
-pub struct ConstWithoutBody {
+pub(crate) struct ConstWithoutBody {
     #[primary_span]
     pub span: Span,
     #[suggestion(code = " = <expr>;", applicability = "has-placeholders")]
@@ -162,7 +162,7 @@ pub struct ConstWithoutBody {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_static_without_body)]
-pub struct StaticWithoutBody {
+pub(crate) struct StaticWithoutBody {
     #[primary_span]
     pub span: Span,
     #[suggestion(code = " = <expr>;", applicability = "has-placeholders")]
@@ -171,7 +171,7 @@ pub struct StaticWithoutBody {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_ty_alias_without_body)]
-pub struct TyAliasWithoutBody {
+pub(crate) struct TyAliasWithoutBody {
     #[primary_span]
     pub span: Span,
     #[suggestion(code = " = <type>;", applicability = "has-placeholders")]
@@ -180,7 +180,7 @@ pub struct TyAliasWithoutBody {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_fn_without_body)]
-pub struct FnWithoutBody {
+pub(crate) struct FnWithoutBody {
     #[primary_span]
     pub span: Span,
     #[suggestion(code = " {{ <body> }}", applicability = "has-placeholders")]
@@ -190,7 +190,7 @@ pub struct FnWithoutBody {
 }
 
 #[derive(Subdiagnostic)]
-pub enum ExternBlockSuggestion {
+pub(crate) enum ExternBlockSuggestion {
     #[multipart_suggestion(ast_passes_extern_block_suggestion, applicability = "maybe-incorrect")]
     Implicit {
         #[suggestion_part(code = "extern {{")]
@@ -210,7 +210,7 @@ pub enum ExternBlockSuggestion {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_extern_invalid_safety)]
-pub struct InvalidSafetyOnExtern {
+pub(crate) struct InvalidSafetyOnExtern {
     #[primary_span]
     pub item_span: Span,
     #[suggestion(code = "unsafe ", applicability = "machine-applicable", style = "verbose")]
@@ -219,28 +219,28 @@ pub struct InvalidSafetyOnExtern {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_item_invalid_safety)]
-pub struct InvalidSafetyOnItem {
+pub(crate) struct InvalidSafetyOnItem {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_bare_fn_invalid_safety)]
-pub struct InvalidSafetyOnBareFn {
+pub(crate) struct InvalidSafetyOnBareFn {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_unsafe_static)]
-pub struct UnsafeStatic {
+pub(crate) struct UnsafeStatic {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_bound_in_context)]
-pub struct BoundInContext<'a> {
+pub(crate) struct BoundInContext<'a> {
     #[primary_span]
     pub span: Span,
     pub ctx: &'a str,
@@ -249,7 +249,7 @@ pub struct BoundInContext<'a> {
 #[derive(Diagnostic)]
 #[diag(ast_passes_extern_types_cannot)]
 #[note(ast_passes_extern_keyword_link)]
-pub struct ExternTypesCannotHave<'a> {
+pub(crate) struct ExternTypesCannotHave<'a> {
     #[primary_span]
     #[suggestion(code = "", applicability = "maybe-incorrect")]
     pub span: Span,
@@ -262,7 +262,7 @@ pub struct ExternTypesCannotHave<'a> {
 #[derive(Diagnostic)]
 #[diag(ast_passes_body_in_extern)]
 #[note(ast_passes_extern_keyword_link)]
-pub struct BodyInExtern<'a> {
+pub(crate) struct BodyInExtern<'a> {
     #[primary_span]
     #[label(ast_passes_cannot_have)]
     pub span: Span,
@@ -277,7 +277,7 @@ pub struct BodyInExtern<'a> {
 #[diag(ast_passes_fn_body_extern)]
 #[help]
 #[note(ast_passes_extern_keyword_link)]
-pub struct FnBodyInExtern {
+pub(crate) struct FnBodyInExtern {
     #[primary_span]
     #[label(ast_passes_cannot_have)]
     pub span: Span,
@@ -289,7 +289,7 @@ pub struct FnBodyInExtern {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_extern_fn_qualifiers)]
-pub struct FnQualifierInExtern {
+pub(crate) struct FnQualifierInExtern {
     #[primary_span]
     #[suggestion(code = "", applicability = "maybe-incorrect")]
     pub span: Span,
@@ -300,7 +300,7 @@ pub struct FnQualifierInExtern {
 #[derive(Diagnostic)]
 #[diag(ast_passes_extern_item_ascii)]
 #[note]
-pub struct ExternItemAscii {
+pub(crate) struct ExternItemAscii {
     #[primary_span]
     pub span: Span,
     #[label]
@@ -309,14 +309,14 @@ pub struct ExternItemAscii {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_bad_c_variadic)]
-pub struct BadCVariadic {
+pub(crate) struct BadCVariadic {
     #[primary_span]
     pub span: Vec<Span>,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_item_underscore)]
-pub struct ItemUnderscore<'a> {
+pub(crate) struct ItemUnderscore<'a> {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -325,7 +325,7 @@ pub struct ItemUnderscore<'a> {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_nomangle_ascii, code = E0754)]
-pub struct NoMangleAscii {
+pub(crate) struct NoMangleAscii {
     #[primary_span]
     pub span: Span,
 }
@@ -333,7 +333,7 @@ pub struct NoMangleAscii {
 #[derive(Diagnostic)]
 #[diag(ast_passes_module_nonascii, code = E0754)]
 #[help]
-pub struct ModuleNonAscii {
+pub(crate) struct ModuleNonAscii {
     #[primary_span]
     pub span: Span,
     pub name: Symbol,
@@ -341,7 +341,7 @@ pub struct ModuleNonAscii {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_auto_generic, code = E0567)]
-pub struct AutoTraitGeneric {
+pub(crate) struct AutoTraitGeneric {
     #[primary_span]
     #[suggestion(code = "", applicability = "machine-applicable")]
     pub span: Span,
@@ -351,7 +351,7 @@ pub struct AutoTraitGeneric {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_auto_super_lifetime, code = E0568)]
-pub struct AutoTraitBounds {
+pub(crate) struct AutoTraitBounds {
     #[primary_span]
     #[suggestion(code = "", applicability = "machine-applicable")]
     pub span: Span,
@@ -361,7 +361,7 @@ pub struct AutoTraitBounds {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_auto_items, code = E0380)]
-pub struct AutoTraitItems {
+pub(crate) struct AutoTraitItems {
     #[primary_span]
     pub spans: Vec<Span>,
     #[suggestion(code = "", applicability = "machine-applicable")]
@@ -372,7 +372,7 @@ pub struct AutoTraitItems {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_generic_before_constraints)]
-pub struct ArgsBeforeConstraint {
+pub(crate) struct ArgsBeforeConstraint {
     #[primary_span]
     pub arg_spans: Vec<Span>,
     #[label(ast_passes_constraints)]
@@ -390,7 +390,7 @@ pub struct ArgsBeforeConstraint {
     pub arg_spans2: EmptyLabelManySpans,
 }
 
-pub struct EmptyLabelManySpans(pub Vec<Span>);
+pub(crate) struct EmptyLabelManySpans(pub Vec<Span>);
 
 // The derive for `Vec<Span>` does multiple calls to `span_label`, adding commas between each
 impl Subdiagnostic for EmptyLabelManySpans {
@@ -405,28 +405,28 @@ impl Subdiagnostic for EmptyLabelManySpans {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_pattern_in_fn_pointer, code = E0561)]
-pub struct PatternFnPointer {
+pub(crate) struct PatternFnPointer {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_trait_object_single_bound, code = E0226)]
-pub struct TraitObjectBound {
+pub(crate) struct TraitObjectBound {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_impl_trait_path, code = E0667)]
-pub struct ImplTraitPath {
+pub(crate) struct ImplTraitPath {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_nested_impl_trait, code = E0666)]
-pub struct NestedImplTrait {
+pub(crate) struct NestedImplTrait {
     #[primary_span]
     pub span: Span,
     #[label(ast_passes_outer)]
@@ -437,14 +437,14 @@ pub struct NestedImplTrait {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_at_least_one_trait)]
-pub struct AtLeastOneTrait {
+pub(crate) struct AtLeastOneTrait {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_out_of_order_params)]
-pub struct OutOfOrderParams<'a> {
+pub(crate) struct OutOfOrderParams<'a> {
     #[primary_span]
     pub spans: Vec<Span>,
     #[suggestion(code = "{ordered_params}", applicability = "machine-applicable")]
@@ -457,14 +457,14 @@ pub struct OutOfOrderParams<'a> {
 #[derive(Diagnostic)]
 #[diag(ast_passes_obsolete_auto)]
 #[help]
-pub struct ObsoleteAuto {
+pub(crate) struct ObsoleteAuto {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_unsafe_negative_impl, code = E0198)]
-pub struct UnsafeNegativeImpl {
+pub(crate) struct UnsafeNegativeImpl {
     #[primary_span]
     pub span: Span,
     #[label(ast_passes_negative)]
@@ -475,7 +475,7 @@ pub struct UnsafeNegativeImpl {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_inherent_cannot_be)]
-pub struct InherentImplCannot<'a> {
+pub(crate) struct InherentImplCannot<'a> {
     #[primary_span]
     pub span: Span,
     #[label(ast_passes_because)]
@@ -489,7 +489,7 @@ pub struct InherentImplCannot<'a> {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_inherent_cannot_be, code = E0197)]
-pub struct InherentImplCannotUnsafe<'a> {
+pub(crate) struct InherentImplCannotUnsafe<'a> {
     #[primary_span]
     pub span: Span,
     #[label(ast_passes_because)]
@@ -501,7 +501,7 @@ pub struct InherentImplCannotUnsafe<'a> {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_unsafe_item)]
-pub struct UnsafeItem {
+pub(crate) struct UnsafeItem {
     #[primary_span]
     pub span: Span,
     pub kind: &'static str,
@@ -509,14 +509,14 @@ pub struct UnsafeItem {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_missing_unsafe_on_extern)]
-pub struct MissingUnsafeOnExtern {
+pub(crate) struct MissingUnsafeOnExtern {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_fieldless_union)]
-pub struct FieldlessUnion {
+pub(crate) struct FieldlessUnion {
     #[primary_span]
     pub span: Span,
 }
@@ -524,7 +524,7 @@ pub struct FieldlessUnion {
 #[derive(Diagnostic)]
 #[diag(ast_passes_where_clause_after_type_alias)]
 #[note]
-pub struct WhereClauseAfterTypeAlias {
+pub(crate) struct WhereClauseAfterTypeAlias {
     #[primary_span]
     pub span: Span,
     #[help]
@@ -534,7 +534,7 @@ pub struct WhereClauseAfterTypeAlias {
 #[derive(Diagnostic)]
 #[diag(ast_passes_where_clause_before_type_alias)]
 #[note]
-pub struct WhereClauseBeforeTypeAlias {
+pub(crate) struct WhereClauseBeforeTypeAlias {
     #[primary_span]
     pub span: Span,
     #[subdiagnostic]
@@ -543,7 +543,7 @@ pub struct WhereClauseBeforeTypeAlias {
 
 #[derive(Subdiagnostic)]
 
-pub enum WhereClauseBeforeTypeAliasSugg {
+pub(crate) enum WhereClauseBeforeTypeAliasSugg {
     #[suggestion(ast_passes_remove_suggestion, applicability = "machine-applicable", code = "")]
     Remove {
         #[primary_span]
@@ -565,14 +565,14 @@ pub enum WhereClauseBeforeTypeAliasSugg {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_generic_default_trailing)]
-pub struct GenericDefaultTrailing {
+pub(crate) struct GenericDefaultTrailing {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_nested_lifetimes, code = E0316)]
-pub struct NestedLifetimes {
+pub(crate) struct NestedLifetimes {
     #[primary_span]
     pub span: Span,
 }
@@ -580,7 +580,7 @@ pub struct NestedLifetimes {
 #[derive(Diagnostic)]
 #[diag(ast_passes_optional_trait_supertrait)]
 #[note]
-pub struct OptionalTraitSupertrait {
+pub(crate) struct OptionalTraitSupertrait {
     #[primary_span]
     pub span: Span,
     pub path_str: String,
@@ -588,14 +588,14 @@ pub struct OptionalTraitSupertrait {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_optional_trait_object)]
-pub struct OptionalTraitObject {
+pub(crate) struct OptionalTraitObject {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_const_bound_trait_object)]
-pub struct ConstBoundTraitObject {
+pub(crate) struct ConstBoundTraitObject {
     #[primary_span]
     pub span: Span,
 }
@@ -604,7 +604,7 @@ pub struct ConstBoundTraitObject {
 // FIXME(effects): Provide structured suggestions (e.g., add `const` / `#[const_trait]` here).
 #[derive(Diagnostic)]
 #[diag(ast_passes_tilde_const_disallowed)]
-pub struct TildeConstDisallowed {
+pub(crate) struct TildeConstDisallowed {
     #[primary_span]
     pub span: Span,
     #[subdiagnostic]
@@ -612,7 +612,7 @@ pub struct TildeConstDisallowed {
 }
 
 #[derive(Subdiagnostic, Copy, Clone)]
-pub enum TildeConstReason {
+pub(crate) enum TildeConstReason {
     #[note(ast_passes_closure)]
     Closure,
     #[note(ast_passes_function)]
@@ -658,7 +658,7 @@ pub enum TildeConstReason {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_const_and_async)]
-pub struct ConstAndAsync {
+pub(crate) struct ConstAndAsync {
     #[primary_span]
     pub spans: Vec<Span>,
     #[label(ast_passes_const)]
@@ -671,7 +671,7 @@ pub struct ConstAndAsync {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_const_and_c_variadic)]
-pub struct ConstAndCVariadic {
+pub(crate) struct ConstAndCVariadic {
     #[primary_span]
     pub spans: Vec<Span>,
     #[label(ast_passes_const)]
@@ -683,7 +683,7 @@ pub struct ConstAndCVariadic {
 #[derive(Diagnostic)]
 #[diag(ast_passes_pattern_in_foreign, code = E0130)]
 // FIXME: deduplicate with rustc_lint (`BuiltinLintDiag::PatternsInFnsWithoutBody`)
-pub struct PatternInForeign {
+pub(crate) struct PatternInForeign {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -692,7 +692,7 @@ pub struct PatternInForeign {
 #[derive(Diagnostic)]
 #[diag(ast_passes_pattern_in_bodiless, code = E0642)]
 // FIXME: deduplicate with rustc_lint (`BuiltinLintDiag::PatternsInFnsWithoutBody`)
-pub struct PatternInBodiless {
+pub(crate) struct PatternInBodiless {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -701,7 +701,7 @@ pub struct PatternInBodiless {
 #[derive(Diagnostic)]
 #[diag(ast_passes_equality_in_where)]
 #[note]
-pub struct EqualityInWhere {
+pub(crate) struct EqualityInWhere {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -718,7 +718,7 @@ pub struct EqualityInWhere {
     style = "verbose",
     applicability = "maybe-incorrect"
 )]
-pub struct AssociatedSuggestion {
+pub(crate) struct AssociatedSuggestion {
     #[primary_span]
     pub span: Span,
     pub ident: Ident,
@@ -728,7 +728,7 @@ pub struct AssociatedSuggestion {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(ast_passes_suggestion_path, applicability = "maybe-incorrect")]
-pub struct AssociatedSuggestion2 {
+pub(crate) struct AssociatedSuggestion2 {
     #[suggestion_part(code = "{args}")]
     pub span: Span,
     pub args: String,
@@ -740,14 +740,14 @@ pub struct AssociatedSuggestion2 {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_stability_outside_std, code = E0734)]
-pub struct StabilityOutsideStd {
+pub(crate) struct StabilityOutsideStd {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_feature_on_non_nightly, code = E0554)]
-pub struct FeatureOnNonNightly {
+pub(crate) struct FeatureOnNonNightly {
     #[primary_span]
     pub span: Span,
     pub channel: &'static str,
@@ -757,7 +757,7 @@ pub struct FeatureOnNonNightly {
     pub sugg: Option<Span>,
 }
 
-pub struct StableFeature {
+pub(crate) struct StableFeature {
     pub name: Symbol,
     pub since: Symbol,
 }
@@ -777,7 +777,7 @@ impl Subdiagnostic for StableFeature {
 #[derive(Diagnostic)]
 #[diag(ast_passes_incompatible_features)]
 #[help]
-pub struct IncompatibleFeatures {
+pub(crate) struct IncompatibleFeatures {
     #[primary_span]
     pub spans: Vec<Span>,
     pub f1: Symbol,
@@ -786,7 +786,7 @@ pub struct IncompatibleFeatures {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_show_span)]
-pub struct ShowSpan {
+pub(crate) struct ShowSpan {
     #[primary_span]
     pub span: Span,
     pub msg: &'static str,
@@ -794,28 +794,28 @@ pub struct ShowSpan {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_negative_bound_not_supported)]
-pub struct NegativeBoundUnsupported {
+pub(crate) struct NegativeBoundUnsupported {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_constraint_on_negative_bound)]
-pub struct ConstraintOnNegativeBound {
+pub(crate) struct ConstraintOnNegativeBound {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_negative_bound_with_parenthetical_notation)]
-pub struct NegativeBoundWithParentheticalNotation {
+pub(crate) struct NegativeBoundWithParentheticalNotation {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_invalid_unnamed_field_ty)]
-pub struct InvalidUnnamedFieldTy {
+pub(crate) struct InvalidUnnamedFieldTy {
     #[primary_span]
     pub span: Span,
     #[label]
@@ -824,7 +824,7 @@ pub struct InvalidUnnamedFieldTy {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_invalid_unnamed_field)]
-pub struct InvalidUnnamedField {
+pub(crate) struct InvalidUnnamedField {
     #[primary_span]
     pub span: Span,
     #[label]
@@ -833,7 +833,7 @@ pub struct InvalidUnnamedField {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_anon_struct_or_union_not_allowed)]
-pub struct AnonStructOrUnionNotAllowed {
+pub(crate) struct AnonStructOrUnionNotAllowed {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -842,7 +842,7 @@ pub struct AnonStructOrUnionNotAllowed {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_match_arm_with_no_body)]
-pub struct MatchArmWithNoBody {
+pub(crate) struct MatchArmWithNoBody {
     #[primary_span]
     pub span: Span,
     #[suggestion(code = " => todo!(),", applicability = "has-placeholders")]
@@ -851,7 +851,7 @@ pub struct MatchArmWithNoBody {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_precise_capturing_not_allowed_here)]
-pub struct PreciseCapturingNotAllowedHere {
+pub(crate) struct PreciseCapturingNotAllowedHere {
     #[primary_span]
     pub span: Span,
     pub loc: &'static str,
@@ -859,7 +859,7 @@ pub struct PreciseCapturingNotAllowedHere {
 
 #[derive(Diagnostic)]
 #[diag(ast_passes_precise_capturing_duplicated)]
-pub struct DuplicatePreciseCapturing {
+pub(crate) struct DuplicatePreciseCapturing {
     #[primary_span]
     pub bound1: Span,
     #[label]
diff --git a/compiler/rustc_ast_passes/src/lib.rs b/compiler/rustc_ast_passes/src/lib.rs
index 1f4bcd59afa01..88c6bde3106d5 100644
--- a/compiler/rustc_ast_passes/src/lib.rs
+++ b/compiler/rustc_ast_passes/src/lib.rs
@@ -12,6 +12,7 @@
 #![feature(iter_is_partitioned)]
 #![feature(let_chains)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 pub mod ast_validation;

From f2fc87db44413bc4706980481c057e30cac2efd9 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Sat, 6 Jul 2024 21:27:29 +1000
Subject: [PATCH 306/685] Add `warn(unreachable_pub)` to `rustc_ast_pretty`.

---
 compiler/rustc_ast_pretty/src/lib.rs          |  1 +
 .../rustc_ast_pretty/src/pp/convenience.rs    |  2 +-
 compiler/rustc_ast_pretty/src/pp/ring.rs      | 22 +++++++++----------
 .../src/pprust/state/fixup.rs                 | 14 ++++++------
 4 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_ast_pretty/src/lib.rs b/compiler/rustc_ast_pretty/src/lib.rs
index 84d9ce278a21a..602ab69ee5b5d 100644
--- a/compiler/rustc_ast_pretty/src/lib.rs
+++ b/compiler/rustc_ast_pretty/src/lib.rs
@@ -3,6 +3,7 @@
 #![doc(rust_logo)]
 #![feature(box_patterns)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 mod helpers;
diff --git a/compiler/rustc_ast_pretty/src/pp/convenience.rs b/compiler/rustc_ast_pretty/src/pp/convenience.rs
index 6d46c26311be3..7559b181f7d41 100644
--- a/compiler/rustc_ast_pretty/src/pp/convenience.rs
+++ b/compiler/rustc_ast_pretty/src/pp/convenience.rs
@@ -89,7 +89,7 @@ impl Printer {
 }
 
 impl Token {
-    pub fn is_hardbreak_tok(&self) -> bool {
+    pub(crate) fn is_hardbreak_tok(&self) -> bool {
         *self == Printer::hardbreak_tok_offset(0)
     }
 }
diff --git a/compiler/rustc_ast_pretty/src/pp/ring.rs b/compiler/rustc_ast_pretty/src/pp/ring.rs
index 8187394fe30e0..003c0a999b50a 100644
--- a/compiler/rustc_ast_pretty/src/pp/ring.rs
+++ b/compiler/rustc_ast_pretty/src/pp/ring.rs
@@ -11,54 +11,54 @@ use std::ops::{Index, IndexMut};
 /// Holding a RingBuffer whose view is elements left..right gives the ability to
 /// use Index and IndexMut to access elements i in the infinitely long queue for
 /// which left <= i < right.
-pub struct RingBuffer<T> {
+pub(super) struct RingBuffer<T> {
     data: VecDeque<T>,
     // Abstract index of data[0] in the infinitely sized queue.
     offset: usize,
 }
 
 impl<T> RingBuffer<T> {
-    pub fn new() -> Self {
+    pub(super) fn new() -> Self {
         RingBuffer { data: VecDeque::new(), offset: 0 }
     }
 
-    pub fn is_empty(&self) -> bool {
+    pub(super) fn is_empty(&self) -> bool {
         self.data.is_empty()
     }
 
-    pub fn push(&mut self, value: T) -> usize {
+    pub(super) fn push(&mut self, value: T) -> usize {
         let index = self.offset + self.data.len();
         self.data.push_back(value);
         index
     }
 
-    pub fn clear(&mut self) {
+    pub(super) fn clear(&mut self) {
         self.data.clear();
     }
 
-    pub fn index_of_first(&self) -> usize {
+    pub(super) fn index_of_first(&self) -> usize {
         self.offset
     }
 
-    pub fn first(&self) -> Option<&T> {
+    pub(super) fn first(&self) -> Option<&T> {
         self.data.front()
     }
 
-    pub fn first_mut(&mut self) -> Option<&mut T> {
+    pub(super) fn first_mut(&mut self) -> Option<&mut T> {
         self.data.front_mut()
     }
 
-    pub fn pop_first(&mut self) -> Option<T> {
+    pub(super) fn pop_first(&mut self) -> Option<T> {
         let first = self.data.pop_front()?;
         self.offset += 1;
         Some(first)
     }
 
-    pub fn last(&self) -> Option<&T> {
+    pub(super) fn last(&self) -> Option<&T> {
         self.data.back()
     }
 
-    pub fn last_mut(&mut self) -> Option<&mut T> {
+    pub(super) fn last_mut(&mut self) -> Option<&mut T> {
         self.data.back_mut()
     }
 }
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/fixup.rs b/compiler/rustc_ast_pretty/src/pprust/state/fixup.rs
index 86d4796e9ce3b..c9baca72485ef 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/fixup.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/fixup.rs
@@ -110,13 +110,13 @@ impl Default for FixupContext {
 impl FixupContext {
     /// Create the initial fixup for printing an expression in statement
     /// position.
-    pub fn new_stmt() -> Self {
+    pub(crate) fn new_stmt() -> Self {
         FixupContext { stmt: true, ..FixupContext::default() }
     }
 
     /// Create the initial fixup for printing an expression as the right-hand
     /// side of a match arm.
-    pub fn new_match_arm() -> Self {
+    pub(crate) fn new_match_arm() -> Self {
         FixupContext { match_arm: true, ..FixupContext::default() }
     }
 
@@ -124,7 +124,7 @@ impl FixupContext {
     /// of an `if` or `while`. There are a few other positions which are
     /// grammatically equivalent and also use this, such as the iterator
     /// expression in `for` and the scrutinee in `match`.
-    pub fn new_cond() -> Self {
+    pub(crate) fn new_cond() -> Self {
         FixupContext { parenthesize_exterior_struct_lit: true, ..FixupContext::default() }
     }
 
@@ -139,7 +139,7 @@ impl FixupContext {
     ///
     /// Not every expression has a leftmost subexpression. For example neither
     /// `-$a` nor `[$a]` have one.
-    pub fn leftmost_subexpression(self) -> Self {
+    pub(crate) fn leftmost_subexpression(self) -> Self {
         FixupContext {
             stmt: false,
             leftmost_subexpression_in_stmt: self.stmt || self.leftmost_subexpression_in_stmt,
@@ -158,7 +158,7 @@ impl FixupContext {
     /// current expression, and is not surrounded by a paren/bracket/brace. For
     /// example the `$b` in `$a + $b` and `-$b`, but not the one in `[$b]` or
     /// `$a.f($b)`.
-    pub fn subsequent_subexpression(self) -> Self {
+    pub(crate) fn subsequent_subexpression(self) -> Self {
         FixupContext {
             stmt: false,
             leftmost_subexpression_in_stmt: false,
@@ -173,7 +173,7 @@ impl FixupContext {
     ///
     /// The documentation on `FixupContext::leftmost_subexpression_in_stmt` has
     /// examples.
-    pub fn would_cause_statement_boundary(self, expr: &Expr) -> bool {
+    pub(crate) fn would_cause_statement_boundary(self, expr: &Expr) -> bool {
         (self.leftmost_subexpression_in_stmt && !classify::expr_requires_semi_to_be_stmt(expr))
             || (self.leftmost_subexpression_in_match_arm && classify::expr_is_complete(expr))
     }
@@ -189,7 +189,7 @@ impl FixupContext {
     ///
     ///   - `true && false`, because otherwise this would be misinterpreted as a
     ///     "let chain".
-    pub fn needs_par_as_let_scrutinee(self, expr: &Expr) -> bool {
+    pub(crate) fn needs_par_as_let_scrutinee(self, expr: &Expr) -> bool {
         self.parenthesize_exterior_struct_lit && parser::contains_exterior_struct_lit(expr)
             || parser::needs_par_as_let_scrutinee(expr.precedence().order())
     }

From 6614165eac9532a843f691fe1b7e3c37fa637ebf Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Sat, 6 Jul 2024 21:31:11 +1000
Subject: [PATCH 307/685] Add `warn(unreachable_pub)` to `rustc_attr`.

---
 compiler/rustc_attr/src/lib.rs                 | 1 +
 compiler/rustc_attr/src/session_diagnostics.rs | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_attr/src/lib.rs b/compiler/rustc_attr/src/lib.rs
index 1ecfc42ec1df4..0dad637238982 100644
--- a/compiler/rustc_attr/src/lib.rs
+++ b/compiler/rustc_attr/src/lib.rs
@@ -9,6 +9,7 @@
 #![doc(rust_logo)]
 #![feature(let_chains)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 mod builtin;
diff --git a/compiler/rustc_attr/src/session_diagnostics.rs b/compiler/rustc_attr/src/session_diagnostics.rs
index 92a3a385a7441..a1a10d2d36422 100644
--- a/compiler/rustc_attr/src/session_diagnostics.rs
+++ b/compiler/rustc_attr/src/session_diagnostics.rs
@@ -127,7 +127,7 @@ pub(crate) enum InvalidIssueStringCause {
 }
 
 impl InvalidIssueStringCause {
-    pub fn from_int_error_kind(span: Span, kind: &IntErrorKind) -> Option<Self> {
+    pub(crate) fn from_int_error_kind(span: Span, kind: &IntErrorKind) -> Option<Self> {
         match kind {
             IntErrorKind::Empty => Some(Self::Empty { span }),
             IntErrorKind::InvalidDigit => Some(Self::InvalidDigit { span }),
@@ -303,7 +303,7 @@ pub(crate) enum IncorrectReprFormatGenericCause<'a> {
 }
 
 impl<'a> IncorrectReprFormatGenericCause<'a> {
-    pub fn from_lit_kind(span: Span, kind: &ast::LitKind, name: &'a str) -> Option<Self> {
+    pub(crate) fn from_lit_kind(span: Span, kind: &ast::LitKind, name: &'a str) -> Option<Self> {
         match kind {
             ast::LitKind::Int(int, ast::LitIntType::Unsuffixed) => {
                 Some(Self::Int { span, name, int: int.get() })

From cb3f43569933111c99222e1d8d87d529117f0bd6 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Sat, 6 Jul 2024 21:35:12 +1000
Subject: [PATCH 308/685] Don't add `warn(unreachable_pub)` to
 `rustc_baked_icu`.

But explain why.
---
 compiler/rustc_baked_icu_data/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_baked_icu_data/src/lib.rs b/compiler/rustc_baked_icu_data/src/lib.rs
index e964a709757cf..f86a9db61c600 100644
--- a/compiler/rustc_baked_icu_data/src/lib.rs
+++ b/compiler/rustc_baked_icu_data/src/lib.rs
@@ -25,6 +25,7 @@
 #![allow(internal_features)]
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
+// #![warn(unreachable_pub)] // don't use because this crate is mostly generated code
 // tidy-alphabetical-end
 
 mod data {

From 0685c978434b21c18ae2575cbbd72b6234b7701e Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Sat, 6 Jul 2024 21:53:49 +1000
Subject: [PATCH 309/685] Add `warn(unreachable_pub)` to `rustc_borrowck`.

---
 .../rustc_borrowck/src/borrowck_errors.rs     |  2 +-
 compiler/rustc_borrowck/src/dataflow.rs       |  4 +-
 compiler/rustc_borrowck/src/def_use.rs        |  4 +-
 .../src/diagnostics/conflict_errors.rs        |  8 ++--
 .../rustc_borrowck/src/diagnostics/mod.rs     |  4 +-
 .../src/diagnostics/move_errors.rs            |  2 +-
 .../src/diagnostics/mutability_errors.rs      |  2 +-
 .../src/diagnostics/outlives_suggestion.rs    |  2 +-
 .../src/diagnostics/region_errors.rs          | 14 ++++---
 compiler/rustc_borrowck/src/lib.rs            | 26 +++++++-----
 compiler/rustc_borrowck/src/prefixes.rs       |  2 +-
 .../rustc_borrowck/src/region_infer/mod.rs    | 12 +++---
 .../src/region_infer/opaque_types.rs          |  8 ++--
 compiler/rustc_borrowck/src/type_check/mod.rs |  2 +-
 .../src/type_check/relate_tys.rs              |  4 +-
 .../rustc_borrowck/src/universal_regions.rs   | 42 +++++++++----------
 .../rustc_borrowck/src/util/collect_writes.rs |  2 +-
 compiler/rustc_borrowck/src/util/mod.rs       |  2 +-
 18 files changed, 74 insertions(+), 68 deletions(-)

diff --git a/compiler/rustc_borrowck/src/borrowck_errors.rs b/compiler/rustc_borrowck/src/borrowck_errors.rs
index 76e39fe94af43..86f46b55bfb44 100644
--- a/compiler/rustc_borrowck/src/borrowck_errors.rs
+++ b/compiler/rustc_borrowck/src/borrowck_errors.rs
@@ -9,7 +9,7 @@ use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::Span;
 
 impl<'infcx, 'tcx> crate::MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
-    pub fn dcx(&self) -> DiagCtxtHandle<'infcx> {
+    pub(crate) fn dcx(&self) -> DiagCtxtHandle<'infcx> {
         self.infcx.dcx()
     }
 
diff --git a/compiler/rustc_borrowck/src/dataflow.rs b/compiler/rustc_borrowck/src/dataflow.rs
index 77794a8525f8d..2795bc7162fc8 100644
--- a/compiler/rustc_borrowck/src/dataflow.rs
+++ b/compiler/rustc_borrowck/src/dataflow.rs
@@ -14,7 +14,7 @@ use rustc_mir_dataflow::{Analysis, AnalysisDomain, GenKill, Results, ResultsVisi
 use crate::{places_conflict, BorrowSet, PlaceConflictBias, PlaceExt, RegionInferenceContext};
 
 /// The results of the dataflow analyses used by the borrow checker.
-pub struct BorrowckResults<'a, 'mir, 'tcx> {
+pub(crate) struct BorrowckResults<'a, 'mir, 'tcx> {
     pub(crate) borrows: Results<'tcx, Borrows<'a, 'mir, 'tcx>>,
     pub(crate) uninits: Results<'tcx, MaybeUninitializedPlaces<'a, 'mir, 'tcx>>,
     pub(crate) ever_inits: Results<'tcx, EverInitializedPlaces<'a, 'mir, 'tcx>>,
@@ -22,7 +22,7 @@ pub struct BorrowckResults<'a, 'mir, 'tcx> {
 
 /// The transient state of the dataflow analyses used by the borrow checker.
 #[derive(Debug)]
-pub struct BorrowckFlowState<'a, 'mir, 'tcx> {
+pub(crate) struct BorrowckFlowState<'a, 'mir, 'tcx> {
     pub(crate) borrows: <Borrows<'a, 'mir, 'tcx> as AnalysisDomain<'tcx>>::Domain,
     pub(crate) uninits: <MaybeUninitializedPlaces<'a, 'mir, 'tcx> as AnalysisDomain<'tcx>>::Domain,
     pub(crate) ever_inits: <EverInitializedPlaces<'a, 'mir, 'tcx> as AnalysisDomain<'tcx>>::Domain,
diff --git a/compiler/rustc_borrowck/src/def_use.rs b/compiler/rustc_borrowck/src/def_use.rs
index 1f0b0981c8f29..7eb9e689afe82 100644
--- a/compiler/rustc_borrowck/src/def_use.rs
+++ b/compiler/rustc_borrowck/src/def_use.rs
@@ -4,13 +4,13 @@ use rustc_middle::mir::visit::{
 };
 
 #[derive(Eq, PartialEq, Clone)]
-pub enum DefUse {
+pub(crate) enum DefUse {
     Def,
     Use,
     Drop,
 }
 
-pub fn categorize(context: PlaceContext) -> Option<DefUse> {
+pub(crate) fn categorize(context: PlaceContext) -> Option<DefUse> {
     match context {
         ///////////////////////////////////////////////////////////////////////////
         // DEFS
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 2b46e5597f778..cd35427b914c2 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -645,7 +645,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
         }
     }
 
-    pub fn suggest_reborrow(
+    pub(crate) fn suggest_reborrow(
         &self,
         err: &mut Diag<'infcx>,
         span: Span,
@@ -1891,10 +1891,10 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
         struct FindUselessClone<'tcx> {
             tcx: TyCtxt<'tcx>,
             typeck_results: &'tcx ty::TypeckResults<'tcx>,
-            pub clones: Vec<&'tcx hir::Expr<'tcx>>,
+            clones: Vec<&'tcx hir::Expr<'tcx>>,
         }
         impl<'tcx> FindUselessClone<'tcx> {
-            pub fn new(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Self {
+            fn new(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Self {
                 Self { tcx, typeck_results: tcx.typeck(def_id), clones: vec![] }
             }
         }
@@ -1916,7 +1916,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
         let body = hir.body(body_id).value;
         expr_finder.visit_expr(body);
 
-        pub struct Holds<'tcx> {
+        struct Holds<'tcx> {
             ty: Ty<'tcx>,
         }
 
diff --git a/compiler/rustc_borrowck/src/diagnostics/mod.rs b/compiler/rustc_borrowck/src/diagnostics/mod.rs
index a2e5c7b85145a..33f91d7ad3043 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mod.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mod.rs
@@ -58,11 +58,11 @@ pub(crate) use region_name::{RegionName, RegionNameSource};
 pub(crate) use rustc_middle::util::CallKind;
 
 pub(super) struct DescribePlaceOpt {
-    pub including_downcast: bool,
+    including_downcast: bool,
 
     /// Enable/Disable tuple fields.
     /// For example `x` tuple. if it's `true` `x.0`. Otherwise `x`
-    pub including_tuple_field: bool,
+    including_tuple_field: bool,
 }
 
 pub(super) struct IncludingTupleField(pub(super) bool);
diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
index 792f1548e081e..42b1ffd58ad3e 100644
--- a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -16,7 +16,7 @@ use crate::prefixes::PrefixSet;
 use crate::MirBorrowckCtxt;
 
 #[derive(Debug)]
-pub enum IllegalMoveOriginKind<'tcx> {
+pub(crate) enum IllegalMoveOriginKind<'tcx> {
     /// Illegal move due to attempt to move from behind a reference.
     BorrowedContent {
         /// The place the reference refers to: if erroneous code was trying to
diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index 0303b80cace45..7b791928689c9 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -1374,7 +1374,7 @@ impl<'tcx> Visitor<'tcx> for BindingFinder {
     }
 }
 
-pub fn mut_borrow_of_mutable_ref(local_decl: &LocalDecl<'_>, local_name: Option<Symbol>) -> bool {
+fn mut_borrow_of_mutable_ref(local_decl: &LocalDecl<'_>, local_name: Option<Symbol>) -> bool {
     debug!("local_info: {:?}, ty.kind(): {:?}", local_decl.local_info, local_decl.ty.kind());
 
     match *local_decl.local_info() {
diff --git a/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs b/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs
index de0df3474299a..a59b7b3cde914 100644
--- a/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs
@@ -31,7 +31,7 @@ enum SuggestedConstraint {
 ///
 /// Adds a help note suggesting adding a where clause with the needed constraints.
 #[derive(Default)]
-pub struct OutlivesSuggestionBuilder {
+pub(crate) struct OutlivesSuggestionBuilder {
     /// The list of outlives constraints that need to be added. Specifically, we map each free
     /// region to all other regions that it must outlive. I will use the shorthand `fr:
     /// outlived_frs`. Not all of these regions will already have names necessarily. Some could be
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
index 451e8bcb16da4..ab48a09cfa4ce 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_errors.rs
@@ -72,22 +72,24 @@ impl<'tcx> ConstraintDescription for ConstraintCategory<'tcx> {
 pub(crate) struct RegionErrors<'tcx>(Vec<(RegionErrorKind<'tcx>, ErrorGuaranteed)>, TyCtxt<'tcx>);
 
 impl<'tcx> RegionErrors<'tcx> {
-    pub fn new(tcx: TyCtxt<'tcx>) -> Self {
+    pub(crate) fn new(tcx: TyCtxt<'tcx>) -> Self {
         Self(vec![], tcx)
     }
     #[track_caller]
-    pub fn push(&mut self, val: impl Into<RegionErrorKind<'tcx>>) {
+    pub(crate) fn push(&mut self, val: impl Into<RegionErrorKind<'tcx>>) {
         let val = val.into();
         let guar = self.1.sess.dcx().delayed_bug(format!("{val:?}"));
         self.0.push((val, guar));
     }
-    pub fn is_empty(&self) -> bool {
+    pub(crate) fn is_empty(&self) -> bool {
         self.0.is_empty()
     }
-    pub fn into_iter(self) -> impl Iterator<Item = (RegionErrorKind<'tcx>, ErrorGuaranteed)> {
+    pub(crate) fn into_iter(
+        self,
+    ) -> impl Iterator<Item = (RegionErrorKind<'tcx>, ErrorGuaranteed)> {
         self.0.into_iter()
     }
-    pub fn has_errors(&self) -> Option<ErrorGuaranteed> {
+    pub(crate) fn has_errors(&self) -> Option<ErrorGuaranteed> {
         self.0.get(0).map(|x| x.1)
     }
 }
@@ -141,7 +143,7 @@ pub(crate) enum RegionErrorKind<'tcx> {
 
 /// Information about the various region constraints involved in a borrow checker error.
 #[derive(Clone, Debug)]
-pub struct ErrorConstraintInfo<'tcx> {
+pub(crate) struct ErrorConstraintInfo<'tcx> {
     // fr: outlived_fr
     pub(super) fr: RegionVid,
     pub(super) fr_is_local: bool,
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 30dd45d847c9b..5d54204bf800a 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -12,6 +12,7 @@
 #![feature(rustdoc_internals)]
 #![feature(stmt_expr_attributes)]
 #![feature(try_blocks)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 #[macro_use]
@@ -2444,7 +2445,7 @@ mod diags {
         }
     }
 
-    pub struct BorrowckDiags<'infcx, 'tcx> {
+    pub(crate) struct BorrowckDiags<'infcx, 'tcx> {
         /// This field keeps track of move errors that are to be reported for given move indices.
         ///
         /// There are situations where many errors can be reported for a single move out (see
@@ -2468,7 +2469,7 @@ mod diags {
     }
 
     impl<'infcx, 'tcx> BorrowckDiags<'infcx, 'tcx> {
-        pub fn new() -> Self {
+        pub(crate) fn new() -> Self {
             BorrowckDiags {
                 buffered_move_errors: BTreeMap::new(),
                 buffered_mut_errors: Default::default(),
@@ -2476,25 +2477,25 @@ mod diags {
             }
         }
 
-        pub fn buffer_error(&mut self, diag: Diag<'infcx>) {
+        pub(crate) fn buffer_error(&mut self, diag: Diag<'infcx>) {
             self.buffered_diags.push(BufferedDiag::Error(diag));
         }
 
-        pub fn buffer_non_error(&mut self, diag: Diag<'infcx, ()>) {
+        pub(crate) fn buffer_non_error(&mut self, diag: Diag<'infcx, ()>) {
             self.buffered_diags.push(BufferedDiag::NonError(diag));
         }
     }
 
     impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
-        pub fn buffer_error(&mut self, diag: Diag<'infcx>) {
+        pub(crate) fn buffer_error(&mut self, diag: Diag<'infcx>) {
             self.diags.buffer_error(diag);
         }
 
-        pub fn buffer_non_error(&mut self, diag: Diag<'infcx, ()>) {
+        pub(crate) fn buffer_non_error(&mut self, diag: Diag<'infcx, ()>) {
             self.diags.buffer_non_error(diag);
         }
 
-        pub fn buffer_move_error(
+        pub(crate) fn buffer_move_error(
             &mut self,
             move_out_indices: Vec<MoveOutIndex>,
             place_and_err: (PlaceRef<'tcx>, Diag<'infcx>),
@@ -2510,16 +2511,19 @@ mod diags {
             }
         }
 
-        pub fn get_buffered_mut_error(&mut self, span: Span) -> Option<(Diag<'infcx>, usize)> {
+        pub(crate) fn get_buffered_mut_error(
+            &mut self,
+            span: Span,
+        ) -> Option<(Diag<'infcx>, usize)> {
             // FIXME(#120456) - is `swap_remove` correct?
             self.diags.buffered_mut_errors.swap_remove(&span)
         }
 
-        pub fn buffer_mut_error(&mut self, span: Span, diag: Diag<'infcx>, count: usize) {
+        pub(crate) fn buffer_mut_error(&mut self, span: Span, diag: Diag<'infcx>, count: usize) {
             self.diags.buffered_mut_errors.insert(span, (diag, count));
         }
 
-        pub fn emit_errors(&mut self) -> Option<ErrorGuaranteed> {
+        pub(crate) fn emit_errors(&mut self) -> Option<ErrorGuaranteed> {
             let mut res = None;
 
             // Buffer any move errors that we collected and de-duplicated.
@@ -2553,7 +2557,7 @@ mod diags {
             self.diags.buffered_diags.is_empty()
         }
 
-        pub fn has_move_error(
+        pub(crate) fn has_move_error(
             &self,
             move_out_indices: &[MoveOutIndex],
         ) -> Option<&(PlaceRef<'tcx>, Diag<'infcx>)> {
diff --git a/compiler/rustc_borrowck/src/prefixes.rs b/compiler/rustc_borrowck/src/prefixes.rs
index d3bfd1c418fe4..39d831378cde6 100644
--- a/compiler/rustc_borrowck/src/prefixes.rs
+++ b/compiler/rustc_borrowck/src/prefixes.rs
@@ -8,7 +8,7 @@ use rustc_middle::mir::{PlaceRef, ProjectionElem};
 
 use super::MirBorrowckCtxt;
 
-pub trait IsPrefixOf<'tcx> {
+pub(crate) trait IsPrefixOf<'tcx> {
     fn is_prefix_of(&self, other: PlaceRef<'tcx>) -> bool;
 }
 
diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs
index c8dc012de4a29..6cbdd890b5e8b 100644
--- a/compiler/rustc_borrowck/src/region_infer/mod.rs
+++ b/compiler/rustc_borrowck/src/region_infer/mod.rs
@@ -42,9 +42,9 @@ mod graphviz;
 mod opaque_types;
 mod reverse_sccs;
 
-pub mod values;
+pub(crate) mod values;
 
-pub type ConstraintSccs = Sccs<RegionVid, ConstraintSccIndex, RegionTracker>;
+pub(crate) type ConstraintSccs = Sccs<RegionVid, ConstraintSccIndex, RegionTracker>;
 
 /// An annotation for region graph SCCs that tracks
 /// the values of its elements.
@@ -226,7 +226,7 @@ pub(crate) struct AppliedMemberConstraint {
 }
 
 #[derive(Debug)]
-pub struct RegionDefinition<'tcx> {
+pub(crate) struct RegionDefinition<'tcx> {
     /// What kind of variable is this -- a free region? existential
     /// variable? etc. (See the `NllRegionVariableOrigin` for more
     /// info.)
@@ -288,7 +288,7 @@ pub(crate) enum Cause {
 /// `InferCtxt::process_registered_region_obligations` and
 /// `InferCtxt::type_must_outlive` in `rustc_infer::infer::InferCtxt`.
 #[derive(Clone, Debug)]
-pub struct TypeTest<'tcx> {
+pub(crate) struct TypeTest<'tcx> {
     /// The type `T` that must outlive the region.
     pub generic_kind: GenericKind<'tcx>,
 
@@ -320,7 +320,7 @@ enum Trace<'tcx> {
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
-pub enum ExtraConstraintInfo {
+pub(crate) enum ExtraConstraintInfo {
     PlaceholderFromPredicate(Span),
 }
 
@@ -2259,7 +2259,7 @@ impl<'tcx> RegionDefinition<'tcx> {
 }
 
 #[derive(Clone, Debug)]
-pub struct BlameConstraint<'tcx> {
+pub(crate) struct BlameConstraint<'tcx> {
     pub category: ConstraintCategory<'tcx>,
     pub from_closure: bool,
     pub cause: ObligationCause<'tcx>,
diff --git a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
index 1073ea4069483..cd66acd0a8f21 100644
--- a/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
+++ b/compiler/rustc_borrowck/src/region_infer/opaque_types.rs
@@ -473,20 +473,20 @@ struct LazyOpaqueTyEnv<'tcx> {
 }
 
 impl<'tcx> LazyOpaqueTyEnv<'tcx> {
-    pub fn new(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Self {
+    fn new(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Self {
         Self { tcx, def_id, canonical_args: std::cell::OnceCell::new() }
     }
 
-    pub fn param_equal_static(&self, param_index: usize) -> bool {
+    fn param_equal_static(&self, param_index: usize) -> bool {
         self.get_canonical_args()[param_index].expect_region().is_static()
     }
 
-    pub fn params_equal(&self, param1: usize, param2: usize) -> bool {
+    fn params_equal(&self, param1: usize, param2: usize) -> bool {
         let canonical_args = self.get_canonical_args();
         canonical_args[param1] == canonical_args[param2]
     }
 
-    pub fn param_is_error(&self, param_index: usize) -> Result<(), ErrorGuaranteed> {
+    fn param_is_error(&self, param_index: usize) -> Result<(), ErrorGuaranteed> {
         self.get_canonical_args()[param_index].error_reported()
     }
 
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index a2669da1b04e8..bbcc2bbdc1086 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -86,7 +86,7 @@ macro_rules! span_mirbug_and_err {
 
 mod canonical;
 mod constraint_conversion;
-pub mod free_region_relations;
+pub(crate) mod free_region_relations;
 mod input_output;
 pub(crate) mod liveness;
 mod relate_tys;
diff --git a/compiler/rustc_borrowck/src/type_check/relate_tys.rs b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
index 8da4d80badfec..35d8e2573fe17 100644
--- a/compiler/rustc_borrowck/src/type_check/relate_tys.rs
+++ b/compiler/rustc_borrowck/src/type_check/relate_tys.rs
@@ -57,7 +57,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
     }
 }
 
-pub struct NllTypeRelating<'me, 'bccx, 'tcx> {
+struct NllTypeRelating<'me, 'bccx, 'tcx> {
     type_checker: &'me mut TypeChecker<'bccx, 'tcx>,
 
     /// Where (and why) is this relation taking place?
@@ -82,7 +82,7 @@ pub struct NllTypeRelating<'me, 'bccx, 'tcx> {
 }
 
 impl<'me, 'bccx, 'tcx> NllTypeRelating<'me, 'bccx, 'tcx> {
-    pub fn new(
+    fn new(
         type_checker: &'me mut TypeChecker<'bccx, 'tcx>,
         locations: Locations,
         category: ConstraintCategory<'tcx>,
diff --git a/compiler/rustc_borrowck/src/universal_regions.rs b/compiler/rustc_borrowck/src/universal_regions.rs
index 1ad80cb122ab6..2e41c91877431 100644
--- a/compiler/rustc_borrowck/src/universal_regions.rs
+++ b/compiler/rustc_borrowck/src/universal_regions.rs
@@ -39,7 +39,7 @@ use crate::renumber::RegionCtxt;
 use crate::BorrowckInferCtxt;
 
 #[derive(Debug)]
-pub struct UniversalRegions<'tcx> {
+pub(crate) struct UniversalRegions<'tcx> {
     indices: UniversalRegionIndices<'tcx>,
 
     /// The vid assigned to `'static`
@@ -95,7 +95,7 @@ pub struct UniversalRegions<'tcx> {
 /// regions appear free in the defining type and late-bound regions
 /// appear bound in the signature.
 #[derive(Copy, Clone, Debug)]
-pub enum DefiningTy<'tcx> {
+pub(crate) enum DefiningTy<'tcx> {
     /// The MIR is a closure. The signature is found via
     /// `ClosureArgs::closure_sig_ty`.
     Closure(DefId, GenericArgsRef<'tcx>),
@@ -131,7 +131,7 @@ impl<'tcx> DefiningTy<'tcx> {
     /// not a closure or coroutine, there are no upvars, and hence it
     /// will be an empty list. The order of types in this list will
     /// match up with the upvar order in the HIR, typesystem, and MIR.
-    pub fn upvar_tys(self) -> &'tcx ty::List<Ty<'tcx>> {
+    pub(crate) fn upvar_tys(self) -> &'tcx ty::List<Ty<'tcx>> {
         match self {
             DefiningTy::Closure(_, args) => args.as_closure().upvar_tys(),
             DefiningTy::CoroutineClosure(_, args) => args.as_coroutine_closure().upvar_tys(),
@@ -145,7 +145,7 @@ impl<'tcx> DefiningTy<'tcx> {
     /// Number of implicit inputs -- notably the "environment"
     /// parameter for closures -- that appear in MIR but not in the
     /// user's code.
-    pub fn implicit_inputs(self) -> usize {
+    pub(crate) fn implicit_inputs(self) -> usize {
         match self {
             DefiningTy::Closure(..)
             | DefiningTy::CoroutineClosure(..)
@@ -154,15 +154,15 @@ impl<'tcx> DefiningTy<'tcx> {
         }
     }
 
-    pub fn is_fn_def(&self) -> bool {
+    pub(crate) fn is_fn_def(&self) -> bool {
         matches!(*self, DefiningTy::FnDef(..))
     }
 
-    pub fn is_const(&self) -> bool {
+    pub(crate) fn is_const(&self) -> bool {
         matches!(*self, DefiningTy::Const(..) | DefiningTy::InlineConst(..))
     }
 
-    pub fn def_id(&self) -> DefId {
+    pub(crate) fn def_id(&self) -> DefId {
         match *self {
             DefiningTy::Closure(def_id, ..)
             | DefiningTy::CoroutineClosure(def_id, ..)
@@ -196,7 +196,7 @@ struct UniversalRegionIndices<'tcx> {
 }
 
 #[derive(Debug, PartialEq)]
-pub enum RegionClassification {
+pub(crate) enum RegionClassification {
     /// A **global** region is one that can be named from
     /// anywhere. There is only one, `'static`.
     Global,
@@ -246,7 +246,7 @@ impl<'tcx> UniversalRegions<'tcx> {
     /// MIR -- that is, all the regions that appear in the function's
     /// signature. This will also compute the relationships that are
     /// known between those regions.
-    pub fn new(
+    pub(crate) fn new(
         infcx: &BorrowckInferCtxt<'tcx>,
         mir_def: LocalDefId,
         param_env: ty::ParamEnv<'tcx>,
@@ -263,7 +263,7 @@ impl<'tcx> UniversalRegions<'tcx> {
     /// if the `ClosureRegionRequirements` contains something like
     /// `'1: '2`, then the caller would impose the constraint that
     /// `V[1]: V[2]`.
-    pub fn closure_mapping(
+    pub(crate) fn closure_mapping(
         tcx: TyCtxt<'tcx>,
         closure_args: GenericArgsRef<'tcx>,
         expected_num_vars: usize,
@@ -289,13 +289,13 @@ impl<'tcx> UniversalRegions<'tcx> {
     }
 
     /// Returns `true` if `r` is a member of this set of universal regions.
-    pub fn is_universal_region(&self, r: RegionVid) -> bool {
+    pub(crate) fn is_universal_region(&self, r: RegionVid) -> bool {
         (FIRST_GLOBAL_INDEX..self.num_universals).contains(&r.index())
     }
 
     /// Classifies `r` as a universal region, returning `None` if this
     /// is not a member of this set of universal regions.
-    pub fn region_classification(&self, r: RegionVid) -> Option<RegionClassification> {
+    pub(crate) fn region_classification(&self, r: RegionVid) -> Option<RegionClassification> {
         let index = r.index();
         if (FIRST_GLOBAL_INDEX..self.first_extern_index).contains(&index) {
             Some(RegionClassification::Global)
@@ -310,17 +310,17 @@ impl<'tcx> UniversalRegions<'tcx> {
 
     /// Returns an iterator over all the RegionVids corresponding to
     /// universally quantified free regions.
-    pub fn universal_regions(&self) -> impl Iterator<Item = RegionVid> {
+    pub(crate) fn universal_regions(&self) -> impl Iterator<Item = RegionVid> {
         (FIRST_GLOBAL_INDEX..self.num_universals).map(RegionVid::from_usize)
     }
 
     /// Returns `true` if `r` is classified as a local region.
-    pub fn is_local_free_region(&self, r: RegionVid) -> bool {
+    pub(crate) fn is_local_free_region(&self, r: RegionVid) -> bool {
         self.region_classification(r) == Some(RegionClassification::Local)
     }
 
     /// Returns the number of universal regions created in any category.
-    pub fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
         self.num_universals
     }
 
@@ -329,19 +329,19 @@ impl<'tcx> UniversalRegions<'tcx> {
     /// closure type (versus those bound in the closure
     /// signature). They are therefore the regions between which the
     /// closure may impose constraints that its creator must verify.
-    pub fn num_global_and_external_regions(&self) -> usize {
+    pub(crate) fn num_global_and_external_regions(&self) -> usize {
         self.first_local_index
     }
 
     /// Gets an iterator over all the early-bound regions that have names.
-    pub fn named_universal_regions<'s>(
+    pub(crate) fn named_universal_regions<'s>(
         &'s self,
     ) -> impl Iterator<Item = (ty::Region<'tcx>, ty::RegionVid)> + 's {
         self.indices.indices.iter().map(|(&r, &v)| (r, v))
     }
 
     /// See `UniversalRegionIndices::to_region_vid`.
-    pub fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
+    pub(crate) fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
         self.indices.to_region_vid(r)
     }
 
@@ -416,7 +416,7 @@ impl<'tcx> UniversalRegions<'tcx> {
         }
     }
 
-    pub fn tainted_by_errors(&self) -> Option<ErrorGuaranteed> {
+    pub(crate) fn tainted_by_errors(&self) -> Option<ErrorGuaranteed> {
         self.indices.tainted_by_errors.get()
     }
 }
@@ -880,7 +880,7 @@ impl<'tcx> UniversalRegionIndices<'tcx> {
     /// reference those regions from the `ParamEnv`. It is also used
     /// during initialization. Relies on the `indices` map having been
     /// fully initialized.
-    pub fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
+    fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
         if let ty::ReVar(..) = *r {
             r.as_var()
         } else if let ty::ReError(guar) = *r {
@@ -899,7 +899,7 @@ impl<'tcx> UniversalRegionIndices<'tcx> {
 
     /// Replaces all free regions in `value` with region vids, as
     /// returned by `to_region_vid`.
-    pub fn fold_to_region_vids<T>(&self, tcx: TyCtxt<'tcx>, value: T) -> T
+    fn fold_to_region_vids<T>(&self, tcx: TyCtxt<'tcx>, value: T) -> T
     where
         T: TypeFoldable<TyCtxt<'tcx>>,
     {
diff --git a/compiler/rustc_borrowck/src/util/collect_writes.rs b/compiler/rustc_borrowck/src/util/collect_writes.rs
index 93c7810b54517..55f1073176aef 100644
--- a/compiler/rustc_borrowck/src/util/collect_writes.rs
+++ b/compiler/rustc_borrowck/src/util/collect_writes.rs
@@ -1,7 +1,7 @@
 use rustc_middle::mir::visit::{PlaceContext, Visitor};
 use rustc_middle::mir::{Body, Local, Location};
 
-pub trait FindAssignments {
+pub(crate) trait FindAssignments {
     // Finds all statements that assign directly to local (i.e., X = ...)
     // and returns their locations.
     fn find_assignments(&self, local: Local) -> Vec<Location>;
diff --git a/compiler/rustc_borrowck/src/util/mod.rs b/compiler/rustc_borrowck/src/util/mod.rs
index 7377d4de7274f..5f2960b768b29 100644
--- a/compiler/rustc_borrowck/src/util/mod.rs
+++ b/compiler/rustc_borrowck/src/util/mod.rs
@@ -1,3 +1,3 @@
 mod collect_writes;
 
-pub use collect_writes::FindAssignments;
+pub(crate) use collect_writes::FindAssignments;

From 0544d3a952056da8d4c69130cc52ca52e8f78bf3 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Sat, 6 Jul 2024 22:08:04 +1000
Subject: [PATCH 310/685] Add `warn(unreachable_pub)` to
 `rustc_builtin_macros`.

---
 .../src/deriving/generic/mod.rs               | 10 +--
 .../src/deriving/generic/ty.rs                | 18 ++---
 .../src/deriving/smart_ptr.rs                 |  2 +-
 compiler/rustc_builtin_macros/src/errors.rs   |  2 +-
 .../src/format_foreign.rs                     | 68 +++++++++----------
 compiler/rustc_builtin_macros/src/lib.rs      |  1 +
 6 files changed, 51 insertions(+), 50 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
index c90a916488606..289e92a69b2c0 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -351,15 +351,15 @@ struct TypeParameter {
 pub(crate) struct BlockOrExpr(ThinVec<ast::Stmt>, Option<P<Expr>>);
 
 impl BlockOrExpr {
-    pub fn new_stmts(stmts: ThinVec<ast::Stmt>) -> BlockOrExpr {
+    pub(crate) fn new_stmts(stmts: ThinVec<ast::Stmt>) -> BlockOrExpr {
         BlockOrExpr(stmts, None)
     }
 
-    pub fn new_expr(expr: P<Expr>) -> BlockOrExpr {
+    pub(crate) fn new_expr(expr: P<Expr>) -> BlockOrExpr {
         BlockOrExpr(ThinVec::new(), Some(expr))
     }
 
-    pub fn new_mixed(stmts: ThinVec<ast::Stmt>, expr: Option<P<Expr>>) -> BlockOrExpr {
+    pub(crate) fn new_mixed(stmts: ThinVec<ast::Stmt>, expr: Option<P<Expr>>) -> BlockOrExpr {
         BlockOrExpr(stmts, expr)
     }
 
@@ -461,7 +461,7 @@ fn find_type_parameters(
 }
 
 impl<'a> TraitDef<'a> {
-    pub fn expand(
+    pub(crate) fn expand(
         self,
         cx: &ExtCtxt<'_>,
         mitem: &ast::MetaItem,
@@ -471,7 +471,7 @@ impl<'a> TraitDef<'a> {
         self.expand_ext(cx, mitem, item, push, false);
     }
 
-    pub fn expand_ext(
+    pub(crate) fn expand_ext(
         self,
         cx: &ExtCtxt<'_>,
         mitem: &ast::MetaItem,
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs b/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
index 747da2ee43bdf..42855e255a806 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/ty.rs
@@ -27,17 +27,17 @@ pub(crate) enum PathKind {
 }
 
 impl Path {
-    pub fn new(path: Vec<Symbol>) -> Path {
+    pub(crate) fn new(path: Vec<Symbol>) -> Path {
         Path::new_(path, Vec::new(), PathKind::Std)
     }
-    pub fn new_local(path: Symbol) -> Path {
+    pub(crate) fn new_local(path: Symbol) -> Path {
         Path::new_(vec![path], Vec::new(), PathKind::Local)
     }
-    pub fn new_(path: Vec<Symbol>, params: Vec<Box<Ty>>, kind: PathKind) -> Path {
+    pub(crate) fn new_(path: Vec<Symbol>, params: Vec<Box<Ty>>, kind: PathKind) -> Path {
         Path { path, params, kind }
     }
 
-    pub fn to_ty(
+    pub(crate) fn to_ty(
         &self,
         cx: &ExtCtxt<'_>,
         span: Span,
@@ -46,7 +46,7 @@ impl Path {
     ) -> P<ast::Ty> {
         cx.ty_path(self.to_path(cx, span, self_ty, self_generics))
     }
-    pub fn to_path(
+    pub(crate) fn to_path(
         &self,
         cx: &ExtCtxt<'_>,
         span: Span,
@@ -87,7 +87,7 @@ pub(crate) fn self_ref() -> Ty {
 }
 
 impl Ty {
-    pub fn to_ty(
+    pub(crate) fn to_ty(
         &self,
         cx: &ExtCtxt<'_>,
         span: Span,
@@ -108,7 +108,7 @@ impl Ty {
         }
     }
 
-    pub fn to_path(
+    pub(crate) fn to_path(
         &self,
         cx: &ExtCtxt<'_>,
         span: Span,
@@ -167,10 +167,10 @@ pub(crate) struct Bounds {
 }
 
 impl Bounds {
-    pub fn empty() -> Bounds {
+    pub(crate) fn empty() -> Bounds {
         Bounds { bounds: Vec::new() }
     }
-    pub fn to_generics(
+    pub(crate) fn to_generics(
         &self,
         cx: &ExtCtxt<'_>,
         span: Span,
diff --git a/compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs b/compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs
index 7eb1f17a59ce3..c88c5bd35a526 100644
--- a/compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs
@@ -18,7 +18,7 @@ macro_rules! path {
     ($span:expr, $($part:ident)::*) => { vec![$(Ident::new(sym::$part, $span),)*] }
 }
 
-pub fn expand_deriving_smart_ptr(
+pub(crate) fn expand_deriving_smart_ptr(
     cx: &ExtCtxt<'_>,
     span: Span,
     _mitem: &MetaItem,
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
index 6ca43441e0582..4fffffb91c8b4 100644
--- a/compiler/rustc_builtin_macros/src/errors.rs
+++ b/compiler/rustc_builtin_macros/src/errors.rs
@@ -930,7 +930,7 @@ pub(crate) struct ExpectedItem<'a> {
 
 #[derive(Diagnostic)]
 #[diag(builtin_macros_naked_functions_testing_attribute, code = E0736)]
-pub struct NakedFunctionTestingAttribute {
+pub(crate) struct NakedFunctionTestingAttribute {
     #[primary_span]
     #[label(builtin_macros_naked_attribute)]
     pub naked_span: Span,
diff --git a/compiler/rustc_builtin_macros/src/format_foreign.rs b/compiler/rustc_builtin_macros/src/format_foreign.rs
index b52f606f342e2..866ec72f11646 100644
--- a/compiler/rustc_builtin_macros/src/format_foreign.rs
+++ b/compiler/rustc_builtin_macros/src/format_foreign.rs
@@ -5,7 +5,7 @@ pub(crate) mod printf {
 
     /// Represents a single `printf`-style substitution.
     #[derive(Clone, PartialEq, Debug)]
-    pub enum Substitution<'a> {
+    pub(crate) enum Substitution<'a> {
         /// A formatted output substitution with its internal byte offset.
         Format(Format<'a>),
         /// A literal `%%` escape, with its start and end indices.
@@ -13,21 +13,21 @@ pub(crate) mod printf {
     }
 
     impl<'a> Substitution<'a> {
-        pub fn as_str(&self) -> &str {
+        pub(crate) fn as_str(&self) -> &str {
             match self {
                 Substitution::Format(fmt) => fmt.span,
                 Substitution::Escape(_) => "%%",
             }
         }
 
-        pub fn position(&self) -> InnerSpan {
+        pub(crate) fn position(&self) -> InnerSpan {
             match self {
                 Substitution::Format(fmt) => fmt.position,
                 &Substitution::Escape((start, end)) => InnerSpan::new(start, end),
             }
         }
 
-        pub fn set_position(&mut self, start: usize, end: usize) {
+        pub(crate) fn set_position(&mut self, start: usize, end: usize) {
             match self {
                 Substitution::Format(fmt) => fmt.position = InnerSpan::new(start, end),
                 Substitution::Escape(pos) => *pos = (start, end),
@@ -38,7 +38,7 @@ pub(crate) mod printf {
         ///
         /// This ignores cases where the substitution does not have an exact equivalent, or where
         /// the substitution would be unnecessary.
-        pub fn translate(&self) -> Result<String, Option<String>> {
+        pub(crate) fn translate(&self) -> Result<String, Option<String>> {
             match self {
                 Substitution::Format(fmt) => fmt.translate(),
                 Substitution::Escape(_) => Err(None),
@@ -48,23 +48,23 @@ pub(crate) mod printf {
 
     #[derive(Clone, PartialEq, Debug)]
     /// A single `printf`-style formatting directive.
-    pub struct Format<'a> {
+    pub(crate) struct Format<'a> {
         /// The entire original formatting directive.
-        pub span: &'a str,
+        span: &'a str,
         /// The (1-based) parameter to be converted.
-        pub parameter: Option<u16>,
+        parameter: Option<u16>,
         /// Formatting flags.
-        pub flags: &'a str,
+        flags: &'a str,
         /// Minimum width of the output.
-        pub width: Option<Num>,
+        width: Option<Num>,
         /// Precision of the conversion.
-        pub precision: Option<Num>,
+        precision: Option<Num>,
         /// Length modifier for the conversion.
-        pub length: Option<&'a str>,
+        length: Option<&'a str>,
         /// Type of parameter being converted.
-        pub type_: &'a str,
+        type_: &'a str,
         /// Byte offset for the start and end of this formatting directive.
-        pub position: InnerSpan,
+        position: InnerSpan,
     }
 
     impl Format<'_> {
@@ -72,7 +72,7 @@ pub(crate) mod printf {
         ///
         /// Returns `Err` in cases where the `printf` directive does not have an exact Rust
         /// equivalent, rather than guessing.
-        pub fn translate(&self) -> Result<String, Option<String>> {
+        pub(crate) fn translate(&self) -> Result<String, Option<String>> {
             use std::fmt::Write;
 
             let (c_alt, c_zero, c_left, c_plus) = {
@@ -249,7 +249,7 @@ pub(crate) mod printf {
 
     /// A general number used in a `printf` formatting directive.
     #[derive(Copy, Clone, PartialEq, Debug)]
-    pub enum Num {
+    enum Num {
         // The range of these values is technically bounded by `NL_ARGMAX`... but, at least for GNU
         // libc, it apparently has no real fixed limit. A `u16` is used here on the basis that it
         // is *vanishingly* unlikely that *anyone* is going to try formatting something wider, or
@@ -288,12 +288,12 @@ pub(crate) mod printf {
     }
 
     /// Returns an iterator over all substitutions in a given string.
-    pub fn iter_subs(s: &str, start_pos: usize) -> Substitutions<'_> {
+    pub(crate) fn iter_subs(s: &str, start_pos: usize) -> Substitutions<'_> {
         Substitutions { s, pos: start_pos }
     }
 
     /// Iterator over substitutions in a string.
-    pub struct Substitutions<'a> {
+    pub(crate) struct Substitutions<'a> {
         s: &'a str,
         pos: usize,
     }
@@ -327,7 +327,7 @@ pub(crate) mod printf {
     }
 
     /// Parse the next substitution from the input string.
-    pub fn parse_next_substitution(s: &str) -> Option<(Substitution<'_>, &str)> {
+    fn parse_next_substitution(s: &str) -> Option<(Substitution<'_>, &str)> {
         use self::State::*;
 
         let at = {
@@ -615,20 +615,20 @@ pub(crate) mod printf {
     mod tests;
 }
 
-pub mod shell {
+pub(crate) mod shell {
     use rustc_span::InnerSpan;
 
     use super::strcursor::StrCursor as Cur;
 
     #[derive(Clone, PartialEq, Debug)]
-    pub enum Substitution<'a> {
+    pub(crate) enum Substitution<'a> {
         Ordinal(u8, (usize, usize)),
         Name(&'a str, (usize, usize)),
         Escape((usize, usize)),
     }
 
     impl Substitution<'_> {
-        pub fn as_str(&self) -> String {
+        pub(crate) fn as_str(&self) -> String {
             match self {
                 Substitution::Ordinal(n, _) => format!("${n}"),
                 Substitution::Name(n, _) => format!("${n}"),
@@ -636,17 +636,17 @@ pub mod shell {
             }
         }
 
-        pub fn position(&self) -> InnerSpan {
+        pub(crate) fn position(&self) -> InnerSpan {
             let (Self::Ordinal(_, pos) | Self::Name(_, pos) | Self::Escape(pos)) = self;
             InnerSpan::new(pos.0, pos.1)
         }
 
-        pub fn set_position(&mut self, start: usize, end: usize) {
+        fn set_position(&mut self, start: usize, end: usize) {
             let (Self::Ordinal(_, pos) | Self::Name(_, pos) | Self::Escape(pos)) = self;
             *pos = (start, end);
         }
 
-        pub fn translate(&self) -> Result<String, Option<String>> {
+        pub(crate) fn translate(&self) -> Result<String, Option<String>> {
             match self {
                 Substitution::Ordinal(n, _) => Ok(format!("{{{}}}", n)),
                 Substitution::Name(n, _) => Ok(format!("{{{}}}", n)),
@@ -656,12 +656,12 @@ pub mod shell {
     }
 
     /// Returns an iterator over all substitutions in a given string.
-    pub fn iter_subs(s: &str, start_pos: usize) -> Substitutions<'_> {
+    pub(crate) fn iter_subs(s: &str, start_pos: usize) -> Substitutions<'_> {
         Substitutions { s, pos: start_pos }
     }
 
     /// Iterator over substitutions in a string.
-    pub struct Substitutions<'a> {
+    pub(crate) struct Substitutions<'a> {
         s: &'a str,
         pos: usize,
     }
@@ -683,7 +683,7 @@ pub mod shell {
     }
 
     /// Parse the next substitution from the input string.
-    pub fn parse_next_substitution(s: &str) -> Option<(Substitution<'_>, &str)> {
+    fn parse_next_substitution(s: &str) -> Option<(Substitution<'_>, &str)> {
         let at = {
             let start = s.find('$')?;
             match s[start + 1..].chars().next()? {
@@ -743,24 +743,24 @@ pub mod shell {
 }
 
 mod strcursor {
-    pub struct StrCursor<'a> {
+    pub(crate) struct StrCursor<'a> {
         s: &'a str,
         pub at: usize,
     }
 
     impl<'a> StrCursor<'a> {
-        pub fn new_at(s: &'a str, at: usize) -> StrCursor<'a> {
+        pub(crate) fn new_at(s: &'a str, at: usize) -> StrCursor<'a> {
             StrCursor { s, at }
         }
 
-        pub fn at_next_cp(mut self) -> Option<StrCursor<'a>> {
+        pub(crate) fn at_next_cp(mut self) -> Option<StrCursor<'a>> {
             match self.try_seek_right_cp() {
                 true => Some(self),
                 false => None,
             }
         }
 
-        pub fn next_cp(mut self) -> Option<(char, StrCursor<'a>)> {
+        pub(crate) fn next_cp(mut self) -> Option<(char, StrCursor<'a>)> {
             let cp = self.cp_after()?;
             self.seek_right(cp.len_utf8());
             Some((cp, self))
@@ -770,11 +770,11 @@ mod strcursor {
             &self.s[0..self.at]
         }
 
-        pub fn slice_after(&self) -> &'a str {
+        pub(crate) fn slice_after(&self) -> &'a str {
             &self.s[self.at..]
         }
 
-        pub fn slice_between(&self, until: StrCursor<'a>) -> Option<&'a str> {
+        pub(crate) fn slice_between(&self, until: StrCursor<'a>) -> Option<&'a str> {
             if !str_eq_literal(self.s, until.s) {
                 None
             } else {
diff --git a/compiler/rustc_builtin_macros/src/lib.rs b/compiler/rustc_builtin_macros/src/lib.rs
index a9ba7334d930e..30e1c8d262216 100644
--- a/compiler/rustc_builtin_macros/src/lib.rs
+++ b/compiler/rustc_builtin_macros/src/lib.rs
@@ -16,6 +16,7 @@
 #![feature(proc_macro_quote)]
 #![feature(rustdoc_internals)]
 #![feature(try_blocks)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 extern crate proc_macro;

From 61627438ebb72977c8480a2d8b573137cfecefb1 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Sat, 6 Jul 2024 22:26:42 +1000
Subject: [PATCH 311/685] Add `warn(unreachable_pub)` to `rustc_codegen_llvm`.

---
 compiler/rustc_codegen_llvm/src/abi.rs        | 14 ++---
 compiler/rustc_codegen_llvm/src/attributes.rs | 20 +++----
 .../rustc_codegen_llvm/src/back/archive.rs    |  2 +-
 compiler/rustc_codegen_llvm/src/back/lto.rs   | 10 ++--
 .../rustc_codegen_llvm/src/back/profiling.rs  |  8 +--
 compiler/rustc_codegen_llvm/src/back/write.rs | 20 +++----
 compiler/rustc_codegen_llvm/src/base.rs       | 15 +++--
 compiler/rustc_codegen_llvm/src/builder.rs    | 58 +++++++++++--------
 compiler/rustc_codegen_llvm/src/callee.rs     |  2 +-
 compiler/rustc_codegen_llvm/src/common.rs     | 22 +++----
 compiler/rustc_codegen_llvm/src/consts.rs     |  2 +-
 compiler/rustc_codegen_llvm/src/context.rs    | 10 ++--
 .../src/coverageinfo/ffi.rs                   | 18 +++---
 .../src/coverageinfo/map_data.rs              |  8 +--
 .../src/coverageinfo/mapgen.rs                |  2 +-
 .../src/coverageinfo/mod.rs                   |  8 +--
 .../src/debuginfo/create_scope_map.rs         |  2 +-
 .../rustc_codegen_llvm/src/debuginfo/gdb.rs   |  8 ++-
 .../src/debuginfo/metadata.rs                 | 22 ++++---
 .../src/debuginfo/metadata/enums/mod.rs       |  2 +-
 .../src/debuginfo/metadata/type_map.rs        | 24 ++++----
 .../rustc_codegen_llvm/src/debuginfo/mod.rs   | 26 ++++-----
 .../src/debuginfo/namespace.rs                |  4 +-
 .../rustc_codegen_llvm/src/debuginfo/utils.rs | 10 ++--
 compiler/rustc_codegen_llvm/src/declare.rs    | 16 ++---
 compiler/rustc_codegen_llvm/src/errors.rs     |  4 +-
 compiler/rustc_codegen_llvm/src/lib.rs        |  9 +--
 compiler/rustc_codegen_llvm/src/llvm_util.rs  | 32 +++++-----
 compiler/rustc_codegen_llvm/src/type_.rs      |  2 +-
 compiler/rustc_codegen_llvm/src/type_of.rs    |  8 +--
 compiler/rustc_codegen_llvm/src/value.rs      |  2 +-
 31 files changed, 206 insertions(+), 184 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/abi.rs b/compiler/rustc_codegen_llvm/src/abi.rs
index 5ff580e295a60..dea574a53cd7b 100644
--- a/compiler/rustc_codegen_llvm/src/abi.rs
+++ b/compiler/rustc_codegen_llvm/src/abi.rs
@@ -6,13 +6,13 @@ use rustc_codegen_ssa::mir::place::{PlaceRef, PlaceValue};
 use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::MemFlags;
 use rustc_middle::ty::layout::LayoutOf;
-pub use rustc_middle::ty::layout::{FAT_PTR_ADDR, FAT_PTR_EXTRA};
+pub(crate) use rustc_middle::ty::layout::{FAT_PTR_ADDR, FAT_PTR_EXTRA};
 use rustc_middle::ty::Ty;
 use rustc_middle::{bug, ty};
 use rustc_session::config;
-pub use rustc_target::abi::call::*;
+pub(crate) use rustc_target::abi::call::*;
 use rustc_target::abi::{self, HasDataLayout, Int, Size};
-pub use rustc_target::spec::abi::Abi;
+pub(crate) use rustc_target::spec::abi::Abi;
 use rustc_target::spec::SanitizerSet;
 use smallvec::SmallVec;
 
@@ -25,7 +25,7 @@ use crate::type_of::LayoutLlvmExt;
 use crate::value::Value;
 use crate::{attributes, llvm_util};
 
-pub trait ArgAttributesExt {
+trait ArgAttributesExt {
     fn apply_attrs_to_llfn(&self, idx: AttributePlace, cx: &CodegenCx<'_, '_>, llfn: &Value);
     fn apply_attrs_to_callsite(
         &self,
@@ -111,7 +111,7 @@ impl ArgAttributesExt for ArgAttributes {
     }
 }
 
-pub trait LlvmType {
+pub(crate) trait LlvmType {
     fn llvm_type<'ll>(&self, cx: &CodegenCx<'ll, '_>) -> &'ll Type;
 }
 
@@ -171,7 +171,7 @@ impl LlvmType for CastTarget {
     }
 }
 
-pub trait ArgAbiExt<'ll, 'tcx> {
+trait ArgAbiExt<'ll, 'tcx> {
     fn memory_ty(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type;
     fn store(
         &self,
@@ -307,7 +307,7 @@ impl<'ll, 'tcx> ArgAbiMethods<'tcx> for Builder<'_, 'll, 'tcx> {
     }
 }
 
-pub trait FnAbiLlvmExt<'ll, 'tcx> {
+pub(crate) trait FnAbiLlvmExt<'ll, 'tcx> {
     fn llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type;
     fn ptr_to_llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type;
     fn llvm_cconv(&self) -> llvm::CallConv;
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index fde95104093e5..317e970d70485 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -1,6 +1,6 @@
 //! Set and unset common attributes on LLVM values.
 
-pub use rustc_attr::{InlineAttr, InstructionSetAttr, OptimizeAttr};
+use rustc_attr::{InlineAttr, InstructionSetAttr, OptimizeAttr};
 use rustc_codegen_ssa::traits::*;
 use rustc_hir::def_id::DefId;
 use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, PatchableFunctionEntry};
@@ -17,13 +17,13 @@ use crate::llvm::{self, AllocKindFlags, Attribute, AttributeKind, AttributePlace
 use crate::value::Value;
 use crate::{attributes, llvm_util};
 
-pub fn apply_to_llfn(llfn: &Value, idx: AttributePlace, attrs: &[&Attribute]) {
+pub(crate) fn apply_to_llfn(llfn: &Value, idx: AttributePlace, attrs: &[&Attribute]) {
     if !attrs.is_empty() {
         llvm::AddFunctionAttributes(llfn, idx, attrs);
     }
 }
 
-pub fn apply_to_callsite(callsite: &Value, idx: AttributePlace, attrs: &[&Attribute]) {
+pub(crate) fn apply_to_callsite(callsite: &Value, idx: AttributePlace, attrs: &[&Attribute]) {
     if !attrs.is_empty() {
         llvm::AddCallSiteAttributes(callsite, idx, attrs);
     }
@@ -80,7 +80,7 @@ fn patchable_function_entry_attrs<'ll>(
 
 /// Get LLVM sanitize attributes.
 #[inline]
-pub fn sanitize_attrs<'ll>(
+pub(crate) fn sanitize_attrs<'ll>(
     cx: &CodegenCx<'ll, '_>,
     no_sanitize: SanitizerSet,
 ) -> SmallVec<[&'ll Attribute; 4]> {
@@ -120,7 +120,7 @@ pub fn sanitize_attrs<'ll>(
 
 /// Tell LLVM to emit or not emit the information necessary to unwind the stack for the function.
 #[inline]
-pub fn uwtable_attr(llcx: &llvm::Context, use_sync_unwind: Option<bool>) -> &Attribute {
+pub(crate) fn uwtable_attr(llcx: &llvm::Context, use_sync_unwind: Option<bool>) -> &Attribute {
     // NOTE: We should determine if we even need async unwind tables, as they
     // take have more overhead and if we can use sync unwind tables we
     // probably should.
@@ -128,7 +128,7 @@ pub fn uwtable_attr(llcx: &llvm::Context, use_sync_unwind: Option<bool>) -> &Att
     llvm::CreateUWTableAttr(llcx, async_unwind)
 }
 
-pub fn frame_pointer_type_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
+pub(crate) fn frame_pointer_type_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
     let mut fp = cx.sess().target.frame_pointer;
     let opts = &cx.sess().opts;
     // "mcount" function relies on stack pointer.
@@ -280,19 +280,19 @@ fn backchain_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
     if found_positive { Some(llvm::CreateAttrString(cx.llcx, "backchain")) } else { None }
 }
 
-pub fn target_cpu_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> &'ll Attribute {
+pub(crate) fn target_cpu_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> &'ll Attribute {
     let target_cpu = llvm_util::target_cpu(cx.tcx.sess);
     llvm::CreateAttrStringValue(cx.llcx, "target-cpu", target_cpu)
 }
 
-pub fn tune_cpu_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
+pub(crate) fn tune_cpu_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
     llvm_util::tune_cpu(cx.tcx.sess)
         .map(|tune_cpu| llvm::CreateAttrStringValue(cx.llcx, "tune-cpu", tune_cpu))
 }
 
 /// Get the `NonLazyBind` LLVM attribute,
 /// if the codegen options allow skipping the PLT.
-pub fn non_lazy_bind_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
+pub(crate) fn non_lazy_bind_attr<'ll>(cx: &CodegenCx<'ll, '_>) -> Option<&'ll Attribute> {
     // Don't generate calls through PLT if it's not necessary
     if !cx.sess().needs_plt() {
         Some(AttributeKind::NonLazyBind.create_attr(cx.llcx))
@@ -327,7 +327,7 @@ fn create_alloc_family_attr(llcx: &llvm::Context) -> &llvm::Attribute {
 /// Helper for `FnAbi::apply_attrs_llfn`:
 /// Composite function which sets LLVM attributes for function depending on its AST (`#[attribute]`)
 /// attributes.
-pub fn llfn_attrs_from_instance<'ll, 'tcx>(
+pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     llfn: &'ll Value,
     instance: ty::Instance<'tcx>,
diff --git a/compiler/rustc_codegen_llvm/src/back/archive.rs b/compiler/rustc_codegen_llvm/src/back/archive.rs
index a2ab19ac800b7..8bc989538c3f8 100644
--- a/compiler/rustc_codegen_llvm/src/back/archive.rs
+++ b/compiler/rustc_codegen_llvm/src/back/archive.rs
@@ -102,7 +102,7 @@ impl<'a> ArchiveBuilder for LlvmArchiveBuilder<'a> {
     }
 }
 
-pub struct LlvmArchiveBuilderBuilder;
+pub(crate) struct LlvmArchiveBuilderBuilder;
 
 impl ArchiveBuilderBuilder for LlvmArchiveBuilderBuilder {
     fn new_archive_builder<'a>(&self, sess: &'a Session) -> Box<dyn ArchiveBuilder + 'a> {
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index f68155f523a6e..d06b240671251 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -33,9 +33,9 @@ use crate::{LlvmCodegenBackend, ModuleLlvm};
 
 /// We keep track of the computed LTO cache keys from the previous
 /// session to determine which CGUs we can reuse.
-pub const THIN_LTO_KEYS_INCR_COMP_FILE_NAME: &str = "thin-lto-past-keys.bin";
+const THIN_LTO_KEYS_INCR_COMP_FILE_NAME: &str = "thin-lto-past-keys.bin";
 
-pub fn crate_type_allows_lto(crate_type: CrateType) -> bool {
+fn crate_type_allows_lto(crate_type: CrateType) -> bool {
     match crate_type {
         CrateType::Executable
         | CrateType::Dylib
@@ -710,7 +710,7 @@ impl Drop for ThinBuffer {
     }
 }
 
-pub unsafe fn optimize_thin_module(
+pub(crate) unsafe fn optimize_thin_module(
     thin_module: ThinModule<LlvmCodegenBackend>,
     cgcx: &CodegenContext<LlvmCodegenBackend>,
 ) -> Result<ModuleCodegen<ModuleLlvm>, FatalError> {
@@ -806,7 +806,7 @@ pub unsafe fn optimize_thin_module(
 
 /// Maps LLVM module identifiers to their corresponding LLVM LTO cache keys
 #[derive(Debug, Default)]
-pub struct ThinLTOKeysMap {
+struct ThinLTOKeysMap {
     // key = llvm name of importing module, value = LLVM cache key
     keys: BTreeMap<String, String>,
 }
@@ -863,7 +863,7 @@ fn module_name_to_str(c_str: &CStr) -> &str {
     })
 }
 
-pub fn parse_module<'a>(
+pub(crate) fn parse_module<'a>(
     cx: &'a llvm::Context,
     name: &CStr,
     data: &[u8],
diff --git a/compiler/rustc_codegen_llvm/src/back/profiling.rs b/compiler/rustc_codegen_llvm/src/back/profiling.rs
index 26fb4a96f846b..79794775b7b66 100644
--- a/compiler/rustc_codegen_llvm/src/back/profiling.rs
+++ b/compiler/rustc_codegen_llvm/src/back/profiling.rs
@@ -21,14 +21,14 @@ fn llvm_args_to_string_id(profiler: &SelfProfiler, pass_name: &str, ir_name: &st
     EventId::from_label(profiler.alloc_string(components.as_slice()))
 }
 
-pub struct LlvmSelfProfiler<'a> {
+pub(crate) struct LlvmSelfProfiler<'a> {
     profiler: Arc<SelfProfiler>,
     stack: Vec<TimingGuard<'a>>,
     llvm_pass_event_kind: StringId,
 }
 
 impl<'a> LlvmSelfProfiler<'a> {
-    pub fn new(profiler: Arc<SelfProfiler>) -> Self {
+    pub(crate) fn new(profiler: Arc<SelfProfiler>) -> Self {
         let llvm_pass_event_kind = profiler.alloc_string("LLVM Pass");
         Self { profiler, stack: Vec::default(), llvm_pass_event_kind }
     }
@@ -43,7 +43,7 @@ impl<'a> LlvmSelfProfiler<'a> {
     }
 }
 
-pub unsafe extern "C" fn selfprofile_before_pass_callback(
+pub(crate) unsafe extern "C" fn selfprofile_before_pass_callback(
     llvm_self_profiler: *mut c_void,
     pass_name: *const c_char,
     ir_name: *const c_char,
@@ -56,7 +56,7 @@ pub unsafe extern "C" fn selfprofile_before_pass_callback(
     }
 }
 
-pub unsafe extern "C" fn selfprofile_after_pass_callback(llvm_self_profiler: *mut c_void) {
+pub(crate) unsafe extern "C" fn selfprofile_after_pass_callback(llvm_self_profiler: *mut c_void) {
     let llvm_self_profiler = unsafe { &mut *(llvm_self_profiler as *mut LlvmSelfProfiler<'_>) };
     llvm_self_profiler.after_pass_callback();
 }
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index a1f2433ab6f3b..853321ef1c7d7 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -43,14 +43,14 @@ use crate::llvm::{self, DiagnosticInfo, PassManager};
 use crate::type_::Type;
 use crate::{base, common, llvm_util, LlvmCodegenBackend, ModuleLlvm};
 
-pub fn llvm_err<'a>(dcx: DiagCtxtHandle<'_>, err: LlvmError<'a>) -> FatalError {
+pub(crate) fn llvm_err<'a>(dcx: DiagCtxtHandle<'_>, err: LlvmError<'a>) -> FatalError {
     match llvm::last_error() {
         Some(llvm_err) => dcx.emit_almost_fatal(WithLlvmError(err, llvm_err)),
         None => dcx.emit_almost_fatal(err),
     }
 }
 
-pub fn write_output_file<'ll>(
+fn write_output_file<'ll>(
     dcx: DiagCtxtHandle<'_>,
     target: &'ll llvm::TargetMachine,
     pm: &llvm::PassManager<'ll>,
@@ -95,7 +95,7 @@ pub fn write_output_file<'ll>(
     }
 }
 
-pub fn create_informational_target_machine(
+pub(crate) fn create_informational_target_machine(
     sess: &Session,
     only_base_features: bool,
 ) -> OwnedTargetMachine {
@@ -107,7 +107,7 @@ pub fn create_informational_target_machine(
         .unwrap_or_else(|err| llvm_err(sess.dcx(), err).raise())
 }
 
-pub fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> OwnedTargetMachine {
+pub(crate) fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> OwnedTargetMachine {
     let split_dwarf_file = if tcx.sess.target_can_use_split_dwarf() {
         tcx.output_filenames(()).split_dwarf_path(
             tcx.sess.split_debuginfo(),
@@ -130,9 +130,7 @@ pub fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> OwnedTargetMach
     .unwrap_or_else(|err| llvm_err(tcx.dcx(), err).raise())
 }
 
-pub fn to_llvm_opt_settings(
-    cfg: config::OptLevel,
-) -> (llvm::CodeGenOptLevel, llvm::CodeGenOptSize) {
+fn to_llvm_opt_settings(cfg: config::OptLevel) -> (llvm::CodeGenOptLevel, llvm::CodeGenOptSize) {
     use self::config::OptLevel::*;
     match cfg {
         No => (llvm::CodeGenOptLevel::None, llvm::CodeGenOptSizeNone),
@@ -179,7 +177,7 @@ pub(crate) fn to_llvm_code_model(code_model: Option<CodeModel>) -> llvm::CodeMod
     }
 }
 
-pub fn target_machine_factory(
+pub(crate) fn target_machine_factory(
     sess: &Session,
     optlvl: config::OptLevel,
     target_features: &[String],
@@ -320,7 +318,7 @@ pub(crate) fn save_temp_bitcode(
 }
 
 /// In what context is a dignostic handler being attached to a codegen unit?
-pub enum CodegenDiagnosticsStage {
+pub(crate) enum CodegenDiagnosticsStage {
     /// Prelink optimization stage.
     Opt,
     /// LTO/ThinLTO postlink optimization stage.
@@ -329,14 +327,14 @@ pub enum CodegenDiagnosticsStage {
     Codegen,
 }
 
-pub struct DiagnosticHandlers<'a> {
+pub(crate) struct DiagnosticHandlers<'a> {
     data: *mut (&'a CodegenContext<LlvmCodegenBackend>, DiagCtxtHandle<'a>),
     llcx: &'a llvm::Context,
     old_handler: Option<&'a llvm::DiagnosticHandler>,
 }
 
 impl<'a> DiagnosticHandlers<'a> {
-    pub fn new(
+    pub(crate) fn new(
         cgcx: &'a CodegenContext<LlvmCodegenBackend>,
         dcx: DiagCtxtHandle<'a>,
         llcx: &'a llvm::Context,
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
index e8236b45c8966..0ba8d82406a82 100644
--- a/compiler/rustc_codegen_llvm/src/base.rs
+++ b/compiler/rustc_codegen_llvm/src/base.rs
@@ -32,7 +32,7 @@ use crate::context::CodegenCx;
 use crate::value::Value;
 use crate::{attributes, llvm};
 
-pub struct ValueIter<'ll> {
+pub(crate) struct ValueIter<'ll> {
     cur: Option<&'ll Value>,
     step: unsafe extern "C" fn(&'ll Value) -> Option<&'ll Value>,
 }
@@ -49,11 +49,14 @@ impl<'ll> Iterator for ValueIter<'ll> {
     }
 }
 
-pub fn iter_globals(llmod: &llvm::Module) -> ValueIter<'_> {
+pub(crate) fn iter_globals(llmod: &llvm::Module) -> ValueIter<'_> {
     unsafe { ValueIter { cur: llvm::LLVMGetFirstGlobal(llmod), step: llvm::LLVMGetNextGlobal } }
 }
 
-pub fn compile_codegen_unit(tcx: TyCtxt<'_>, cgu_name: Symbol) -> (ModuleCodegen<ModuleLlvm>, u64) {
+pub(crate) fn compile_codegen_unit(
+    tcx: TyCtxt<'_>,
+    cgu_name: Symbol,
+) -> (ModuleCodegen<ModuleLlvm>, u64) {
     let start_time = Instant::now();
 
     let dep_node = tcx.codegen_unit(cgu_name).codegen_dep_node(tcx);
@@ -140,7 +143,7 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'_>, cgu_name: Symbol) -> (ModuleCodegen
     (module, cost)
 }
 
-pub fn set_link_section(llval: &Value, attrs: &CodegenFnAttrs) {
+pub(crate) fn set_link_section(llval: &Value, attrs: &CodegenFnAttrs) {
     let Some(sect) = attrs.link_section else { return };
     unsafe {
         let buf = SmallCStr::new(sect.as_str());
@@ -148,7 +151,7 @@ pub fn set_link_section(llval: &Value, attrs: &CodegenFnAttrs) {
     }
 }
 
-pub fn linkage_to_llvm(linkage: Linkage) -> llvm::Linkage {
+pub(crate) fn linkage_to_llvm(linkage: Linkage) -> llvm::Linkage {
     match linkage {
         Linkage::External => llvm::Linkage::ExternalLinkage,
         Linkage::AvailableExternally => llvm::Linkage::AvailableExternallyLinkage,
@@ -164,7 +167,7 @@ pub fn linkage_to_llvm(linkage: Linkage) -> llvm::Linkage {
     }
 }
 
-pub fn visibility_to_llvm(linkage: Visibility) -> llvm::Visibility {
+pub(crate) fn visibility_to_llvm(linkage: Visibility) -> llvm::Visibility {
     match linkage {
         Visibility::Default => llvm::Visibility::Default,
         Visibility::Hidden => llvm::Visibility::Hidden,
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index cc081f29e128e..40783825cae57 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -36,7 +36,7 @@ use crate::{attributes, llvm_util};
 
 // All Builders must have an llfn associated with them
 #[must_use]
-pub struct Builder<'a, 'll, 'tcx> {
+pub(crate) struct Builder<'a, 'll, 'tcx> {
     pub llbuilder: &'ll mut llvm::Builder<'ll>,
     pub cx: &'a CodegenCx<'ll, 'tcx>,
 }
@@ -1343,7 +1343,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         Builder { llbuilder, cx }
     }
 
-    pub fn llfn(&self) -> &'ll Value {
+    pub(crate) fn llfn(&self) -> &'ll Value {
         unsafe { llvm::LLVMGetBasicBlockParent(self.llbb()) }
     }
 
@@ -1375,7 +1375,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         }
     }
 
-    pub fn set_unpredictable(&mut self, inst: &'ll Value) {
+    pub(crate) fn set_unpredictable(&mut self, inst: &'ll Value) {
         unsafe {
             llvm::LLVMSetMetadata(
                 inst,
@@ -1385,15 +1385,15 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         }
     }
 
-    pub fn minnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
+    pub(crate) fn minnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildMinNum(self.llbuilder, lhs, rhs) }
     }
 
-    pub fn maxnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
+    pub(crate) fn maxnum(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildMaxNum(self.llbuilder, lhs, rhs) }
     }
 
-    pub fn insert_element(
+    pub(crate) fn insert_element(
         &mut self,
         vec: &'ll Value,
         elt: &'ll Value,
@@ -1402,7 +1402,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         unsafe { llvm::LLVMBuildInsertElement(self.llbuilder, vec, elt, idx, UNNAMED) }
     }
 
-    pub fn shuffle_vector(
+    pub(crate) fn shuffle_vector(
         &mut self,
         v1: &'ll Value,
         v2: &'ll Value,
@@ -1411,65 +1411,77 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         unsafe { llvm::LLVMBuildShuffleVector(self.llbuilder, v1, v2, mask, UNNAMED) }
     }
 
-    pub fn vector_reduce_fadd(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_fadd(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildVectorReduceFAdd(self.llbuilder, acc, src) }
     }
-    pub fn vector_reduce_fmul(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_fmul(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildVectorReduceFMul(self.llbuilder, acc, src) }
     }
-    pub fn vector_reduce_fadd_reassoc(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_fadd_reassoc(
+        &mut self,
+        acc: &'ll Value,
+        src: &'ll Value,
+    ) -> &'ll Value {
         unsafe {
             let instr = llvm::LLVMRustBuildVectorReduceFAdd(self.llbuilder, acc, src);
             llvm::LLVMRustSetAllowReassoc(instr);
             instr
         }
     }
-    pub fn vector_reduce_fmul_reassoc(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_fmul_reassoc(
+        &mut self,
+        acc: &'ll Value,
+        src: &'ll Value,
+    ) -> &'ll Value {
         unsafe {
             let instr = llvm::LLVMRustBuildVectorReduceFMul(self.llbuilder, acc, src);
             llvm::LLVMRustSetAllowReassoc(instr);
             instr
         }
     }
-    pub fn vector_reduce_add(&mut self, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_add(&mut self, src: &'ll Value) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildVectorReduceAdd(self.llbuilder, src) }
     }
-    pub fn vector_reduce_mul(&mut self, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_mul(&mut self, src: &'ll Value) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildVectorReduceMul(self.llbuilder, src) }
     }
-    pub fn vector_reduce_and(&mut self, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_and(&mut self, src: &'ll Value) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildVectorReduceAnd(self.llbuilder, src) }
     }
-    pub fn vector_reduce_or(&mut self, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_or(&mut self, src: &'ll Value) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildVectorReduceOr(self.llbuilder, src) }
     }
-    pub fn vector_reduce_xor(&mut self, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_xor(&mut self, src: &'ll Value) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildVectorReduceXor(self.llbuilder, src) }
     }
-    pub fn vector_reduce_fmin(&mut self, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_fmin(&mut self, src: &'ll Value) -> &'ll Value {
         unsafe {
             llvm::LLVMRustBuildVectorReduceFMin(self.llbuilder, src, /*NoNaNs:*/ false)
         }
     }
-    pub fn vector_reduce_fmax(&mut self, src: &'ll Value) -> &'ll Value {
+    pub(crate) fn vector_reduce_fmax(&mut self, src: &'ll Value) -> &'ll Value {
         unsafe {
             llvm::LLVMRustBuildVectorReduceFMax(self.llbuilder, src, /*NoNaNs:*/ false)
         }
     }
-    pub fn vector_reduce_min(&mut self, src: &'ll Value, is_signed: bool) -> &'ll Value {
+    pub(crate) fn vector_reduce_min(&mut self, src: &'ll Value, is_signed: bool) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildVectorReduceMin(self.llbuilder, src, is_signed) }
     }
-    pub fn vector_reduce_max(&mut self, src: &'ll Value, is_signed: bool) -> &'ll Value {
+    pub(crate) fn vector_reduce_max(&mut self, src: &'ll Value, is_signed: bool) -> &'ll Value {
         unsafe { llvm::LLVMRustBuildVectorReduceMax(self.llbuilder, src, is_signed) }
     }
 
-    pub fn add_clause(&mut self, landing_pad: &'ll Value, clause: &'ll Value) {
+    pub(crate) fn add_clause(&mut self, landing_pad: &'ll Value, clause: &'ll Value) {
         unsafe {
             llvm::LLVMAddClause(landing_pad, clause);
         }
     }
 
-    pub fn catch_ret(&mut self, funclet: &Funclet<'ll>, unwind: &'ll BasicBlock) -> &'ll Value {
+    pub(crate) fn catch_ret(
+        &mut self,
+        funclet: &Funclet<'ll>,
+        unwind: &'ll BasicBlock,
+    ) -> &'ll Value {
         let ret = unsafe { llvm::LLVMBuildCatchRet(self.llbuilder, funclet.cleanuppad(), unwind) };
         ret.expect("LLVM does not have support for catchret")
     }
@@ -1515,7 +1527,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         Cow::Owned(casted_args)
     }
 
-    pub fn va_arg(&mut self, list: &'ll Value, ty: &'ll Type) -> &'ll Value {
+    pub(crate) fn va_arg(&mut self, list: &'ll Value, ty: &'ll Type) -> &'ll Value {
         unsafe { llvm::LLVMBuildVAArg(self.llbuilder, list, ty, UNNAMED) }
     }
 
diff --git a/compiler/rustc_codegen_llvm/src/callee.rs b/compiler/rustc_codegen_llvm/src/callee.rs
index 663c5be46e5e4..949fd1bc124f5 100644
--- a/compiler/rustc_codegen_llvm/src/callee.rs
+++ b/compiler/rustc_codegen_llvm/src/callee.rs
@@ -20,7 +20,7 @@ use crate::value::Value;
 ///
 /// - `cx`: the crate context
 /// - `instance`: the instance to be instantiated
-pub fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'tcx>) -> &'ll Value {
+pub(crate) fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'tcx>) -> &'ll Value {
     let tcx = cx.tcx();
 
     debug!("get_fn(instance={:?})", instance);
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
index a399790018439..ef6560ecbe59e 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -13,7 +13,7 @@ use rustc_target::abi::{self, AddressSpace, HasDataLayout, Pointer};
 use tracing::debug;
 
 use crate::consts::const_alloc_to_llvm;
-pub use crate::context::CodegenCx;
+pub(crate) use crate::context::CodegenCx;
 use crate::llvm::{self, BasicBlock, Bool, ConstantInt, False, OperandBundleDef, True};
 use crate::type_::Type;
 use crate::value::Value;
@@ -58,21 +58,21 @@ use crate::value::Value;
 /// When inside of a landing pad, each function call in LLVM IR needs to be
 /// annotated with which landing pad it's a part of. This is accomplished via
 /// the `OperandBundleDef` value created for MSVC landing pads.
-pub struct Funclet<'ll> {
+pub(crate) struct Funclet<'ll> {
     cleanuppad: &'ll Value,
     operand: OperandBundleDef<'ll>,
 }
 
 impl<'ll> Funclet<'ll> {
-    pub fn new(cleanuppad: &'ll Value) -> Self {
+    pub(crate) fn new(cleanuppad: &'ll Value) -> Self {
         Funclet { cleanuppad, operand: OperandBundleDef::new("funclet", &[cleanuppad]) }
     }
 
-    pub fn cleanuppad(&self) -> &'ll Value {
+    pub(crate) fn cleanuppad(&self) -> &'ll Value {
         self.cleanuppad
     }
 
-    pub fn bundle(&self) -> &OperandBundleDef<'ll> {
+    pub(crate) fn bundle(&self) -> &OperandBundleDef<'ll> {
         &self.operand
     }
 }
@@ -92,16 +92,16 @@ impl<'ll> BackendTypes for CodegenCx<'ll, '_> {
 }
 
 impl<'ll> CodegenCx<'ll, '_> {
-    pub fn const_array(&self, ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value {
+    pub(crate) fn const_array(&self, ty: &'ll Type, elts: &[&'ll Value]) -> &'ll Value {
         let len = u64::try_from(elts.len()).expect("LLVMConstArray2 elements len overflow");
         unsafe { llvm::LLVMConstArray2(ty, elts.as_ptr(), len) }
     }
 
-    pub fn const_bytes(&self, bytes: &[u8]) -> &'ll Value {
+    pub(crate) fn const_bytes(&self, bytes: &[u8]) -> &'ll Value {
         bytes_in_context(self.llcx, bytes)
     }
 
-    pub fn const_get_elt(&self, v: &'ll Value, idx: u64) -> &'ll Value {
+    pub(crate) fn const_get_elt(&self, v: &'ll Value, idx: u64) -> &'ll Value {
         unsafe {
             let idx = c_uint::try_from(idx).expect("LLVMGetAggregateElement index overflow");
             let r = llvm::LLVMGetAggregateElement(v, idx).unwrap();
@@ -339,18 +339,18 @@ impl<'ll, 'tcx> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 }
 
 /// Get the [LLVM type][Type] of a [`Value`].
-pub fn val_ty(v: &Value) -> &Type {
+pub(crate) fn val_ty(v: &Value) -> &Type {
     unsafe { llvm::LLVMTypeOf(v) }
 }
 
-pub fn bytes_in_context<'ll>(llcx: &'ll llvm::Context, bytes: &[u8]) -> &'ll Value {
+pub(crate) fn bytes_in_context<'ll>(llcx: &'ll llvm::Context, bytes: &[u8]) -> &'ll Value {
     unsafe {
         let ptr = bytes.as_ptr() as *const c_char;
         llvm::LLVMConstStringInContext2(llcx, ptr, bytes.len(), True)
     }
 }
 
-pub fn struct_in_context<'ll>(
+fn struct_in_context<'ll>(
     llcx: &'ll llvm::Context,
     elts: &[&'ll Value],
     packed: bool,
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 75b298f14ca1e..18fadca8d33f0 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -29,7 +29,7 @@ use crate::type_of::LayoutLlvmExt;
 use crate::value::Value;
 use crate::{base, debuginfo};
 
-pub fn const_alloc_to_llvm<'ll>(
+pub(crate) fn const_alloc_to_llvm<'ll>(
     cx: &CodegenCx<'ll, '_>,
     alloc: ConstAllocation<'_>,
     is_static: bool,
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index dd3f39eceadb6..7b12ff2fd8868 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -39,7 +39,7 @@ use crate::{attributes, coverageinfo, debuginfo, llvm, llvm_util};
 /// There is one `CodegenCx` per compilation unit. Each one has its own LLVM
 /// `llvm::Context` so that several compilation units may be optimized in parallel.
 /// All other LLVM data structures in the `CodegenCx` are tied to that `llvm::Context`.
-pub struct CodegenCx<'ll, 'tcx> {
+pub(crate) struct CodegenCx<'ll, 'tcx> {
     pub tcx: TyCtxt<'tcx>,
     pub use_dll_storage_attrs: bool,
     pub tls_model: llvm::ThreadLocalMode,
@@ -110,7 +110,7 @@ fn to_llvm_tls_model(tls_model: TlsModel) -> llvm::ThreadLocalMode {
     }
 }
 
-pub unsafe fn create_module<'ll>(
+pub(crate) unsafe fn create_module<'ll>(
     tcx: TyCtxt<'_>,
     llcx: &'ll llvm::Context,
     mod_name: &str,
@@ -531,7 +531,9 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
     }
 
     #[inline]
-    pub fn coverage_context(&self) -> Option<&coverageinfo::CrateCoverageContext<'ll, 'tcx>> {
+    pub(crate) fn coverage_context(
+        &self,
+    ) -> Option<&coverageinfo::CrateCoverageContext<'ll, 'tcx>> {
         self.coverage_cx.as_ref()
     }
 
@@ -1064,7 +1066,7 @@ impl<'ll> CodegenCx<'ll, '_> {
 impl CodegenCx<'_, '_> {
     /// Generates a new symbol name with the given prefix. This symbol name must
     /// only be used for definitions with `internal` or `private` linkage.
-    pub fn generate_local_symbol_name(&self, prefix: &str) -> String {
+    pub(crate) fn generate_local_symbol_name(&self, prefix: &str) -> String {
         let idx = self.local_gen_sym_counter.get();
         self.local_gen_sym_counter.set(idx + 1);
         // Include a '.' character, so there can be no accidental conflicts with
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs
index 584d033d6bdd1..cabdd310d1fc8 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs
@@ -80,7 +80,7 @@ pub struct CounterExpression {
 /// Must match the layout of `LLVMRustCounterMappingRegionKind`.
 #[derive(Copy, Clone, Debug)]
 #[repr(C)]
-pub enum RegionKind {
+enum RegionKind {
     /// A CodeRegion associates some code with a counter
     CodeRegion = 0,
 
@@ -110,13 +110,13 @@ pub enum RegionKind {
     MCDCBranchRegion = 6,
 }
 
-pub mod mcdc {
+mod mcdc {
     use rustc_middle::mir::coverage::{ConditionInfo, DecisionInfo};
 
     /// Must match the layout of `LLVMRustMCDCDecisionParameters`.
     #[repr(C)]
     #[derive(Clone, Copy, Debug, Default)]
-    pub struct DecisionParameters {
+    pub(crate) struct DecisionParameters {
         bitmap_idx: u32,
         num_conditions: u16,
     }
@@ -127,14 +127,14 @@ pub mod mcdc {
     /// Must match the layout of `LLVMRustMCDCBranchParameters`.
     #[repr(C)]
     #[derive(Clone, Copy, Debug, Default)]
-    pub struct BranchParameters {
+    pub(crate) struct BranchParameters {
         condition_id: LLVMConditionId,
         condition_ids: [LLVMConditionId; 2],
     }
 
     #[repr(C)]
     #[derive(Clone, Copy, Debug)]
-    pub enum ParameterTag {
+    enum ParameterTag {
         None = 0,
         Decision = 1,
         Branch = 2,
@@ -142,24 +142,24 @@ pub mod mcdc {
     /// Same layout with `LLVMRustMCDCParameters`
     #[repr(C)]
     #[derive(Clone, Copy, Debug)]
-    pub struct Parameters {
+    pub(crate) struct Parameters {
         tag: ParameterTag,
         decision_params: DecisionParameters,
         branch_params: BranchParameters,
     }
 
     impl Parameters {
-        pub fn none() -> Self {
+        pub(crate) fn none() -> Self {
             Self {
                 tag: ParameterTag::None,
                 decision_params: Default::default(),
                 branch_params: Default::default(),
             }
         }
-        pub fn decision(decision_params: DecisionParameters) -> Self {
+        pub(crate) fn decision(decision_params: DecisionParameters) -> Self {
             Self { tag: ParameterTag::Decision, decision_params, branch_params: Default::default() }
         }
-        pub fn branch(branch_params: BranchParameters) -> Self {
+        pub(crate) fn branch(branch_params: BranchParameters) -> Self {
             Self { tag: ParameterTag::Branch, decision_params: Default::default(), branch_params }
         }
     }
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
index 9433385c23a5b..44eafab6060b3 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
@@ -14,7 +14,7 @@ use crate::coverageinfo::ffi::{Counter, CounterExpression, ExprKind};
 /// Holds all of the coverage mapping data associated with a function instance,
 /// collected during traversal of `Coverage` statements in the function's MIR.
 #[derive(Debug)]
-pub struct FunctionCoverageCollector<'tcx> {
+pub(crate) struct FunctionCoverageCollector<'tcx> {
     /// Coverage info that was attached to this function by the instrumentor.
     function_coverage_info: &'tcx FunctionCoverageInfo,
     is_used: bool,
@@ -32,7 +32,7 @@ pub struct FunctionCoverageCollector<'tcx> {
 
 impl<'tcx> FunctionCoverageCollector<'tcx> {
     /// Creates a new set of coverage data for a used (called) function.
-    pub fn new(
+    pub(crate) fn new(
         instance: Instance<'tcx>,
         function_coverage_info: &'tcx FunctionCoverageInfo,
     ) -> Self {
@@ -40,7 +40,7 @@ impl<'tcx> FunctionCoverageCollector<'tcx> {
     }
 
     /// Creates a new set of coverage data for an unused (never called) function.
-    pub fn unused(
+    pub(crate) fn unused(
         instance: Instance<'tcx>,
         function_coverage_info: &'tcx FunctionCoverageInfo,
     ) -> Self {
@@ -195,7 +195,7 @@ impl<'tcx> FunctionCoverage<'tcx> {
 
     /// Return the source hash, generated from the HIR node structure, and used to indicate whether
     /// or not the source code structure changed between different compilations.
-    pub fn source_hash(&self) -> u64 {
+    pub(crate) fn source_hash(&self) -> u64 {
         if self.is_used { self.function_coverage_info.function_source_hash } else { 0 }
     }
 
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
index f8929a26011ab..069b62af5e748 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
@@ -27,7 +27,7 @@ use crate::{coverageinfo, llvm};
 /// implementing this Rust version, and though the format documentation is very explicit and
 /// detailed, some undocumented details in Clang's implementation (that may or may not be important)
 /// were also replicated for Rust's Coverage Map.
-pub fn finalize(cx: &CodegenCx<'_, '_>) {
+pub(crate) fn finalize(cx: &CodegenCx<'_, '_>) {
     let tcx = cx.tcx;
 
     // Ensure that LLVM is using a version of the coverage mapping format that
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs
index 20a713b856419..69babc7c9cf3e 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs
@@ -22,10 +22,10 @@ use crate::llvm;
 
 pub(crate) mod ffi;
 pub(crate) mod map_data;
-pub mod mapgen;
+mod mapgen;
 
 /// A context object for maintaining all state needed by the coverageinfo module.
-pub struct CrateCoverageContext<'ll, 'tcx> {
+pub(crate) struct CrateCoverageContext<'ll, 'tcx> {
     /// Coverage data for each instrumented function identified by DefId.
     pub(crate) function_coverage_map:
         RefCell<FxIndexMap<Instance<'tcx>, FunctionCoverageCollector<'tcx>>>,
@@ -34,7 +34,7 @@ pub struct CrateCoverageContext<'ll, 'tcx> {
 }
 
 impl<'ll, 'tcx> CrateCoverageContext<'ll, 'tcx> {
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self {
             function_coverage_map: Default::default(),
             pgo_func_name_var_map: Default::default(),
@@ -42,7 +42,7 @@ impl<'ll, 'tcx> CrateCoverageContext<'ll, 'tcx> {
         }
     }
 
-    pub fn take_function_coverage_map(
+    fn take_function_coverage_map(
         &self,
     ) -> FxIndexMap<Instance<'tcx>, FunctionCoverageCollector<'tcx>> {
         self.function_coverage_map.replace(FxIndexMap::default())
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs b/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs
index efe616838bfe4..19100ed3f3312 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/create_scope_map.rs
@@ -15,7 +15,7 @@ use crate::llvm::debuginfo::{DILocation, DIScope};
 
 /// Produces DIScope DIEs for each MIR Scope which has variables defined in it.
 // FIXME(eddyb) almost all of this should be in `rustc_codegen_ssa::mir::debuginfo`.
-pub fn compute_mir_scopes<'ll, 'tcx>(
+pub(crate) fn compute_mir_scopes<'ll, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     instance: Instance<'tcx>,
     mir: &Body<'tcx>,
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
index 5a08f2f00e5be..42b03fd053796 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
@@ -16,7 +16,7 @@ use crate::value::Value;
 
 /// Inserts a side-effect free instruction sequence that makes sure that the
 /// .debug_gdb_scripts global is referenced, so it isn't removed by the linker.
-pub fn insert_reference_to_gdb_debug_scripts_section_global(bx: &mut Builder<'_, '_, '_>) {
+pub(crate) fn insert_reference_to_gdb_debug_scripts_section_global(bx: &mut Builder<'_, '_, '_>) {
     if needs_gdb_debug_scripts_section(bx) {
         let gdb_debug_scripts_section = get_or_insert_gdb_debug_scripts_section_global(bx);
         // Load just the first byte as that's all that's necessary to force
@@ -30,7 +30,9 @@ pub fn insert_reference_to_gdb_debug_scripts_section_global(bx: &mut Builder<'_,
 
 /// Allocates the global variable responsible for the .debug_gdb_scripts binary
 /// section.
-pub fn get_or_insert_gdb_debug_scripts_section_global<'ll>(cx: &CodegenCx<'ll, '_>) -> &'ll Value {
+pub(crate) fn get_or_insert_gdb_debug_scripts_section_global<'ll>(
+    cx: &CodegenCx<'ll, '_>,
+) -> &'ll Value {
     let c_section_var_name = c"__rustc_debug_gdb_scripts_section__";
     let section_var_name = c_section_var_name.to_str().unwrap();
 
@@ -83,7 +85,7 @@ pub fn get_or_insert_gdb_debug_scripts_section_global<'ll>(cx: &CodegenCx<'ll, '
     })
 }
 
-pub fn needs_gdb_debug_scripts_section(cx: &CodegenCx<'_, '_>) -> bool {
+pub(crate) fn needs_gdb_debug_scripts_section(cx: &CodegenCx<'_, '_>) -> bool {
     let omit_gdb_pretty_printer_section =
         attr::contains_name(cx.tcx.hir().krate_attrs(), sym::omit_gdb_pretty_printer_section);
 
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 87bea22d8ddaf..26999d8103536 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -85,7 +85,7 @@ const NO_GENERICS: for<'ll> fn(&CodegenCx<'ll, '_>) -> SmallVec<&'ll DIType> = |
 
 // SmallVec is used quite a bit in this module, so create a shorthand.
 // The actual number of elements is not so important.
-pub type SmallVec<T> = smallvec::SmallVec<[T; 16]>;
+type SmallVec<T> = smallvec::SmallVec<[T; 16]>;
 
 mod enums;
 mod type_map;
@@ -425,7 +425,7 @@ fn build_slice_type_di_node<'ll, 'tcx>(
 ///
 /// This function will look up the debuginfo node in the TypeMap. If it can't find it, it
 /// will create the node by dispatching to the corresponding `build_*_di_node()` function.
-pub fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll DIType {
+pub(crate) fn type_di_node<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll DIType {
     let unique_type_id = UniqueTypeId::for_ty(cx.tcx, t);
 
     if let Some(existing_di_node) = debug_context(cx).type_map.di_node_for_unique_id(unique_type_id)
@@ -531,7 +531,7 @@ fn hex_encode(data: &[u8]) -> String {
     hex_string
 }
 
-pub fn file_metadata<'ll>(cx: &CodegenCx<'ll, '_>, source_file: &SourceFile) -> &'ll DIFile {
+pub(crate) fn file_metadata<'ll>(cx: &CodegenCx<'ll, '_>, source_file: &SourceFile) -> &'ll DIFile {
     let cache_key = Some((source_file.stable_id, source_file.src_hash));
     return debug_context(cx)
         .created_files
@@ -644,7 +644,7 @@ pub fn file_metadata<'ll>(cx: &CodegenCx<'ll, '_>, source_file: &SourceFile) ->
     }
 }
 
-pub fn unknown_file_metadata<'ll>(cx: &CodegenCx<'ll, '_>) -> &'ll DIFile {
+fn unknown_file_metadata<'ll>(cx: &CodegenCx<'ll, '_>) -> &'ll DIFile {
     debug_context(cx).created_files.borrow_mut().entry(None).or_insert_with(|| unsafe {
         let file_name = "<unknown>";
         let directory = "";
@@ -859,7 +859,7 @@ fn build_param_type_di_node<'ll, 'tcx>(
     }
 }
 
-pub fn build_compile_unit_di_node<'ll, 'tcx>(
+pub(crate) fn build_compile_unit_di_node<'ll, 'tcx>(
     tcx: TyCtxt<'tcx>,
     codegen_unit_name: &str,
     debug_context: &CodegenUnitDebugContext<'ll, 'tcx>,
@@ -1319,7 +1319,11 @@ fn build_generic_type_param_di_nodes<'ll, 'tcx>(
 /// Creates debug information for the given global variable.
 ///
 /// Adds the created debuginfo nodes directly to the crate's IR.
-pub fn build_global_var_di_node<'ll>(cx: &CodegenCx<'ll, '_>, def_id: DefId, global: &'ll Value) {
+pub(crate) fn build_global_var_di_node<'ll>(
+    cx: &CodegenCx<'ll, '_>,
+    def_id: DefId,
+    global: &'ll Value,
+) {
     if cx.dbg_cx.is_none() {
         return;
     }
@@ -1559,7 +1563,7 @@ pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
 /// given type.
 ///
 /// Adds the created metadata nodes directly to the crate's IR.
-pub fn create_vtable_di_node<'ll, 'tcx>(
+pub(crate) fn create_vtable_di_node<'ll, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     ty: Ty<'tcx>,
     poly_trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
@@ -1604,7 +1608,7 @@ pub fn create_vtable_di_node<'ll, 'tcx>(
 }
 
 /// Creates an "extension" of an existing `DIScope` into another file.
-pub fn extend_scope_to_file<'ll>(
+pub(crate) fn extend_scope_to_file<'ll>(
     cx: &CodegenCx<'ll, '_>,
     scope_metadata: &'ll DIScope,
     file: &SourceFile,
@@ -1613,7 +1617,7 @@ pub fn extend_scope_to_file<'ll>(
     unsafe { llvm::LLVMRustDIBuilderCreateLexicalBlockFile(DIB(cx), scope_metadata, file_metadata) }
 }
 
-pub fn tuple_field_name(field_index: usize) -> Cow<'static, str> {
+fn tuple_field_name(field_index: usize) -> Cow<'static, str> {
     const TUPLE_FIELD_NAMES: [&'static str; 16] = [
         "__0", "__1", "__2", "__3", "__4", "__5", "__6", "__7", "__8", "__9", "__10", "__11",
         "__12", "__13", "__14", "__15",
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs
index fc3adaf068111..373ccc77f9200 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/enums/mod.rs
@@ -301,7 +301,7 @@ fn build_enum_variant_struct_type_di_node<'ll, 'tcx>(
 ///  --->   DW_TAG_structure_type            (type of variant 3)
 ///
 /// ```
-pub fn build_coroutine_variant_struct_type_di_node<'ll, 'tcx>(
+fn build_coroutine_variant_struct_type_di_node<'ll, 'tcx>(
     cx: &CodegenCx<'ll, 'tcx>,
     variant_index: VariantIdx,
     coroutine_type_and_layout: TyAndLayout<'tcx>,
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs
index 25b2df9c52c3a..6d21f4204e361 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata/type_map.rs
@@ -22,7 +22,7 @@ mod private {
     // `UniqueTypeId` from being constructed directly, without asserting
     // the preconditions.
     #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, HashStable)]
-    pub struct HiddenZst;
+    pub(crate) struct HiddenZst;
 }
 
 /// A unique identifier for anything that we create a debuginfo node for.
@@ -48,17 +48,17 @@ pub(super) enum UniqueTypeId<'tcx> {
 }
 
 impl<'tcx> UniqueTypeId<'tcx> {
-    pub fn for_ty(tcx: TyCtxt<'tcx>, t: Ty<'tcx>) -> Self {
+    pub(crate) fn for_ty(tcx: TyCtxt<'tcx>, t: Ty<'tcx>) -> Self {
         assert_eq!(t, tcx.normalize_erasing_regions(ParamEnv::reveal_all(), t));
         UniqueTypeId::Ty(t, private::HiddenZst)
     }
 
-    pub fn for_enum_variant_part(tcx: TyCtxt<'tcx>, enum_ty: Ty<'tcx>) -> Self {
+    pub(crate) fn for_enum_variant_part(tcx: TyCtxt<'tcx>, enum_ty: Ty<'tcx>) -> Self {
         assert_eq!(enum_ty, tcx.normalize_erasing_regions(ParamEnv::reveal_all(), enum_ty));
         UniqueTypeId::VariantPart(enum_ty, private::HiddenZst)
     }
 
-    pub fn for_enum_variant_struct_type(
+    pub(crate) fn for_enum_variant_struct_type(
         tcx: TyCtxt<'tcx>,
         enum_ty: Ty<'tcx>,
         variant_idx: VariantIdx,
@@ -67,7 +67,7 @@ impl<'tcx> UniqueTypeId<'tcx> {
         UniqueTypeId::VariantStructType(enum_ty, variant_idx, private::HiddenZst)
     }
 
-    pub fn for_enum_variant_struct_type_wrapper(
+    pub(crate) fn for_enum_variant_struct_type_wrapper(
         tcx: TyCtxt<'tcx>,
         enum_ty: Ty<'tcx>,
         variant_idx: VariantIdx,
@@ -76,7 +76,7 @@ impl<'tcx> UniqueTypeId<'tcx> {
         UniqueTypeId::VariantStructTypeCppLikeWrapper(enum_ty, variant_idx, private::HiddenZst)
     }
 
-    pub fn for_vtable_ty(
+    pub(crate) fn for_vtable_ty(
         tcx: TyCtxt<'tcx>,
         self_type: Ty<'tcx>,
         implemented_trait: Option<PolyExistentialTraitRef<'tcx>>,
@@ -93,7 +93,7 @@ impl<'tcx> UniqueTypeId<'tcx> {
     /// argument of the various `LLVMRustDIBuilderCreate*Type()` methods.
     ///
     /// Right now this takes the form of a hex-encoded opaque hash value.
-    pub fn generate_unique_id_string(self, tcx: TyCtxt<'tcx>) -> String {
+    fn generate_unique_id_string(self, tcx: TyCtxt<'tcx>) -> String {
         let mut hasher = StableHasher::new();
         tcx.with_stable_hashing_context(|mut hcx| {
             hcx.while_hashing_spans(false, |hcx| self.hash_stable(hcx, &mut hasher))
@@ -101,7 +101,7 @@ impl<'tcx> UniqueTypeId<'tcx> {
         hasher.finish::<Fingerprint>().to_hex()
     }
 
-    pub fn expect_ty(self) -> Ty<'tcx> {
+    pub(crate) fn expect_ty(self) -> Ty<'tcx> {
         match self {
             UniqueTypeId::Ty(ty, _) => ty,
             _ => bug!("Expected `UniqueTypeId::Ty` but found `{:?}`", self),
@@ -133,25 +133,25 @@ impl<'ll, 'tcx> TypeMap<'ll, 'tcx> {
     }
 }
 
-pub struct DINodeCreationResult<'ll> {
+pub(crate) struct DINodeCreationResult<'ll> {
     pub di_node: &'ll DIType,
     pub already_stored_in_typemap: bool,
 }
 
 impl<'ll> DINodeCreationResult<'ll> {
-    pub fn new(di_node: &'ll DIType, already_stored_in_typemap: bool) -> Self {
+    pub(crate) fn new(di_node: &'ll DIType, already_stored_in_typemap: bool) -> Self {
         DINodeCreationResult { di_node, already_stored_in_typemap }
     }
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum Stub<'ll> {
+pub(crate) enum Stub<'ll> {
     Struct,
     Union,
     VTableTy { vtable_holder: &'ll DIType },
 }
 
-pub struct StubInfo<'ll, 'tcx> {
+pub(crate) struct StubInfo<'ll, 'tcx> {
     metadata: &'ll DIType,
     unique_type_id: UniqueTypeId<'tcx>,
 }
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index b23e05182ca1b..50d08441025a9 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -40,13 +40,13 @@ use crate::llvm::debuginfo::{
 use crate::value::Value;
 
 mod create_scope_map;
-pub mod gdb;
-pub mod metadata;
+mod gdb;
+pub(crate) mod metadata;
 mod namespace;
 mod utils;
 
-pub use self::create_scope_map::compute_mir_scopes;
-pub use self::metadata::build_global_var_di_node;
+use self::create_scope_map::compute_mir_scopes;
+pub(crate) use self::metadata::build_global_var_di_node;
 
 #[allow(non_upper_case_globals)]
 const DW_TAG_auto_variable: c_uint = 0x100;
@@ -54,7 +54,7 @@ const DW_TAG_auto_variable: c_uint = 0x100;
 const DW_TAG_arg_variable: c_uint = 0x101;
 
 /// A context object for maintaining all state needed by the debuginfo module.
-pub struct CodegenUnitDebugContext<'ll, 'tcx> {
+pub(crate) struct CodegenUnitDebugContext<'ll, 'tcx> {
     llcontext: &'ll llvm::Context,
     llmod: &'ll llvm::Module,
     builder: &'ll mut DIBuilder<'ll>,
@@ -74,7 +74,7 @@ impl Drop for CodegenUnitDebugContext<'_, '_> {
 }
 
 impl<'ll, 'tcx> CodegenUnitDebugContext<'ll, 'tcx> {
-    pub fn new(llmod: &'ll llvm::Module) -> Self {
+    pub(crate) fn new(llmod: &'ll llvm::Module) -> Self {
         debug!("CodegenUnitDebugContext::new");
         let builder = unsafe { llvm::LLVMRustDIBuilderCreate(llmod) };
         // DIBuilder inherits context from the module, so we'd better use the same one
@@ -90,7 +90,7 @@ impl<'ll, 'tcx> CodegenUnitDebugContext<'ll, 'tcx> {
         }
     }
 
-    pub fn finalize(&self, sess: &Session) {
+    pub(crate) fn finalize(&self, sess: &Session) {
         unsafe {
             llvm::LLVMRustDIBuilderFinalize(self.builder);
 
@@ -134,7 +134,7 @@ impl<'ll, 'tcx> CodegenUnitDebugContext<'ll, 'tcx> {
 }
 
 /// Creates any deferred debug metadata nodes
-pub fn finalize(cx: &CodegenCx<'_, '_>) {
+pub(crate) fn finalize(cx: &CodegenCx<'_, '_>) {
     if let Some(dbg_cx) = &cx.dbg_cx {
         debug!("finalize");
 
@@ -241,13 +241,13 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
 // FIXME(eddyb) rename this to better indicate it's a duplicate of
 // `rustc_span::Loc` rather than `DILocation`, perhaps by making
 // `lookup_char_pos` return the right information instead.
-pub struct DebugLoc {
+struct DebugLoc {
     /// Information about the original source file.
-    pub file: Lrc<SourceFile>,
+    file: Lrc<SourceFile>,
     /// The (1-based) line number.
-    pub line: u32,
+    line: u32,
     /// The (1-based) column number.
-    pub col: u32,
+    col: u32,
 }
 
 impl CodegenCx<'_, '_> {
@@ -255,7 +255,7 @@ impl CodegenCx<'_, '_> {
     // FIXME(eddyb) rename this to better indicate it's a duplicate of
     // `lookup_char_pos` rather than `dbg_loc`, perhaps by making
     // `lookup_char_pos` return the right information instead.
-    pub fn lookup_debug_loc(&self, pos: BytePos) -> DebugLoc {
+    fn lookup_debug_loc(&self, pos: BytePos) -> DebugLoc {
         let (file, line, col) = match self.sess().source_map().lookup_line(pos) {
             Ok(SourceFileAndLine { sf: file, line }) => {
                 let line_pos = file.lines()[line];
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/namespace.rs b/compiler/rustc_codegen_llvm/src/debuginfo/namespace.rs
index 5c4f8fe99e3d9..83d7a82dadc4d 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/namespace.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/namespace.rs
@@ -9,7 +9,7 @@ use crate::common::CodegenCx;
 use crate::llvm;
 use crate::llvm::debuginfo::DIScope;
 
-pub fn mangled_name_of_instance<'a, 'tcx>(
+pub(crate) fn mangled_name_of_instance<'a, 'tcx>(
     cx: &CodegenCx<'a, 'tcx>,
     instance: Instance<'tcx>,
 ) -> ty::SymbolName<'tcx> {
@@ -17,7 +17,7 @@ pub fn mangled_name_of_instance<'a, 'tcx>(
     tcx.symbol_name(instance)
 }
 
-pub fn item_namespace<'ll>(cx: &CodegenCx<'ll, '_>, def_id: DefId) -> &'ll DIScope {
+pub(crate) fn item_namespace<'ll>(cx: &CodegenCx<'ll, '_>, def_id: DefId) -> &'ll DIScope {
     if let Some(&scope) = debug_context(cx).namespace_map.borrow().get(&def_id) {
         return scope;
     }
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs b/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs
index e542aa96e8a23..321553a3df0bd 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs
@@ -11,7 +11,7 @@ use crate::common::CodegenCx;
 use crate::llvm;
 use crate::llvm::debuginfo::{DIArray, DIBuilder, DIDescriptor, DIScope};
 
-pub fn is_node_local_to_unit(cx: &CodegenCx<'_, '_>, def_id: DefId) -> bool {
+pub(crate) fn is_node_local_to_unit(cx: &CodegenCx<'_, '_>, def_id: DefId) -> bool {
     // The is_local_to_unit flag indicates whether a function is local to the
     // current compilation unit (i.e., if it is *static* in the C-sense). The
     // *reachable* set should provide a good approximation of this, as it
@@ -24,7 +24,7 @@ pub fn is_node_local_to_unit(cx: &CodegenCx<'_, '_>, def_id: DefId) -> bool {
 }
 
 #[allow(non_snake_case)]
-pub fn create_DIArray<'ll>(
+pub(crate) fn create_DIArray<'ll>(
     builder: &DIBuilder<'ll>,
     arr: &[Option<&'ll DIDescriptor>],
 ) -> &'ll DIArray {
@@ -32,7 +32,7 @@ pub fn create_DIArray<'ll>(
 }
 
 #[inline]
-pub fn debug_context<'a, 'll, 'tcx>(
+pub(crate) fn debug_context<'a, 'll, 'tcx>(
     cx: &'a CodegenCx<'ll, 'tcx>,
 ) -> &'a CodegenUnitDebugContext<'ll, 'tcx> {
     cx.dbg_cx.as_ref().unwrap()
@@ -40,11 +40,11 @@ pub fn debug_context<'a, 'll, 'tcx>(
 
 #[inline]
 #[allow(non_snake_case)]
-pub fn DIB<'a, 'll>(cx: &'a CodegenCx<'ll, '_>) -> &'a DIBuilder<'ll> {
+pub(crate) fn DIB<'a, 'll>(cx: &'a CodegenCx<'ll, '_>) -> &'a DIBuilder<'ll> {
     cx.dbg_cx.as_ref().unwrap().builder
 }
 
-pub fn get_namespace_for_item<'ll>(cx: &CodegenCx<'ll, '_>, def_id: DefId) -> &'ll DIScope {
+pub(crate) fn get_namespace_for_item<'ll>(cx: &CodegenCx<'ll, '_>, def_id: DefId) -> &'ll DIScope {
     item_namespace(cx, cx.tcx.parent(def_id))
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
index 2aa349b278234..4e4500b637328 100644
--- a/compiler/rustc_codegen_llvm/src/declare.rs
+++ b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -65,7 +65,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
     ///
     /// If there’s a value with the same name already declared, the function will
     /// return its Value instead.
-    pub fn declare_global(&self, name: &str, ty: &'ll Type) -> &'ll Value {
+    pub(crate) fn declare_global(&self, name: &str, ty: &'ll Type) -> &'ll Value {
         debug!("declare_global(name={:?})", name);
         unsafe { llvm::LLVMRustGetOrInsertGlobal(self.llmod, name.as_ptr().cast(), name.len(), ty) }
     }
@@ -77,7 +77,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
     ///
     /// If there’s a value with the same name already declared, the function will
     /// update the declaration and return existing Value instead.
-    pub fn declare_cfn(
+    pub(crate) fn declare_cfn(
         &self,
         name: &str,
         unnamed: llvm::UnnamedAddr,
@@ -100,7 +100,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
     ///
     /// If there’s a value with the same name already declared, the function will
     /// update the declaration and return existing Value instead.
-    pub fn declare_entry_fn(
+    pub(crate) fn declare_entry_fn(
         &self,
         name: &str,
         callconv: llvm::CallConv,
@@ -119,7 +119,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
     ///
     /// If there’s a value with the same name already declared, the function will
     /// update the declaration and return existing Value instead.
-    pub fn declare_fn(
+    pub(crate) fn declare_fn(
         &self,
         name: &str,
         fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
@@ -199,7 +199,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
     /// return `None` if the name already has a definition associated with it. In that
     /// case an error should be reported to the user, because it usually happens due
     /// to user’s fault (e.g., misuse of `#[no_mangle]` or `#[export_name]` attributes).
-    pub fn define_global(&self, name: &str, ty: &'ll Type) -> Option<&'ll Value> {
+    pub(crate) fn define_global(&self, name: &str, ty: &'ll Type) -> Option<&'ll Value> {
         if self.get_defined_value(name).is_some() {
             None
         } else {
@@ -210,19 +210,19 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
     /// Declare a private global
     ///
     /// Use this function when you intend to define a global without a name.
-    pub fn define_private_global(&self, ty: &'ll Type) -> &'ll Value {
+    pub(crate) fn define_private_global(&self, ty: &'ll Type) -> &'ll Value {
         unsafe { llvm::LLVMRustInsertPrivateGlobal(self.llmod, ty) }
     }
 
     /// Gets declared value by name.
-    pub fn get_declared_value(&self, name: &str) -> Option<&'ll Value> {
+    pub(crate) fn get_declared_value(&self, name: &str) -> Option<&'ll Value> {
         debug!("get_declared_value(name={:?})", name);
         unsafe { llvm::LLVMRustGetNamedValue(self.llmod, name.as_ptr().cast(), name.len()) }
     }
 
     /// Gets defined or externally defined (AvailableExternally linkage) value by
     /// name.
-    pub fn get_defined_value(&self, name: &str) -> Option<&'ll Value> {
+    pub(crate) fn get_defined_value(&self, name: &str) -> Option<&'ll Value> {
         self.get_declared_value(name).and_then(|val| {
             let declaration = unsafe { llvm::LLVMIsDeclaration(val) != 0 };
             if !declaration { Some(val) } else { None }
diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs
index 7e53d32ce8cd3..766f8db1788fa 100644
--- a/compiler/rustc_codegen_llvm/src/errors.rs
+++ b/compiler/rustc_codegen_llvm/src/errors.rs
@@ -214,13 +214,13 @@ pub(crate) struct CopyBitcode {
 
 #[derive(Diagnostic)]
 #[diag(codegen_llvm_unknown_debuginfo_compression)]
-pub struct UnknownCompression {
+pub(crate) struct UnknownCompression {
     pub algorithm: &'static str,
 }
 
 #[derive(Diagnostic)]
 #[diag(codegen_llvm_mismatch_data_layout)]
-pub struct MismatchedDataLayout<'a> {
+pub(crate) struct MismatchedDataLayout<'a> {
     pub rustc_target: &'a str,
     pub rustc_layout: &'a str,
     pub llvm_target: &'a str,
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 43164390a1c6c..7f26bbd7f8757 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -16,6 +16,7 @@
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 use std::any::Any;
@@ -45,11 +46,11 @@ use rustc_session::Session;
 use rustc_span::symbol::Symbol;
 
 mod back {
-    pub mod archive;
-    pub mod lto;
-    pub mod owned_target_machine;
+    pub(crate) mod archive;
+    pub(crate) mod lto;
+    pub(crate) mod owned_target_machine;
     mod profiling;
-    pub mod write;
+    pub(crate) mod write;
 }
 
 mod abi;
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 9fd8ca43789dd..7af5eb9278f38 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -136,14 +136,14 @@ unsafe fn configure_llvm(sess: &Session) {
     unsafe { llvm::LLVMRustSetLLVMOptions(llvm_args.len() as c_int, llvm_args.as_ptr()) };
 }
 
-pub fn time_trace_profiler_finish(file_name: &Path) {
+pub(crate) fn time_trace_profiler_finish(file_name: &Path) {
     unsafe {
         let file_name = path_to_c_string(file_name);
         llvm::LLVMRustTimeTraceProfilerFinish(file_name.as_ptr());
     }
 }
 
-pub enum TargetFeatureFoldStrength<'a> {
+enum TargetFeatureFoldStrength<'a> {
     // The feature is only tied when enabling the feature, disabling
     // this feature shouldn't disable the tied feature.
     EnableOnly(&'a str),
@@ -160,28 +160,28 @@ impl<'a> TargetFeatureFoldStrength<'a> {
     }
 }
 
-pub struct LLVMFeature<'a> {
-    pub llvm_feature_name: &'a str,
-    pub dependency: Option<TargetFeatureFoldStrength<'a>>,
+pub(crate) struct LLVMFeature<'a> {
+    llvm_feature_name: &'a str,
+    dependency: Option<TargetFeatureFoldStrength<'a>>,
 }
 
 impl<'a> LLVMFeature<'a> {
-    pub fn new(llvm_feature_name: &'a str) -> Self {
+    fn new(llvm_feature_name: &'a str) -> Self {
         Self { llvm_feature_name, dependency: None }
     }
 
-    pub fn with_dependency(
+    fn with_dependency(
         llvm_feature_name: &'a str,
         dependency: TargetFeatureFoldStrength<'a>,
     ) -> Self {
         Self { llvm_feature_name, dependency: Some(dependency) }
     }
 
-    pub fn contains(&self, feat: &str) -> bool {
+    fn contains(&self, feat: &str) -> bool {
         self.iter().any(|dep| dep == feat)
     }
 
-    pub fn iter(&'a self) -> impl Iterator<Item = &'a str> {
+    fn iter(&'a self) -> impl Iterator<Item = &'a str> {
         let dependencies = self.dependency.iter().map(|feat| feat.as_str());
         std::iter::once(self.llvm_feature_name).chain(dependencies)
     }
@@ -209,7 +209,7 @@ impl<'a> IntoIterator for LLVMFeature<'a> {
 // Though note that Rust can also be build with an external precompiled version of LLVM
 // which might lead to failures if the oldest tested / supported LLVM version
 // doesn't yet support the relevant intrinsics
-pub fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a> {
+pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a> {
     let arch = if sess.target.arch == "x86_64" {
         "x86"
     } else if sess.target.arch == "arm64ec" {
@@ -257,7 +257,7 @@ pub fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a> {
 
 /// Given a map from target_features to whether they are enabled or disabled,
 /// ensure only valid combinations are allowed.
-pub fn check_tied_features(
+pub(crate) fn check_tied_features(
     sess: &Session,
     features: &FxHashMap<&str, bool>,
 ) -> Option<&'static [&'static str]> {
@@ -337,19 +337,19 @@ pub fn target_features(sess: &Session, allow_unstable: bool) -> Vec<Symbol> {
         .collect()
 }
 
-pub fn print_version() {
+pub(crate) fn print_version() {
     let (major, minor, patch) = get_version();
     println!("LLVM version: {major}.{minor}.{patch}");
 }
 
-pub fn get_version() -> (u32, u32, u32) {
+pub(crate) fn get_version() -> (u32, u32, u32) {
     // Can be called without initializing LLVM
     unsafe {
         (llvm::LLVMRustVersionMajor(), llvm::LLVMRustVersionMinor(), llvm::LLVMRustVersionPatch())
     }
 }
 
-pub fn print_passes() {
+pub(crate) fn print_passes() {
     // Can be called without initializing LLVM
     unsafe {
         llvm::LLVMRustPrintPasses();
@@ -479,7 +479,7 @@ fn handle_native(name: &str) -> &str {
     }
 }
 
-pub fn target_cpu(sess: &Session) -> &str {
+pub(crate) fn target_cpu(sess: &Session) -> &str {
     match sess.opts.cg.target_cpu {
         Some(ref name) => handle_native(name),
         None => handle_native(sess.target.cpu.as_ref()),
@@ -699,7 +699,7 @@ fn backend_feature_name<'a>(sess: &Session, s: &'a str) -> Option<&'a str> {
     Some(feature)
 }
 
-pub fn tune_cpu(sess: &Session) -> Option<&str> {
+pub(crate) fn tune_cpu(sess: &Session) -> Option<&str> {
     let name = sess.opts.unstable_opts.tune_cpu.as_ref()?;
     Some(handle_native(name))
 }
diff --git a/compiler/rustc_codegen_llvm/src/type_.rs b/compiler/rustc_codegen_llvm/src/type_.rs
index 7e3ab19898d36..ec1e2cb809421 100644
--- a/compiler/rustc_codegen_llvm/src/type_.rs
+++ b/compiler/rustc_codegen_llvm/src/type_.rs
@@ -12,7 +12,7 @@ use rustc_target::abi::{AddressSpace, Align, Integer, Size};
 
 use crate::abi::{FnAbiLlvmExt, LlvmType};
 use crate::context::CodegenCx;
-pub use crate::llvm::Type;
+pub(crate) use crate::llvm::Type;
 use crate::llvm::{Bool, False, True};
 use crate::type_of::LayoutLlvmExt;
 use crate::value::Value;
diff --git a/compiler/rustc_codegen_llvm/src/type_of.rs b/compiler/rustc_codegen_llvm/src/type_of.rs
index 4755fa08afb7c..6e429a1674ade 100644
--- a/compiler/rustc_codegen_llvm/src/type_of.rs
+++ b/compiler/rustc_codegen_llvm/src/type_of.rs
@@ -139,21 +139,21 @@ fn struct_llfields<'a, 'tcx>(
 }
 
 impl<'a, 'tcx> CodegenCx<'a, 'tcx> {
-    pub fn align_of(&self, ty: Ty<'tcx>) -> Align {
+    pub(crate) fn align_of(&self, ty: Ty<'tcx>) -> Align {
         self.layout_of(ty).align.abi
     }
 
-    pub fn size_of(&self, ty: Ty<'tcx>) -> Size {
+    pub(crate) fn size_of(&self, ty: Ty<'tcx>) -> Size {
         self.layout_of(ty).size
     }
 
-    pub fn size_and_align_of(&self, ty: Ty<'tcx>) -> (Size, Align) {
+    pub(crate) fn size_and_align_of(&self, ty: Ty<'tcx>) -> (Size, Align) {
         let layout = self.layout_of(ty);
         (layout.size, layout.align.abi)
     }
 }
 
-pub trait LayoutLlvmExt<'tcx> {
+pub(crate) trait LayoutLlvmExt<'tcx> {
     fn is_llvm_immediate(&self) -> bool;
     fn is_llvm_scalar_pair(&self) -> bool;
     fn llvm_type<'a>(&self, cx: &CodegenCx<'a, 'tcx>) -> &'a Type;
diff --git a/compiler/rustc_codegen_llvm/src/value.rs b/compiler/rustc_codegen_llvm/src/value.rs
index 6295b0de35649..2eabac3be8c56 100644
--- a/compiler/rustc_codegen_llvm/src/value.rs
+++ b/compiler/rustc_codegen_llvm/src/value.rs
@@ -2,7 +2,7 @@ use std::hash::{Hash, Hasher};
 use std::{fmt, ptr};
 
 use crate::llvm;
-pub use crate::llvm::Value;
+pub(crate) use crate::llvm::Value;
 
 impl PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {

From cc8444274b33ffd01fd8cb35199f02697e632852 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Sat, 6 Jul 2024 22:30:39 +1000
Subject: [PATCH 312/685] Add `warn(unreachable_pub)` to `rustc_codegen_ssa`.

---
 compiler/rustc_codegen_ssa/src/back/link.rs   | 4 ++--
 compiler/rustc_codegen_ssa/src/back/write.rs  | 2 +-
 compiler/rustc_codegen_ssa/src/lib.rs         | 1 +
 compiler/rustc_codegen_ssa/src/mir/analyze.rs | 8 ++++----
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 7bad9d33e7d31..8d271f61a9c75 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1207,7 +1207,7 @@ mod win {
 
     /// Get the Windows system OEM code page. This is most notably the code page
     /// used for link.exe's output.
-    pub fn oem_code_page() -> u32 {
+    pub(super) fn oem_code_page() -> u32 {
         unsafe {
             let mut cp: u32 = 0;
             // We're using the `LOCALE_RETURN_NUMBER` flag to return a u32.
@@ -1230,7 +1230,7 @@ mod win {
     ///
     /// It will fail if the multi-byte string is longer than `i32::MAX` or if it contains
     /// any invalid bytes for the expected encoding.
-    pub fn locale_byte_str_to_string(s: &[u8], code_page: u32) -> Option<String> {
+    pub(super) fn locale_byte_str_to_string(s: &[u8], code_page: u32) -> Option<String> {
         // `MultiByteToWideChar` requires a length to be a "positive integer".
         if s.len() > isize::MAX as usize {
             return None;
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 70b45a852ca0e..7ad31802454f2 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -754,7 +754,7 @@ pub(crate) enum WorkItem<B: WriteBackendMethods> {
 }
 
 impl<B: WriteBackendMethods> WorkItem<B> {
-    pub fn module_kind(&self) -> ModuleKind {
+    fn module_kind(&self) -> ModuleKind {
         match *self {
             WorkItem::Optimize(ref m) => m.kind,
             WorkItem::CopyPostLtoArtifacts(_) | WorkItem::LTO(_) => ModuleKind::Regular,
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index cb6d9d6f66e78..c89bfca668789 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -12,6 +12,7 @@
 #![feature(rustdoc_internals)]
 #![feature(strict_provenance)]
 #![feature(try_blocks)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 //! This crate contains codegen code that is used by all codegen backends (LLVM and others).
diff --git a/compiler/rustc_codegen_ssa/src/mir/analyze.rs b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
index 6794365c9beef..5f3766421f0f1 100644
--- a/compiler/rustc_codegen_ssa/src/mir/analyze.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
@@ -13,7 +13,7 @@ use tracing::debug;
 use super::FunctionCx;
 use crate::traits::*;
 
-pub fn non_ssa_locals<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
+pub(crate) fn non_ssa_locals<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     fx: &FunctionCx<'a, 'tcx, Bx>,
 ) -> BitSet<mir::Local> {
     let mir = fx.mir;
@@ -251,14 +251,14 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum CleanupKind {
+pub(crate) enum CleanupKind {
     NotCleanup,
     Funclet,
     Internal { funclet: mir::BasicBlock },
 }
 
 impl CleanupKind {
-    pub fn funclet_bb(self, for_bb: mir::BasicBlock) -> Option<mir::BasicBlock> {
+    pub(crate) fn funclet_bb(self, for_bb: mir::BasicBlock) -> Option<mir::BasicBlock> {
         match self {
             CleanupKind::NotCleanup => None,
             CleanupKind::Funclet => Some(for_bb),
@@ -270,7 +270,7 @@ impl CleanupKind {
 /// MSVC requires unwinding code to be split to a tree of *funclets*, where each funclet can only
 /// branch to itself or to its parent. Luckily, the code we generates matches this pattern.
 /// Recover that structure in an analyze pass.
-pub fn cleanup_kinds(mir: &mir::Body<'_>) -> IndexVec<mir::BasicBlock, CleanupKind> {
+pub(crate) fn cleanup_kinds(mir: &mir::Body<'_>) -> IndexVec<mir::BasicBlock, CleanupKind> {
     fn discover_masters<'tcx>(
         result: &mut IndexSlice<mir::BasicBlock, CleanupKind>,
         mir: &mir::Body<'tcx>,

From af0093a6b84d297ddcc68d3346a498e412cb2866 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 6 Aug 2024 14:05:29 +1000
Subject: [PATCH 313/685] Remove size assertion on `AttrWrapper`.

It's not an important type when it comes to memory use.
---
 compiler/rustc_parse/src/parser/attr_wrapper.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs
index abf61036c2deb..0581acb12f78a 100644
--- a/compiler/rustc_parse/src/parser/attr_wrapper.rs
+++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs
@@ -490,7 +490,6 @@ mod size_asserts {
 
     use super::*;
     // tidy-alphabetical-start
-    static_assert_size!(AttrWrapper, 16);
     static_assert_size!(LazyAttrTokenStreamImpl, 96);
     // tidy-alphabetical-end
 }

From 55906aa2407b10b4f910c221be6f40e549780bb8 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Mon, 5 Aug 2024 13:35:59 +1000
Subject: [PATCH 314/685] Make visibilities minimal and consistent in
 `attr_wrapper.rs`.

---
 compiler/rustc_parse/src/parser/attr_wrapper.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs
index 0581acb12f78a..8eb23c22cec38 100644
--- a/compiler/rustc_parse/src/parser/attr_wrapper.rs
+++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs
@@ -29,7 +29,7 @@ use super::{
 /// This struct has its own module, to ensure that the parser code
 /// cannot directly access the `attrs` field.
 #[derive(Debug, Clone)]
-pub struct AttrWrapper {
+pub(super) struct AttrWrapper {
     attrs: AttrVec,
     // The start of the outer attributes in the parser's token stream.
     // This lets us create a `NodeReplacement` for the entire attribute
@@ -41,11 +41,11 @@ impl AttrWrapper {
     pub(super) fn new(attrs: AttrVec, start_pos: u32) -> AttrWrapper {
         AttrWrapper { attrs, start_pos }
     }
-    pub fn empty() -> AttrWrapper {
+    pub(super) fn empty() -> AttrWrapper {
         AttrWrapper { attrs: AttrVec::new(), start_pos: u32::MAX }
     }
 
-    pub(crate) fn take_for_recovery(self, psess: &ParseSess) -> AttrVec {
+    pub(super) fn take_for_recovery(self, psess: &ParseSess) -> AttrVec {
         psess.dcx().span_delayed_bug(
             self.attrs.get(0).map(|attr| attr.span).unwrap_or(DUMMY_SP),
             "AttrVec is taken for recovery but no error is produced",
@@ -56,12 +56,12 @@ impl AttrWrapper {
 
     /// Prepend `self.attrs` to `attrs`.
     // FIXME: require passing an NT to prevent misuse of this method
-    pub(crate) fn prepend_to_nt_inner(mut self, attrs: &mut AttrVec) {
+    pub(super) fn prepend_to_nt_inner(mut self, attrs: &mut AttrVec) {
         mem::swap(attrs, &mut self.attrs);
         attrs.extend(self.attrs);
     }
 
-    pub fn is_empty(&self) -> bool {
+    pub(super) fn is_empty(&self) -> bool {
         self.attrs.is_empty()
     }
 }
@@ -197,7 +197,7 @@ impl<'a> Parser<'a> {
     ///     }                               //  32..33
     /// }                                   //  33..34
     /// ```
-    pub fn collect_tokens_trailing_token<R: HasAttrs + HasTokens>(
+    pub(super) fn collect_tokens_trailing_token<R: HasAttrs + HasTokens>(
         &mut self,
         attrs: AttrWrapper,
         force_collect: ForceCollect,

From c8098be41fa767a96cfb3665147fabf06f456be9 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 6 Aug 2024 10:17:46 +1000
Subject: [PATCH 315/685] Convert a bool to `Trailing`.

This pre-existing type is suitable for use with the return value of the
`f` parameter in `collect_tokens_trailing_token`. The more descriptive
name will be useful because the next commit will add another boolean
value to the return value of `f`.
---
 compiler/rustc_parse/src/parser/attr.rs       |  6 ++++--
 .../rustc_parse/src/parser/attr_wrapper.rs    | 12 +++++------
 compiler/rustc_parse/src/parser/expr.rs       | 20 ++++++++++--------
 compiler/rustc_parse/src/parser/generics.rs   | 10 ++++-----
 compiler/rustc_parse/src/parser/item.rs       | 21 ++++++++++---------
 compiler/rustc_parse/src/parser/mod.rs        |  8 ++++++-
 compiler/rustc_parse/src/parser/pat.rs        |  2 +-
 compiler/rustc_parse/src/parser/stmt.rs       | 13 ++++++------
 8 files changed, 52 insertions(+), 40 deletions(-)

diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index 645fde25cd440..1ae26309e4418 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -8,7 +8,9 @@ use rustc_span::{sym, BytePos, Span};
 use thin_vec::ThinVec;
 use tracing::debug;
 
-use super::{AttrWrapper, Capturing, FnParseMode, ForceCollect, Parser, ParserRange, PathStyle};
+use super::{
+    AttrWrapper, Capturing, FnParseMode, ForceCollect, Parser, ParserRange, PathStyle, Trailing,
+};
 use crate::{errors, fluent_generated as fluent, maybe_whole};
 
 // Public for rustfmt usage
@@ -273,7 +275,7 @@ impl<'a> Parser<'a> {
             if is_unsafe {
                 this.expect(&token::CloseDelim(Delimiter::Parenthesis))?;
             }
-            Ok((ast::AttrItem { unsafety, path, args, tokens: None }, false))
+            Ok((ast::AttrItem { unsafety, path, args, tokens: None }, Trailing::No))
         };
         // Attr items don't have attributes.
         self.collect_tokens_trailing_token(AttrWrapper::empty(), force_collect, do_parse)
diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs
index 8eb23c22cec38..65722f2b7e3d6 100644
--- a/compiler/rustc_parse/src/parser/attr_wrapper.rs
+++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs
@@ -12,7 +12,7 @@ use rustc_span::{sym, Span, DUMMY_SP};
 
 use super::{
     Capturing, FlatToken, ForceCollect, NodeRange, NodeReplacement, Parser, ParserRange,
-    TokenCursor,
+    TokenCursor, Trailing,
 };
 
 /// A wrapper type to ensure that the parser handles outer attributes correctly.
@@ -168,7 +168,7 @@ impl ToAttrTokenStream for LazyAttrTokenStreamImpl {
 impl<'a> Parser<'a> {
     /// Parses code with `f`. If appropriate, it records the tokens (in
     /// `LazyAttrTokenStream` form) that were parsed in the result, accessible
-    /// via the `HasTokens` trait. The second (bool) part of the callback's
+    /// via the `HasTokens` trait. The `Trailing` part of the callback's
     /// result indicates if an extra token should be captured, e.g. a comma or
     /// semicolon.
     ///
@@ -201,7 +201,7 @@ impl<'a> Parser<'a> {
         &mut self,
         attrs: AttrWrapper,
         force_collect: ForceCollect,
-        f: impl FnOnce(&mut Self, ast::AttrVec) -> PResult<'a, (R, bool)>,
+        f: impl FnOnce(&mut Self, ast::AttrVec) -> PResult<'a, (R, Trailing)>,
     ) -> PResult<'a, R> {
         // We must collect if anything could observe the collected tokens, i.e.
         // if any of the following conditions hold.
@@ -234,9 +234,9 @@ impl<'a> Parser<'a> {
         // `Parser::parse_inner_attributes`.
         let (mut ret, capture_trailing) = {
             let prev_capturing = mem::replace(&mut self.capture_state.capturing, Capturing::Yes);
-            let ret_and_trailing = f(self, attrs.attrs);
+            let f_res = f(self, attrs.attrs);
             self.capture_state.capturing = prev_capturing;
-            ret_and_trailing?
+            f_res?
         };
 
         // When we're not in `capture_cfg` mode, then skip collecting and
@@ -282,7 +282,7 @@ impl<'a> Parser<'a> {
         let parser_replacements_end = self.capture_state.parser_replacements.len();
 
         assert!(
-            !(self.break_last_token && capture_trailing),
+            !(self.break_last_token && matches!(capture_trailing, Trailing::Yes)),
             "Cannot set break_last_token and have trailing token"
         );
 
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 536160c813616..e284c7a11bcc5 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -2462,7 +2462,7 @@ impl<'a> Parser<'a> {
                     id: DUMMY_NODE_ID,
                     is_placeholder: false,
                 },
-                this.token == token::Comma,
+                Trailing::from(this.token == token::Comma),
             ))
         })
     }
@@ -3243,7 +3243,7 @@ impl<'a> Parser<'a> {
                     id: DUMMY_NODE_ID,
                     is_placeholder: false,
                 },
-                false,
+                Trailing::No,
             ))
         })
     }
@@ -3752,7 +3752,7 @@ impl<'a> Parser<'a> {
                     id: DUMMY_NODE_ID,
                     is_placeholder: false,
                 },
-                this.token == token::Comma,
+                Trailing::from(this.token == token::Comma),
             ))
         })
     }
@@ -3848,12 +3848,14 @@ impl<'a> Parser<'a> {
     ) -> PResult<'a, P<Expr>> {
         self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
             let res = f(this, attrs)?;
-            let trailing = (this.restrictions.contains(Restrictions::STMT_EXPR)
-                 && this.token == token::Semi)
-            // FIXME: pass an additional condition through from the place
-            // where we know we need a comma, rather than assuming that
-            // `#[attr] expr,` always captures a trailing comma.
-            || this.token == token::Comma;
+            let trailing = Trailing::from(
+                this.restrictions.contains(Restrictions::STMT_EXPR)
+                     && this.token == token::Semi
+                // FIXME: pass an additional condition through from the place
+                // where we know we need a comma, rather than assuming that
+                // `#[attr] expr,` always captures a trailing comma.
+                || this.token == token::Comma,
+            );
             Ok((res, trailing))
         })
     }
diff --git a/compiler/rustc_parse/src/parser/generics.rs b/compiler/rustc_parse/src/parser/generics.rs
index f1bb7187e2f4b..47b801d149030 100644
--- a/compiler/rustc_parse/src/parser/generics.rs
+++ b/compiler/rustc_parse/src/parser/generics.rs
@@ -7,7 +7,7 @@ use rustc_span::symbol::{kw, Ident};
 use rustc_span::Span;
 use thin_vec::ThinVec;
 
-use super::{ForceCollect, Parser};
+use super::{ForceCollect, Parser, Trailing};
 use crate::errors::{
     self, MultipleWhereClauses, UnexpectedDefaultValueForLifetimeInGenericParameters,
     UnexpectedSelfInGenericParameters, WhereClauseBeforeTupleStructBody,
@@ -228,13 +228,13 @@ impl<'a> Parser<'a> {
                                     span: where_predicate.span(),
                                 });
                                 // FIXME - try to continue parsing other generics?
-                                return Ok((None, false));
+                                return Ok((None, Trailing::No));
                             }
                             Err(err) => {
                                 err.cancel();
                                 // FIXME - maybe we should overwrite 'self' outside of `collect_tokens`?
                                 this.restore_snapshot(snapshot);
-                                return Ok((None, false));
+                                return Ok((None, Trailing::No));
                             }
                         }
                     } else {
@@ -248,14 +248,14 @@ impl<'a> Parser<'a> {
                                     .emit_err(errors::AttrWithoutGenerics { span: attrs[0].span });
                             }
                         }
-                        return Ok((None, false));
+                        return Ok((None, Trailing::No));
                     };
 
                     if !this.eat(&token::Comma) {
                         done = true;
                     }
                     // We just ate the comma, so no need to capture the trailing token.
-                    Ok((param, false))
+                    Ok((param, Trailing::No))
                 })?;
 
             if let Some(param) = param {
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index e34e82bcd7b2e..fb205c5797a9e 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -145,7 +145,7 @@ impl<'a> Parser<'a> {
                 let span = lo.to(this.prev_token.span);
                 let id = DUMMY_NODE_ID;
                 let item = Item { ident, attrs, id, kind, vis, span, tokens: None };
-                return Ok((Some(item), false));
+                return Ok((Some(item), Trailing::No));
             }
 
             // At this point, we have failed to parse an item.
@@ -160,7 +160,7 @@ impl<'a> Parser<'a> {
             if !attrs_allowed {
                 this.recover_attrs_no_item(&attrs)?;
             }
-            Ok((None, false))
+            Ok((None, Trailing::No))
         })
     }
 
@@ -1554,7 +1554,7 @@ impl<'a> Parser<'a> {
 
                 let vis = this.parse_visibility(FollowedByType::No)?;
                 if !this.recover_nested_adt_item(kw::Enum)? {
-                    return Ok((None, false));
+                    return Ok((None, Trailing::No));
                 }
                 let ident = this.parse_field_ident("enum", vlo)?;
 
@@ -1566,7 +1566,7 @@ impl<'a> Parser<'a> {
                     this.bump();
                     this.parse_delim_args()?;
 
-                    return Ok((None, this.token == token::Comma));
+                    return Ok((None, Trailing::from(this.token == token::Comma)));
                 }
 
                 let struct_def = if this.check(&token::OpenDelim(Delimiter::Brace)) {
@@ -1623,7 +1623,7 @@ impl<'a> Parser<'a> {
                     is_placeholder: false,
                 };
 
-                Ok((Some(vr), this.token == token::Comma))
+                Ok((Some(vr), Trailing::from(this.token == token::Comma)))
             },
         )
         .map_err(|mut err| {
@@ -1815,7 +1815,7 @@ impl<'a> Parser<'a> {
                         attrs,
                         is_placeholder: false,
                     },
-                    p.token == token::Comma,
+                    Trailing::from(p.token == token::Comma),
                 ))
             })
         })
@@ -1830,7 +1830,8 @@ impl<'a> Parser<'a> {
         self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
             let lo = this.token.span;
             let vis = this.parse_visibility(FollowedByType::No)?;
-            this.parse_single_struct_field(adt_ty, lo, vis, attrs).map(|field| (field, false))
+            this.parse_single_struct_field(adt_ty, lo, vis, attrs)
+                .map(|field| (field, Trailing::No))
         })
     }
 
@@ -2810,7 +2811,7 @@ impl<'a> Parser<'a> {
             if let Some(mut param) = this.parse_self_param()? {
                 param.attrs = attrs;
                 let res = if first_param { Ok(param) } else { this.recover_bad_self_param(param) };
-                return Ok((res?, false));
+                return Ok((res?, Trailing::No));
             }
 
             let is_name_required = match this.token.kind {
@@ -2826,7 +2827,7 @@ impl<'a> Parser<'a> {
                         this.parameter_without_type(&mut err, pat, is_name_required, first_param)
                     {
                         let guar = err.emit();
-                        Ok((dummy_arg(ident, guar), false))
+                        Ok((dummy_arg(ident, guar), Trailing::No))
                     } else {
                         Err(err)
                     };
@@ -2869,7 +2870,7 @@ impl<'a> Parser<'a> {
 
             Ok((
                 Param { attrs, id: ast::DUMMY_NODE_ID, is_placeholder: false, pat, span, ty },
-                false,
+                Trailing::No,
             ))
         })
     }
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index db74ea6279097..05758fe06240b 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -388,6 +388,12 @@ enum Trailing {
     Yes,
 }
 
+impl From<bool> for Trailing {
+    fn from(b: bool) -> Trailing {
+        if b { Trailing::Yes } else { Trailing::No }
+    }
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub(super) enum TokenDescription {
     ReservedIdentifier,
@@ -1549,7 +1555,7 @@ impl<'a> Parser<'a> {
         self.collect_tokens_trailing_token(
             AttrWrapper::empty(),
             ForceCollect::Yes,
-            |this, _attrs| Ok((f(this)?, false)),
+            |this, _attrs| Ok((f(this)?, Trailing::No)),
         )
     }
 
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 089da1ffaf4a8..164be7c94963e 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -1318,7 +1318,7 @@ impl<'a> Parser<'a> {
                     last_non_comma_dotdot_span = Some(this.prev_token.span);
 
                     // We just ate a comma, so there's no need to capture a trailing token.
-                    Ok((field, false))
+                    Ok((field, Trailing::No))
                 })?;
 
             fields.push(field)
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index c4fc0dfbaecf6..ac6a459060aa8 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -21,6 +21,7 @@ use super::pat::{PatternLocation, RecoverComma};
 use super::path::PathStyle;
 use super::{
     AttrWrapper, BlockMode, FnParseMode, ForceCollect, Parser, Restrictions, SemiColonMode,
+    Trailing,
 };
 use crate::errors::MalformedLoopLabel;
 use crate::{errors, maybe_whole};
@@ -68,7 +69,7 @@ impl<'a> Parser<'a> {
             self.collect_tokens_trailing_token(attrs, force_collect, |this, attrs| {
                 this.expect_keyword(kw::Let)?;
                 let local = this.parse_local(attrs)?;
-                let trailing = capture_semi && this.token == token::Semi;
+                let trailing = Trailing::from(capture_semi && this.token == token::Semi);
                 Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), trailing))
             })?
         } else if self.is_kw_followed_by_ident(kw::Mut) && self.may_recover() {
@@ -106,7 +107,7 @@ impl<'a> Parser<'a> {
             let stmt = self.collect_tokens_trailing_token(
                 AttrWrapper::empty(),
                 force_collect,
-                |this, _empty_attrs| Ok((this.parse_stmt_path_start(lo, attrs)?, false)),
+                |this, _empty_attrs| Ok((this.parse_stmt_path_start(lo, attrs)?, Trailing::No)),
             );
             match stmt {
                 Ok(stmt) => stmt,
@@ -133,7 +134,7 @@ impl<'a> Parser<'a> {
                 AttrWrapper::empty(),
                 force_collect,
                 |this, _empty_attrs| {
-                    Ok((this.parse_expr_res(Restrictions::STMT_EXPR, attrs)?, false))
+                    Ok((this.parse_expr_res(Restrictions::STMT_EXPR, attrs)?, Trailing::No))
                 },
             )?;
             if matches!(e.kind, ExprKind::Assign(..)) && self.eat_keyword(kw::Else) {
@@ -155,7 +156,7 @@ impl<'a> Parser<'a> {
 
             if this.eat(&token::Not) {
                 let stmt_mac = this.parse_stmt_mac(lo, attrs, path)?;
-                return Ok((stmt_mac, this.token == token::Semi));
+                return Ok((stmt_mac, Trailing::from(this.token == token::Semi)));
             }
 
             let expr = if this.eat(&token::OpenDelim(Delimiter::Brace)) {
@@ -169,7 +170,7 @@ impl<'a> Parser<'a> {
                 this.parse_expr_dot_or_call_with(attrs, expr, lo)
             })?;
             // `DUMMY_SP` will get overwritten later in this function
-            Ok((this.mk_stmt(rustc_span::DUMMY_SP, StmtKind::Expr(expr)), false))
+            Ok((this.mk_stmt(rustc_span::DUMMY_SP, StmtKind::Expr(expr)), Trailing::No))
         })?;
 
         if let StmtKind::Expr(expr) = stmt.kind {
@@ -242,7 +243,7 @@ impl<'a> Parser<'a> {
         let stmt = self.collect_tokens_trailing_token(attrs, force_collect, |this, attrs| {
             let local = this.parse_local(attrs)?;
             // FIXME - maybe capture semicolon in recovery?
-            Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), false))
+            Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), Trailing::No))
         })?;
         self.dcx()
             .emit_err(errors::InvalidVariableDeclaration { span: lo, sub: subdiagnostic(lo) });

From 5aaa2f92ee050dadca1c3639dc9283971a7b4e8b Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Fri, 2 Aug 2024 09:39:28 +1000
Subject: [PATCH 316/685] Add an assertion to `NodeRange::new`.

---
 compiler/rustc_parse/src/parser/mod.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 05758fe06240b..6a3c4a0c106ad 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -238,6 +238,7 @@ impl NodeRange {
     // is the position of the function's start token. This gives
     // `NodeRange(10..15)`.
     fn new(ParserRange(parser_range): ParserRange, start_pos: u32) -> NodeRange {
+        assert!(parser_range.start >= start_pos && parser_range.end >= start_pos);
         NodeRange((parser_range.start - start_pos)..(parser_range.end - start_pos))
     }
 }

From fe460ac28b63ea97685f131c318af99158a5f87c Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 6 Aug 2024 06:28:31 +1000
Subject: [PATCH 317/685] Add some attribute `stringify!` tests.

A couple of these are marked `FIXME` because they demonstrate existing
bugs with token collection.
---
 tests/ui/macros/stringify.rs | 55 ++++++++++++++++++++++++++++++++++--
 1 file changed, 53 insertions(+), 2 deletions(-)

diff --git a/tests/ui/macros/stringify.rs b/tests/ui/macros/stringify.rs
index f06c1f99069ae..a8b73ac7e158c 100644
--- a/tests/ui/macros/stringify.rs
+++ b/tests/ui/macros/stringify.rs
@@ -33,8 +33,6 @@ macro_rules! stmt { ($stmt:stmt) => { stringify!($stmt) }; }
 macro_rules! ty { ($ty:ty) => { stringify!($ty) }; }
 macro_rules! vis { ($vis:vis) => { stringify!($vis) }; }
 
-// Use this when AST pretty-printing and TokenStream pretty-printing give
-// the same result (which is preferable.)
 macro_rules! c1 {
     ($frag:ident, [$($tt:tt)*], $s:literal) => {
         // Prior to #125174:
@@ -53,6 +51,14 @@ macro_rules! c1 {
     };
 }
 
+// FIXME: temporary
+macro_rules! c2 {
+    ($frag:ident, [$($tt:tt)*], $s1:literal, $s2:literal) => {
+        assert_eq!($frag!($($tt)*), $s1);
+        assert_eq!(stringify!($($tt)*), $s2);
+    };
+}
+
 #[test]
 fn test_block() {
     c1!(block, [ {} ], "{}");
@@ -66,6 +72,8 @@ fn test_block() {
         } ],
         "{ let _; true }"
     );
+
+    // Attributes are not allowed on vanilla blocks.
 }
 
 #[test]
@@ -332,6 +340,20 @@ fn test_expr() {
     // ExprKind::FormatArgs: untestable because this test works pre-expansion.
 
     // ExprKind::Err: untestable.
+
+    // Ones involving attributes.
+    c1!(expr, [ #[aa] 1 ], "#[aa] 1");
+    c1!(expr, [ #[aa] #[bb] x ], "#[aa] #[bb] x");
+    c2!(expr, [ #[aa] 1 + 2 ], "1 + 2", "#[aa] 1 + 2"); // FIXME
+    c2!(expr, [ #[aa] x + 2 ], "x + 2", "#[aa] x + 2"); // FIXME
+    c2!(expr, [ #[aa] 1 / #[bb] 2 ], "1 / #[bb] 2", "#[aa] 1 / #[bb] 2"); // FIXME
+    c2!(expr, [ #[aa] x / #[bb] 2 ], "x / #[bb] 2", "#[aa] x / #[bb] 2"); // FIXME
+    c1!(expr, [ 1 << #[bb] 2 ], "1 << #[bb] 2");
+    c1!(expr, [ x << #[bb] 2 ], "x << #[bb] 2");
+    c1!(expr, [ #[aa] (1 + 2) ], "#[aa] (1 + 2)");
+    c1!(expr, [ #[aa] #[bb] (x + 2) ], "#[aa] #[bb] (x + 2)");
+    c1!(expr, [ #[aa] x[0].p ], "#[aa] x[0].p");
+    c1!(expr, [ #[aa] { #![bb] 0 } ], "#[aa] { #![bb] 0 }");
 }
 
 #[test]
@@ -484,6 +506,11 @@ fn test_item() {
         "macro_rules! stringify { () => {}; }"
     );
     c1!(item, [ pub macro stringify() {} ], "pub macro stringify() {}");
+
+    // Ones involving attributes.
+    c1!(item, [ #[aa] mod m; ], "#[aa] mod m;");
+    c1!(item, [ mod m { #![bb] } ], "mod m { #![bb] }");
+    c1!(item, [ #[aa] mod m { #![bb] } ], "#[aa] mod m { #![bb] }");
 }
 
 #[test]
@@ -492,6 +519,8 @@ fn test_meta() {
     c1!(meta, [ k = "v" ], "k = \"v\"");
     c1!(meta, [ list(k1, k2 = "v") ], "list(k1, k2 = \"v\")");
     c1!(meta, [ serde::k ], "serde::k");
+
+    // Attributes are not allowed on metas.
 }
 
 #[test]
@@ -580,6 +609,8 @@ fn test_pat() {
     c1!(pat, [ mac!(...) ], "mac!(...)");
     c1!(pat, [ mac![...] ], "mac![...]");
     c1!(pat, [ mac! { ... } ], "mac! { ... }");
+
+    // Attributes are not allowed on patterns.
 }
 
 #[test]
@@ -593,6 +624,8 @@ fn test_path() {
     c1!(path, [ Self::<'static> ], "Self::<'static>");
     c1!(path, [ Self() ], "Self()");
     c1!(path, [ Self() -> () ], "Self() -> ()");
+
+    // Attributes are not allowed on paths.
 }
 
 #[test]
@@ -622,6 +655,20 @@ fn test_stmt() {
     c1!(stmt, [ mac!(...) ], "mac!(...)");
     c1!(stmt, [ mac![...] ], "mac![...]");
     c1!(stmt, [ mac! { ... } ], "mac! { ... }");
+
+    // Ones involving attributes.
+    c1!(stmt, [ #[aa] 1 ], "#[aa] 1");
+    c1!(stmt, [ #[aa] #[bb] x ], "#[aa] #[bb] x");
+    c2!(stmt, [ #[aa] 1 as u32 ], "1 as u32", "#[aa] 1 as u32"); // FIXME
+    c2!(stmt, [ #[aa] x as u32 ], "x as u32", "#[aa] x as u32"); // FIXME
+    c2!(stmt, [ #[aa] 1 .. #[bb] 2 ], "1 .. #[bb] 2", "#[aa] 1 .. #[bb] 2"); // FIXME
+    c2!(stmt, [ #[aa] x .. #[bb] 2 ], "x .. #[bb] 2", "#[aa] x .. #[bb] 2"); // FIXME
+    c1!(stmt, [ 1 || #[bb] 2 ], "1 || #[bb] 2");
+    c1!(stmt, [ x || #[bb] 2 ], "x || #[bb] 2");
+    c1!(stmt, [ #[aa] (1 + 2) ], "#[aa] (1 + 2)");
+    c1!(stmt, [ #[aa] #[bb] (x + 2) ], "#[aa] #[bb] (x + 2)");
+    c1!(stmt, [ #[aa] x[0].p ], "#[aa] x[0].p");
+    c1!(stmt, [ #[aa] { #![bb] 0 } ], "#[aa] { #![bb] 0 }");
 }
 
 #[test]
@@ -708,6 +755,8 @@ fn test_ty() {
 
     // TyKind::CVarArgs
     // FIXME: todo
+
+    // Attributes are not allowed on types.
 }
 
 #[test]
@@ -732,6 +781,8 @@ fn test_vis() {
     macro_rules! inherited_vis { ($vis:vis struct) => { vis!($vis) }; }
     assert_eq!(inherited_vis!(struct), "");
     assert_eq!(stringify!(), "");
+
+    // Attributes are not allowed on visibilities.
 }
 
 macro_rules! p {

From 9d31f86f0d1482b4e5084579238009cc5d98e49f Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 6 Aug 2024 17:16:40 +1000
Subject: [PATCH 318/685] Overhaul token collection.

This commit does the following.

- Renames `collect_tokens_trailing_token` as `collect_tokens`, because
  (a) it's annoying long, and (b) the `_trailing_token` bit is less
  accurate now that its types have changed.

- In `collect_tokens`, adds a `Option<CollectPos>` argument and a
  `UsePreAttrPos` in the return type of `f`. These are used in
  `parse_expr_force_collect` (for vanilla expressions) and in
  `parse_stmt_without_recovery` (for two different cases of expression
  statements). Together these ensure are enough to fix all the problems
  with token collection and assoc expressions. The changes to the
  `stringify.rs` test demonstrate some of these.

- Adds a new test. The code in this test was causing an assertion
  failure prior to this commit, due to an invalid `NodeRange`.

The extra complexity is annoying, but necessary to fix the existing
problems.
---
 compiler/rustc_parse/src/parser/attr.rs       |  18 +-
 .../rustc_parse/src/parser/attr_wrapper.rs    |  95 +++++++----
 .../rustc_parse/src/parser/diagnostics.rs     |  19 ++-
 compiler/rustc_parse/src/parser/expr.rs       |  89 ++++++----
 compiler/rustc_parse/src/parser/generics.rs   | 158 +++++++++---------
 compiler/rustc_parse/src/parser/item.rs       | 146 ++++++++--------
 compiler/rustc_parse/src/parser/mod.rs        |  16 +-
 compiler/rustc_parse/src/parser/pat.rs        |  33 ++--
 compiler/rustc_parse/src/parser/path.rs       |   2 +-
 compiler/rustc_parse/src/parser/stmt.rs       |  62 +++++--
 tests/ui/attributes/assoc-expr.rs             |  42 +++++
 tests/ui/macros/stringify.rs                  |  24 +--
 12 files changed, 413 insertions(+), 291 deletions(-)
 create mode 100644 tests/ui/attributes/assoc-expr.rs

diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index 1ae26309e4418..3d06017fcf3c0 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -10,6 +10,7 @@ use tracing::debug;
 
 use super::{
     AttrWrapper, Capturing, FnParseMode, ForceCollect, Parser, ParserRange, PathStyle, Trailing,
+    UsePreAttrPos,
 };
 use crate::{errors, fluent_generated as fluent, maybe_whole};
 
@@ -259,7 +260,8 @@ impl<'a> Parser<'a> {
     pub fn parse_attr_item(&mut self, force_collect: ForceCollect) -> PResult<'a, ast::AttrItem> {
         maybe_whole!(self, NtMeta, |attr| attr.into_inner());
 
-        let do_parse = |this: &mut Self, _empty_attrs| {
+        // Attr items don't have attributes.
+        self.collect_tokens(None, AttrWrapper::empty(), force_collect, |this, _empty_attrs| {
             let is_unsafe = this.eat_keyword(kw::Unsafe);
             let unsafety = if is_unsafe {
                 let unsafe_span = this.prev_token.span;
@@ -275,10 +277,12 @@ impl<'a> Parser<'a> {
             if is_unsafe {
                 this.expect(&token::CloseDelim(Delimiter::Parenthesis))?;
             }
-            Ok((ast::AttrItem { unsafety, path, args, tokens: None }, Trailing::No))
-        };
-        // Attr items don't have attributes.
-        self.collect_tokens_trailing_token(AttrWrapper::empty(), force_collect, do_parse)
+            Ok((
+                ast::AttrItem { unsafety, path, args, tokens: None },
+                Trailing::No,
+                UsePreAttrPos::No,
+            ))
+        })
     }
 
     /// Parses attributes that appear after the opening of an item. These should
@@ -311,8 +315,8 @@ impl<'a> Parser<'a> {
             };
             if let Some(attr) = attr {
                 // If we are currently capturing tokens (i.e. we are within a call to
-                // `Parser::collect_tokens_trailing_tokens`) record the token positions of this
-                // inner attribute, for possible later processing in a `LazyAttrTokenStream`.
+                // `Parser::collect_tokens`) record the token positions of this inner attribute,
+                // for possible later processing in a `LazyAttrTokenStream`.
                 if let Capturing::Yes = self.capture_state.capturing {
                     let end_pos = self.num_bump_calls;
                     let parser_range = ParserRange(start_pos..end_pos);
diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs
index 65722f2b7e3d6..49df2811d525b 100644
--- a/compiler/rustc_parse/src/parser/attr_wrapper.rs
+++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs
@@ -15,6 +15,20 @@ use super::{
     TokenCursor, Trailing,
 };
 
+// When collecting tokens, this fully captures the start point. Usually its
+// just after outer attributes, but occasionally it's before.
+#[derive(Clone, Debug)]
+pub(super) struct CollectPos {
+    start_token: (Token, Spacing),
+    cursor_snapshot: TokenCursor,
+    start_pos: u32,
+}
+
+pub(super) enum UsePreAttrPos {
+    No,
+    Yes,
+}
+
 /// A wrapper type to ensure that the parser handles outer attributes correctly.
 /// When we parse outer attributes, we need to ensure that we capture tokens
 /// for the attribute target. This allows us to perform cfg-expansion on
@@ -22,7 +36,7 @@ use super::{
 ///
 /// This wrapper prevents direct access to the underlying `ast::AttrVec`.
 /// Parsing code can only get access to the underlying attributes
-/// by passing an `AttrWrapper` to `collect_tokens_trailing_token`.
+/// by passing an `AttrWrapper` to `collect_tokens`.
 /// This makes it difficult to accidentally construct an AST node
 /// (which stores an `ast::AttrVec`) without first collecting tokens.
 ///
@@ -33,16 +47,18 @@ pub(super) struct AttrWrapper {
     attrs: AttrVec,
     // The start of the outer attributes in the parser's token stream.
     // This lets us create a `NodeReplacement` for the entire attribute
-    // target, including outer attributes.
-    start_pos: u32,
+    // target, including outer attributes. `None` if there are no outer
+    // attributes.
+    start_pos: Option<u32>,
 }
 
 impl AttrWrapper {
     pub(super) fn new(attrs: AttrVec, start_pos: u32) -> AttrWrapper {
-        AttrWrapper { attrs, start_pos }
+        AttrWrapper { attrs, start_pos: Some(start_pos) }
     }
+
     pub(super) fn empty() -> AttrWrapper {
-        AttrWrapper { attrs: AttrVec::new(), start_pos: u32::MAX }
+        AttrWrapper { attrs: AttrVec::new(), start_pos: None }
     }
 
     pub(super) fn take_for_recovery(self, psess: &ParseSess) -> AttrVec {
@@ -77,7 +93,7 @@ fn has_cfg_or_cfg_attr(attrs: &[Attribute]) -> bool {
 }
 
 // From a value of this type we can reconstruct the `TokenStream` seen by the
-// `f` callback passed to a call to `Parser::collect_tokens_trailing_token`, by
+// `f` callback passed to a call to `Parser::collect_tokens`, by
 // replaying the getting of the tokens. This saves us producing a `TokenStream`
 // if it is never needed, e.g. a captured `macro_rules!` argument that is never
 // passed to a proc macro. In practice, token stream creation happens rarely
@@ -166,16 +182,30 @@ impl ToAttrTokenStream for LazyAttrTokenStreamImpl {
 }
 
 impl<'a> Parser<'a> {
+    pub(super) fn collect_pos(&self) -> CollectPos {
+        CollectPos {
+            start_token: (self.token.clone(), self.token_spacing),
+            cursor_snapshot: self.token_cursor.clone(),
+            start_pos: self.num_bump_calls,
+        }
+    }
+
     /// Parses code with `f`. If appropriate, it records the tokens (in
     /// `LazyAttrTokenStream` form) that were parsed in the result, accessible
     /// via the `HasTokens` trait. The `Trailing` part of the callback's
     /// result indicates if an extra token should be captured, e.g. a comma or
-    /// semicolon.
+    /// semicolon. The `UsePreAttrPos` part of the callback's result indicates
+    /// if we should use `pre_attr_pos` as the collection start position (only
+    /// required in a few cases).
     ///
     /// The `attrs` passed in are in `AttrWrapper` form, which is opaque. The
     /// `AttrVec` within is passed to `f`. See the comment on `AttrWrapper` for
     /// details.
     ///
+    /// `pre_attr_pos` is the position before the outer attributes (or the node
+    /// itself, if no outer attributes are present). It is only needed if `f`
+    /// can return `UsePreAttrPos::Yes`.
+    ///
     /// Note: If your callback consumes an opening delimiter (including the
     /// case where `self.token` is an opening delimiter on entry to this
     /// function), you must also consume the corresponding closing delimiter.
@@ -197,11 +227,12 @@ impl<'a> Parser<'a> {
     ///     }                               //  32..33
     /// }                                   //  33..34
     /// ```
-    pub(super) fn collect_tokens_trailing_token<R: HasAttrs + HasTokens>(
+    pub(super) fn collect_tokens<R: HasAttrs + HasTokens>(
         &mut self,
+        pre_attr_pos: Option<CollectPos>,
         attrs: AttrWrapper,
         force_collect: ForceCollect,
-        f: impl FnOnce(&mut Self, ast::AttrVec) -> PResult<'a, (R, Trailing)>,
+        f: impl FnOnce(&mut Self, AttrVec) -> PResult<'a, (R, Trailing, UsePreAttrPos)>,
     ) -> PResult<'a, R> {
         // We must collect if anything could observe the collected tokens, i.e.
         // if any of the following conditions hold.
@@ -220,23 +251,20 @@ impl<'a> Parser<'a> {
             return Ok(f(self, attrs.attrs)?.0);
         }
 
-        let start_token = (self.token.clone(), self.token_spacing);
-        let cursor_snapshot = self.token_cursor.clone();
-        let start_pos = self.num_bump_calls;
+        let mut collect_pos = self.collect_pos();
         let has_outer_attrs = !attrs.attrs.is_empty();
         let parser_replacements_start = self.capture_state.parser_replacements.len();
 
         // We set and restore `Capturing::Yes` on either side of the call to
-        // `f`, so we can distinguish the outermost call to
-        // `collect_tokens_trailing_token` (e.g. parsing `m` in the example
-        // above) from any inner (indirectly recursive) calls (e.g. parsing `g`
-        // in the example above). This distinction is used below and in
-        // `Parser::parse_inner_attributes`.
-        let (mut ret, capture_trailing) = {
+        // `f`, so we can distinguish the outermost call to `collect_tokens`
+        // (e.g. parsing `m` in the example above) from any inner (indirectly
+        // recursive) calls (e.g. parsing `g` in the example above). This
+        // distinction is used below and in `Parser::parse_inner_attributes`.
+        let (mut ret, capture_trailing, use_pre_attr_pos) = {
             let prev_capturing = mem::replace(&mut self.capture_state.capturing, Capturing::Yes);
-            let f_res = f(self, attrs.attrs);
+            let res = f(self, attrs.attrs);
             self.capture_state.capturing = prev_capturing;
-            f_res?
+            res?
         };
 
         // When we're not in `capture_cfg` mode, then skip collecting and
@@ -279,6 +307,14 @@ impl<'a> Parser<'a> {
             return Ok(ret);
         }
 
+        // Replace the post-attribute collection start position with the
+        // pre-attribute position supplied, if `f` indicated it is necessary.
+        // (The caller is responsible for providing a non-`None` `pre_attr_pos`
+        // if this is a possibility.)
+        if matches!(use_pre_attr_pos, UsePreAttrPos::Yes) {
+            collect_pos = pre_attr_pos.unwrap();
+        }
+
         let parser_replacements_end = self.capture_state.parser_replacements.len();
 
         assert!(
@@ -294,7 +330,7 @@ impl<'a> Parser<'a> {
             // `AttrTokenStream`, we will create the proper token.
             + self.break_last_token as u32;
 
-        let num_calls = end_pos - start_pos;
+        let num_calls = end_pos - collect_pos.start_pos;
 
         // Take the captured `ParserRange`s for any inner attributes that we parsed in
         // `Parser::parse_inner_attributes`, and pair them in a `ParserReplacement` with `None`,
@@ -328,7 +364,9 @@ impl<'a> Parser<'a> {
                 .iter()
                 .cloned()
                 .chain(inner_attr_parser_replacements.iter().cloned())
-                .map(|(parser_range, data)| (NodeRange::new(parser_range, start_pos), data))
+                .map(|(parser_range, data)| {
+                    (NodeRange::new(parser_range, collect_pos.start_pos), data)
+                })
                 .collect()
         };
 
@@ -355,9 +393,9 @@ impl<'a> Parser<'a> {
         //     - `tokens`: lazy tokens for `g` (with its inner attr deleted).
 
         let tokens = LazyAttrTokenStream::new(LazyAttrTokenStreamImpl {
-            start_token,
+            start_token: collect_pos.start_token,
+            cursor_snapshot: collect_pos.cursor_snapshot,
             num_calls,
-            cursor_snapshot,
             break_last_token: self.break_last_token,
             node_replacements,
         });
@@ -368,9 +406,9 @@ impl<'a> Parser<'a> {
         }
 
         // If `capture_cfg` is set and we're inside a recursive call to
-        // `collect_tokens_trailing_token`, then we need to register a replace range
-        // if we have `#[cfg]` or `#[cfg_attr]`. This allows us to run eager cfg-expansion
-        // on the captured token stream.
+        // `collect_tokens`, then we need to register a replace range if we
+        // have `#[cfg]` or `#[cfg_attr]`. This allows us to run eager
+        // cfg-expansion on the captured token stream.
         if self.capture_cfg
             && matches!(self.capture_state.capturing, Capturing::Yes)
             && has_cfg_or_cfg_attr(ret.attrs())
@@ -389,7 +427,8 @@ impl<'a> Parser<'a> {
             // Set things up so that the entire AST node that we just parsed, including attributes,
             // will be replaced with `target` in the lazy token stream. This will allow us to
             // cfg-expand this AST node.
-            let start_pos = if has_outer_attrs { attrs.start_pos } else { start_pos };
+            let start_pos =
+                if has_outer_attrs { attrs.start_pos.unwrap() } else { collect_pos.start_pos };
             let target = AttrsTarget { attrs: ret.attrs().iter().cloned().collect(), tokens };
             self.capture_state
                 .parser_replacements
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index ba4e222a41a51..ef1387c50fa8c 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -2487,13 +2487,14 @@ impl<'a> Parser<'a> {
     pub(super) fn handle_unambiguous_unbraced_const_arg(&mut self) -> PResult<'a, P<Expr>> {
         let start = self.token.span;
         let attrs = self.parse_outer_attributes()?;
-        let expr = self.parse_expr_res(Restrictions::CONST_EXPR, attrs).map_err(|mut err| {
-            err.span_label(
-                start.shrink_to_lo(),
-                "while parsing a const generic argument starting here",
-            );
-            err
-        })?;
+        let (expr, _) =
+            self.parse_expr_res(Restrictions::CONST_EXPR, attrs).map_err(|mut err| {
+                err.span_label(
+                    start.shrink_to_lo(),
+                    "while parsing a const generic argument starting here",
+                );
+                err
+            })?;
         if !self.expr_is_valid_const_arg(&expr) {
             self.dcx().emit_err(ConstGenericWithoutBraces {
                 span: expr.span,
@@ -2613,7 +2614,7 @@ impl<'a> Parser<'a> {
             let attrs = self.parse_outer_attributes()?;
             self.parse_expr_res(Restrictions::CONST_EXPR, attrs)
         })() {
-            Ok(expr) => {
+            Ok((expr, _)) => {
                 // Find a mistake like `MyTrait<Assoc == S::Assoc>`.
                 if snapshot.token == token::EqEq {
                     err.span_suggestion(
@@ -2671,7 +2672,7 @@ impl<'a> Parser<'a> {
         })() {
             // Since we don't know the exact reason why we failed to parse the type or the
             // expression, employ a simple heuristic to weed out some pathological cases.
-            Ok(expr) if let token::Comma | token::Gt = snapshot.token.kind => {
+            Ok((expr, _)) if let token::Comma | token::Gt = snapshot.token.kind => {
                 self.restore_snapshot(snapshot);
                 Some(expr)
             }
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index e284c7a11bcc5..e0917ba43e41c 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -36,7 +36,7 @@ use super::pat::{CommaRecoveryMode, Expected, RecoverColon, RecoverComma};
 use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
 use super::{
     AttrWrapper, BlockMode, ClosureSpans, ForceCollect, Parser, PathStyle, Restrictions,
-    SemiColonMode, SeqSep, TokenType, Trailing,
+    SemiColonMode, SeqSep, TokenType, Trailing, UsePreAttrPos,
 };
 use crate::{errors, maybe_recover_from_interpolated_ty_qpath};
 
@@ -59,15 +59,30 @@ impl<'a> Parser<'a> {
         self.current_closure.take();
 
         let attrs = self.parse_outer_attributes()?;
-        self.parse_expr_res(Restrictions::empty(), attrs)
+        self.parse_expr_res(Restrictions::empty(), attrs).map(|res| res.0)
     }
 
     /// Parses an expression, forcing tokens to be collected.
     pub fn parse_expr_force_collect(&mut self) -> PResult<'a, P<Expr>> {
         self.current_closure.take();
 
+        // If the expression is associative (e.g. `1 + 2`), then any preceding
+        // outer attribute actually belongs to the first inner sub-expression.
+        // In which case we must use the pre-attr pos to include the attribute
+        // in the collected tokens for the outer expression.
+        let pre_attr_pos = self.collect_pos();
         let attrs = self.parse_outer_attributes()?;
-        self.collect_tokens_no_attrs(|this| this.parse_expr_res(Restrictions::empty(), attrs))
+        self.collect_tokens(
+            Some(pre_attr_pos),
+            AttrWrapper::empty(),
+            ForceCollect::Yes,
+            |this, _empty_attrs| {
+                let (expr, is_assoc) = this.parse_expr_res(Restrictions::empty(), attrs)?;
+                let use_pre_attr_pos =
+                    if is_assoc { UsePreAttrPos::Yes } else { UsePreAttrPos::No };
+                Ok((expr, Trailing::No, use_pre_attr_pos))
+            },
+        )
     }
 
     pub fn parse_expr_anon_const(&mut self) -> PResult<'a, AnonConst> {
@@ -77,7 +92,7 @@ impl<'a> Parser<'a> {
     fn parse_expr_catch_underscore(&mut self, restrictions: Restrictions) -> PResult<'a, P<Expr>> {
         let attrs = self.parse_outer_attributes()?;
         match self.parse_expr_res(restrictions, attrs) {
-            Ok(expr) => Ok(expr),
+            Ok((expr, _)) => Ok(expr),
             Err(err) => match self.token.ident() {
                 Some((Ident { name: kw::Underscore, .. }, IdentIsRaw::No))
                     if self.may_recover() && self.look_ahead(1, |t| t == &token::Comma) =>
@@ -104,18 +119,20 @@ impl<'a> Parser<'a> {
         &mut self,
         r: Restrictions,
         attrs: AttrWrapper,
-    ) -> PResult<'a, P<Expr>> {
+    ) -> PResult<'a, (P<Expr>, bool)> {
         self.with_res(r, |this| this.parse_expr_assoc_with(0, attrs))
     }
 
     /// Parses an associative expression with operators of at least `min_prec` precedence.
+    /// The `bool` in the return value indicates if it was an assoc expr, i.e. with an operator
+    /// followed by a subexpression (e.g. `1 + 2`).
     pub(super) fn parse_expr_assoc_with(
         &mut self,
         min_prec: usize,
         attrs: AttrWrapper,
-    ) -> PResult<'a, P<Expr>> {
+    ) -> PResult<'a, (P<Expr>, bool)> {
         let lhs = if self.token.is_range_separator() {
-            return self.parse_expr_prefix_range(attrs);
+            return self.parse_expr_prefix_range(attrs).map(|res| (res, false));
         } else {
             self.parse_expr_prefix(attrs)?
         };
@@ -123,15 +140,17 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses the rest of an associative expression (i.e. the part after the lhs) with operators
-    /// of at least `min_prec` precedence.
+    /// of at least `min_prec` precedence. The `bool` in the return value indicates if something
+    /// was actually parsed.
     pub(super) fn parse_expr_assoc_rest_with(
         &mut self,
         min_prec: usize,
         starts_stmt: bool,
         mut lhs: P<Expr>,
-    ) -> PResult<'a, P<Expr>> {
+    ) -> PResult<'a, (P<Expr>, bool)> {
+        let mut parsed_something = false;
         if !self.should_continue_as_assoc_expr(&lhs) {
-            return Ok(lhs);
+            return Ok((lhs, parsed_something));
         }
 
         self.expected_tokens.push(TokenType::Operator);
@@ -156,10 +175,11 @@ impl<'a> Parser<'a> {
                 self.err_larrow_operator(self.token.span);
             }
 
+            parsed_something = true;
             self.bump();
             if op.node.is_comparison() {
                 if let Some(expr) = self.check_no_chained_comparison(&lhs, &op)? {
-                    return Ok(expr);
+                    return Ok((expr, parsed_something));
                 }
             }
 
@@ -263,7 +283,7 @@ impl<'a> Parser<'a> {
                 // the special cases. The code is here only for future convenience.
                 Fixity::None => 1,
             };
-            let rhs = self.with_res(restrictions - Restrictions::STMT_EXPR, |this| {
+            let (rhs, _) = self.with_res(restrictions - Restrictions::STMT_EXPR, |this| {
                 let attrs = this.parse_outer_attributes()?;
                 this.parse_expr_assoc_with(prec + prec_adjustment, attrs)
             })?;
@@ -319,7 +339,7 @@ impl<'a> Parser<'a> {
             }
         }
 
-        Ok(lhs)
+        Ok((lhs, parsed_something))
     }
 
     fn should_continue_as_assoc_expr(&mut self, lhs: &Expr) -> bool {
@@ -441,7 +461,8 @@ impl<'a> Parser<'a> {
             let attrs = self.parse_outer_attributes()?;
             Some(
                 self.parse_expr_assoc_with(prec + 1, attrs)
-                    .map_err(|err| self.maybe_err_dotdotlt_syntax(maybe_lt, err))?,
+                    .map_err(|err| self.maybe_err_dotdotlt_syntax(maybe_lt, err))?
+                    .0,
             )
         } else {
             None
@@ -498,7 +519,7 @@ impl<'a> Parser<'a> {
                 // RHS must be parsed with more associativity than the dots.
                 let attrs = this.parse_outer_attributes()?;
                 this.parse_expr_assoc_with(op.unwrap().precedence() + 1, attrs)
-                    .map(|x| (lo.to(x.span), Some(x)))
+                    .map(|(x, _)| (lo.to(x.span), Some(x)))
                     .map_err(|err| this.maybe_err_dotdotlt_syntax(maybe_lt, err))?
             } else {
                 (lo, None)
@@ -2335,7 +2356,7 @@ impl<'a> Parser<'a> {
                 let token = self.token.clone();
                 let attrs = self.parse_outer_attributes()?;
                 match self.parse_expr_res(restrictions, attrs) {
-                    Ok(expr) => expr,
+                    Ok((expr, _)) => expr,
                     Err(err) => self.recover_closure_body(err, before, prev, token, lo, decl_hi)?,
                 }
             }
@@ -2445,7 +2466,7 @@ impl<'a> Parser<'a> {
     fn parse_fn_block_param(&mut self) -> PResult<'a, Param> {
         let lo = self.token.span;
         let attrs = self.parse_outer_attributes()?;
-        self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
+        self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
             let pat = this.parse_pat_no_top_alt(Some(Expected::ParameterName), None)?;
             let ty = if this.eat(&token::Colon) {
                 this.parse_ty()?
@@ -2463,6 +2484,7 @@ impl<'a> Parser<'a> {
                     is_placeholder: false,
                 },
                 Trailing::from(this.token == token::Comma),
+                UsePreAttrPos::No,
             ))
         })
     }
@@ -2583,7 +2605,7 @@ impl<'a> Parser<'a> {
     /// Parses the condition of a `if` or `while` expression.
     fn parse_expr_cond(&mut self) -> PResult<'a, P<Expr>> {
         let attrs = self.parse_outer_attributes()?;
-        let mut cond =
+        let (mut cond, _) =
             self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL | Restrictions::ALLOW_LET, attrs)?;
 
         CondChecker::new(self).visit_expr(&mut cond);
@@ -2632,7 +2654,7 @@ impl<'a> Parser<'a> {
             self.expect(&token::Eq)?;
         }
         let attrs = self.parse_outer_attributes()?;
-        let expr = self.parse_expr_assoc_with(1 + prec_let_scrutinee_needs_par(), attrs)?;
+        let (expr, _) = self.parse_expr_assoc_with(1 + prec_let_scrutinee_needs_par(), attrs)?;
         let span = lo.to(expr.span);
         Ok(self.mk_expr(span, ExprKind::Let(pat, expr, span, recovered)))
     }
@@ -2766,7 +2788,7 @@ impl<'a> Parser<'a> {
                 // We know for sure we have seen `for ($SOMETHING in`. In the happy path this would
                 // happen right before the return of this method.
                 let attrs = self.parse_outer_attributes()?;
-                let expr = match self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, attrs) {
+                let (expr, _) = match self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, attrs) {
                     Ok(expr) => expr,
                     Err(expr_err) => {
                         // We don't know what followed the `in`, so cancel and bubble up the
@@ -2801,7 +2823,7 @@ impl<'a> Parser<'a> {
         }
         self.check_for_for_in_in_typo(self.prev_token.span);
         let attrs = self.parse_outer_attributes()?;
-        let expr = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, attrs)?;
+        let (expr, _) = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, attrs)?;
         Ok((pat, expr))
     }
 
@@ -2921,7 +2943,7 @@ impl<'a> Parser<'a> {
     fn parse_expr_match(&mut self) -> PResult<'a, P<Expr>> {
         let match_span = self.prev_token.span;
         let attrs = self.parse_outer_attributes()?;
-        let scrutinee = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, attrs)?;
+        let (scrutinee, _) = self.parse_expr_res(Restrictions::NO_STRUCT_LITERAL, attrs)?;
 
         self.parse_match_block(match_span, match_span, scrutinee, MatchKind::Prefix)
     }
@@ -3069,7 +3091,7 @@ impl<'a> Parser<'a> {
 
     pub(super) fn parse_arm(&mut self) -> PResult<'a, Arm> {
         let attrs = self.parse_outer_attributes()?;
-        self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
+        self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
             let lo = this.token.span;
             let (pat, guard) = this.parse_match_arm_pat_and_guard()?;
 
@@ -3126,7 +3148,7 @@ impl<'a> Parser<'a> {
                 let arm_start_span = this.token.span;
 
                 let attrs = this.parse_outer_attributes()?;
-                let expr =
+                let (expr, _) =
                     this.parse_expr_res(Restrictions::STMT_EXPR, attrs).map_err(|mut err| {
                         err.span_label(arrow_span, "while parsing the `match` arm starting here");
                         err
@@ -3244,6 +3266,7 @@ impl<'a> Parser<'a> {
                     is_placeholder: false,
                 },
                 Trailing::No,
+                UsePreAttrPos::No,
             ))
         })
     }
@@ -3334,8 +3357,9 @@ impl<'a> Parser<'a> {
 
     fn parse_match_guard_condition(&mut self) -> PResult<'a, P<Expr>> {
         let attrs = self.parse_outer_attributes()?;
-        self.parse_expr_res(Restrictions::ALLOW_LET | Restrictions::IN_IF_GUARD, attrs).map_err(
-            |mut err| {
+        match self.parse_expr_res(Restrictions::ALLOW_LET | Restrictions::IN_IF_GUARD, attrs) {
+            Ok((expr, _)) => Ok(expr),
+            Err(mut err) => {
                 if self.prev_token == token::OpenDelim(Delimiter::Brace) {
                     let sugg_sp = self.prev_token.span.shrink_to_lo();
                     // Consume everything within the braces, let's avoid further parse
@@ -3355,9 +3379,9 @@ impl<'a> Parser<'a> {
                         err.span_suggestion_verbose(sugg_sp, msg, "=> ", applicability);
                     }
                 }
-                err
-            },
-        )
+                Err(err)
+            }
+        }
     }
 
     pub(crate) fn is_builtin(&self) -> bool {
@@ -3708,7 +3732,7 @@ impl<'a> Parser<'a> {
     fn parse_expr_field(&mut self) -> PResult<'a, ExprField> {
         let attrs = self.parse_outer_attributes()?;
         self.recover_vcs_conflict_marker();
-        self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
+        self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
             let lo = this.token.span;
 
             // Check if a colon exists one ahead. This means we're parsing a fieldname.
@@ -3753,6 +3777,7 @@ impl<'a> Parser<'a> {
                     is_placeholder: false,
                 },
                 Trailing::from(this.token == token::Comma),
+                UsePreAttrPos::No,
             ))
         })
     }
@@ -3846,7 +3871,7 @@ impl<'a> Parser<'a> {
         attrs: AttrWrapper,
         f: impl FnOnce(&mut Self, ast::AttrVec) -> PResult<'a, P<Expr>>,
     ) -> PResult<'a, P<Expr>> {
-        self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
+        self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
             let res = f(this, attrs)?;
             let trailing = Trailing::from(
                 this.restrictions.contains(Restrictions::STMT_EXPR)
@@ -3856,7 +3881,7 @@ impl<'a> Parser<'a> {
                 // `#[attr] expr,` always captures a trailing comma.
                 || this.token == token::Comma,
             );
-            Ok((res, trailing))
+            Ok((res, trailing, UsePreAttrPos::No))
         })
     }
 }
diff --git a/compiler/rustc_parse/src/parser/generics.rs b/compiler/rustc_parse/src/parser/generics.rs
index 47b801d149030..af3b6f740e3d7 100644
--- a/compiler/rustc_parse/src/parser/generics.rs
+++ b/compiler/rustc_parse/src/parser/generics.rs
@@ -7,7 +7,7 @@ use rustc_span::symbol::{kw, Ident};
 use rustc_span::Span;
 use thin_vec::ThinVec;
 
-use super::{ForceCollect, Parser, Trailing};
+use super::{ForceCollect, Parser, Trailing, UsePreAttrPos};
 use crate::errors::{
     self, MultipleWhereClauses, UnexpectedDefaultValueForLifetimeInGenericParameters,
     UnexpectedSelfInGenericParameters, WhereClauseBeforeTupleStructBody,
@@ -169,94 +169,88 @@ impl<'a> Parser<'a> {
         let mut done = false;
         while !done {
             let attrs = self.parse_outer_attributes()?;
-            let param =
-                self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
-                    if this.eat_keyword_noexpect(kw::SelfUpper) {
-                        // `Self` as a generic param is invalid. Here we emit the diagnostic and continue parsing
-                        // as if `Self` never existed.
-                        this.dcx().emit_err(UnexpectedSelfInGenericParameters {
-                            span: this.prev_token.span,
-                        });
+            let param = self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
+                if this.eat_keyword_noexpect(kw::SelfUpper) {
+                    // `Self` as a generic param is invalid. Here we emit the diagnostic and continue parsing
+                    // as if `Self` never existed.
+                    this.dcx()
+                        .emit_err(UnexpectedSelfInGenericParameters { span: this.prev_token.span });
+
+                    // Eat a trailing comma, if it exists.
+                    let _ = this.eat(&token::Comma);
+                }
+
+                let param = if this.check_lifetime() {
+                    let lifetime = this.expect_lifetime();
+                    // Parse lifetime parameter.
+                    let (colon_span, bounds) = if this.eat(&token::Colon) {
+                        (Some(this.prev_token.span), this.parse_lt_param_bounds())
+                    } else {
+                        (None, Vec::new())
+                    };
 
-                        // Eat a trailing comma, if it exists.
-                        let _ = this.eat(&token::Comma);
+                    if this.check_noexpect(&token::Eq) && this.look_ahead(1, |t| t.is_lifetime()) {
+                        let lo = this.token.span;
+                        // Parse `= 'lifetime`.
+                        this.bump(); // `=`
+                        this.bump(); // `'lifetime`
+                        let span = lo.to(this.prev_token.span);
+                        this.dcx().emit_err(UnexpectedDefaultValueForLifetimeInGenericParameters {
+                            span,
+                        });
                     }
 
-                    let param = if this.check_lifetime() {
-                        let lifetime = this.expect_lifetime();
-                        // Parse lifetime parameter.
-                        let (colon_span, bounds) = if this.eat(&token::Colon) {
-                            (Some(this.prev_token.span), this.parse_lt_param_bounds())
-                        } else {
-                            (None, Vec::new())
-                        };
-
-                        if this.check_noexpect(&token::Eq)
-                            && this.look_ahead(1, |t| t.is_lifetime())
-                        {
-                            let lo = this.token.span;
-                            // Parse `= 'lifetime`.
-                            this.bump(); // `=`
-                            this.bump(); // `'lifetime`
-                            let span = lo.to(this.prev_token.span);
-                            this.dcx().emit_err(
-                                UnexpectedDefaultValueForLifetimeInGenericParameters { span },
-                            );
+                    Some(ast::GenericParam {
+                        ident: lifetime.ident,
+                        id: lifetime.id,
+                        attrs,
+                        bounds,
+                        kind: ast::GenericParamKind::Lifetime,
+                        is_placeholder: false,
+                        colon_span,
+                    })
+                } else if this.check_keyword(kw::Const) {
+                    // Parse const parameter.
+                    Some(this.parse_const_param(attrs)?)
+                } else if this.check_ident() {
+                    // Parse type parameter.
+                    Some(this.parse_ty_param(attrs)?)
+                } else if this.token.can_begin_type() {
+                    // Trying to write an associated type bound? (#26271)
+                    let snapshot = this.create_snapshot_for_diagnostic();
+                    match this.parse_ty_where_predicate() {
+                        Ok(where_predicate) => {
+                            this.dcx().emit_err(errors::BadAssocTypeBounds {
+                                span: where_predicate.span(),
+                            });
+                            // FIXME - try to continue parsing other generics?
                         }
-
-                        Some(ast::GenericParam {
-                            ident: lifetime.ident,
-                            id: lifetime.id,
-                            attrs,
-                            bounds,
-                            kind: ast::GenericParamKind::Lifetime,
-                            is_placeholder: false,
-                            colon_span,
-                        })
-                    } else if this.check_keyword(kw::Const) {
-                        // Parse const parameter.
-                        Some(this.parse_const_param(attrs)?)
-                    } else if this.check_ident() {
-                        // Parse type parameter.
-                        Some(this.parse_ty_param(attrs)?)
-                    } else if this.token.can_begin_type() {
-                        // Trying to write an associated type bound? (#26271)
-                        let snapshot = this.create_snapshot_for_diagnostic();
-                        match this.parse_ty_where_predicate() {
-                            Ok(where_predicate) => {
-                                this.dcx().emit_err(errors::BadAssocTypeBounds {
-                                    span: where_predicate.span(),
-                                });
-                                // FIXME - try to continue parsing other generics?
-                                return Ok((None, Trailing::No));
-                            }
-                            Err(err) => {
-                                err.cancel();
-                                // FIXME - maybe we should overwrite 'self' outside of `collect_tokens`?
-                                this.restore_snapshot(snapshot);
-                                return Ok((None, Trailing::No));
-                            }
+                        Err(err) => {
+                            err.cancel();
+                            // FIXME - maybe we should overwrite 'self' outside of `collect_tokens`?
+                            this.restore_snapshot(snapshot);
                         }
-                    } else {
-                        // Check for trailing attributes and stop parsing.
-                        if !attrs.is_empty() {
-                            if !params.is_empty() {
-                                this.dcx()
-                                    .emit_err(errors::AttrAfterGeneric { span: attrs[0].span });
-                            } else {
-                                this.dcx()
-                                    .emit_err(errors::AttrWithoutGenerics { span: attrs[0].span });
-                            }
+                    }
+                    return Ok((None, Trailing::No, UsePreAttrPos::No));
+                } else {
+                    // Check for trailing attributes and stop parsing.
+                    if !attrs.is_empty() {
+                        if !params.is_empty() {
+                            this.dcx().emit_err(errors::AttrAfterGeneric { span: attrs[0].span });
+                        } else {
+                            this.dcx()
+                                .emit_err(errors::AttrWithoutGenerics { span: attrs[0].span });
                         }
-                        return Ok((None, Trailing::No));
-                    };
-
-                    if !this.eat(&token::Comma) {
-                        done = true;
                     }
-                    // We just ate the comma, so no need to capture the trailing token.
-                    Ok((param, Trailing::No))
-                })?;
+                    return Ok((None, Trailing::No, UsePreAttrPos::No));
+                };
+
+                if !this.eat(&token::Comma) {
+                    done = true;
+                }
+                // We just ate the comma, so no need to capture the trailing token.
+                Ok((param, Trailing::No, UsePreAttrPos::No))
+            })?;
 
             if let Some(param) = param {
                 params.push(param);
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index fb205c5797a9e..47820e93c23d2 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -20,7 +20,9 @@ use tracing::debug;
 
 use super::diagnostics::{dummy_arg, ConsumeClosingDelim};
 use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
-use super::{AttrWrapper, FollowedByType, ForceCollect, Parser, PathStyle, Trailing};
+use super::{
+    AttrWrapper, FollowedByType, ForceCollect, Parser, PathStyle, Trailing, UsePreAttrPos,
+};
 use crate::errors::{self, MacroExpandsToAdtField};
 use crate::{fluent_generated as fluent, maybe_whole};
 
@@ -127,7 +129,7 @@ impl<'a> Parser<'a> {
             Some(item.into_inner())
         });
 
-        self.collect_tokens_trailing_token(attrs, force_collect, |this, mut attrs| {
+        self.collect_tokens(None, attrs, force_collect, |this, mut attrs| {
             let lo = this.token.span;
             let vis = this.parse_visibility(FollowedByType::No)?;
             let mut def = this.parse_defaultness();
@@ -145,7 +147,7 @@ impl<'a> Parser<'a> {
                 let span = lo.to(this.prev_token.span);
                 let id = DUMMY_NODE_ID;
                 let item = Item { ident, attrs, id, kind, vis, span, tokens: None };
-                return Ok((Some(item), Trailing::No));
+                return Ok((Some(item), Trailing::No, UsePreAttrPos::No));
             }
 
             // At this point, we have failed to parse an item.
@@ -160,7 +162,7 @@ impl<'a> Parser<'a> {
             if !attrs_allowed {
                 this.recover_attrs_no_item(&attrs)?;
             }
-            Ok((None, Trailing::No))
+            Ok((None, Trailing::No, UsePreAttrPos::No))
         })
     }
 
@@ -1546,86 +1548,82 @@ impl<'a> Parser<'a> {
         self.recover_vcs_conflict_marker();
         let help = "enum variants can be `Variant`, `Variant = <integer>`, \
                     `Variant(Type, ..., TypeN)` or `Variant { fields: Types }`";
-        self.collect_tokens_trailing_token(
-            variant_attrs,
-            ForceCollect::No,
-            |this, variant_attrs| {
-                let vlo = this.token.span;
-
-                let vis = this.parse_visibility(FollowedByType::No)?;
-                if !this.recover_nested_adt_item(kw::Enum)? {
-                    return Ok((None, Trailing::No));
-                }
-                let ident = this.parse_field_ident("enum", vlo)?;
-
-                if this.token == token::Not {
-                    if let Err(err) = this.unexpected() {
-                        err.with_note(fluent::parse_macro_expands_to_enum_variant).emit();
-                    }
+        self.collect_tokens(None, variant_attrs, ForceCollect::No, |this, variant_attrs| {
+            let vlo = this.token.span;
 
-                    this.bump();
-                    this.parse_delim_args()?;
+            let vis = this.parse_visibility(FollowedByType::No)?;
+            if !this.recover_nested_adt_item(kw::Enum)? {
+                return Ok((None, Trailing::No, UsePreAttrPos::No));
+            }
+            let ident = this.parse_field_ident("enum", vlo)?;
 
-                    return Ok((None, Trailing::from(this.token == token::Comma)));
+            if this.token == token::Not {
+                if let Err(err) = this.unexpected() {
+                    err.with_note(fluent::parse_macro_expands_to_enum_variant).emit();
                 }
 
-                let struct_def = if this.check(&token::OpenDelim(Delimiter::Brace)) {
-                    // Parse a struct variant.
-                    let (fields, recovered) =
-                        match this.parse_record_struct_body("struct", ident.span, false) {
-                            Ok((fields, recovered)) => (fields, recovered),
-                            Err(mut err) => {
-                                if this.token == token::Colon {
-                                    // We handle `enum` to `struct` suggestion in the caller.
-                                    return Err(err);
-                                }
-                                this.eat_to_tokens(&[&token::CloseDelim(Delimiter::Brace)]);
-                                this.bump(); // }
-                                err.span_label(span, "while parsing this enum");
-                                err.help(help);
-                                let guar = err.emit();
-                                (thin_vec![], Recovered::Yes(guar))
-                            }
-                        };
-                    VariantData::Struct { fields, recovered: recovered.into() }
-                } else if this.check(&token::OpenDelim(Delimiter::Parenthesis)) {
-                    let body = match this.parse_tuple_struct_body() {
-                        Ok(body) => body,
+                this.bump();
+                this.parse_delim_args()?;
+
+                return Ok((None, Trailing::from(this.token == token::Comma), UsePreAttrPos::No));
+            }
+
+            let struct_def = if this.check(&token::OpenDelim(Delimiter::Brace)) {
+                // Parse a struct variant.
+                let (fields, recovered) =
+                    match this.parse_record_struct_body("struct", ident.span, false) {
+                        Ok((fields, recovered)) => (fields, recovered),
                         Err(mut err) => {
                             if this.token == token::Colon {
                                 // We handle `enum` to `struct` suggestion in the caller.
                                 return Err(err);
                             }
-                            this.eat_to_tokens(&[&token::CloseDelim(Delimiter::Parenthesis)]);
-                            this.bump(); // )
+                            this.eat_to_tokens(&[&token::CloseDelim(Delimiter::Brace)]);
+                            this.bump(); // }
                             err.span_label(span, "while parsing this enum");
                             err.help(help);
-                            err.emit();
-                            thin_vec![]
+                            let guar = err.emit();
+                            (thin_vec![], Recovered::Yes(guar))
                         }
                     };
-                    VariantData::Tuple(body, DUMMY_NODE_ID)
-                } else {
-                    VariantData::Unit(DUMMY_NODE_ID)
+                VariantData::Struct { fields, recovered: recovered.into() }
+            } else if this.check(&token::OpenDelim(Delimiter::Parenthesis)) {
+                let body = match this.parse_tuple_struct_body() {
+                    Ok(body) => body,
+                    Err(mut err) => {
+                        if this.token == token::Colon {
+                            // We handle `enum` to `struct` suggestion in the caller.
+                            return Err(err);
+                        }
+                        this.eat_to_tokens(&[&token::CloseDelim(Delimiter::Parenthesis)]);
+                        this.bump(); // )
+                        err.span_label(span, "while parsing this enum");
+                        err.help(help);
+                        err.emit();
+                        thin_vec![]
+                    }
                 };
+                VariantData::Tuple(body, DUMMY_NODE_ID)
+            } else {
+                VariantData::Unit(DUMMY_NODE_ID)
+            };
 
-                let disr_expr =
-                    if this.eat(&token::Eq) { Some(this.parse_expr_anon_const()?) } else { None };
+            let disr_expr =
+                if this.eat(&token::Eq) { Some(this.parse_expr_anon_const()?) } else { None };
 
-                let vr = ast::Variant {
-                    ident,
-                    vis,
-                    id: DUMMY_NODE_ID,
-                    attrs: variant_attrs,
-                    data: struct_def,
-                    disr_expr,
-                    span: vlo.to(this.prev_token.span),
-                    is_placeholder: false,
-                };
+            let vr = ast::Variant {
+                ident,
+                vis,
+                id: DUMMY_NODE_ID,
+                attrs: variant_attrs,
+                data: struct_def,
+                disr_expr,
+                span: vlo.to(this.prev_token.span),
+                is_placeholder: false,
+            };
 
-                Ok((Some(vr), Trailing::from(this.token == token::Comma)))
-            },
-        )
+            Ok((Some(vr), Trailing::from(this.token == token::Comma), UsePreAttrPos::No))
+        })
         .map_err(|mut err| {
             err.help(help);
             err
@@ -1777,7 +1775,7 @@ impl<'a> Parser<'a> {
         // Unit like structs are handled in parse_item_struct function
         self.parse_paren_comma_seq(|p| {
             let attrs = p.parse_outer_attributes()?;
-            p.collect_tokens_trailing_token(attrs, ForceCollect::No, |p, attrs| {
+            p.collect_tokens(None, attrs, ForceCollect::No, |p, attrs| {
                 let mut snapshot = None;
                 if p.is_vcs_conflict_marker(&TokenKind::BinOp(token::Shl), &TokenKind::Lt) {
                     // Account for `<<<<<<<` diff markers. We can't proactively error here because
@@ -1816,6 +1814,7 @@ impl<'a> Parser<'a> {
                         is_placeholder: false,
                     },
                     Trailing::from(p.token == token::Comma),
+                    UsePreAttrPos::No,
                 ))
             })
         })
@@ -1827,11 +1826,11 @@ impl<'a> Parser<'a> {
         self.recover_vcs_conflict_marker();
         let attrs = self.parse_outer_attributes()?;
         self.recover_vcs_conflict_marker();
-        self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
+        self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
             let lo = this.token.span;
             let vis = this.parse_visibility(FollowedByType::No)?;
             this.parse_single_struct_field(adt_ty, lo, vis, attrs)
-                .map(|field| (field, Trailing::No))
+                .map(|field| (field, Trailing::No, UsePreAttrPos::No))
         })
     }
 
@@ -2806,12 +2805,12 @@ impl<'a> Parser<'a> {
     fn parse_param_general(&mut self, req_name: ReqName, first_param: bool) -> PResult<'a, Param> {
         let lo = self.token.span;
         let attrs = self.parse_outer_attributes()?;
-        self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
+        self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
             // Possibly parse `self`. Recover if we parsed it and it wasn't allowed here.
             if let Some(mut param) = this.parse_self_param()? {
                 param.attrs = attrs;
                 let res = if first_param { Ok(param) } else { this.recover_bad_self_param(param) };
-                return Ok((res?, Trailing::No));
+                return Ok((res?, Trailing::No, UsePreAttrPos::No));
             }
 
             let is_name_required = match this.token.kind {
@@ -2827,7 +2826,7 @@ impl<'a> Parser<'a> {
                         this.parameter_without_type(&mut err, pat, is_name_required, first_param)
                     {
                         let guar = err.emit();
-                        Ok((dummy_arg(ident, guar), Trailing::No))
+                        Ok((dummy_arg(ident, guar), Trailing::No, UsePreAttrPos::No))
                     } else {
                         Err(err)
                     };
@@ -2871,6 +2870,7 @@ impl<'a> Parser<'a> {
             Ok((
                 Param { attrs, id: ast::DUMMY_NODE_ID, is_placeholder: false, pat, span, ty },
                 Trailing::No,
+                UsePreAttrPos::No,
             ))
         })
     }
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 6a3c4a0c106ad..61e3fa2e6c560 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -14,7 +14,7 @@ use std::assert_matches::debug_assert_matches;
 use std::ops::Range;
 use std::{fmt, mem, slice};
 
-use attr_wrapper::AttrWrapper;
+use attr_wrapper::{AttrWrapper, UsePreAttrPos};
 pub use diagnostics::AttemptLocalParseRecovery;
 pub(crate) use expr::ForbiddenLetReason;
 pub(crate) use item::FnParseMode;
@@ -254,7 +254,7 @@ enum Capturing {
     Yes,
 }
 
-// This state is used by `Parser::collect_tokens_trailing_token`.
+// This state is used by `Parser::collect_tokens`.
 #[derive(Clone, Debug)]
 struct CaptureState {
     capturing: Capturing,
@@ -466,8 +466,8 @@ impl<'a> Parser<'a> {
         parser.bump();
 
         // Change this from 1 back to 0 after the bump. This eases debugging of
-        // `Parser::collect_tokens_trailing_token` nicer because it makes the
-        // token positions 0-indexed which is nicer than 1-indexed.
+        // `Parser::collect_tokens` because 0-indexed token positions are nicer
+        // than 1-indexed token positions.
         parser.num_bump_calls = 0;
 
         parser
@@ -1553,11 +1553,9 @@ impl<'a> Parser<'a> {
     ) -> PResult<'a, R> {
         // The only reason to call `collect_tokens_no_attrs` is if you want tokens, so use
         // `ForceCollect::Yes`
-        self.collect_tokens_trailing_token(
-            AttrWrapper::empty(),
-            ForceCollect::Yes,
-            |this, _attrs| Ok((f(this)?, Trailing::No)),
-        )
+        self.collect_tokens(None, AttrWrapper::empty(), ForceCollect::Yes, |this, _attrs| {
+            Ok((f(this)?, Trailing::No, UsePreAttrPos::No))
+        })
     }
 
     /// `::{` or `::*`
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 164be7c94963e..eb9a957032f6c 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -13,7 +13,7 @@ use rustc_span::symbol::{kw, sym, Ident};
 use rustc_span::{BytePos, ErrorGuaranteed, Span};
 use thin_vec::{thin_vec, ThinVec};
 
-use super::{ForceCollect, Parser, PathStyle, Restrictions, Trailing};
+use super::{ForceCollect, Parser, PathStyle, Restrictions, Trailing, UsePreAttrPos};
 use crate::errors::{
     self, AmbiguousRangePattern, DotDotDotForRemainingFields, DotDotDotRangeToPatternNotAllowed,
     DotDotDotRestPattern, EnumPatternInsteadOfIdentifier, ExpectedBindingLeftOfAt,
@@ -403,7 +403,7 @@ impl<'a> Parser<'a> {
 
             // Parse an associative expression such as `+ expr`, `% expr`, ...
             // Assignements, ranges and `|` are disabled by [`Restrictions::IS_PAT`].
-            if let Ok(expr) =
+            if let Ok((expr, _)) =
                 snapshot.parse_expr_assoc_rest_with(0, false, expr).map_err(|err| err.cancel())
             {
                 // We got a valid expression.
@@ -1302,24 +1302,23 @@ impl<'a> Parser<'a> {
                 }
             }
 
-            let field =
-                self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
-                    let field = match this.parse_pat_field(lo, attrs) {
-                        Ok(field) => Ok(field),
-                        Err(err) => {
-                            if let Some(delayed_err) = delayed_err.take() {
-                                delayed_err.emit();
-                            }
-                            return Err(err);
+            let field = self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
+                let field = match this.parse_pat_field(lo, attrs) {
+                    Ok(field) => Ok(field),
+                    Err(err) => {
+                        if let Some(delayed_err) = delayed_err.take() {
+                            delayed_err.emit();
                         }
-                    }?;
-                    ate_comma = this.eat(&token::Comma);
+                        return Err(err);
+                    }
+                }?;
+                ate_comma = this.eat(&token::Comma);
 
-                    last_non_comma_dotdot_span = Some(this.prev_token.span);
+                last_non_comma_dotdot_span = Some(this.prev_token.span);
 
-                    // We just ate a comma, so there's no need to capture a trailing token.
-                    Ok((field, Trailing::No))
-                })?;
+                // We just ate a comma, so there's no need to capture a trailing token.
+                Ok((field, Trailing::No, UsePreAttrPos::No))
+            })?;
 
             fields.push(field)
         }
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index 007d760aba392..b58f398efede2 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -913,7 +913,7 @@ impl<'a> Parser<'a> {
             let snapshot = self.create_snapshot_for_diagnostic();
             let attrs = self.parse_outer_attributes()?;
             match self.parse_expr_res(Restrictions::CONST_EXPR, attrs) {
-                Ok(expr) => {
+                Ok((expr, _)) => {
                     return Ok(Some(self.dummy_const_arg_needs_braces(
                         self.dcx().struct_span_err(expr.span, "invalid const generic expression"),
                         expr.span,
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index ac6a459060aa8..69044192780bc 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -21,7 +21,7 @@ use super::pat::{PatternLocation, RecoverComma};
 use super::path::PathStyle;
 use super::{
     AttrWrapper, BlockMode, FnParseMode, ForceCollect, Parser, Restrictions, SemiColonMode,
-    Trailing,
+    Trailing, UsePreAttrPos,
 };
 use crate::errors::MalformedLoopLabel;
 use crate::{errors, maybe_whole};
@@ -46,6 +46,7 @@ impl<'a> Parser<'a> {
         capture_semi: bool,
         force_collect: ForceCollect,
     ) -> PResult<'a, Option<Stmt>> {
+        let pre_attr_pos = self.collect_pos();
         let attrs = self.parse_outer_attributes()?;
         let lo = self.token.span;
 
@@ -66,11 +67,15 @@ impl<'a> Parser<'a> {
         }
 
         Ok(Some(if self.token.is_keyword(kw::Let) {
-            self.collect_tokens_trailing_token(attrs, force_collect, |this, attrs| {
+            self.collect_tokens(None, attrs, force_collect, |this, attrs| {
                 this.expect_keyword(kw::Let)?;
                 let local = this.parse_local(attrs)?;
                 let trailing = Trailing::from(capture_semi && this.token == token::Semi);
-                Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), trailing))
+                Ok((
+                    this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)),
+                    trailing,
+                    UsePreAttrPos::No,
+                ))
             })?
         } else if self.is_kw_followed_by_ident(kw::Mut) && self.may_recover() {
             self.recover_stmt_local_after_let(
@@ -104,10 +109,18 @@ impl<'a> Parser<'a> {
             // or `auto trait` items. We aim to parse an arbitrary path `a::b` but not something
             // that starts like a path (1 token), but it fact not a path.
             // Also, we avoid stealing syntax from `parse_item_`.
-            let stmt = self.collect_tokens_trailing_token(
+            //
+            // `UsePreAttrPos::Yes` here means the attribute belongs unconditionally to the
+            // expression, not the statement. (But the statement attributes/tokens are obtained
+            // from the expression anyway, because `Stmt` delegates `HasAttrs`/`HasTokens` to
+            // the things within `StmtKind`.)
+            let stmt = self.collect_tokens(
+                Some(pre_attr_pos),
                 AttrWrapper::empty(),
                 force_collect,
-                |this, _empty_attrs| Ok((this.parse_stmt_path_start(lo, attrs)?, Trailing::No)),
+                |this, _empty_attrs| {
+                    Ok((this.parse_stmt_path_start(lo, attrs)?, Trailing::No, UsePreAttrPos::Yes))
+                },
             );
             match stmt {
                 Ok(stmt) => stmt,
@@ -129,12 +142,15 @@ impl<'a> Parser<'a> {
             self.error_outer_attrs(attrs);
             self.mk_stmt(lo, StmtKind::Empty)
         } else if self.token != token::CloseDelim(Delimiter::Brace) {
-            // Remainder are line-expr stmts.
-            let e = self.collect_tokens_trailing_token(
+            // Remainder are line-expr stmts. This is similar to the `parse_stmt_path_start` case
+            // above.
+            let e = self.collect_tokens(
+                Some(pre_attr_pos),
                 AttrWrapper::empty(),
                 force_collect,
                 |this, _empty_attrs| {
-                    Ok((this.parse_expr_res(Restrictions::STMT_EXPR, attrs)?, Trailing::No))
+                    let (expr, _) = this.parse_expr_res(Restrictions::STMT_EXPR, attrs)?;
+                    Ok((expr, Trailing::No, UsePreAttrPos::Yes))
                 },
             )?;
             if matches!(e.kind, ExprKind::Assign(..)) && self.eat_keyword(kw::Else) {
@@ -151,12 +167,16 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_stmt_path_start(&mut self, lo: Span, attrs: AttrWrapper) -> PResult<'a, Stmt> {
-        let stmt = self.collect_tokens_trailing_token(attrs, ForceCollect::No, |this, attrs| {
+        let stmt = self.collect_tokens(None, attrs, ForceCollect::No, |this, attrs| {
             let path = this.parse_path(PathStyle::Expr)?;
 
             if this.eat(&token::Not) {
                 let stmt_mac = this.parse_stmt_mac(lo, attrs, path)?;
-                return Ok((stmt_mac, Trailing::from(this.token == token::Semi)));
+                return Ok((
+                    stmt_mac,
+                    Trailing::from(this.token == token::Semi),
+                    UsePreAttrPos::No,
+                ));
             }
 
             let expr = if this.eat(&token::OpenDelim(Delimiter::Brace)) {
@@ -170,13 +190,17 @@ impl<'a> Parser<'a> {
                 this.parse_expr_dot_or_call_with(attrs, expr, lo)
             })?;
             // `DUMMY_SP` will get overwritten later in this function
-            Ok((this.mk_stmt(rustc_span::DUMMY_SP, StmtKind::Expr(expr)), Trailing::No))
+            Ok((
+                this.mk_stmt(rustc_span::DUMMY_SP, StmtKind::Expr(expr)),
+                Trailing::No,
+                UsePreAttrPos::No,
+            ))
         })?;
 
         if let StmtKind::Expr(expr) = stmt.kind {
-            // Perform this outside of the `collect_tokens_trailing_token` closure,
-            // since our outer attributes do not apply to this part of the expression
-            let expr = self.with_res(Restrictions::STMT_EXPR, |this| {
+            // Perform this outside of the `collect_tokens` closure, since our
+            // outer attributes do not apply to this part of the expression.
+            let (expr, _) = self.with_res(Restrictions::STMT_EXPR, |this| {
                 this.parse_expr_assoc_rest_with(0, true, expr)
             })?;
             Ok(self.mk_stmt(lo.to(self.prev_token.span), StmtKind::Expr(expr)))
@@ -210,7 +234,7 @@ impl<'a> Parser<'a> {
             let e = self.mk_expr(lo.to(hi), ExprKind::MacCall(mac));
             let e = self.maybe_recover_from_bad_qpath(e)?;
             let e = self.parse_expr_dot_or_call_with(attrs, e, lo)?;
-            let e = self.parse_expr_assoc_rest_with(0, false, e)?;
+            let (e, _) = self.parse_expr_assoc_rest_with(0, false, e)?;
             StmtKind::Expr(e)
         };
         Ok(self.mk_stmt(lo.to(hi), kind))
@@ -240,10 +264,14 @@ impl<'a> Parser<'a> {
         subdiagnostic: fn(Span) -> errors::InvalidVariableDeclarationSub,
         force_collect: ForceCollect,
     ) -> PResult<'a, Stmt> {
-        let stmt = self.collect_tokens_trailing_token(attrs, force_collect, |this, attrs| {
+        let stmt = self.collect_tokens(None, attrs, force_collect, |this, attrs| {
             let local = this.parse_local(attrs)?;
             // FIXME - maybe capture semicolon in recovery?
-            Ok((this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)), Trailing::No))
+            Ok((
+                this.mk_stmt(lo.to(this.prev_token.span), StmtKind::Let(local)),
+                Trailing::No,
+                UsePreAttrPos::No,
+            ))
         })?;
         self.dcx()
             .emit_err(errors::InvalidVariableDeclaration { span: lo, sub: subdiagnostic(lo) });
diff --git a/tests/ui/attributes/assoc-expr.rs b/tests/ui/attributes/assoc-expr.rs
new file mode 100644
index 0000000000000..f39557d2ef017
--- /dev/null
+++ b/tests/ui/attributes/assoc-expr.rs
@@ -0,0 +1,42 @@
+//@ check-pass
+// This test triggered an assertion failure in token collection due to
+// mishandling of attributes on associative expressions.
+
+#![feature(cfg_eval)]
+#![feature(rustc_attrs)]
+#![feature(stmt_expr_attributes)]
+#![allow(internal_features)]
+
+fn main() {}
+
+#[cfg_eval]
+struct Foo1(
+    [ bool; {
+        let _x = 30;
+        #[cfg_attr(unix, rustc_dummy(aa))] 1
+    } ]
+);
+
+#[cfg_eval]
+struct Foo12(
+    [ bool; {
+        let _x = 30;
+        #[cfg_attr(unix, rustc_dummy(bb))] 1 + 2
+    } ]
+);
+
+#[cfg_eval]
+struct Foox(
+    [ bool; {
+        let _x = 30;
+        #[cfg_attr(unix, rustc_dummy(cc))] _x
+    } ]
+);
+
+#[cfg_eval]
+struct Foox2(
+    [ bool; {
+        let _x = 30;
+        #[cfg_attr(unix, rustc_dummy(dd))] _x + 2
+    } ]
+);
diff --git a/tests/ui/macros/stringify.rs b/tests/ui/macros/stringify.rs
index a8b73ac7e158c..37409dd066d5d 100644
--- a/tests/ui/macros/stringify.rs
+++ b/tests/ui/macros/stringify.rs
@@ -51,14 +51,6 @@ macro_rules! c1 {
     };
 }
 
-// FIXME: temporary
-macro_rules! c2 {
-    ($frag:ident, [$($tt:tt)*], $s1:literal, $s2:literal) => {
-        assert_eq!($frag!($($tt)*), $s1);
-        assert_eq!(stringify!($($tt)*), $s2);
-    };
-}
-
 #[test]
 fn test_block() {
     c1!(block, [ {} ], "{}");
@@ -344,10 +336,10 @@ fn test_expr() {
     // Ones involving attributes.
     c1!(expr, [ #[aa] 1 ], "#[aa] 1");
     c1!(expr, [ #[aa] #[bb] x ], "#[aa] #[bb] x");
-    c2!(expr, [ #[aa] 1 + 2 ], "1 + 2", "#[aa] 1 + 2"); // FIXME
-    c2!(expr, [ #[aa] x + 2 ], "x + 2", "#[aa] x + 2"); // FIXME
-    c2!(expr, [ #[aa] 1 / #[bb] 2 ], "1 / #[bb] 2", "#[aa] 1 / #[bb] 2"); // FIXME
-    c2!(expr, [ #[aa] x / #[bb] 2 ], "x / #[bb] 2", "#[aa] x / #[bb] 2"); // FIXME
+    c1!(expr, [ #[aa] 1 + 2 ], "#[aa] 1 + 2");
+    c1!(expr, [ #[aa] x + 2 ], "#[aa] x + 2");
+    c1!(expr, [ #[aa] 1 / #[bb] 2 ], "#[aa] 1 / #[bb] 2");
+    c1!(expr, [ #[aa] x / #[bb] 2 ], "#[aa] x / #[bb] 2");
     c1!(expr, [ 1 << #[bb] 2 ], "1 << #[bb] 2");
     c1!(expr, [ x << #[bb] 2 ], "x << #[bb] 2");
     c1!(expr, [ #[aa] (1 + 2) ], "#[aa] (1 + 2)");
@@ -659,10 +651,10 @@ fn test_stmt() {
     // Ones involving attributes.
     c1!(stmt, [ #[aa] 1 ], "#[aa] 1");
     c1!(stmt, [ #[aa] #[bb] x ], "#[aa] #[bb] x");
-    c2!(stmt, [ #[aa] 1 as u32 ], "1 as u32", "#[aa] 1 as u32"); // FIXME
-    c2!(stmt, [ #[aa] x as u32 ], "x as u32", "#[aa] x as u32"); // FIXME
-    c2!(stmt, [ #[aa] 1 .. #[bb] 2 ], "1 .. #[bb] 2", "#[aa] 1 .. #[bb] 2"); // FIXME
-    c2!(stmt, [ #[aa] x .. #[bb] 2 ], "x .. #[bb] 2", "#[aa] x .. #[bb] 2"); // FIXME
+    c1!(stmt, [ #[aa] 1 as u32 ], "#[aa] 1 as u32");
+    c1!(stmt, [ #[aa] x as u32 ], "#[aa] x as u32");
+    c1!(stmt, [ #[aa] 1 .. #[bb] 2 ], "#[aa] 1 .. #[bb] 2");
+    c1!(stmt, [ #[aa] x .. #[bb] 2 ], "#[aa] x .. #[bb] 2");
     c1!(stmt, [ 1 || #[bb] 2 ], "1 || #[bb] 2");
     c1!(stmt, [ x || #[bb] 2 ], "x || #[bb] 2");
     c1!(stmt, [ #[aa] (1 + 2) ], "#[aa] (1 + 2)");

From cd2b0309cc948a54a7bdbc3050b0d7d6b0826f93 Mon Sep 17 00:00:00 2001
From: Jaic1 <506933131@qq.com>
Date: Tue, 13 Aug 2024 16:21:58 +0800
Subject: [PATCH 319/685] Special-case alias ty in `try_from_lit`

---
 compiler/rustc_middle/src/ty/consts.rs                        | 4 ++++
 .../{crashes => ui/const-generics/adt_const_params}/116308.rs | 4 +++-
 2 files changed, 7 insertions(+), 1 deletion(-)
 rename tests/{crashes => ui/const-generics/adt_const_params}/116308.rs (81%)

diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index c380019e63f47..e373292741b90 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -305,6 +305,10 @@ impl<'tcx> Const<'tcx> {
             // mir.
             match tcx.at(expr.span).lit_to_const(lit_input) {
                 Ok(c) => return Some(c),
+                Err(_) if lit_input.ty.has_aliases() => {
+                    // allow the `ty` to be an alias type, though we cannot handle it here
+                    return None;
+                }
                 Err(e) => {
                     tcx.dcx().span_delayed_bug(
                         expr.span,
diff --git a/tests/crashes/116308.rs b/tests/ui/const-generics/adt_const_params/116308.rs
similarity index 81%
rename from tests/crashes/116308.rs
rename to tests/ui/const-generics/adt_const_params/116308.rs
index cb96c80d79bdc..9ea7022e29c8a 100644
--- a/tests/crashes/116308.rs
+++ b/tests/ui/const-generics/adt_const_params/116308.rs
@@ -1,6 +1,8 @@
-//@ known-bug: #116308
+//@ check-pass
 #![feature(adt_const_params)]
 
+// Regression test for #116308
+
 pub trait Identity {
     type Identity;
 }

From 26fae1ed1c7a5e614eae684fa806a1cc4ea0b527 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?=
 <jieyouxu@outlook.com>
Date: Sun, 11 Aug 2024 15:37:49 +0000
Subject: [PATCH 320/685] bootstrap: fix trying to modify file times on
 read-only file on Windows

---
 src/bootstrap/src/core/download.rs       |  4 +---
 src/bootstrap/src/lib.rs                 | 15 +++++++-------
 src/bootstrap/src/utils/helpers.rs       | 12 ++++++++++++
 src/bootstrap/src/utils/helpers/tests.rs | 25 +++++++++++++++++++++++-
 4 files changed, 45 insertions(+), 11 deletions(-)

diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index fd85650bc5620..0e44bd287c06d 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -703,9 +703,7 @@ download-rustc = false
             let file_times = fs::FileTimes::new().set_accessed(now).set_modified(now);
 
             let llvm_config = llvm_root.join("bin").join(exe("llvm-config", self.build));
-            let llvm_config_file = t!(File::options().write(true).open(llvm_config));
-
-            t!(llvm_config_file.set_times(file_times));
+            t!(crate::utils::helpers::set_file_times(llvm_config, file_times));
 
             if self.should_fix_bins_and_dylibs() {
                 let llvm_lib = llvm_root.join("lib");
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 1e2e90105a9a9..784519a20a2d8 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -37,7 +37,9 @@ use crate::core::builder;
 use crate::core::builder::{Builder, Kind};
 use crate::core::config::{flags, DryRun, LldMode, LlvmLibunwind, Target, TargetSelection};
 use crate::utils::exec::{command, BehaviorOnFailure, BootstrapCommand, CommandOutput, OutputMode};
-use crate::utils::helpers::{self, dir_is_empty, exe, libdir, mtime, output, symlink_dir};
+use crate::utils::helpers::{
+    self, dir_is_empty, exe, libdir, mtime, output, set_file_times, symlink_dir,
+};
 
 mod core;
 mod utils;
@@ -1792,21 +1794,20 @@ Executed at: {executed_at}"#,
             }
         }
         if let Ok(()) = fs::hard_link(&src, dst) {
-            // Attempt to "easy copy" by creating a hard link
-            // (symlinks don't work on windows), but if that fails
-            // just fall back to a slow `copy` operation.
+            // Attempt to "easy copy" by creating a hard link (symlinks are priviledged on windows),
+            // but if that fails just fall back to a slow `copy` operation.
         } else {
             if let Err(e) = fs::copy(&src, dst) {
                 panic!("failed to copy `{}` to `{}`: {}", src.display(), dst.display(), e)
             }
             t!(fs::set_permissions(dst, metadata.permissions()));
 
+            // Restore file times because changing permissions on e.g. Linux using `chmod` can cause
+            // file access time to change.
             let file_times = fs::FileTimes::new()
                 .set_accessed(t!(metadata.accessed()))
                 .set_modified(t!(metadata.modified()));
-
-            let dst_file = t!(fs::File::open(dst));
-            t!(dst_file.set_times(file_times));
+            t!(set_file_times(dst, file_times));
         }
     }
 
diff --git a/src/bootstrap/src/utils/helpers.rs b/src/bootstrap/src/utils/helpers.rs
index 65e75f114bbeb..a856c99ff55a5 100644
--- a/src/bootstrap/src/utils/helpers.rs
+++ b/src/bootstrap/src/utils/helpers.rs
@@ -544,3 +544,15 @@ pub fn get_closest_merge_base_commit(
 
     Ok(output_result(git.as_command_mut())?.trim().to_owned())
 }
+
+/// Sets the file times for a given file at `path`.
+pub fn set_file_times<P: AsRef<Path>>(path: P, times: fs::FileTimes) -> io::Result<()> {
+    // Windows requires file to be writable to modify file times. But on Linux CI the file does not
+    // need to be writable to modify file times and might be read-only.
+    let f = if cfg!(windows) {
+        fs::File::options().write(true).open(path)?
+    } else {
+        fs::File::open(path)?
+    };
+    f.set_times(times)
+}
diff --git a/src/bootstrap/src/utils/helpers/tests.rs b/src/bootstrap/src/utils/helpers/tests.rs
index 103c4d26a1854..86016a91e49b1 100644
--- a/src/bootstrap/src/utils/helpers/tests.rs
+++ b/src/bootstrap/src/utils/helpers/tests.rs
@@ -3,7 +3,8 @@ use std::io::Write;
 use std::path::PathBuf;
 
 use crate::utils::helpers::{
-    check_cfg_arg, extract_beta_rev, hex_encode, make, program_out_of_date, symlink_dir,
+    check_cfg_arg, extract_beta_rev, hex_encode, make, program_out_of_date, set_file_times,
+    symlink_dir,
 };
 use crate::{Config, Flags};
 
@@ -92,3 +93,25 @@ fn test_symlink_dir() {
     #[cfg(not(windows))]
     fs::remove_file(link_path).unwrap();
 }
+
+#[test]
+fn test_set_file_times_sanity_check() {
+    let config =
+        Config::parse(Flags::parse(&["check".to_owned(), "--config=/does/not/exist".to_owned()]));
+    let tempfile = config.tempdir().join(".tmp-file");
+
+    {
+        File::create(&tempfile).unwrap().write_all(b"dummy value").unwrap();
+        assert!(tempfile.exists());
+    }
+
+    // This might only fail on Windows (if file is default read-only then we try to modify file
+    // times).
+    let unix_epoch = std::time::SystemTime::UNIX_EPOCH;
+    let target_time = fs::FileTimes::new().set_accessed(unix_epoch).set_modified(unix_epoch);
+    set_file_times(&tempfile, target_time).unwrap();
+
+    let found_metadata = fs::metadata(tempfile).unwrap();
+    assert_eq!(found_metadata.accessed().unwrap(), unix_epoch);
+    assert_eq!(found_metadata.modified().unwrap(), unix_epoch)
+}

From 368a4c6808c49baf5e03f9debeff3d53a013e968 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 3 Aug 2024 11:51:16 +0200
Subject: [PATCH 321/685] float to/from bits and classify: update comments
 regarding non-conformant hardware

---
 library/core/src/num/f128.rs                  | 110 +-----------
 library/core/src/num/f16.rs                   | 163 +++--------------
 library/core/src/num/f32.rs                   | 169 +++---------------
 library/core/src/num/f64.rs                   | 143 +++------------
 tests/ui/consts/const-float-bits-conv.rs      |  22 +++
 .../ui/consts/const-float-bits-reject-conv.rs |  68 -------
 .../const-float-bits-reject-conv.stderr       | 115 ------------
 7 files changed, 107 insertions(+), 683 deletions(-)
 delete mode 100644 tests/ui/consts/const-float-bits-reject-conv.rs
 delete mode 100644 tests/ui/consts/const-float-bits-reject-conv.stderr

diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 0c04f47fe7df1..38e69e7641ab4 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -290,7 +290,7 @@ impl f128 {
     #[inline]
     #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
     pub(crate) const fn abs_private(self) -> f128 {
-        // SAFETY: This transmutation is fine. Probably. For the reasons std is using it.
+        // SAFETY: This transmutation is fine just like in `to_bits`/`from_bits`.
         unsafe {
             mem::transmute::<u128, f128>(mem::transmute::<f128, u128>(self) & !Self::SIGN_MASK)
         }
@@ -439,22 +439,12 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
     pub const fn classify(self) -> FpCategory {
-        // Other float types cannot use a bitwise classify because they may suffer a variety
-        // of errors if the backend chooses to cast to different float types (x87). `f128` cannot
-        // fit into any other float types so this is not a concern, and we rely on bit patterns.
+        // Other float types suffer from various platform bugs that violate the usual IEEE semantics
+        // and also make bitwise classification not always work reliably. However, `f128` cannot fit
+        // into any other float types so this is not a concern, and we can rely on bit patterns.
 
-        // SAFETY: POD bitcast, same as in `to_bits`.
-        let bits = unsafe { mem::transmute::<f128, u128>(self) };
-        Self::classify_bits(bits)
-    }
-
-    /// This operates on bits, and only bits, so it can ignore concerns about weird FPUs.
-    /// FIXME(jubilee): In a just world, this would be the entire impl for classify,
-    /// plus a transmute. We do not live in a just world, but we can make it more so.
-    #[inline]
-    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
-    const fn classify_bits(b: u128) -> FpCategory {
-        match (b & Self::MAN_MASK, b & Self::EXP_MASK) {
+        let bits = self.to_bits();
+        match (bits & Self::MAN_MASK, bits & Self::EXP_MASK) {
             (0, Self::EXP_MASK) => FpCategory::Infinite,
             (_, Self::EXP_MASK) => FpCategory::Nan,
             (0, 0) => FpCategory::Zero,
@@ -922,48 +912,7 @@ impl f128 {
     #[must_use = "this returns the result of the operation, without modifying the original"]
     pub const fn to_bits(self) -> u128 {
         // SAFETY: `u128` is a plain old datatype so we can always transmute to it.
-        // ...sorta.
-        //
-        // It turns out that at runtime, it is possible for a floating point number
-        // to be subject to a floating point mode that alters nonzero subnormal numbers
-        // to zero on reads and writes, aka "denormals are zero" and "flush to zero".
-        //
-        // And, of course evaluating to a NaN value is fairly nondeterministic.
-        // More precisely: when NaN should be returned is knowable, but which NaN?
-        // So far that's defined by a combination of LLVM and the CPU, not Rust.
-        // This function, however, allows observing the bitstring of a NaN,
-        // thus introspection on CTFE.
-        //
-        // In order to preserve, at least for the moment, const-to-runtime equivalence,
-        // we reject any of these possible situations from happening.
-        #[inline]
-        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
-        const fn ct_f128_to_u128(ct: f128) -> u128 {
-            // FIXME(f16_f128): we should use `.classify()` like `f32` and `f64`, but that
-            // is not available on all platforms (needs `netf2` and `unordtf2`). So classify
-            // the bits instead.
-
-            // SAFETY: this is a POD transmutation
-            let bits = unsafe { mem::transmute::<f128, u128>(ct) };
-            match f128::classify_bits(bits) {
-                FpCategory::Nan => {
-                    panic!("const-eval error: cannot use f128::to_bits on a NaN")
-                }
-                FpCategory::Subnormal => {
-                    panic!("const-eval error: cannot use f128::to_bits on a subnormal number")
-                }
-                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => bits,
-            }
-        }
-
-        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
-        fn rt_f128_to_u128(x: f128) -> u128 {
-            // SAFETY: `u128` is a plain old datatype so we can always... uh...
-            // ...look, just pretend you forgot what you just read.
-            // Stability concerns.
-            unsafe { mem::transmute(x) }
-        }
-        intrinsics::const_eval_select((self,), ct_f128_to_u128, rt_f128_to_u128)
+        unsafe { mem::transmute(self) }
     }
 
     /// Raw transmutation from `u128`.
@@ -1011,49 +960,8 @@ impl f128 {
     #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
     pub const fn from_bits(v: u128) -> Self {
         // It turns out the safety issues with sNaN were overblown! Hooray!
-        // SAFETY: `u128` is a plain old datatype so we can always transmute from it
-        // ...sorta.
-        //
-        // It turns out that at runtime, it is possible for a floating point number
-        // to be subject to floating point modes that alter nonzero subnormal numbers
-        // to zero on reads and writes, aka "denormals are zero" and "flush to zero".
-        // This is not a problem usually, but at least one tier2 platform for Rust
-        // actually exhibits this behavior by default: thumbv7neon
-        // aka "the Neon FPU in AArch32 state"
-        //
-        // And, of course evaluating to a NaN value is fairly nondeterministic.
-        // More precisely: when NaN should be returned is knowable, but which NaN?
-        // So far that's defined by a combination of LLVM and the CPU, not Rust.
-        // This function, however, allows observing the bitstring of a NaN,
-        // thus introspection on CTFE.
-        //
-        // In order to preserve, at least for the moment, const-to-runtime equivalence,
-        // reject any of these possible situations from happening.
-        #[inline]
-        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
-        const fn ct_u128_to_f128(ct: u128) -> f128 {
-            match f128::classify_bits(ct) {
-                FpCategory::Subnormal => {
-                    panic!("const-eval error: cannot use f128::from_bits on a subnormal number")
-                }
-                FpCategory::Nan => {
-                    panic!("const-eval error: cannot use f128::from_bits on NaN")
-                }
-                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => {
-                    // SAFETY: It's not a frumious number
-                    unsafe { mem::transmute::<u128, f128>(ct) }
-                }
-            }
-        }
-
-        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
-        fn rt_u128_to_f128(x: u128) -> f128 {
-            // SAFETY: `u128` is a plain old datatype so we can always... uh...
-            // ...look, just pretend you forgot what you just read.
-            // Stability concerns.
-            unsafe { mem::transmute(x) }
-        }
-        intrinsics::const_eval_select((v,), ct_u128_to_f128, rt_u128_to_f128)
+        // SAFETY: `u128` is a plain old datatype so we can always transmute from it.
+        unsafe { mem::transmute(v) }
     }
 
     /// Returns the memory representation of this floating point number as a byte array in
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index e5b1148e19215..41bd34a270238 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -284,7 +284,7 @@ impl f16 {
     #[inline]
     #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
     pub(crate) const fn abs_private(self) -> f16 {
-        // SAFETY: This transmutation is fine. Probably. For the reasons std is using it.
+        // SAFETY: This transmutation is fine just like in `to_bits`/`from_bits`.
         unsafe { mem::transmute::<u16, f16>(mem::transmute::<f16, u16>(self) & !Self::SIGN_MASK) }
     }
 
@@ -426,15 +426,15 @@ impl f16 {
     pub const fn classify(self) -> FpCategory {
         // A previous implementation for f32/f64 tried to only use bitmask-based checks,
         // using `to_bits` to transmute the float to its bit repr and match on that.
-        // Unfortunately, floating point numbers can be much worse than that.
-        // This also needs to not result in recursive evaluations of `to_bits`.
+        // If we only cared about being "technically" correct, that's an entirely legit
+        // implementation.
         //
-
-        // Platforms without native support generally convert to `f32` to perform operations,
-        // and most of these platforms correctly round back to `f16` after each operation.
-        // However, some platforms have bugs where they keep the excess `f32` precision (e.g.
-        // WASM, see llvm/llvm-project#96437). This implementation makes a best-effort attempt
-        // to account for that excess precision.
+        // Unfortunately, there are platforms out there that do not correctly implement the IEEE
+        // float semantics Rust relies on: some hardware flushes denormals to zero, and some
+        // platforms convert to `f32` to perform operations without properly rounding back (e.g.
+        // WASM, see llvm/llvm-project#96437). These are platforms bugs, and Rust will misbehave on
+        // such platforms, but we can at least try to make things seem as sane as possible by being
+        // careful here.
         if self.is_infinite() {
             // Thus, a value may compare unequal to infinity, despite having a "full" exponent mask.
             FpCategory::Infinite
@@ -446,49 +446,20 @@ impl f16 {
             // as correctness requires avoiding equality tests that may be Subnormal == -0.0
             // because it may be wrong under "denormals are zero" and "flush to zero" modes.
             // Most of std's targets don't use those, but they are used for thumbv7neon.
-            // So, this does use bitpattern matching for the rest.
-
-            // SAFETY: f16 to u16 is fine. Usually.
-            // If classify has gotten this far, the value is definitely in one of these categories.
-            unsafe { f16::partial_classify(self) }
-        }
-    }
-
-    /// This doesn't actually return a right answer for NaN on purpose,
-    /// seeing as how it cannot correctly discern between a floating point NaN,
-    /// and some normal floating point numbers truncated from an x87 FPU.
-    ///
-    /// # Safety
-    ///
-    /// This requires making sure you call this function for values it answers correctly on,
-    /// otherwise it returns a wrong answer. This is not important for memory safety per se,
-    /// but getting floats correct is important for not accidentally leaking const eval
-    /// runtime-deviating logic which may or may not be acceptable.
-    #[inline]
-    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
-    const unsafe fn partial_classify(self) -> FpCategory {
-        // SAFETY: The caller is not asking questions for which this will tell lies.
-        let b = unsafe { mem::transmute::<f16, u16>(self) };
-        match (b & Self::MAN_MASK, b & Self::EXP_MASK) {
-            (0, Self::EXP_MASK) => FpCategory::Infinite,
-            (0, 0) => FpCategory::Zero,
-            (_, 0) => FpCategory::Subnormal,
-            _ => FpCategory::Normal,
-        }
-    }
-
-    /// This operates on bits, and only bits, so it can ignore concerns about weird FPUs.
-    /// FIXME(jubilee): In a just world, this would be the entire impl for classify,
-    /// plus a transmute. We do not live in a just world, but we can make it more so.
-    #[inline]
-    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
-    const fn classify_bits(b: u16) -> FpCategory {
-        match (b & Self::MAN_MASK, b & Self::EXP_MASK) {
-            (0, Self::EXP_MASK) => FpCategory::Infinite,
-            (_, Self::EXP_MASK) => FpCategory::Nan,
-            (0, 0) => FpCategory::Zero,
-            (_, 0) => FpCategory::Subnormal,
-            _ => FpCategory::Normal,
+            // So, this does use bitpattern matching for the rest. On x87, due to the incorrect
+            // float codegen on this hardware, this doesn't actually return a right answer for NaN
+            // because it cannot correctly discern between a floating point NaN, and some normal
+            // floating point numbers truncated from an x87 FPU -- but we took care of NaN above, so
+            // we are fine.
+            // FIXME(jubilee): This probably could at least answer things correctly for Infinity,
+            // like the f64 version does, but I need to run more checks on how things go on x86.
+            // I fear losing mantissa data that would have answered that differently.
+            let b = self.to_bits();
+            match (b & Self::MAN_MASK, b & Self::EXP_MASK) {
+                (0, 0) => FpCategory::Zero,
+                (_, 0) => FpCategory::Subnormal,
+                _ => FpCategory::Normal,
+            }
         }
     }
 
@@ -952,48 +923,7 @@ impl f16 {
     #[must_use = "this returns the result of the operation, without modifying the original"]
     pub const fn to_bits(self) -> u16 {
         // SAFETY: `u16` is a plain old datatype so we can always transmute to it.
-        // ...sorta.
-        //
-        // It turns out that at runtime, it is possible for a floating point number
-        // to be subject to a floating point mode that alters nonzero subnormal numbers
-        // to zero on reads and writes, aka "denormals are zero" and "flush to zero".
-        //
-        // And, of course evaluating to a NaN value is fairly nondeterministic.
-        // More precisely: when NaN should be returned is knowable, but which NaN?
-        // So far that's defined by a combination of LLVM and the CPU, not Rust.
-        // This function, however, allows observing the bitstring of a NaN,
-        // thus introspection on CTFE.
-        //
-        // In order to preserve, at least for the moment, const-to-runtime equivalence,
-        // we reject any of these possible situations from happening.
-        #[inline]
-        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
-        const fn ct_f16_to_u16(ct: f16) -> u16 {
-            // FIXME(f16_f128): we should use `.classify()` like `f32` and `f64`, but we don't yet
-            // want to rely on that on all platforms because it is nondeterministic (e.g. x86 has
-            // convention discrepancies calling intrinsics). So just classify the bits instead.
-
-            // SAFETY: this is a POD transmutation
-            let bits = unsafe { mem::transmute::<f16, u16>(ct) };
-            match f16::classify_bits(bits) {
-                FpCategory::Nan => {
-                    panic!("const-eval error: cannot use f16::to_bits on a NaN")
-                }
-                FpCategory::Subnormal => {
-                    panic!("const-eval error: cannot use f16::to_bits on a subnormal number")
-                }
-                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => bits,
-            }
-        }
-
-        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
-        fn rt_f16_to_u16(x: f16) -> u16 {
-            // SAFETY: `u16` is a plain old datatype so we can always... uh...
-            // ...look, just pretend you forgot what you just read.
-            // Stability concerns.
-            unsafe { mem::transmute(x) }
-        }
-        intrinsics::const_eval_select((self,), ct_f16_to_u16, rt_f16_to_u16)
+        unsafe { mem::transmute(self) }
     }
 
     /// Raw transmutation from `u16`.
@@ -1040,49 +970,8 @@ impl f16 {
     #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
     pub const fn from_bits(v: u16) -> Self {
         // It turns out the safety issues with sNaN were overblown! Hooray!
-        // SAFETY: `u16` is a plain old datatype so we can always transmute from it
-        // ...sorta.
-        //
-        // It turns out that at runtime, it is possible for a floating point number
-        // to be subject to floating point modes that alter nonzero subnormal numbers
-        // to zero on reads and writes, aka "denormals are zero" and "flush to zero".
-        // This is not a problem usually, but at least one tier2 platform for Rust
-        // actually exhibits this behavior by default: thumbv7neon
-        // aka "the Neon FPU in AArch32 state"
-        //
-        // And, of course evaluating to a NaN value is fairly nondeterministic.
-        // More precisely: when NaN should be returned is knowable, but which NaN?
-        // So far that's defined by a combination of LLVM and the CPU, not Rust.
-        // This function, however, allows observing the bitstring of a NaN,
-        // thus introspection on CTFE.
-        //
-        // In order to preserve, at least for the moment, const-to-runtime equivalence,
-        // reject any of these possible situations from happening.
-        #[inline]
-        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
-        const fn ct_u16_to_f16(ct: u16) -> f16 {
-            match f16::classify_bits(ct) {
-                FpCategory::Subnormal => {
-                    panic!("const-eval error: cannot use f16::from_bits on a subnormal number")
-                }
-                FpCategory::Nan => {
-                    panic!("const-eval error: cannot use f16::from_bits on NaN")
-                }
-                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => {
-                    // SAFETY: It's not a frumious number
-                    unsafe { mem::transmute::<u16, f16>(ct) }
-                }
-            }
-        }
-
-        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
-        fn rt_u16_to_f16(x: u16) -> f16 {
-            // SAFETY: `u16` is a plain old datatype so we can always... uh...
-            // ...look, just pretend you forgot what you just read.
-            // Stability concerns.
-            unsafe { mem::transmute(x) }
-        }
-        intrinsics::const_eval_select((v,), ct_u16_to_f16, rt_u16_to_f16)
+        // SAFETY: `u16` is a plain old datatype so we can always transmute from it.
+        unsafe { mem::transmute(v) }
     }
 
     /// Returns the memory representation of this floating point number as a byte array in
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index 7710e23edf0ba..719727e2f1e0a 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -529,7 +529,7 @@ impl f32 {
     #[inline]
     #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
     pub(crate) const fn abs_private(self) -> f32 {
-        // SAFETY: This transmutation is fine. Probably. For the reasons std is using it.
+        // SAFETY: This transmutation is fine just like in `to_bits`/`from_bits`.
         unsafe { mem::transmute::<u32, f32>(mem::transmute::<f32, u32>(self) & !Self::SIGN_MASK) }
     }
 
@@ -654,18 +654,20 @@ impl f32 {
     pub const fn classify(self) -> FpCategory {
         // A previous implementation tried to only use bitmask-based checks,
         // using f32::to_bits to transmute the float to its bit repr and match on that.
-        // Unfortunately, floating point numbers can be much worse than that.
-        // This also needs to not result in recursive evaluations of f64::to_bits.
+        // If we only cared about being "technically" correct, that's an entirely legit
+        // implementation.
+        //
+        // Unfortunately, there is hardware out there that does not correctly implement the IEEE
+        // float semantics Rust relies on: x87 uses a too-large mantissa and exponent, and some
+        // hardware flushes subnormals to zero. These are platforms bugs, and Rust will misbehave on
+        // such hardware, but we can at least try to make things seem as sane as possible by being
+        // careful here.
         //
-        // On some processors, in some cases, LLVM will "helpfully" lower floating point ops,
-        // in spite of a request for them using f32 and f64, to things like x87 operations.
-        // These have an f64's mantissa, but can have a larger than normal exponent.
         // FIXME(jubilee): Using x87 operations is never necessary in order to function
         // on x86 processors for Rust-to-Rust calls, so this issue should not happen.
         // Code generation should be adjusted to use non-C calling conventions, avoiding this.
-        //
         if self.is_infinite() {
-            // Thus, a value may compare unequal to infinity, despite having a "full" exponent mask.
+            // A value may compare unequal to infinity, despite having a "full" exponent mask.
             FpCategory::Infinite
         } else if self.is_nan() {
             // And it may not be NaN, as it can simply be an "overextended" finite value.
@@ -675,48 +677,20 @@ impl f32 {
             // as correctness requires avoiding equality tests that may be Subnormal == -0.0
             // because it may be wrong under "denormals are zero" and "flush to zero" modes.
             // Most of std's targets don't use those, but they are used for thumbv7neon.
-            // So, this does use bitpattern matching for the rest.
-
-            // SAFETY: f32 to u32 is fine. Usually.
-            // If classify has gotten this far, the value is definitely in one of these categories.
-            unsafe { f32::partial_classify(self) }
-        }
-    }
-
-    // This doesn't actually return a right answer for NaN on purpose,
-    // seeing as how it cannot correctly discern between a floating point NaN,
-    // and some normal floating point numbers truncated from an x87 FPU.
-    // FIXME(jubilee): This probably could at least answer things correctly for Infinity,
-    // like the f64 version does, but I need to run more checks on how things go on x86.
-    // I fear losing mantissa data that would have answered that differently.
-    //
-    // # Safety
-    // This requires making sure you call this function for values it answers correctly on,
-    // otherwise it returns a wrong answer. This is not important for memory safety per se,
-    // but getting floats correct is important for not accidentally leaking const eval
-    // runtime-deviating logic which may or may not be acceptable.
-    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
-    const unsafe fn partial_classify(self) -> FpCategory {
-        // SAFETY: The caller is not asking questions for which this will tell lies.
-        let b = unsafe { mem::transmute::<f32, u32>(self) };
-        match (b & Self::MAN_MASK, b & Self::EXP_MASK) {
-            (0, 0) => FpCategory::Zero,
-            (_, 0) => FpCategory::Subnormal,
-            _ => FpCategory::Normal,
-        }
-    }
-
-    // This operates on bits, and only bits, so it can ignore concerns about weird FPUs.
-    // FIXME(jubilee): In a just world, this would be the entire impl for classify,
-    // plus a transmute. We do not live in a just world, but we can make it more so.
-    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
-    const fn classify_bits(b: u32) -> FpCategory {
-        match (b & Self::MAN_MASK, b & Self::EXP_MASK) {
-            (0, Self::EXP_MASK) => FpCategory::Infinite,
-            (_, Self::EXP_MASK) => FpCategory::Nan,
-            (0, 0) => FpCategory::Zero,
-            (_, 0) => FpCategory::Subnormal,
-            _ => FpCategory::Normal,
+            // So, this does use bitpattern matching for the rest. On x87, due to the incorrect
+            // float codegen on this hardware, this doesn't actually return a right answer for NaN
+            // because it cannot correctly discern between a floating point NaN, and some normal
+            // floating point numbers truncated from an x87 FPU -- but we took care of NaN above, so
+            // we are fine.
+            // FIXME(jubilee): This probably could at least answer things correctly for Infinity,
+            // like the f64 version does, but I need to run more checks on how things go on x86.
+            // I fear losing mantissa data that would have answered that differently.
+            let b = self.to_bits();
+            match (b & Self::MAN_MASK, b & Self::EXP_MASK) {
+                (0, 0) => FpCategory::Zero,
+                (_, 0) => FpCategory::Subnormal,
+                _ => FpCategory::Normal,
+            }
         }
     }
 
@@ -1143,51 +1117,7 @@ impl f32 {
     #[inline]
     pub const fn to_bits(self) -> u32 {
         // SAFETY: `u32` is a plain old datatype so we can always transmute to it.
-        // ...sorta.
-        //
-        // It turns out that at runtime, it is possible for a floating point number
-        // to be subject to a floating point mode that alters nonzero subnormal numbers
-        // to zero on reads and writes, aka "denormals are zero" and "flush to zero".
-        // This is not a problem per se, but at least one tier2 platform for Rust
-        // actually exhibits this behavior by default.
-        //
-        // In addition, on x86 targets with SSE or SSE2 disabled and the x87 FPU enabled,
-        // i.e. not soft-float, the way Rust does parameter passing can actually alter
-        // a number that is "not infinity" to have the same exponent as infinity,
-        // in a slightly unpredictable manner.
-        //
-        // And, of course evaluating to a NaN value is fairly nondeterministic.
-        // More precisely: when NaN should be returned is knowable, but which NaN?
-        // So far that's defined by a combination of LLVM and the CPU, not Rust.
-        // This function, however, allows observing the bitstring of a NaN,
-        // thus introspection on CTFE.
-        //
-        // In order to preserve, at least for the moment, const-to-runtime equivalence,
-        // we reject any of these possible situations from happening.
-        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
-        const fn ct_f32_to_u32(ct: f32) -> u32 {
-            match ct.classify() {
-                FpCategory::Nan => {
-                    panic!("const-eval error: cannot use f32::to_bits on a NaN")
-                }
-                FpCategory::Subnormal => {
-                    panic!("const-eval error: cannot use f32::to_bits on a subnormal number")
-                }
-                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => {
-                    // SAFETY: We have a normal floating point number. Now we transmute, i.e. do a bitcopy.
-                    unsafe { mem::transmute::<f32, u32>(ct) }
-                }
-            }
-        }
-
-        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
-        fn rt_f32_to_u32(x: f32) -> u32 {
-            // SAFETY: `u32` is a plain old datatype so we can always... uh...
-            // ...look, just pretend you forgot what you just read.
-            // Stability concerns.
-            unsafe { mem::transmute(x) }
-        }
-        intrinsics::const_eval_select((self,), ct_f32_to_u32, rt_f32_to_u32)
+        unsafe { mem::transmute(self) }
     }
 
     /// Raw transmutation from `u32`.
@@ -1232,53 +1162,8 @@ impl f32 {
     #[inline]
     pub const fn from_bits(v: u32) -> Self {
         // It turns out the safety issues with sNaN were overblown! Hooray!
-        // SAFETY: `u32` is a plain old datatype so we can always transmute from it
-        // ...sorta.
-        //
-        // It turns out that at runtime, it is possible for a floating point number
-        // to be subject to floating point modes that alter nonzero subnormal numbers
-        // to zero on reads and writes, aka "denormals are zero" and "flush to zero".
-        // This is not a problem usually, but at least one tier2 platform for Rust
-        // actually exhibits this behavior by default: thumbv7neon
-        // aka "the Neon FPU in AArch32 state"
-        //
-        // In addition, on x86 targets with SSE or SSE2 disabled and the x87 FPU enabled,
-        // i.e. not soft-float, the way Rust does parameter passing can actually alter
-        // a number that is "not infinity" to have the same exponent as infinity,
-        // in a slightly unpredictable manner.
-        //
-        // And, of course evaluating to a NaN value is fairly nondeterministic.
-        // More precisely: when NaN should be returned is knowable, but which NaN?
-        // So far that's defined by a combination of LLVM and the CPU, not Rust.
-        // This function, however, allows observing the bitstring of a NaN,
-        // thus introspection on CTFE.
-        //
-        // In order to preserve, at least for the moment, const-to-runtime equivalence,
-        // reject any of these possible situations from happening.
-        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
-        const fn ct_u32_to_f32(ct: u32) -> f32 {
-            match f32::classify_bits(ct) {
-                FpCategory::Subnormal => {
-                    panic!("const-eval error: cannot use f32::from_bits on a subnormal number")
-                }
-                FpCategory::Nan => {
-                    panic!("const-eval error: cannot use f32::from_bits on NaN")
-                }
-                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => {
-                    // SAFETY: It's not a frumious number
-                    unsafe { mem::transmute::<u32, f32>(ct) }
-                }
-            }
-        }
-
-        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
-        fn rt_u32_to_f32(x: u32) -> f32 {
-            // SAFETY: `u32` is a plain old datatype so we can always... uh...
-            // ...look, just pretend you forgot what you just read.
-            // Stability concerns.
-            unsafe { mem::transmute(x) }
-        }
-        intrinsics::const_eval_select((v,), ct_u32_to_f32, rt_u32_to_f32)
+        // SAFETY: `u32` is a plain old datatype so we can always transmute from it.
+        unsafe { mem::transmute(v) }
     }
 
     /// Returns the memory representation of this floating point number as a byte array in
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index a89859be7efe8..85eb152ad1f19 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -528,7 +528,7 @@ impl f64 {
     #[inline]
     #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
     pub(crate) const fn abs_private(self) -> f64 {
-        // SAFETY: This transmutation is fine. Probably. For the reasons std is using it.
+        // SAFETY: This transmutation is fine just like in `to_bits`/`from_bits`.
         unsafe { mem::transmute::<u64, f64>(mem::transmute::<f64, u64>(self) & !Self::SIGN_MASK) }
     }
 
@@ -653,12 +653,14 @@ impl f64 {
     pub const fn classify(self) -> FpCategory {
         // A previous implementation tried to only use bitmask-based checks,
         // using f64::to_bits to transmute the float to its bit repr and match on that.
-        // Unfortunately, floating point numbers can be much worse than that.
-        // This also needs to not result in recursive evaluations of f64::to_bits.
+        // If we only cared about being "technically" correct, that's an entirely legit
+        // implementation.
+        //
+        // Unfortunately, there is hardware out there that does not correctly implement the IEEE
+        // float semantics Rust relies on: x87 uses a too-large exponent, and some hardware flushes
+        // subnormals to zero. These are platforms bugs, and Rust will misbehave on such hardware,
+        // but we can at least try to make things seem as sane as possible by being careful here.
         //
-        // On some processors, in some cases, LLVM will "helpfully" lower floating point ops,
-        // in spite of a request for them using f32 and f64, to things like x87 operations.
-        // These have an f64's mantissa, but can have a larger than normal exponent.
         // FIXME(jubilee): Using x87 operations is never necessary in order to function
         // on x86 processors for Rust-to-Rust calls, so this issue should not happen.
         // Code generation should be adjusted to use non-C calling conventions, avoiding this.
@@ -672,41 +674,18 @@ impl f64 {
             // as correctness requires avoiding equality tests that may be Subnormal == -0.0
             // because it may be wrong under "denormals are zero" and "flush to zero" modes.
             // Most of std's targets don't use those, but they are used for thumbv7neon.
-            // So, this does use bitpattern matching for the rest.
-
-            // SAFETY: f64 to u64 is fine. Usually.
-            // If control flow has gotten this far, the value is definitely in one of the categories
-            // that f64::partial_classify can correctly analyze.
-            unsafe { f64::partial_classify(self) }
-        }
-    }
-
-    // This doesn't actually return a right answer for NaN on purpose,
-    // seeing as how it cannot correctly discern between a floating point NaN,
-    // and some normal floating point numbers truncated from an x87 FPU.
-    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
-    const unsafe fn partial_classify(self) -> FpCategory {
-        // SAFETY: The caller is not asking questions for which this will tell lies.
-        let b = unsafe { mem::transmute::<f64, u64>(self) };
-        match (b & Self::MAN_MASK, b & Self::EXP_MASK) {
-            (0, Self::EXP_MASK) => FpCategory::Infinite,
-            (0, 0) => FpCategory::Zero,
-            (_, 0) => FpCategory::Subnormal,
-            _ => FpCategory::Normal,
-        }
-    }
-
-    // This operates on bits, and only bits, so it can ignore concerns about weird FPUs.
-    // FIXME(jubilee): In a just world, this would be the entire impl for classify,
-    // plus a transmute. We do not live in a just world, but we can make it more so.
-    #[rustc_const_unstable(feature = "const_float_classify", issue = "72505")]
-    const fn classify_bits(b: u64) -> FpCategory {
-        match (b & Self::MAN_MASK, b & Self::EXP_MASK) {
-            (0, Self::EXP_MASK) => FpCategory::Infinite,
-            (_, Self::EXP_MASK) => FpCategory::Nan,
-            (0, 0) => FpCategory::Zero,
-            (_, 0) => FpCategory::Subnormal,
-            _ => FpCategory::Normal,
+            // So, this does use bitpattern matching for the rest. On x87, due to the incorrect
+            // float codegen on this hardware, this doesn't actually return a right answer for NaN
+            // because it cannot correctly discern between a floating point NaN, and some normal
+            // floating point numbers truncated from an x87 FPU -- but we took care of NaN above, so
+            // we are fine.
+            let b = self.to_bits();
+            match (b & Self::MAN_MASK, b & Self::EXP_MASK) {
+                (0, Self::EXP_MASK) => FpCategory::Infinite,
+                (0, 0) => FpCategory::Zero,
+                (_, 0) => FpCategory::Subnormal,
+                _ => FpCategory::Normal,
+            }
         }
     }
 
@@ -1134,33 +1113,7 @@ impl f64 {
     #[inline]
     pub const fn to_bits(self) -> u64 {
         // SAFETY: `u64` is a plain old datatype so we can always transmute to it.
-        // ...sorta.
-        //
-        // See the SAFETY comment in f64::from_bits for more.
-        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
-        const fn ct_f64_to_u64(ct: f64) -> u64 {
-            match ct.classify() {
-                FpCategory::Nan => {
-                    panic!("const-eval error: cannot use f64::to_bits on a NaN")
-                }
-                FpCategory::Subnormal => {
-                    panic!("const-eval error: cannot use f64::to_bits on a subnormal number")
-                }
-                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => {
-                    // SAFETY: We have a normal floating point number. Now we transmute, i.e. do a bitcopy.
-                    unsafe { mem::transmute::<f64, u64>(ct) }
-                }
-            }
-        }
-
-        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
-        fn rt_f64_to_u64(rt: f64) -> u64 {
-            // SAFETY: `u64` is a plain old datatype so we can always... uh...
-            // ...look, just pretend you forgot what you just read.
-            // Stability concerns.
-            unsafe { mem::transmute::<f64, u64>(rt) }
-        }
-        intrinsics::const_eval_select((self,), ct_f64_to_u64, rt_f64_to_u64)
+        unsafe { mem::transmute(self) }
     }
 
     /// Raw transmutation from `u64`.
@@ -1205,58 +1158,8 @@ impl f64 {
     #[inline]
     pub const fn from_bits(v: u64) -> Self {
         // It turns out the safety issues with sNaN were overblown! Hooray!
-        // SAFETY: `u64` is a plain old datatype so we can always transmute from it
-        // ...sorta.
-        //
-        // It turns out that at runtime, it is possible for a floating point number
-        // to be subject to floating point modes that alter nonzero subnormal numbers
-        // to zero on reads and writes, aka "denormals are zero" and "flush to zero".
-        // This is not a problem usually, but at least one tier2 platform for Rust
-        // actually exhibits an FTZ behavior by default: thumbv7neon
-        // aka "the Neon FPU in AArch32 state"
-        //
-        // Even with this, not all instructions exhibit the FTZ behaviors on thumbv7neon,
-        // so this should load the same bits if LLVM emits the "correct" instructions,
-        // but LLVM sometimes makes interesting choices about float optimization,
-        // and other FPUs may do similar. Thus, it is wise to indulge luxuriously in caution.
-        //
-        // In addition, on x86 targets with SSE or SSE2 disabled and the x87 FPU enabled,
-        // i.e. not soft-float, the way Rust does parameter passing can actually alter
-        // a number that is "not infinity" to have the same exponent as infinity,
-        // in a slightly unpredictable manner.
-        //
-        // And, of course evaluating to a NaN value is fairly nondeterministic.
-        // More precisely: when NaN should be returned is knowable, but which NaN?
-        // So far that's defined by a combination of LLVM and the CPU, not Rust.
-        // This function, however, allows observing the bitstring of a NaN,
-        // thus introspection on CTFE.
-        //
-        // In order to preserve, at least for the moment, const-to-runtime equivalence,
-        // reject any of these possible situations from happening.
-        #[rustc_const_unstable(feature = "const_float_bits_conv", issue = "72447")]
-        const fn ct_u64_to_f64(ct: u64) -> f64 {
-            match f64::classify_bits(ct) {
-                FpCategory::Subnormal => {
-                    panic!("const-eval error: cannot use f64::from_bits on a subnormal number")
-                }
-                FpCategory::Nan => {
-                    panic!("const-eval error: cannot use f64::from_bits on NaN")
-                }
-                FpCategory::Infinite | FpCategory::Normal | FpCategory::Zero => {
-                    // SAFETY: It's not a frumious number
-                    unsafe { mem::transmute::<u64, f64>(ct) }
-                }
-            }
-        }
-
-        #[inline(always)] // See https://github.com/rust-lang/compiler-builtins/issues/491
-        fn rt_u64_to_f64(rt: u64) -> f64 {
-            // SAFETY: `u64` is a plain old datatype so we can always... uh...
-            // ...look, just pretend you forgot what you just read.
-            // Stability concerns.
-            unsafe { mem::transmute::<u64, f64>(rt) }
-        }
-        intrinsics::const_eval_select((v,), ct_u64_to_f64, rt_u64_to_f64)
+        // SAFETY: `u64` is a plain old datatype so we can always transmute from it.
+        unsafe { mem::transmute(v) }
     }
 
     /// Returns the memory representation of this floating point number as a byte array in
diff --git a/tests/ui/consts/const-float-bits-conv.rs b/tests/ui/consts/const-float-bits-conv.rs
index ba8db4c23dc9b..74df901394788 100644
--- a/tests/ui/consts/const-float-bits-conv.rs
+++ b/tests/ui/consts/const-float-bits-conv.rs
@@ -38,6 +38,17 @@ fn f32() {
     const_assert!(f32::from_bits(0x44a72000), 1337.0);
     const_assert!(f32::from_ne_bytes(0x44a72000u32.to_ne_bytes()), 1337.0);
     const_assert!(f32::from_bits(0xc1640000), -14.25);
+
+    // Check that NaNs roundtrip their bits regardless of signalingness
+    // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
+    // ...actually, let's just check that these break. :D
+    const MASKED_NAN1: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA;
+    const MASKED_NAN2: u32 = f32::NAN.to_bits() ^ 0x0055_5555;
+
+    const_assert!(f32::from_bits(MASKED_NAN1).is_nan());
+    const_assert!(f32::from_bits(MASKED_NAN1).is_nan());
+    const_assert!(f32::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1);
+    const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
 }
 
 fn f64() {
@@ -55,6 +66,17 @@ fn f64() {
     const_assert!(f64::from_bits(0x4094e40000000000), 1337.0);
     const_assert!(f64::from_ne_bytes(0x4094e40000000000u64.to_ne_bytes()), 1337.0);
     const_assert!(f64::from_bits(0xc02c800000000000), -14.25);
+
+    // Check that NaNs roundtrip their bits regardless of signalingness
+    // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
+    // ...actually, let's just check that these break. :D
+    const MASKED_NAN1: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA;
+    const MASKED_NAN2: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555;
+
+    const_assert!(f64::from_bits(MASKED_NAN1).is_nan());
+    const_assert!(f64::from_bits(MASKED_NAN1).is_nan());
+    const_assert!(f64::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1);
+    const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
 }
 
 fn main() {
diff --git a/tests/ui/consts/const-float-bits-reject-conv.rs b/tests/ui/consts/const-float-bits-reject-conv.rs
deleted file mode 100644
index febb272869a37..0000000000000
--- a/tests/ui/consts/const-float-bits-reject-conv.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-//@ compile-flags: -Zmir-opt-level=0
-//@ error-pattern: cannot use f32::to_bits on a NaN
-#![feature(const_float_bits_conv)]
-#![feature(const_float_classify)]
-
-// Don't promote
-const fn nop<T>(x: T) -> T { x }
-
-macro_rules! const_assert {
-    ($a:expr) => {
-        {
-            const _: () = assert!($a);
-            assert!(nop($a));
-        }
-    };
-    ($a:expr, $b:expr) => {
-        {
-            const _: () = assert!($a == $b);
-            assert_eq!(nop($a), nop($b));
-        }
-    };
-}
-
-fn f32() {
-    // Check that NaNs roundtrip their bits regardless of signalingness
-    // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
-    // ...actually, let's just check that these break. :D
-    const MASKED_NAN1: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA;
-    //~^ inside
-    const MASKED_NAN2: u32 = f32::NAN.to_bits() ^ 0x0055_5555;
-    //~^ inside
-
-    // The rest of the code is dead because the constants already fail to evaluate.
-
-    const_assert!(f32::from_bits(MASKED_NAN1).is_nan());
-    const_assert!(f32::from_bits(MASKED_NAN1).is_nan());
-
-    // LLVM does not guarantee that loads and stores of NaNs preserve their exact bit pattern.
-    // In practice, this seems to only cause a problem on x86, since the most widely used calling
-    // convention mandates that floating point values are returned on the x87 FPU stack. See #73328.
-    // However, during CTFE we still preserve bit patterns (though that is not a guarantee).
-    const_assert!(f32::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1);
-    const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
-}
-
-fn f64() {
-    // Check that NaNs roundtrip their bits regardless of signalingness
-    // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
-    // ...actually, let's just check that these break. :D
-    const MASKED_NAN1: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA;
-    //~^ inside
-    const MASKED_NAN2: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555;
-    //~^ inside
-
-    // The rest of the code is dead because the constants already fail to evaluate.
-
-    const_assert!(f64::from_bits(MASKED_NAN1).is_nan());
-    const_assert!(f64::from_bits(MASKED_NAN1).is_nan());
-
-    // See comment above.
-    const_assert!(f64::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1);
-    const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
-}
-
-fn main() {
-    f32();
-    f64();
-}
diff --git a/tests/ui/consts/const-float-bits-reject-conv.stderr b/tests/ui/consts/const-float-bits-reject-conv.stderr
deleted file mode 100644
index 1511dab12b0e3..0000000000000
--- a/tests/ui/consts/const-float-bits-reject-conv.stderr
+++ /dev/null
@@ -1,115 +0,0 @@
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/num/f32.rs:LL:COL
-   |
-   = note: the evaluated program panicked at 'const-eval error: cannot use f32::to_bits on a NaN', $SRC_DIR/core/src/num/f32.rs:LL:COL
-   |
-note: inside `core::f32::<impl f32>::to_bits::ct_f32_to_u32`
-  --> $SRC_DIR/core/src/num/f32.rs:LL:COL
-note: inside `core::f32::<impl f32>::to_bits`
-  --> $SRC_DIR/core/src/num/f32.rs:LL:COL
-note: inside `f32::MASKED_NAN1`
-  --> $DIR/const-float-bits-reject-conv.rs:28:30
-   |
-LL |     const MASKED_NAN1: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA;
-   |                              ^^^^^^^^^^^^^^^^^^
-   = 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[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/num/f32.rs:LL:COL
-   |
-   = note: the evaluated program panicked at 'const-eval error: cannot use f32::to_bits on a NaN', $SRC_DIR/core/src/num/f32.rs:LL:COL
-   |
-note: inside `core::f32::<impl f32>::to_bits::ct_f32_to_u32`
-  --> $SRC_DIR/core/src/num/f32.rs:LL:COL
-note: inside `core::f32::<impl f32>::to_bits`
-  --> $SRC_DIR/core/src/num/f32.rs:LL:COL
-note: inside `f32::MASKED_NAN2`
-  --> $DIR/const-float-bits-reject-conv.rs:30:30
-   |
-LL |     const MASKED_NAN2: u32 = f32::NAN.to_bits() ^ 0x0055_5555;
-   |                              ^^^^^^^^^^^^^^^^^^
-   = 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)
-
-note: erroneous constant encountered
-  --> $DIR/const-float-bits-reject-conv.rs:35:34
-   |
-LL |     const_assert!(f32::from_bits(MASKED_NAN1).is_nan());
-   |                                  ^^^^^^^^^^^
-
-note: erroneous constant encountered
-  --> $DIR/const-float-bits-reject-conv.rs:36:34
-   |
-LL |     const_assert!(f32::from_bits(MASKED_NAN1).is_nan());
-   |                                  ^^^^^^^^^^^
-
-note: erroneous constant encountered
-  --> $DIR/const-float-bits-reject-conv.rs:42:34
-   |
-LL |     const_assert!(f32::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1);
-   |                                  ^^^^^^^^^^^
-
-note: erroneous constant encountered
-  --> $DIR/const-float-bits-reject-conv.rs:43:34
-   |
-LL |     const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
-   |                                  ^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/num/f64.rs:LL:COL
-   |
-   = note: the evaluated program panicked at 'const-eval error: cannot use f64::to_bits on a NaN', $SRC_DIR/core/src/num/f64.rs:LL:COL
-   |
-note: inside `core::f64::<impl f64>::to_bits::ct_f64_to_u64`
-  --> $SRC_DIR/core/src/num/f64.rs:LL:COL
-note: inside `core::f64::<impl f64>::to_bits`
-  --> $SRC_DIR/core/src/num/f64.rs:LL:COL
-note: inside `f64::MASKED_NAN1`
-  --> $DIR/const-float-bits-reject-conv.rs:50:30
-   |
-LL |     const MASKED_NAN1: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA;
-   |                              ^^^^^^^^^^^^^^^^^^
-   = 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[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/num/f64.rs:LL:COL
-   |
-   = note: the evaluated program panicked at 'const-eval error: cannot use f64::to_bits on a NaN', $SRC_DIR/core/src/num/f64.rs:LL:COL
-   |
-note: inside `core::f64::<impl f64>::to_bits::ct_f64_to_u64`
-  --> $SRC_DIR/core/src/num/f64.rs:LL:COL
-note: inside `core::f64::<impl f64>::to_bits`
-  --> $SRC_DIR/core/src/num/f64.rs:LL:COL
-note: inside `f64::MASKED_NAN2`
-  --> $DIR/const-float-bits-reject-conv.rs:52:30
-   |
-LL |     const MASKED_NAN2: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555;
-   |                              ^^^^^^^^^^^^^^^^^^
-   = 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)
-
-note: erroneous constant encountered
-  --> $DIR/const-float-bits-reject-conv.rs:57:34
-   |
-LL |     const_assert!(f64::from_bits(MASKED_NAN1).is_nan());
-   |                                  ^^^^^^^^^^^
-
-note: erroneous constant encountered
-  --> $DIR/const-float-bits-reject-conv.rs:58:34
-   |
-LL |     const_assert!(f64::from_bits(MASKED_NAN1).is_nan());
-   |                                  ^^^^^^^^^^^
-
-note: erroneous constant encountered
-  --> $DIR/const-float-bits-reject-conv.rs:61:34
-   |
-LL |     const_assert!(f64::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1);
-   |                                  ^^^^^^^^^^^
-
-note: erroneous constant encountered
-  --> $DIR/const-float-bits-reject-conv.rs:62:34
-   |
-LL |     const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
-   |                                  ^^^^^^^^^^^
-
-error: aborting due to 4 previous errors
-
-For more information about this error, try `rustc --explain E0080`.

From 953c7ed41ef6e98a484c1d15f9b06169f49c56f4 Mon Sep 17 00:00:00 2001
From: Alexey Semenyuk <alexsemenyuk88@gmail.com>
Date: Fri, 16 Aug 2024 16:17:24 +0500
Subject: [PATCH 322/685] Disable assigning_clones for tests

---
 clippy_lints/src/assigning_clones.rs |  3 ++-
 tests/ui/assigning_clones.fixed      | 20 ++++++++++++++++++++
 tests/ui/assigning_clones.rs         | 20 ++++++++++++++++++++
 3 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/clippy_lints/src/assigning_clones.rs b/clippy_lints/src/assigning_clones.rs
index 6e336efbb90a2..55645d04eef36 100644
--- a/clippy_lints/src/assigning_clones.rs
+++ b/clippy_lints/src/assigning_clones.rs
@@ -3,7 +3,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::mir::{enclosing_mir, PossibleBorrowerMap};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{is_diag_trait_item, last_path_segment, local_is_initialized, path_to_local};
+use clippy_utils::{is_diag_trait_item, is_in_test, last_path_segment, local_is_initialized, path_to_local};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
@@ -118,6 +118,7 @@ impl<'tcx> LateLintPass<'tcx> for AssigningClones {
                 }
             )
             && !clone_source_borrows_from_dest(cx, lhs, rhs.span)
+            && !is_in_test(cx.tcx, e.hir_id)
         {
             span_lint_and_then(
                 cx,
diff --git a/tests/ui/assigning_clones.fixed b/tests/ui/assigning_clones.fixed
index b376d55a40250..09732d1a50ce0 100644
--- a/tests/ui/assigning_clones.fixed
+++ b/tests/ui/assigning_clones.fixed
@@ -396,3 +396,23 @@ impl<T: Clone> Clone for DerefWrapperWithClone<T> {
         *self = Self(source.0.clone());
     }
 }
+
+#[cfg(test)]
+mod test {
+    #[derive(Default)]
+    struct Data {
+        field: String,
+    }
+
+    fn test_data() -> Data {
+        Data {
+            field: "default_value".to_string(),
+        }
+    }
+
+    #[test]
+    fn test() {
+        let mut data = test_data();
+        data.field = "override_value".to_owned();
+    }
+}
diff --git a/tests/ui/assigning_clones.rs b/tests/ui/assigning_clones.rs
index 11a5d4459c350..6be25ae17a55d 100644
--- a/tests/ui/assigning_clones.rs
+++ b/tests/ui/assigning_clones.rs
@@ -396,3 +396,23 @@ impl<T: Clone> Clone for DerefWrapperWithClone<T> {
         *self = Self(source.0.clone());
     }
 }
+
+#[cfg(test)]
+mod test {
+    #[derive(Default)]
+    struct Data {
+        field: String,
+    }
+
+    fn test_data() -> Data {
+        Data {
+            field: "default_value".to_string(),
+        }
+    }
+
+    #[test]
+    fn test() {
+        let mut data = test_data();
+        data.field = "override_value".to_owned();
+    }
+}

From e03cc14b7a781f9b921da50928b0a480b4aaca16 Mon Sep 17 00:00:00 2001
From: Wafarm <qinyy07@gmail.com>
Date: Fri, 16 Aug 2024 20:58:13 +0800
Subject: [PATCH 323/685] Fix wrong source location for some incorrect macro
 definitions

---
 compiler/rustc_expand/src/mbe/quoted.rs       | 19 +++++++++++++------
 .../ui/macros/macro-match-nonterminal.stderr  | 12 ++++++------
 2 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_expand/src/mbe/quoted.rs b/compiler/rustc_expand/src/mbe/quoted.rs
index e5a1c6c789928..b2f7c8f5183a2 100644
--- a/compiler/rustc_expand/src/mbe/quoted.rs
+++ b/compiler/rustc_expand/src/mbe/quoted.rs
@@ -54,18 +54,24 @@ pub(super) fn parse(
 
     // For each token tree in `input`, parse the token into a `self::TokenTree`, consuming
     // additional trees if need be.
-    let mut trees = input.trees();
+    let mut trees = input.trees().peekable();
     while let Some(tree) = trees.next() {
         // Given the parsed tree, if there is a metavar and we are expecting matchers, actually
         // parse out the matcher (i.e., in `$id:ident` this would parse the `:` and `ident`).
         let tree = parse_tree(tree, &mut trees, parsing_patterns, sess, node_id, features, edition);
         match tree {
             TokenTree::MetaVar(start_sp, ident) if parsing_patterns => {
-                let span = match trees.next() {
+                // Not consuming the next token immediately, as it may not be a colon
+                let span = match trees.peek() {
                     Some(&tokenstream::TokenTree::Token(
                         Token { kind: token::Colon, span: colon_span },
                         _,
                     )) => {
+                        // Consume the colon first
+                        trees.next();
+
+                        // It's ok to consume the next tree no matter how,
+                        // since if it's not a token then it will be an invalid declaration.
                         match trees.next() {
                             Some(tokenstream::TokenTree::Token(token, _)) => match token.ident() {
                                 Some((fragment, _)) => {
@@ -125,12 +131,13 @@ pub(super) fn parse(
                                 }
                                 _ => token.span,
                             },
-                            Some(tree) => tree.span(),
-                            None => colon_span,
+                            // Invalid, return a nice source location
+                            _ => colon_span.with_lo(start_sp.lo()),
                         }
                     }
-                    Some(tree) => tree.span(),
-                    None => start_sp,
+                    // Whether it's none or some other tree, it doesn't belong to
+                    // the current meta variable, returning the original span.
+                    _ => start_sp,
                 };
 
                 result.push(TokenTree::MetaVarDecl(span, ident, None));
diff --git a/tests/ui/macros/macro-match-nonterminal.stderr b/tests/ui/macros/macro-match-nonterminal.stderr
index 831579c4fefd5..f221f92c3cda6 100644
--- a/tests/ui/macros/macro-match-nonterminal.stderr
+++ b/tests/ui/macros/macro-match-nonterminal.stderr
@@ -1,14 +1,14 @@
 error: missing fragment specifier
-  --> $DIR/macro-match-nonterminal.rs:2:8
+  --> $DIR/macro-match-nonterminal.rs:2:6
    |
 LL |     ($a, $b) => {
-   |        ^
+   |      ^^
 
 error: missing fragment specifier
-  --> $DIR/macro-match-nonterminal.rs:2:8
+  --> $DIR/macro-match-nonterminal.rs:2:6
    |
 LL |     ($a, $b) => {
-   |        ^
+   |      ^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #40107 <https://github.com/rust-lang/rust/issues/40107>
@@ -27,10 +27,10 @@ error: aborting due to 3 previous errors
 
 Future incompatibility report: Future breakage diagnostic:
 error: missing fragment specifier
-  --> $DIR/macro-match-nonterminal.rs:2:8
+  --> $DIR/macro-match-nonterminal.rs:2:6
    |
 LL |     ($a, $b) => {
-   |        ^
+   |      ^^
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #40107 <https://github.com/rust-lang/rust/issues/40107>

From 3c68b113c06d6ebda8cc7d4bc331916eff0e89c8 Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Wed, 31 Jul 2024 14:56:34 -0400
Subject: [PATCH 324/685] rewrite reproducible-build to rmake

---
 .../tidy/src/allowed_run_make_makefiles.txt   |   1 -
 tests/run-make/reproducible-build/Makefile    | 140 -----------
 tests/run-make/reproducible-build/rmake.rs    | 222 ++++++++++++++++++
 3 files changed, 222 insertions(+), 141 deletions(-)
 delete mode 100644 tests/run-make/reproducible-build/Makefile
 create mode 100644 tests/run-make/reproducible-build/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 92405bdb876be..f55abb513b80d 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -8,7 +8,6 @@ run-make/jobserver-error/Makefile
 run-make/libs-through-symlinks/Makefile
 run-make/libtest-thread-limit/Makefile
 run-make/macos-deployment-target/Makefile
-run-make/reproducible-build/Makefile
 run-make/split-debuginfo/Makefile
 run-make/symbol-mangling-hashed/Makefile
 run-make/translation/Makefile
diff --git a/tests/run-make/reproducible-build/Makefile b/tests/run-make/reproducible-build/Makefile
deleted file mode 100644
index f5d17a234c0ac..0000000000000
--- a/tests/run-make/reproducible-build/Makefile
+++ /dev/null
@@ -1,140 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-# ignore-musl
-# Objects are reproducible but their path is not.
-
-all:  \
-	smoke \
-	debug \
-	opt \
-	link_paths \
-	remap_paths \
-	different_source_dirs_rlib \
-	remap_cwd_rlib \
-	remap_cwd_to_empty \
-	extern_flags
-
-# TODO: Builds of `bin` crate types are not deterministic with debuginfo=2 on
-# Windows.
-# See: https://github.com/rust-lang/rust/pull/87320#issuecomment-920105533
-# Issue: https://github.com/rust-lang/rust/issues/88982
-#
-#	different_source_dirs_bin \
-#	remap_cwd_bin \
-
-smoke:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) linker.rs -O
-	$(RUSTC) reproducible-build-aux.rs
-	$(RUSTC) reproducible-build.rs -C linker=$(call RUN_BINFILE,linker)
-	$(RUSTC) reproducible-build.rs -C linker=$(call RUN_BINFILE,linker)
-	diff -u "$(TMPDIR)/linker-arguments1" "$(TMPDIR)/linker-arguments2"
-
-debug:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) linker.rs -O
-	$(RUSTC) reproducible-build-aux.rs -g
-	$(RUSTC) reproducible-build.rs -C linker=$(call RUN_BINFILE,linker) -g
-	$(RUSTC) reproducible-build.rs -C linker=$(call RUN_BINFILE,linker) -g
-	diff -u "$(TMPDIR)/linker-arguments1" "$(TMPDIR)/linker-arguments2"
-
-opt:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) linker.rs -O
-	$(RUSTC) reproducible-build-aux.rs -O
-	$(RUSTC) reproducible-build.rs -C linker=$(call RUN_BINFILE,linker) -O
-	$(RUSTC) reproducible-build.rs -C linker=$(call RUN_BINFILE,linker) -O
-	diff -u "$(TMPDIR)/linker-arguments1" "$(TMPDIR)/linker-arguments2"
-
-link_paths:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) reproducible-build-aux.rs
-	$(RUSTC) reproducible-build.rs --crate-type rlib -L /b
-	cp $(TMPDIR)/libreproducible_build.rlib $(TMPDIR)/libfoo.rlib
-	$(RUSTC) reproducible-build.rs --crate-type rlib -L /a
-	cmp "$(TMPDIR)/libreproducible_build.rlib" "$(TMPDIR)/libfoo.rlib" || exit 1
-
-remap_paths:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) reproducible-build-aux.rs
-	$(RUSTC) reproducible-build.rs --crate-type rlib --remap-path-prefix=/a=/c
-	cp $(TMPDIR)/libreproducible_build.rlib $(TMPDIR)/libfoo.rlib
-	$(RUSTC) reproducible-build.rs --crate-type rlib --remap-path-prefix=/b=/c
-	cmp "$(TMPDIR)/libreproducible_build.rlib" "$(TMPDIR)/libfoo.rlib" || exit 1
-
-different_source_dirs_bin:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) reproducible-build-aux.rs
-	mkdir $(TMPDIR)/test
-	cp reproducible-build.rs $(TMPDIR)/test
-	$(RUSTC) reproducible-build.rs --crate-type bin --remap-path-prefix=$$PWD=/b
-	cp $(TMPDIR)/reproducible-build $(TMPDIR)/foo
-	(cd $(TMPDIR)/test && $(RUSTC) reproducible-build.rs \
-		--remap-path-prefix=$(TMPDIR)/test=/b \
-		--crate-type bin)
-	cmp "$(TMPDIR)/reproducible-build" "$(TMPDIR)/foo" || exit 1
-
-different_source_dirs_rlib:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) reproducible-build-aux.rs
-	mkdir $(TMPDIR)/test
-	cp reproducible-build.rs $(TMPDIR)/test
-	$(RUSTC) reproducible-build.rs --crate-type rlib --remap-path-prefix=$$PWD=/b
-	cp $(TMPDIR)/libreproducible_build.rlib $(TMPDIR)/libfoo.rlib
-	(cd $(TMPDIR)/test && $(RUSTC) reproducible-build.rs \
-		--remap-path-prefix=$(TMPDIR)/test=/b \
-		--crate-type rlib)
-	cmp "$(TMPDIR)/libreproducible_build.rlib" "$(TMPDIR)/libfoo.rlib" || exit 1
-
-remap_cwd_bin:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) reproducible-build-aux.rs
-	mkdir $(TMPDIR)/test
-	cp reproducible-build.rs $(TMPDIR)/test
-	$(RUSTC) reproducible-build.rs --crate-type bin -C debuginfo=2 \
-	  -Z remap-cwd-prefix=.
-	cp $(TMPDIR)/reproducible-build $(TMPDIR)/first
-	(cd $(TMPDIR)/test && \
-	 $(RUSTC) reproducible-build.rs --crate-type bin -C debuginfo=2 \
-	   -Z remap-cwd-prefix=.)
-	cmp "$(TMPDIR)/first" "$(TMPDIR)/reproducible-build" || exit 1
-
-remap_cwd_rlib:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) reproducible-build-aux.rs
-	mkdir $(TMPDIR)/test
-	cp reproducible-build.rs $(TMPDIR)/test
-	$(RUSTC) reproducible-build.rs --crate-type rlib -C debuginfo=2 \
-	  -Z remap-cwd-prefix=.
-	cp $(TMPDIR)/libreproducible_build.rlib $(TMPDIR)/libfirst.rlib
-	(cd $(TMPDIR)/test && \
-	 $(RUSTC) reproducible-build.rs --crate-type rlib -C debuginfo=2 \
-	   -Z remap-cwd-prefix=.)
-	cmp "$(TMPDIR)/libfirst.rlib" "$(TMPDIR)/libreproducible_build.rlib" || exit 1
-
-remap_cwd_to_empty:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) reproducible-build-aux.rs
-	mkdir $(TMPDIR)/test
-	cp reproducible-build.rs $(TMPDIR)/test
-	$(RUSTC) reproducible-build.rs --crate-type rlib -C debuginfo=2 \
-	  -Z remap-cwd-prefix=
-	cp $(TMPDIR)/libreproducible_build.rlib $(TMPDIR)/libfirst.rlib
-	(cd $(TMPDIR)/test && \
-	 $(RUSTC) reproducible-build.rs --crate-type rlib -C debuginfo=2 \
-	   -Z remap-cwd-prefix=)
-	cmp "$(TMPDIR)/libfirst.rlib" "$(TMPDIR)/libreproducible_build.rlib" || exit 1
-
-extern_flags:
-	rm -rf $(TMPDIR) && mkdir $(TMPDIR)
-	$(RUSTC) reproducible-build-aux.rs
-	$(RUSTC) reproducible-build.rs \
-		--extern reproducible_build_aux=$(TMPDIR)/libreproducible_build_aux.rlib \
-		--crate-type rlib
-	cp $(TMPDIR)/libreproducible_build_aux.rlib $(TMPDIR)/libbar.rlib
-	cp $(TMPDIR)/libreproducible_build.rlib $(TMPDIR)/libfoo.rlib
-	$(RUSTC) reproducible-build.rs \
-		--extern reproducible_build_aux=$(TMPDIR)/libbar.rlib \
-		--crate-type rlib
-	cmp "$(TMPDIR)/libreproducible_build.rlib" "$(TMPDIR)/libfoo.rlib" || exit 1
diff --git a/tests/run-make/reproducible-build/rmake.rs b/tests/run-make/reproducible-build/rmake.rs
new file mode 100644
index 0000000000000..a5f27f34f4fcc
--- /dev/null
+++ b/tests/run-make/reproducible-build/rmake.rs
@@ -0,0 +1,222 @@
+// This test case makes sure that two identical invocations of the compiler
+// (i.e. same code base, same compile-flags, same compiler-versions, etc.)
+// produce the same output. In the past, symbol names of monomorphized functions
+// were not deterministic (which we want to avoid).
+//
+// The test tries to exercise as many different paths into symbol name
+// generation as possible:
+//
+// - regular functions
+// - generic functions
+// - methods
+// - statics
+// - closures
+// - enum variant constructors
+// - tuple struct constructors
+// - drop glue
+// - FnOnce adapters
+// - Trait object shims
+// - Fn Pointer shims
+// See https://github.com/rust-lang/rust/pull/32293
+
+// FIXME(Oneirical): ignore-musl
+// FIXME(Oneirical): two of these test blocks will apparently fail on windows
+// FIXME(Oneirical): try it on test-various
+// # FIXME: Builds of `bin` crate types are not deterministic with debuginfo=2 on
+// # Windows.
+// # See: https://github.com/rust-lang/rust/pull/87320#issuecomment-920105533
+// # Issue: https://github.com/rust-lang/rust/issues/88982
+
+use run_make_support::{bin_name, cwd, diff, rfs, run_in_tmpdir, rust_lib_name, rustc};
+
+fn main() {
+    run_in_tmpdir(|| {
+        rustc().input("linker.rs").opt().run();
+        rustc().input("reproducible-build-aux.rs").run();
+        rustc()
+            .input("reproducible-build.rs")
+            .linker(&cwd().join(bin_name("linker")).display().to_string())
+            .run();
+        rustc()
+            .input("reproducible-build.rs")
+            .linker(&cwd().join(bin_name("linker")).display().to_string())
+            .run();
+        diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
+    });
+
+    run_in_tmpdir(|| {
+        rustc().input("linker.rs").opt().run();
+        rustc().arg("-g").input("reproducible-build-aux.rs").run();
+        rustc()
+            .arg("-g")
+            .input("reproducible-build.rs")
+            .linker(&cwd().join(bin_name("linker")).display().to_string())
+            .run();
+        rustc()
+            .arg("-g")
+            .input("reproducible-build.rs")
+            .linker(&cwd().join(bin_name("linker")).display().to_string())
+            .run();
+        diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
+    });
+
+    run_in_tmpdir(|| {
+        rustc().input("linker.rs").opt().run();
+        rustc().opt().input("reproducible-build-aux.rs").run();
+        rustc()
+            .opt()
+            .input("reproducible-build.rs")
+            .linker(&cwd().join(bin_name("linker")).display().to_string())
+            .run();
+        rustc()
+            .opt()
+            .input("reproducible-build.rs")
+            .linker(&cwd().join(bin_name("linker")).display().to_string())
+            .run();
+        diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
+    });
+
+    run_in_tmpdir(|| {
+        rustc().input("reproducible-build-aux.rs").run();
+        rustc().input("reproducible-build.rs").crate_type("rlib").library_search_path("b").run();
+        rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
+        rustc().input("reproducible-build.rs").crate_type("rlib").library_search_path("a").run();
+        assert_eq!(rfs::read(rust_lib_name("reproducible_build")), rfs::read(rust_lib_name("foo")));
+    });
+
+    run_in_tmpdir(|| {
+        rustc().input("reproducible-build-aux.rs").run();
+        rustc()
+            .input("reproducible-build.rs")
+            .crate_type("rlib")
+            .arg("--remap-path-prefix=/a=/c")
+            .run();
+        rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
+        rustc()
+            .input("reproducible-build.rs")
+            .crate_type("rlib")
+            .arg("--remap-path-prefix=/b=/c")
+            .run();
+        assert_eq!(rfs::read(rust_lib_name("reproducible_build")), rfs::read(rust_lib_name("foo")));
+    });
+
+    run_in_tmpdir(|| {
+        rustc().input("reproducible-build-aux.rs").run();
+        rfs::create_dir("test");
+        rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
+        rustc()
+            .input("reproducible-build.rs")
+            .crate_type("bin")
+            .arg(&format!("--remap-path-prefix={}=/b", cwd().display()))
+            .run();
+        eprintln!("{:#?}", rfs::shallow_find_dir_entries(cwd()));
+        rfs::copy(bin_name("reproducible_build"), bin_name("foo"));
+        rustc()
+            .input("test/reproducible-build.rs")
+            .crate_type("bin")
+            .arg("--remap-path-prefix=/test=/b")
+            .run();
+        assert_eq!(rfs::read(bin_name("reproducible_build")), rfs::read(bin_name("foo")));
+    });
+
+    run_in_tmpdir(|| {
+        rustc().input("reproducible-build-aux.rs").run();
+        rfs::create_dir("test");
+        rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
+        rustc()
+            .input("reproducible-build.rs")
+            .crate_type("rlib")
+            .arg(&format!("--remap-path-prefix={}=/b", cwd().display()))
+            .run();
+        rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
+        rustc()
+            .input("test/reproducible-build.rs")
+            .crate_type("rlib")
+            .arg("--remap-path-prefix=/test=/b")
+            .run();
+        assert_eq!(rfs::read(rust_lib_name("reproducible_build")), rfs::read(rust_lib_name("foo")));
+    });
+
+    run_in_tmpdir(|| {
+        rustc().input("reproducible-build-aux.rs").run();
+        rfs::create_dir("test");
+        rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
+        rustc()
+            .input("reproducible-build.rs")
+            .crate_type("bin")
+            .arg("-Zremap-path-prefix=.")
+            .arg("-Cdebuginfo=2")
+            .run();
+        rfs::copy(bin_name("reproducible_build"), bin_name("first"));
+        rustc()
+            .input("test/reproducible-build.rs")
+            .crate_type("bin")
+            .arg("-Zremap-path-prefix=.")
+            .arg("-Cdebuginfo=2")
+            .run();
+        assert_eq!(rfs::read(bin_name("first")), rfs::read(bin_name("reproducible_build")));
+    });
+
+    run_in_tmpdir(|| {
+        rustc().input("reproducible-build-aux.rs").run();
+        rfs::create_dir("test");
+        rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
+        rustc()
+            .input("reproducible-build.rs")
+            .crate_type("rlib")
+            .arg("-Zremap-path-prefix=.")
+            .arg("-Cdebuginfo=2")
+            .run();
+        rfs::copy("reproducible_build", "first");
+        rustc()
+            .input("test/reproducible-build.rs")
+            .crate_type("rlib")
+            .arg("-Zremap-path-prefix=.")
+            .arg("-Cdebuginfo=2")
+            .run();
+        assert_eq!(
+            rfs::read(rust_lib_name("first")),
+            rfs::read(rust_lib_name("reproducible_build"))
+        );
+    });
+
+    run_in_tmpdir(|| {
+        rustc().input("reproducible-build-aux.rs").run();
+        rfs::create_dir("test");
+        rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
+        rustc()
+            .input("reproducible-build.rs")
+            .crate_type("rlib")
+            .arg("-Zremap-path-prefix=")
+            .arg("-Cdebuginfo=2")
+            .run();
+        rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("first"));
+        rustc()
+            .input("test/reproducible-build.rs")
+            .crate_type("rlib")
+            .arg("-Zremap-path-prefix=")
+            .arg("-Cdebuginfo=2")
+            .run();
+        assert_eq!(
+            rfs::read(rust_lib_name("first")),
+            rfs::read(rust_lib_name("reproducible_build"))
+        );
+    });
+
+    run_in_tmpdir(|| {
+        rustc().input("reproducible-build-aux.rs").run();
+        rustc()
+            .input("reproducible-build.rs")
+            .crate_type("rlib")
+            .extern_("reproducible_build_aux", rust_lib_name("reproducible_build_aux"))
+            .run();
+        rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
+        rfs::copy(rust_lib_name("reproducible_build_aux"), rust_lib_name("bar"));
+        rustc()
+            .input("reproducible-build.rs")
+            .crate_type("rlib")
+            .extern_("reproducible_build_aux", rust_lib_name("bar"))
+            .run();
+        assert_eq!(rfs::read(rust_lib_name("foo")), rfs::read(rust_lib_name("reproducible_build")));
+    });
+}

From e752410a43f2141ed592498219c808898b0cce61 Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Tue, 6 Aug 2024 12:37:15 -0400
Subject: [PATCH 325/685] massive refactor of reproducible-build test

---
 tests/run-make/reproducible-build/rmake.rs | 340 +++++++++++----------
 1 file changed, 179 insertions(+), 161 deletions(-)

diff --git a/tests/run-make/reproducible-build/rmake.rs b/tests/run-make/reproducible-build/rmake.rs
index a5f27f34f4fcc..34410d224fbc4 100644
--- a/tests/run-make/reproducible-build/rmake.rs
+++ b/tests/run-make/reproducible-build/rmake.rs
@@ -18,205 +18,223 @@
 // - Trait object shims
 // - Fn Pointer shims
 // See https://github.com/rust-lang/rust/pull/32293
+// Tracking Issue: https://github.com/rust-lang/rust/issues/129080
 
-// FIXME(Oneirical): ignore-musl
-// FIXME(Oneirical): two of these test blocks will apparently fail on windows
-// FIXME(Oneirical): try it on test-various
-// # FIXME: Builds of `bin` crate types are not deterministic with debuginfo=2 on
-// # Windows.
-// # See: https://github.com/rust-lang/rust/pull/87320#issuecomment-920105533
-// # Issue: https://github.com/rust-lang/rust/issues/88982
-
-use run_make_support::{bin_name, cwd, diff, rfs, run_in_tmpdir, rust_lib_name, rustc};
+use run_make_support::{
+    bin_name, cwd, diff, is_darwin, is_windows, rfs, run_in_tmpdir, rust_lib_name, rustc,
+};
 
 fn main() {
-    run_in_tmpdir(|| {
-        rustc().input("linker.rs").opt().run();
-        rustc().input("reproducible-build-aux.rs").run();
-        rustc()
-            .input("reproducible-build.rs")
-            .linker(&cwd().join(bin_name("linker")).display().to_string())
-            .run();
-        rustc()
-            .input("reproducible-build.rs")
-            .linker(&cwd().join(bin_name("linker")).display().to_string())
-            .run();
-        diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
-    });
+    // Smoke tests. Simple flags, build should be reproducible.
+    eprintln!("smoke_test => None");
+    smoke_test(None);
+    eprintln!("smoke_test => SmokeFlag::Debug");
+    smoke_test(Some(SmokeFlag::Debug));
+    eprintln!("smoke_test => SmokeFlag::Opt");
+    smoke_test(Some(SmokeFlag::Opt));
 
-    run_in_tmpdir(|| {
-        rustc().input("linker.rs").opt().run();
-        rustc().arg("-g").input("reproducible-build-aux.rs").run();
-        rustc()
-            .arg("-g")
-            .input("reproducible-build.rs")
-            .linker(&cwd().join(bin_name("linker")).display().to_string())
-            .run();
-        rustc()
-            .arg("-g")
-            .input("reproducible-build.rs")
-            .linker(&cwd().join(bin_name("linker")).display().to_string())
-            .run();
-        diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
-    });
+    // Builds should be reproducible even through custom library search paths
+    // or remap path prefixes.
+    eprintln!("paths_test => PathsFlag::Link");
+    paths_test(PathsFlag::Link);
+    eprintln!("paths_test => PathsFlag::Remap");
+    paths_test(PathsFlag::Remap);
 
-    run_in_tmpdir(|| {
-        rustc().input("linker.rs").opt().run();
-        rustc().opt().input("reproducible-build-aux.rs").run();
-        rustc()
-            .opt()
-            .input("reproducible-build.rs")
-            .linker(&cwd().join(bin_name("linker")).display().to_string())
-            .run();
-        rustc()
-            .opt()
-            .input("reproducible-build.rs")
-            .linker(&cwd().join(bin_name("linker")).display().to_string())
-            .run();
-        diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
-    });
+    // Builds should be reproducible even if each build is done in a different directory,
+    // with both --remap-path-prefix and -Z remap-cwd-prefix.
 
-    run_in_tmpdir(|| {
-        rustc().input("reproducible-build-aux.rs").run();
-        rustc().input("reproducible-build.rs").crate_type("rlib").library_search_path("b").run();
-        rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
-        rustc().input("reproducible-build.rs").crate_type("rlib").library_search_path("a").run();
-        assert_eq!(rfs::read(rust_lib_name("reproducible_build")), rfs::read(rust_lib_name("foo")));
-    });
+    // FIXME(Oneirical): Building with crate type set to `bin` AND having -Cdebuginfo=2
+    // (or `-g`, the shorthand form) enabled will cause reproducibility failures.
+    // See https://github.com/rust-lang/rust/issues/89911
+
+    if !is_darwin() && !is_windows() {
+        // FIXME(Oneirical): Bin builds are not reproducible on non-Linux targets.
+        eprintln!("diff_dir_test => Bin, Path");
+        diff_dir_test(CrateType::Bin, RemapType::Path);
+    }
+
+    eprintln!("diff_dir_test => Rlib, Path");
+    diff_dir_test(CrateType::Rlib, RemapType::Path);
+
+    // FIXME(Oneirical): This specific case would fail on Linux, should -Cdebuginfo=2
+    // be added.
+    // FIXME(Oneirical): Bin builds are not reproducible on non-Linux targets.
+    // See https://github.com/rust-lang/rust/issues/89911
+    if !is_darwin() && !is_windows() {
+        eprintln!("diff_dir_test => Bin, Cwd false");
+        diff_dir_test(CrateType::Bin, RemapType::Cwd { is_empty: false });
+    }
 
+    eprintln!("diff_dir_test => Rlib, Cwd false");
+    diff_dir_test(CrateType::Rlib, RemapType::Cwd { is_empty: false });
+    eprintln!("diff_dir_test => Rlib, Cwd true");
+    diff_dir_test(CrateType::Rlib, RemapType::Cwd { is_empty: true });
+
+    eprintln!("final extern test");
+    // Builds should be reproducible when using the --extern flag.
     run_in_tmpdir(|| {
         rustc().input("reproducible-build-aux.rs").run();
         rustc()
             .input("reproducible-build.rs")
             .crate_type("rlib")
-            .arg("--remap-path-prefix=/a=/c")
+            .extern_("reproducible_build_aux", rust_lib_name("reproducible_build_aux"))
             .run();
         rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
+        rfs::copy(rust_lib_name("reproducible_build_aux"), rust_lib_name("bar"));
         rustc()
             .input("reproducible-build.rs")
             .crate_type("rlib")
-            .arg("--remap-path-prefix=/b=/c")
+            .extern_("reproducible_build_aux", rust_lib_name("bar"))
             .run();
-        assert_eq!(rfs::read(rust_lib_name("reproducible_build")), rfs::read(rust_lib_name("foo")));
+        assert!(rfs::read(rust_lib_name("foo")) == rfs::read(rust_lib_name("reproducible_build")))
     });
+}
 
+#[track_caller]
+fn smoke_test(flag: Option<SmokeFlag>) {
     run_in_tmpdir(|| {
+        rustc().input("linker.rs").opt().run();
         rustc().input("reproducible-build-aux.rs").run();
-        rfs::create_dir("test");
-        rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
-        rustc()
+        let mut compiler1 = rustc();
+        let mut compiler2 = rustc();
+        if let Some(flag) = flag {
+            match flag {
+                SmokeFlag::Debug => {
+                    compiler1.arg("-g");
+                    compiler2.arg("-g");
+                }
+                SmokeFlag::Opt => {
+                    compiler1.opt();
+                    compiler2.opt();
+                }
+            };
+        };
+        compiler1
             .input("reproducible-build.rs")
-            .crate_type("bin")
-            .arg(&format!("--remap-path-prefix={}=/b", cwd().display()))
-            .run();
-        eprintln!("{:#?}", rfs::shallow_find_dir_entries(cwd()));
-        rfs::copy(bin_name("reproducible_build"), bin_name("foo"));
-        rustc()
-            .input("test/reproducible-build.rs")
-            .crate_type("bin")
-            .arg("--remap-path-prefix=/test=/b")
+            .linker(&cwd().join(bin_name("linker")).display().to_string())
             .run();
-        assert_eq!(rfs::read(bin_name("reproducible_build")), rfs::read(bin_name("foo")));
-    });
-
-    run_in_tmpdir(|| {
-        rustc().input("reproducible-build-aux.rs").run();
-        rfs::create_dir("test");
-        rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
-        rustc()
+        compiler2
             .input("reproducible-build.rs")
-            .crate_type("rlib")
-            .arg(&format!("--remap-path-prefix={}=/b", cwd().display()))
-            .run();
-        rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
-        rustc()
-            .input("test/reproducible-build.rs")
-            .crate_type("rlib")
-            .arg("--remap-path-prefix=/test=/b")
+            .linker(&cwd().join(bin_name("linker")).display().to_string())
             .run();
-        assert_eq!(rfs::read(rust_lib_name("reproducible_build")), rfs::read(rust_lib_name("foo")));
+        diff().actual_file("linker-arguments1").expected_file("linker-arguments2").run();
     });
+}
 
+#[track_caller]
+fn paths_test(flag: PathsFlag) {
     run_in_tmpdir(|| {
         rustc().input("reproducible-build-aux.rs").run();
-        rfs::create_dir("test");
-        rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
-        rustc()
-            .input("reproducible-build.rs")
-            .crate_type("bin")
-            .arg("-Zremap-path-prefix=.")
-            .arg("-Cdebuginfo=2")
-            .run();
-        rfs::copy(bin_name("reproducible_build"), bin_name("first"));
-        rustc()
-            .input("test/reproducible-build.rs")
-            .crate_type("bin")
-            .arg("-Zremap-path-prefix=.")
-            .arg("-Cdebuginfo=2")
-            .run();
-        assert_eq!(rfs::read(bin_name("first")), rfs::read(bin_name("reproducible_build")));
+        let mut compiler1 = rustc();
+        let mut compiler2 = rustc();
+        match flag {
+            PathsFlag::Link => {
+                compiler1.library_search_path("a");
+                compiler2.library_search_path("b");
+            }
+            PathsFlag::Remap => {
+                compiler1.arg("--remap-path-prefix=/a=/c");
+                compiler2.arg("--remap-path-prefix=/b=/c");
+            }
+        }
+        compiler1.input("reproducible-build.rs").crate_type("rlib").run();
+        rfs::rename(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
+        compiler2.input("reproducible-build.rs").crate_type("rlib").run();
+        assert!(rfs::read(rust_lib_name("foo")) == rfs::read(rust_lib_name("reproducible_build")))
     });
+}
 
+#[track_caller]
+fn diff_dir_test(crate_type: CrateType, remap_type: RemapType) {
     run_in_tmpdir(|| {
+        let base_dir = cwd();
         rustc().input("reproducible-build-aux.rs").run();
         rfs::create_dir("test");
         rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
-        rustc()
+        let mut compiler1 = rustc();
+        let mut compiler2 = rustc();
+        match crate_type {
+            CrateType::Bin => {
+                compiler1.crate_type("bin");
+                compiler2.crate_type("bin");
+            }
+            CrateType::Rlib => {
+                compiler1.crate_type("rlib");
+                compiler2.crate_type("rlib");
+            }
+        }
+        match remap_type {
+            RemapType::Path => {
+                compiler1.arg(&format!("--remap-path-prefix={}=/b", cwd().display()));
+                compiler2
+                    .arg(format!("--remap-path-prefix={}=/b", base_dir.join("test").display()));
+            }
+            RemapType::Cwd { is_empty } => {
+                // FIXME(Oneirical): Building with crate type set to `bin` AND having -Cdebuginfo=2
+                // (or `-g`, the shorthand form) enabled will cause reproducibility failures
+                // for multiple platforms.
+                // See https://github.com/rust-lang/rust/issues/89911
+                // FIXME(#129117): Windows rlib + `-Cdebuginfo=2` + `-Z remap-cwd-prefix=.` seems
+                // to be unreproducible.
+                if !matches!(crate_type, CrateType::Bin) && !is_windows() {
+                    compiler1.arg("-Cdebuginfo=2");
+                    compiler2.arg("-Cdebuginfo=2");
+                }
+                if is_empty {
+                    compiler1.arg("-Zremap-cwd-prefix=");
+                    compiler2.arg("-Zremap-cwd-prefix=");
+                } else {
+                    compiler1.arg("-Zremap-cwd-prefix=.");
+                    compiler2.arg("-Zremap-cwd-prefix=.");
+                }
+            }
+        }
+        compiler1.input("reproducible-build.rs").run();
+        match crate_type {
+            CrateType::Bin => {
+                rfs::rename(bin_name("reproducible-build"), bin_name("foo"));
+            }
+            CrateType::Rlib => {
+                rfs::rename(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
+            }
+        }
+        std::env::set_current_dir("test").unwrap();
+        compiler2
             .input("reproducible-build.rs")
-            .crate_type("rlib")
-            .arg("-Zremap-path-prefix=.")
-            .arg("-Cdebuginfo=2")
-            .run();
-        rfs::copy("reproducible_build", "first");
-        rustc()
-            .input("test/reproducible-build.rs")
-            .crate_type("rlib")
-            .arg("-Zremap-path-prefix=.")
-            .arg("-Cdebuginfo=2")
-            .run();
-        assert_eq!(
-            rfs::read(rust_lib_name("first")),
-            rfs::read(rust_lib_name("reproducible_build"))
-        );
+            .library_search_path(&base_dir)
+            .out_dir(&base_dir)
+            .run();
+        std::env::set_current_dir(&base_dir).unwrap();
+        match crate_type {
+            CrateType::Bin => {
+                assert!(rfs::read(bin_name("reproducible-build")) == rfs::read(bin_name("foo")));
+            }
+            CrateType::Rlib => {
+                assert!(
+                    rfs::read(rust_lib_name("foo"))
+                        == rfs::read(rust_lib_name("reproducible_build"))
+                );
+            }
+        }
     });
+}
 
-    run_in_tmpdir(|| {
-        rustc().input("reproducible-build-aux.rs").run();
-        rfs::create_dir("test");
-        rfs::copy("reproducible-build.rs", "test/reproducible-build.rs");
-        rustc()
-            .input("reproducible-build.rs")
-            .crate_type("rlib")
-            .arg("-Zremap-path-prefix=")
-            .arg("-Cdebuginfo=2")
-            .run();
-        rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("first"));
-        rustc()
-            .input("test/reproducible-build.rs")
-            .crate_type("rlib")
-            .arg("-Zremap-path-prefix=")
-            .arg("-Cdebuginfo=2")
-            .run();
-        assert_eq!(
-            rfs::read(rust_lib_name("first")),
-            rfs::read(rust_lib_name("reproducible_build"))
-        );
-    });
+enum SmokeFlag {
+    Debug,
+    Opt,
+}
 
-    run_in_tmpdir(|| {
-        rustc().input("reproducible-build-aux.rs").run();
-        rustc()
-            .input("reproducible-build.rs")
-            .crate_type("rlib")
-            .extern_("reproducible_build_aux", rust_lib_name("reproducible_build_aux"))
-            .run();
-        rfs::copy(rust_lib_name("reproducible_build"), rust_lib_name("foo"));
-        rfs::copy(rust_lib_name("reproducible_build_aux"), rust_lib_name("bar"));
-        rustc()
-            .input("reproducible-build.rs")
-            .crate_type("rlib")
-            .extern_("reproducible_build_aux", rust_lib_name("bar"))
-            .run();
-        assert_eq!(rfs::read(rust_lib_name("foo")), rfs::read(rust_lib_name("reproducible_build")));
-    });
+enum PathsFlag {
+    Link,
+    Remap,
+}
+
+enum CrateType {
+    Bin,
+    Rlib,
+}
+
+enum RemapType {
+    Path,
+    Cwd { is_empty: bool },
 }

From 17cfbc6fa37b7b82a4b4f2fb1637082fec2967ad Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 16 Aug 2024 12:03:42 +0200
Subject: [PATCH 326/685] FD: remove big surrounding RefCell, simplify
 socketpair

---
 src/tools/miri/src/shims/unix/fd.rs           | 101 ++++++-------
 src/tools/miri/src/shims/unix/fs.rs           |  48 +++---
 src/tools/miri/src/shims/unix/linux/epoll.rs  |  24 ++-
 .../miri/src/shims/unix/linux/eventfd.rs      |  37 +++--
 src/tools/miri/src/shims/unix/socket.rs       | 142 ++++++++----------
 .../miri/tests/pass-dep/libc/libc-epoll.rs    |   4 +
 6 files changed, 169 insertions(+), 187 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/fd.rs b/src/tools/miri/src/shims/unix/fd.rs
index 98a124b9a5620..1fd1cf4d99e0e 100644
--- a/src/tools/miri/src/shims/unix/fd.rs
+++ b/src/tools/miri/src/shims/unix/fd.rs
@@ -2,9 +2,9 @@
 //! standard file descriptors (stdin/stdout/stderr).
 
 use std::any::Any;
-use std::cell::{Ref, RefCell, RefMut};
 use std::collections::BTreeMap;
 use std::io::{self, ErrorKind, IsTerminal, Read, SeekFrom, Write};
+use std::ops::Deref;
 use std::rc::Rc;
 use std::rc::Weak;
 
@@ -27,7 +27,7 @@ pub trait FileDescription: std::fmt::Debug + Any {
 
     /// Reads as much as possible into the given buffer, and returns the number of bytes read.
     fn read<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         _fd_id: FdId,
         _bytes: &mut [u8],
@@ -38,7 +38,7 @@ pub trait FileDescription: std::fmt::Debug + Any {
 
     /// Writes as much as possible from the given buffer, and returns the number of bytes written.
     fn write<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         _fd_id: FdId,
         _bytes: &[u8],
@@ -50,7 +50,7 @@ pub trait FileDescription: std::fmt::Debug + Any {
     /// Reads as much as possible into the given buffer from a given offset,
     /// and returns the number of bytes read.
     fn pread<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         _bytes: &mut [u8],
         _offset: u64,
@@ -62,7 +62,7 @@ pub trait FileDescription: std::fmt::Debug + Any {
     /// Writes as much as possible from the given buffer starting at a given offset,
     /// and returns the number of bytes written.
     fn pwrite<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         _bytes: &[u8],
         _offset: u64,
@@ -74,7 +74,7 @@ pub trait FileDescription: std::fmt::Debug + Any {
     /// Seeks to the given offset (which can be relative to the beginning, end, or current position).
     /// Returns the new position from the start of the stream.
     fn seek<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         _offset: SeekFrom,
     ) -> InterpResult<'tcx, io::Result<u64>> {
@@ -111,14 +111,9 @@ pub trait FileDescription: std::fmt::Debug + Any {
 
 impl dyn FileDescription {
     #[inline(always)]
-    pub fn downcast_ref<T: Any>(&self) -> Option<&T> {
+    pub fn downcast<T: Any>(&self) -> Option<&T> {
         (self as &dyn Any).downcast_ref()
     }
-
-    #[inline(always)]
-    pub fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> {
-        (self as &mut dyn Any).downcast_mut()
-    }
 }
 
 impl FileDescription for io::Stdin {
@@ -127,7 +122,7 @@ impl FileDescription for io::Stdin {
     }
 
     fn read<'tcx>(
-        &mut self,
+        &self,
         communicate_allowed: bool,
         _fd_id: FdId,
         bytes: &mut [u8],
@@ -137,7 +132,7 @@ impl FileDescription for io::Stdin {
             // We want isolation mode to be deterministic, so we have to disallow all reads, even stdin.
             helpers::isolation_abort_error("`read` from stdin")?;
         }
-        Ok(Read::read(self, bytes))
+        Ok(Read::read(&mut { self }, bytes))
     }
 
     fn is_tty(&self, communicate_allowed: bool) -> bool {
@@ -151,14 +146,14 @@ impl FileDescription for io::Stdout {
     }
 
     fn write<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         _fd_id: FdId,
         bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         // We allow writing to stderr even with isolation enabled.
-        let result = Write::write(self, bytes);
+        let result = Write::write(&mut { self }, bytes);
         // Stdout is buffered, flush to make sure it appears on the
         // screen.  This is the write() syscall of the interpreted
         // program, we want it to correspond to a write() syscall on
@@ -180,7 +175,7 @@ impl FileDescription for io::Stderr {
     }
 
     fn write<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         _fd_id: FdId,
         bytes: &[u8],
@@ -206,7 +201,7 @@ impl FileDescription for NullOutput {
     }
 
     fn write<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         _fd_id: FdId,
         bytes: &[u8],
@@ -221,26 +216,23 @@ impl FileDescription for NullOutput {
 #[derive(Clone, Debug)]
 pub struct FileDescWithId<T: FileDescription + ?Sized> {
     id: FdId,
-    file_description: RefCell<Box<T>>,
+    file_description: Box<T>,
 }
 
 #[derive(Clone, Debug)]
 pub struct FileDescriptionRef(Rc<FileDescWithId<dyn FileDescription>>);
 
-impl FileDescriptionRef {
-    fn new(fd: impl FileDescription, id: FdId) -> Self {
-        FileDescriptionRef(Rc::new(FileDescWithId {
-            id,
-            file_description: RefCell::new(Box::new(fd)),
-        }))
-    }
+impl Deref for FileDescriptionRef {
+    type Target = dyn FileDescription;
 
-    pub fn borrow(&self) -> Ref<'_, dyn FileDescription> {
-        Ref::map(self.0.file_description.borrow(), |fd| fd.as_ref())
+    fn deref(&self) -> &Self::Target {
+        &*self.0.file_description
     }
+}
 
-    pub fn borrow_mut(&self) -> RefMut<'_, dyn FileDescription> {
-        RefMut::map(self.0.file_description.borrow_mut(), |fd| fd.as_mut())
+impl FileDescriptionRef {
+    fn new(fd: impl FileDescription, id: FdId) -> Self {
+        FileDescriptionRef(Rc::new(FileDescWithId { id, file_description: Box::new(fd) }))
     }
 
     pub fn close<'tcx>(
@@ -256,7 +248,7 @@ impl FileDescriptionRef {
                 // Remove entry from the global epoll_event_interest table.
                 ecx.machine.epoll_interests.remove(id);
 
-                RefCell::into_inner(fd.file_description).close(communicate_allowed, ecx)
+                fd.file_description.close(communicate_allowed, ecx)
             }
             None => Ok(Ok(())),
         }
@@ -277,7 +269,7 @@ impl FileDescriptionRef {
         ecx: &mut InterpCx<'tcx, MiriMachine<'tcx>>,
     ) -> InterpResult<'tcx, ()> {
         use crate::shims::unix::linux::epoll::EvalContextExt;
-        ecx.check_and_update_readiness(self.get_id(), || self.borrow_mut().get_epoll_ready_events())
+        ecx.check_and_update_readiness(self.get_id(), || self.get_epoll_ready_events())
     }
 }
 
@@ -334,11 +326,20 @@ impl FdTable {
         fds
     }
 
-    /// Insert a new file description to the FdTable.
-    pub fn insert_new(&mut self, fd: impl FileDescription) -> i32 {
+    pub fn new_ref(&mut self, fd: impl FileDescription) -> FileDescriptionRef {
         let file_handle = FileDescriptionRef::new(fd, self.next_file_description_id);
         self.next_file_description_id = FdId(self.next_file_description_id.0.strict_add(1));
-        self.insert_ref_with_min_fd(file_handle, 0)
+        file_handle
+    }
+
+    /// Insert a new file description to the FdTable.
+    pub fn insert_new(&mut self, fd: impl FileDescription) -> i32 {
+        let fd_ref = self.new_ref(fd);
+        self.insert(fd_ref)
+    }
+
+    pub fn insert(&mut self, fd_ref: FileDescriptionRef) -> i32 {
+        self.insert_ref_with_min_fd(fd_ref, 0)
     }
 
     /// Insert a file description, giving it a file descriptor that is at least `min_fd`.
@@ -368,17 +369,7 @@ impl FdTable {
         new_fd
     }
 
-    pub fn get(&self, fd: i32) -> Option<Ref<'_, dyn FileDescription>> {
-        let fd = self.fds.get(&fd)?;
-        Some(fd.borrow())
-    }
-
-    pub fn get_mut(&self, fd: i32) -> Option<RefMut<'_, dyn FileDescription>> {
-        let fd = self.fds.get(&fd)?;
-        Some(fd.borrow_mut())
-    }
-
-    pub fn get_ref(&self, fd: i32) -> Option<FileDescriptionRef> {
+    pub fn get(&self, fd: i32) -> Option<FileDescriptionRef> {
         let fd = self.fds.get(&fd)?;
         Some(fd.clone())
     }
@@ -397,7 +388,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn dup(&mut self, old_fd: i32) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_mut();
 
-        let Some(dup_fd) = this.machine.fds.get_ref(old_fd) else {
+        let Some(dup_fd) = this.machine.fds.get(old_fd) else {
             return Ok(Scalar::from_i32(this.fd_not_found()?));
         };
         Ok(Scalar::from_i32(this.machine.fds.insert_ref_with_min_fd(dup_fd, 0)))
@@ -406,7 +397,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn dup2(&mut self, old_fd: i32, new_fd: i32) -> InterpResult<'tcx, Scalar> {
         let this = self.eval_context_mut();
 
-        let Some(dup_fd) = this.machine.fds.get_ref(old_fd) else {
+        let Some(dup_fd) = this.machine.fds.get(old_fd) else {
             return Ok(Scalar::from_i32(this.fd_not_found()?));
         };
         if new_fd != old_fd {
@@ -492,7 +483,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
             let start = this.read_scalar(&args[2])?.to_i32()?;
 
-            match this.machine.fds.get_ref(fd) {
+            match this.machine.fds.get(fd) {
                 Some(dup_fd) =>
                     Ok(Scalar::from_i32(this.machine.fds.insert_ref_with_min_fd(dup_fd, start))),
                 None => Ok(Scalar::from_i32(this.fd_not_found()?)),
@@ -565,7 +556,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let communicate = this.machine.communicate();
 
         // We temporarily dup the FD to be able to retain mutable access to `this`.
-        let Some(fd) = this.machine.fds.get_ref(fd) else {
+        let Some(fd) = this.machine.fds.get(fd) else {
             trace!("read: FD not found");
             return Ok(Scalar::from_target_isize(this.fd_not_found()?, this));
         };
@@ -576,14 +567,14 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // `usize::MAX` because it is bounded by the host's `isize`.
         let mut bytes = vec![0; usize::try_from(count).unwrap()];
         let result = match offset {
-            None => fd.borrow_mut().read(communicate, fd.get_id(), &mut bytes, this),
+            None => fd.read(communicate, fd.get_id(), &mut bytes, this),
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
                     let einval = this.eval_libc("EINVAL");
                     this.set_last_error(einval)?;
                     return Ok(Scalar::from_target_isize(-1, this));
                 };
-                fd.borrow_mut().pread(communicate, &mut bytes, offset, this)
+                fd.pread(communicate, &mut bytes, offset, this)
             }
         };
 
@@ -629,19 +620,19 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let bytes = this.read_bytes_ptr_strip_provenance(buf, Size::from_bytes(count))?.to_owned();
         // We temporarily dup the FD to be able to retain mutable access to `this`.
-        let Some(fd) = this.machine.fds.get_ref(fd) else {
+        let Some(fd) = this.machine.fds.get(fd) else {
             return Ok(Scalar::from_target_isize(this.fd_not_found()?, this));
         };
 
         let result = match offset {
-            None => fd.borrow_mut().write(communicate, fd.get_id(), &bytes, this),
+            None => fd.write(communicate, fd.get_id(), &bytes, this),
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
                     let einval = this.eval_libc("EINVAL");
                     this.set_last_error(einval)?;
                     return Ok(Scalar::from_target_isize(-1, this));
                 };
-                fd.borrow_mut().pwrite(communicate, &bytes, offset, this)
+                fd.pwrite(communicate, &bytes, offset, this)
             }
         };
 
diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index 9da36e64a0f99..e6076abedbd49 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -31,29 +31,29 @@ impl FileDescription for FileHandle {
     }
 
     fn read<'tcx>(
-        &mut self,
+        &self,
         communicate_allowed: bool,
         _fd_id: FdId,
         bytes: &mut [u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
-        Ok(self.file.read(bytes))
+        Ok((&mut &self.file).read(bytes))
     }
 
     fn write<'tcx>(
-        &mut self,
+        &self,
         communicate_allowed: bool,
         _fd_id: FdId,
         bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
-        Ok(self.file.write(bytes))
+        Ok((&mut &self.file).write(bytes))
     }
 
     fn pread<'tcx>(
-        &mut self,
+        &self,
         communicate_allowed: bool,
         bytes: &mut [u8],
         offset: u64,
@@ -63,13 +63,13 @@ impl FileDescription for FileHandle {
         // Emulates pread using seek + read + seek to restore cursor position.
         // Correctness of this emulation relies on sequential nature of Miri execution.
         // The closure is used to emulate `try` block, since we "bubble" `io::Error` using `?`.
+        let file = &mut &self.file;
         let mut f = || {
-            let cursor_pos = self.file.stream_position()?;
-            self.file.seek(SeekFrom::Start(offset))?;
-            let res = self.file.read(bytes);
+            let cursor_pos = file.stream_position()?;
+            file.seek(SeekFrom::Start(offset))?;
+            let res = file.read(bytes);
             // Attempt to restore cursor position even if the read has failed
-            self.file
-                .seek(SeekFrom::Start(cursor_pos))
+            file.seek(SeekFrom::Start(cursor_pos))
                 .expect("failed to restore file position, this shouldn't be possible");
             res
         };
@@ -77,7 +77,7 @@ impl FileDescription for FileHandle {
     }
 
     fn pwrite<'tcx>(
-        &mut self,
+        &self,
         communicate_allowed: bool,
         bytes: &[u8],
         offset: u64,
@@ -87,13 +87,13 @@ impl FileDescription for FileHandle {
         // Emulates pwrite using seek + write + seek to restore cursor position.
         // Correctness of this emulation relies on sequential nature of Miri execution.
         // The closure is used to emulate `try` block, since we "bubble" `io::Error` using `?`.
+        let file = &mut &self.file;
         let mut f = || {
-            let cursor_pos = self.file.stream_position()?;
-            self.file.seek(SeekFrom::Start(offset))?;
-            let res = self.file.write(bytes);
+            let cursor_pos = file.stream_position()?;
+            file.seek(SeekFrom::Start(offset))?;
+            let res = file.write(bytes);
             // Attempt to restore cursor position even if the write has failed
-            self.file
-                .seek(SeekFrom::Start(cursor_pos))
+            file.seek(SeekFrom::Start(cursor_pos))
                 .expect("failed to restore file position, this shouldn't be possible");
             res
         };
@@ -101,12 +101,12 @@ impl FileDescription for FileHandle {
     }
 
     fn seek<'tcx>(
-        &mut self,
+        &self,
         communicate_allowed: bool,
         offset: SeekFrom,
     ) -> InterpResult<'tcx, io::Result<u64>> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
-        Ok(self.file.seek(offset))
+        Ok((&mut &self.file).seek(offset))
     }
 
     fn close<'tcx>(
@@ -580,7 +580,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let communicate = this.machine.communicate();
 
-        let Some(mut file_description) = this.machine.fds.get_mut(fd) else {
+        let Some(file_description) = this.machine.fds.get(fd) else {
             return Ok(Scalar::from_i64(this.fd_not_found()?));
         };
         let result = file_description
@@ -1276,7 +1276,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // FIXME: Support ftruncate64 for all FDs
         let FileHandle { file, writable } =
-            file_description.downcast_ref::<FileHandle>().ok_or_else(|| {
+            file_description.downcast::<FileHandle>().ok_or_else(|| {
                 err_unsup_format!("`ftruncate64` is only supported on file-backed file descriptors")
             })?;
 
@@ -1328,7 +1328,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         };
         // Only regular files support synchronization.
         let FileHandle { file, writable } =
-            file_description.downcast_ref::<FileHandle>().ok_or_else(|| {
+            file_description.downcast::<FileHandle>().ok_or_else(|| {
                 err_unsup_format!("`fsync` is only supported on file-backed file descriptors")
             })?;
         let io_result = maybe_sync_file(file, *writable, File::sync_all);
@@ -1353,7 +1353,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         };
         // Only regular files support synchronization.
         let FileHandle { file, writable } =
-            file_description.downcast_ref::<FileHandle>().ok_or_else(|| {
+            file_description.downcast::<FileHandle>().ok_or_else(|| {
                 err_unsup_format!("`fdatasync` is only supported on file-backed file descriptors")
             })?;
         let io_result = maybe_sync_file(file, *writable, File::sync_data);
@@ -1401,7 +1401,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         };
         // Only regular files support synchronization.
         let FileHandle { file, writable } =
-            file_description.downcast_ref::<FileHandle>().ok_or_else(|| {
+            file_description.downcast::<FileHandle>().ok_or_else(|| {
                 err_unsup_format!(
                     "`sync_data_range` is only supported on file-backed file descriptors"
                 )
@@ -1708,7 +1708,7 @@ impl FileMetadata {
         };
 
         let file = &file_description
-            .downcast_ref::<FileHandle>()
+            .downcast::<FileHandle>()
             .ok_or_else(|| {
                 err_unsup_format!(
                     "obtaining metadata is only supported on file-backed file descriptors"
diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index 89616bd0d0723..a1b943f2e82a1 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -12,7 +12,7 @@ use crate::*;
 struct Epoll {
     /// A map of EpollEventInterests registered under this epoll instance.
     /// Each entry is differentiated using FdId and file descriptor value.
-    interest_list: BTreeMap<(FdId, i32), Rc<RefCell<EpollEventInterest>>>,
+    interest_list: RefCell<BTreeMap<(FdId, i32), Rc<RefCell<EpollEventInterest>>>>,
     /// A map of EpollEventInstance that will be returned when `epoll_wait` is called.
     /// Similar to interest_list, the entry is also differentiated using FdId
     /// and file descriptor value.
@@ -226,18 +226,17 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         }
 
         // Check if epfd is a valid epoll file descriptor.
-        let Some(epfd) = this.machine.fds.get_ref(epfd_value) else {
+        let Some(epfd) = this.machine.fds.get(epfd_value) else {
             return Ok(Scalar::from_i32(this.fd_not_found()?));
         };
-        let mut binding = epfd.borrow_mut();
-        let epoll_file_description = &mut binding
-            .downcast_mut::<Epoll>()
+        let epoll_file_description = epfd
+            .downcast::<Epoll>()
             .ok_or_else(|| err_unsup_format!("non-epoll FD passed to `epoll_ctl`"))?;
 
-        let interest_list = &mut epoll_file_description.interest_list;
+        let mut interest_list = epoll_file_description.interest_list.borrow_mut();
         let ready_list = &epoll_file_description.ready_list;
 
-        let Some(file_descriptor) = this.machine.fds.get_ref(fd) else {
+        let Some(file_descriptor) = this.machine.fds.get(fd) else {
             return Ok(Scalar::from_i32(this.fd_not_found()?));
         };
         let id = file_descriptor.get_id();
@@ -399,16 +398,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             throw_unsup_format!("epoll_wait: timeout value can only be 0");
         }
 
-        let Some(epfd) = this.machine.fds.get_ref(epfd) else {
+        let Some(epfd) = this.machine.fds.get(epfd) else {
             return Ok(Scalar::from_i32(this.fd_not_found()?));
         };
-        let mut binding = epfd.borrow_mut();
-        let epoll_file_description = &mut binding
-            .downcast_mut::<Epoll>()
+        let epoll_file_description = epfd
+            .downcast::<Epoll>()
             .ok_or_else(|| err_unsup_format!("non-epoll FD passed to `epoll_wait`"))?;
 
-        let binding = epoll_file_description.get_ready_list();
-        let mut ready_list = binding.borrow_mut();
+        let ready_list = epoll_file_description.get_ready_list();
+        let mut ready_list = ready_list.borrow_mut();
         let mut num_of_events: i32 = 0;
         let mut array_iter = this.project_array_fields(&event)?;
 
diff --git a/src/tools/miri/src/shims/unix/linux/eventfd.rs b/src/tools/miri/src/shims/unix/linux/eventfd.rs
index 8a11f225b2248..cede3967bc846 100644
--- a/src/tools/miri/src/shims/unix/linux/eventfd.rs
+++ b/src/tools/miri/src/shims/unix/linux/eventfd.rs
@@ -1,4 +1,5 @@
 //! Linux `eventfd` implementation.
+use std::cell::{Cell, RefCell};
 use std::io;
 use std::io::{Error, ErrorKind};
 use std::mem;
@@ -27,9 +28,9 @@ const MAX_COUNTER: u64 = u64::MAX - 1;
 struct Event {
     /// The object contains an unsigned 64-bit integer (uint64_t) counter that is maintained by the
     /// kernel. This counter is initialized with the value specified in the argument initval.
-    counter: u64,
+    counter: Cell<u64>,
     is_nonblock: bool,
-    clock: VClock,
+    clock: RefCell<VClock>,
 }
 
 impl FileDescription for Event {
@@ -42,8 +43,8 @@ impl FileDescription for Event {
         // need to be supported in the future, the check should be added here.
 
         Ok(EpollReadyEvents {
-            epollin: self.counter != 0,
-            epollout: self.counter != MAX_COUNTER,
+            epollin: self.counter.get() != 0,
+            epollout: self.counter.get() != MAX_COUNTER,
             ..EpollReadyEvents::new()
         })
     }
@@ -58,7 +59,7 @@ impl FileDescription for Event {
 
     /// Read the counter in the buffer and return the counter if succeeded.
     fn read<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         fd_id: FdId,
         bytes: &mut [u8],
@@ -69,7 +70,8 @@ impl FileDescription for Event {
             return Ok(Err(Error::from(ErrorKind::InvalidInput)));
         };
         // Block when counter == 0.
-        if self.counter == 0 {
+        let counter = self.counter.get();
+        if counter == 0 {
             if self.is_nonblock {
                 return Ok(Err(Error::from(ErrorKind::WouldBlock)));
             } else {
@@ -78,13 +80,13 @@ impl FileDescription for Event {
             }
         } else {
             // Synchronize with all prior `write` calls to this FD.
-            ecx.acquire_clock(&self.clock);
+            ecx.acquire_clock(&self.clock.borrow());
             // Return the counter in the host endianness using the buffer provided by caller.
             *bytes = match ecx.tcx.sess.target.endian {
-                Endian::Little => self.counter.to_le_bytes(),
-                Endian::Big => self.counter.to_be_bytes(),
+                Endian::Little => counter.to_le_bytes(),
+                Endian::Big => counter.to_be_bytes(),
             };
-            self.counter = 0;
+            self.counter.set(0);
             // When any of the event happened, we check and update the status of all supported event
             // types for current file description.
 
@@ -114,7 +116,7 @@ impl FileDescription for Event {
     /// supplied buffer is less than 8 bytes, or if an attempt is
     /// made to write the value 0xffffffffffffffff.
     fn write<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         fd_id: FdId,
         bytes: &[u8],
@@ -135,13 +137,13 @@ impl FileDescription for Event {
         }
         // If the addition does not let the counter to exceed the maximum value, update the counter.
         // Else, block.
-        match self.counter.checked_add(num) {
+        match self.counter.get().checked_add(num) {
             Some(new_count @ 0..=MAX_COUNTER) => {
                 // Future `read` calls will synchronize with this write, so update the FD clock.
                 if let Some(clock) = &ecx.release_clock() {
-                    self.clock.join(clock);
+                    self.clock.borrow_mut().join(clock);
                 }
-                self.counter = new_count;
+                self.counter.set(new_count);
             }
             None | Some(u64::MAX) => {
                 if self.is_nonblock {
@@ -219,8 +221,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let fds = &mut this.machine.fds;
 
-        let fd_value =
-            fds.insert_new(Event { counter: val.into(), is_nonblock, clock: VClock::default() });
+        let fd_value = fds.insert_new(Event {
+            counter: Cell::new(val.into()),
+            is_nonblock,
+            clock: RefCell::new(VClock::default()),
+        });
 
         Ok(Scalar::from_i32(fd_value))
     }
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index 0f40d9776bbb8..2694391dfbb34 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -1,8 +1,7 @@
-use std::cell::RefCell;
+use std::cell::{OnceCell, RefCell};
 use std::collections::VecDeque;
 use std::io;
 use std::io::{Error, ErrorKind, Read};
-use std::rc::{Rc, Weak};
 
 use crate::shims::unix::fd::{FdId, WeakFileDescriptionRef};
 use crate::shims::unix::linux::epoll::EpollReadyEvents;
@@ -17,15 +16,12 @@ const MAX_SOCKETPAIR_BUFFER_CAPACITY: usize = 212992;
 /// Pair of connected sockets.
 #[derive(Debug)]
 struct SocketPair {
-    // By making the write link weak, a `write` can detect when all readers are
-    // gone, and trigger EPIPE as appropriate.
-    writebuf: Weak<RefCell<Buffer>>,
-    readbuf: Rc<RefCell<Buffer>>,
-    /// When a socketpair instance is created, two socketpair file descriptions are generated.
-    /// The peer_fd field holds a weak reference to the file description of peer socketpair.
-    // TODO: It might be possible to retrieve writebuf from peer_fd and remove the writebuf
-    // field above.
-    peer_fd: WeakFileDescriptionRef,
+    /// The buffer we are reading from.
+    readbuf: RefCell<Buffer>,
+    /// The `SocketPair` file descriptor that is our "peer", and that holds the buffer we are
+    /// writing to. This is a weak reference because the other side may be closed before us; all
+    /// future writes will then trigger EPIPE.
+    peer_fd: OnceCell<WeakFileDescriptionRef>,
     is_nonblock: bool,
 }
 
@@ -39,6 +35,18 @@ struct Buffer {
     buf_has_writer: bool,
 }
 
+impl Buffer {
+    fn new() -> Self {
+        Buffer { buf: VecDeque::new(), clock: VClock::default(), buf_has_writer: true }
+    }
+}
+
+impl SocketPair {
+    fn peer_fd(&self) -> &WeakFileDescriptionRef {
+        self.peer_fd.get().unwrap()
+    }
+}
+
 impl FileDescription for SocketPair {
     fn name(&self) -> &'static str {
         "socketpair"
@@ -49,29 +57,29 @@ impl FileDescription for SocketPair {
         // need to be supported in the future, the check should be added here.
 
         let mut epoll_ready_events = EpollReadyEvents::new();
-        let readbuf = self.readbuf.borrow();
 
         // Check if it is readable.
+        let readbuf = self.readbuf.borrow();
         if !readbuf.buf.is_empty() {
             epoll_ready_events.epollin = true;
         }
 
         // Check if is writable.
-        if let Some(writebuf) = self.writebuf.upgrade() {
-            let writebuf = writebuf.borrow();
+        if let Some(peer_fd) = self.peer_fd().upgrade() {
+            let writebuf = &peer_fd.downcast::<SocketPair>().unwrap().readbuf.borrow();
             let data_size = writebuf.buf.len();
             let available_space = MAX_SOCKETPAIR_BUFFER_CAPACITY.strict_sub(data_size);
             if available_space != 0 {
                 epoll_ready_events.epollout = true;
             }
-        }
-
-        // Check if the peer_fd closed
-        if self.peer_fd.upgrade().is_none() {
+        } else {
+            // Peer FD has been closed.
             epoll_ready_events.epollrdhup = true;
-            // This is an edge case. Whenever epollrdhup is triggered, epollin will be added
-            // even though there is no data in the buffer.
+            // This is an edge case. Whenever epollrdhup is triggered, epollin and epollout will be
+            // added even though there is no data in the buffer.
+            // FIXME: Figure out why. This looks like a bug.
             epoll_ready_events.epollin = true;
+            epoll_ready_events.epollout = true;
         }
         Ok(epoll_ready_events)
     }
@@ -81,15 +89,13 @@ impl FileDescription for SocketPair {
         _communicate_allowed: bool,
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<()>> {
-        // This is used to signal socketfd of other side that there is no writer to its readbuf.
-        // If the upgrade fails, there is no need to update as all read ends have been dropped.
-        if let Some(writebuf) = self.writebuf.upgrade() {
-            writebuf.borrow_mut().buf_has_writer = false;
-        };
+        if let Some(peer_fd) = self.peer_fd().upgrade() {
+            // This is used to signal socketfd of other side that there is no writer to its readbuf.
+            // If the upgrade fails, there is no need to update as all read ends have been dropped.
+            peer_fd.downcast::<SocketPair>().unwrap().readbuf.borrow_mut().buf_has_writer = false;
 
-        // Notify peer fd that closed has happened.
-        if let Some(peer_fd) = self.peer_fd.upgrade() {
-            // When any of the event happened, we check and update the status of all supported events
+            // Notify peer fd that closed has happened.
+            // When any of the events happened, we check and update the status of all supported events
             // types of peer fd.
             peer_fd.check_and_update_readiness(ecx)?;
         }
@@ -97,20 +103,20 @@ impl FileDescription for SocketPair {
     }
 
     fn read<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         _fd_id: FdId,
         bytes: &mut [u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
         let request_byte_size = bytes.len();
-        let mut readbuf = self.readbuf.borrow_mut();
 
         // Always succeed on read size 0.
         if request_byte_size == 0 {
             return Ok(Ok(0));
         }
 
+        let mut readbuf = self.readbuf.borrow_mut();
         if readbuf.buf.is_empty() {
             if !readbuf.buf_has_writer {
                 // Socketpair with no writer and empty buffer.
@@ -141,8 +147,7 @@ impl FileDescription for SocketPair {
         // Conveniently, `read` exists on `VecDeque` and has exactly the desired behavior.
         let actual_read_size = readbuf.buf.read(bytes).unwrap();
 
-        // The readbuf needs to be explicitly dropped because it will cause panic when
-        // check_and_update_readiness borrows it again.
+        // Need to drop before others can access the readbuf again.
         drop(readbuf);
 
         // A notification should be provided for the peer file description even when it can
@@ -152,7 +157,7 @@ impl FileDescription for SocketPair {
         // don't know what that *certain number* is, we will provide a notification every time
         // a read is successful. This might result in our epoll emulation providing more
         // notifications than the real system.
-        if let Some(peer_fd) = self.peer_fd.upgrade() {
+        if let Some(peer_fd) = self.peer_fd().upgrade() {
             peer_fd.check_and_update_readiness(ecx)?;
         }
 
@@ -160,7 +165,7 @@ impl FileDescription for SocketPair {
     }
 
     fn write<'tcx>(
-        &mut self,
+        &self,
         _communicate_allowed: bool,
         _fd_id: FdId,
         bytes: &[u8],
@@ -173,12 +178,13 @@ impl FileDescription for SocketPair {
             return Ok(Ok(0));
         }
 
-        let Some(writebuf) = self.writebuf.upgrade() else {
+        // We are writing to our peer's readbuf.
+        let Some(peer_fd) = self.peer_fd().upgrade() else {
             // If the upgrade from Weak to Rc fails, it indicates that all read ends have been
             // closed.
             return Ok(Err(Error::from(ErrorKind::BrokenPipe)));
         };
-        let mut writebuf = writebuf.borrow_mut();
+        let mut writebuf = peer_fd.downcast::<SocketPair>().unwrap().readbuf.borrow_mut();
         let data_size = writebuf.buf.len();
         let available_space = MAX_SOCKETPAIR_BUFFER_CAPACITY.strict_sub(data_size);
         if available_space == 0 {
@@ -198,13 +204,12 @@ impl FileDescription for SocketPair {
         let actual_write_size = write_size.min(available_space);
         writebuf.buf.extend(&bytes[..actual_write_size]);
 
-        // The writebuf needs to be explicitly dropped because it will cause panic when
-        // check_and_update_readiness borrows it again.
+        // Need to stop accessing peer_fd so that it can be notified.
         drop(writebuf);
+
         // Notification should be provided for peer fd as it became readable.
-        if let Some(peer_fd) = self.peer_fd.upgrade() {
-            peer_fd.check_and_update_readiness(ecx)?;
-        }
+        peer_fd.check_and_update_readiness(ecx)?;
+
         return Ok(Ok(actual_write_size));
     }
 }
@@ -268,51 +273,30 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             );
         }
 
-        let buffer1 = Rc::new(RefCell::new(Buffer {
-            buf: VecDeque::new(),
-            clock: VClock::default(),
-            buf_has_writer: true,
-        }));
-
-        let buffer2 = Rc::new(RefCell::new(Buffer {
-            buf: VecDeque::new(),
-            clock: VClock::default(),
-            buf_has_writer: true,
-        }));
-
-        let socketpair_0 = SocketPair {
-            writebuf: Rc::downgrade(&buffer1),
-            readbuf: Rc::clone(&buffer2),
-            peer_fd: WeakFileDescriptionRef::default(),
+        // Generate file descriptions.
+        let fds = &mut this.machine.fds;
+        let fd0 = fds.new_ref(SocketPair {
+            readbuf: RefCell::new(Buffer::new()),
+            peer_fd: OnceCell::new(),
             is_nonblock: is_sock_nonblock,
-        };
-        let socketpair_1 = SocketPair {
-            writebuf: Rc::downgrade(&buffer2),
-            readbuf: Rc::clone(&buffer1),
-            peer_fd: WeakFileDescriptionRef::default(),
+        });
+        let fd1 = fds.new_ref(SocketPair {
+            readbuf: RefCell::new(Buffer::new()),
+            peer_fd: OnceCell::new(),
             is_nonblock: is_sock_nonblock,
-        };
-
-        // Insert the file description to the fd table.
-        let fds = &mut this.machine.fds;
-        let sv0 = fds.insert_new(socketpair_0);
-        let sv1 = fds.insert_new(socketpair_1);
-
-        // Get weak file descriptor and file description id value.
-        let fd_ref0 = fds.get_ref(sv0).unwrap();
-        let fd_ref1 = fds.get_ref(sv1).unwrap();
-        let weak_fd_ref0 = fd_ref0.downgrade();
-        let weak_fd_ref1 = fd_ref1.downgrade();
+        });
 
-        // Update peer_fd and id field.
-        fd_ref1.borrow_mut().downcast_mut::<SocketPair>().unwrap().peer_fd = weak_fd_ref0;
+        // Make the file descriptions point to each other.
+        fd0.downcast::<SocketPair>().unwrap().peer_fd.set(fd1.downgrade()).unwrap();
+        fd1.downcast::<SocketPair>().unwrap().peer_fd.set(fd0.downgrade()).unwrap();
 
-        fd_ref0.borrow_mut().downcast_mut::<SocketPair>().unwrap().peer_fd = weak_fd_ref1;
+        // Insert the file description to the fd table, generating the file descriptors.
+        let sv0 = fds.insert(fd0);
+        let sv1 = fds.insert(fd1);
 
-        // Return socketpair file description value to the caller.
+        // Return socketpair file descriptors to the caller.
         let sv0 = Scalar::from_int(sv0, sv.layout.size);
         let sv1 = Scalar::from_int(sv1, sv.layout.size);
-
         this.write_scalar(sv0, &sv)?;
         this.write_scalar(sv1, &sv.offset(sv.layout.size, sv.layout, this)?)?;
 
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index 11a0257dc4e3d..95fdf2f603507 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -19,6 +19,7 @@ fn main() {
     test_socketpair_read();
 }
 
+#[track_caller]
 fn check_epoll_wait<const N: usize>(
     epfd: i32,
     mut expected_notifications: Vec<(u32, u64)>,
@@ -28,6 +29,9 @@ fn check_epoll_wait<const N: usize>(
     let maxsize = N;
     let array_ptr = array.as_mut_ptr();
     let res = unsafe { libc::epoll_wait(epfd, array_ptr, maxsize.try_into().unwrap(), 0) };
+    if res < 0 {
+        panic!("epoll_wait failed: {}", std::io::Error::last_os_error());
+    }
     assert_eq!(res, expected_notifications.len().try_into().unwrap());
     let slice = unsafe { std::slice::from_raw_parts(array_ptr, res.try_into().unwrap()) };
     let mut return_events = slice.iter();

From 82c39ffda785753d90d1d1b98537e7b9d2d889b3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 16 Aug 2024 12:15:07 +0200
Subject: [PATCH 327/685] buf_has_writer is not needed any more

---
 src/tools/miri/src/shims/unix/socket.rs | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index 2694391dfbb34..fba63890dd275 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -29,15 +29,11 @@ struct SocketPair {
 struct Buffer {
     buf: VecDeque<u8>,
     clock: VClock,
-    /// Indicates if there is at least one active writer to this buffer.
-    /// If all writers of this buffer are dropped, buf_has_writer becomes false and we
-    /// indicate EOF instead of blocking.
-    buf_has_writer: bool,
 }
 
 impl Buffer {
     fn new() -> Self {
-        Buffer { buf: VecDeque::new(), clock: VClock::default(), buf_has_writer: true }
+        Buffer { buf: VecDeque::new(), clock: VClock::default() }
     }
 }
 
@@ -90,10 +86,6 @@ impl FileDescription for SocketPair {
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<()>> {
         if let Some(peer_fd) = self.peer_fd().upgrade() {
-            // This is used to signal socketfd of other side that there is no writer to its readbuf.
-            // If the upgrade fails, there is no need to update as all read ends have been dropped.
-            peer_fd.downcast::<SocketPair>().unwrap().readbuf.borrow_mut().buf_has_writer = false;
-
             // Notify peer fd that closed has happened.
             // When any of the events happened, we check and update the status of all supported events
             // types of peer fd.
@@ -118,8 +110,8 @@ impl FileDescription for SocketPair {
 
         let mut readbuf = self.readbuf.borrow_mut();
         if readbuf.buf.is_empty() {
-            if !readbuf.buf_has_writer {
-                // Socketpair with no writer and empty buffer.
+            if self.peer_fd().upgrade().is_none() {
+                // Socketpair with no peer and empty buffer.
                 // 0 bytes successfully read indicates end-of-file.
                 return Ok(Ok(0));
             } else {

From 34aec7c2067c1eb959061e1df6e2998c359e2ea8 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 16 Aug 2024 12:22:00 +0200
Subject: [PATCH 328/685] make ecx.check_and_update_readiness a truly private
 helper function

---
 src/tools/miri/src/shims/unix/fd.rs           | 26 ++++++------------
 src/tools/miri/src/shims/unix/fs.rs           |  6 ++---
 src/tools/miri/src/shims/unix/linux/epoll.rs  | 21 +++++----------
 .../miri/src/shims/unix/linux/eventfd.rs      | 27 +++++--------------
 src/tools/miri/src/shims/unix/socket.rs       | 14 +++++-----
 5 files changed, 31 insertions(+), 63 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/fd.rs b/src/tools/miri/src/shims/unix/fd.rs
index 1fd1cf4d99e0e..e3b9835e360a6 100644
--- a/src/tools/miri/src/shims/unix/fd.rs
+++ b/src/tools/miri/src/shims/unix/fd.rs
@@ -28,8 +28,8 @@ pub trait FileDescription: std::fmt::Debug + Any {
     /// Reads as much as possible into the given buffer, and returns the number of bytes read.
     fn read<'tcx>(
         &self,
+        _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _fd_id: FdId,
         _bytes: &mut [u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -39,8 +39,8 @@ pub trait FileDescription: std::fmt::Debug + Any {
     /// Writes as much as possible from the given buffer, and returns the number of bytes written.
     fn write<'tcx>(
         &self,
+        _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _fd_id: FdId,
         _bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -123,8 +123,8 @@ impl FileDescription for io::Stdin {
 
     fn read<'tcx>(
         &self,
+        _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
-        _fd_id: FdId,
         bytes: &mut [u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -147,8 +147,8 @@ impl FileDescription for io::Stdout {
 
     fn write<'tcx>(
         &self,
+        _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _fd_id: FdId,
         bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -176,8 +176,8 @@ impl FileDescription for io::Stderr {
 
     fn write<'tcx>(
         &self,
+        _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _fd_id: FdId,
         bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -202,8 +202,8 @@ impl FileDescription for NullOutput {
 
     fn write<'tcx>(
         &self,
+        _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _fd_id: FdId,
         bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -261,16 +261,6 @@ impl FileDescriptionRef {
     pub fn get_id(&self) -> FdId {
         self.0.id
     }
-
-    /// Function used to retrieve the readiness events of a file description and insert
-    /// an `EpollEventInstance` into the ready list if the file description is ready.
-    pub(crate) fn check_and_update_readiness<'tcx>(
-        &self,
-        ecx: &mut InterpCx<'tcx, MiriMachine<'tcx>>,
-    ) -> InterpResult<'tcx, ()> {
-        use crate::shims::unix::linux::epoll::EvalContextExt;
-        ecx.check_and_update_readiness(self.get_id(), || self.get_epoll_ready_events())
-    }
 }
 
 /// Holds a weak reference to the actual file description.
@@ -567,7 +557,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // `usize::MAX` because it is bounded by the host's `isize`.
         let mut bytes = vec![0; usize::try_from(count).unwrap()];
         let result = match offset {
-            None => fd.read(communicate, fd.get_id(), &mut bytes, this),
+            None => fd.read(&fd, communicate, &mut bytes, this),
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
                     let einval = this.eval_libc("EINVAL");
@@ -625,7 +615,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         };
 
         let result = match offset {
-            None => fd.write(communicate, fd.get_id(), &bytes, this),
+            None => fd.write(&fd, communicate, &bytes, this),
             Some(offset) => {
                 let Ok(offset) = u64::try_from(offset) else {
                     let einval = this.eval_libc("EINVAL");
diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index e6076abedbd49..80f4b89bf34d3 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -12,7 +12,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_target::abi::Size;
 
 use crate::shims::os_str::bytes_to_os_str;
-use crate::shims::unix::fd::FdId;
+use crate::shims::unix::fd::FileDescriptionRef;
 use crate::shims::unix::*;
 use crate::*;
 use shims::time::system_time_to_duration;
@@ -32,8 +32,8 @@ impl FileDescription for FileHandle {
 
     fn read<'tcx>(
         &self,
+        _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
-        _fd_id: FdId,
         bytes: &mut [u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -43,8 +43,8 @@ impl FileDescription for FileHandle {
 
     fn write<'tcx>(
         &self,
+        _self_ref: &FileDescriptionRef,
         communicate_allowed: bool,
-        _fd_id: FdId,
         bytes: &[u8],
         _ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index a1b943f2e82a1..1ec2dbe233e2d 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -3,7 +3,7 @@ use std::collections::BTreeMap;
 use std::io;
 use std::rc::{Rc, Weak};
 
-use crate::shims::unix::fd::FdId;
+use crate::shims::unix::fd::{FdId, FileDescriptionRef};
 use crate::shims::unix::*;
 use crate::*;
 
@@ -309,7 +309,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
 
             // Readiness will be updated immediately when the epoll_event_interest is added or modified.
-            file_descriptor.check_and_update_readiness(this)?;
+            this.check_and_update_readiness(&file_descriptor)?;
 
             return Ok(Scalar::from_i32(0));
         } else if op == epoll_ctl_del {
@@ -432,22 +432,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         Ok(Scalar::from_i32(num_of_events))
     }
 
-    /// For a specific unique file descriptor id, get its ready events and update
+    /// For a specific file description, get its ready events and update
     /// the corresponding ready list. This function is called whenever a file description
-    /// is registered with epoll, or when read, write, or close operations are performed,
-    /// regardless of any changes in readiness.
-    ///
-    /// This is an internal helper function and is typically not meant to be used directly.
-    /// In most cases, `FileDescriptionRef::check_and_update_readiness` should be preferred.
-    fn check_and_update_readiness(
-        &self,
-        id: FdId,
-        get_ready_events: impl FnOnce() -> InterpResult<'tcx, EpollReadyEvents>,
-    ) -> InterpResult<'tcx, ()> {
+    /// is registered with epoll, or when its readiness *might* have changed.
+    fn check_and_update_readiness(&self, fd_ref: &FileDescriptionRef) -> InterpResult<'tcx, ()> {
         let this = self.eval_context_ref();
+        let id = fd_ref.get_id();
         // Get a list of EpollEventInterest that is associated to a specific file description.
         if let Some(epoll_interests) = this.machine.epoll_interests.get_epoll_interest(id) {
-            let epoll_ready_events = get_ready_events()?;
+            let epoll_ready_events = fd_ref.get_epoll_ready_events()?;
             // Get the bitmask of ready events.
             let ready_events = epoll_ready_events.get_event_bitmask(this);
 
diff --git a/src/tools/miri/src/shims/unix/linux/eventfd.rs b/src/tools/miri/src/shims/unix/linux/eventfd.rs
index cede3967bc846..77d16a032aae9 100644
--- a/src/tools/miri/src/shims/unix/linux/eventfd.rs
+++ b/src/tools/miri/src/shims/unix/linux/eventfd.rs
@@ -4,10 +4,10 @@ use std::io;
 use std::io::{Error, ErrorKind};
 use std::mem;
 
-use fd::FdId;
 use rustc_target::abi::Endian;
 
-use crate::shims::unix::linux::epoll::EpollReadyEvents;
+use crate::shims::unix::fd::FileDescriptionRef;
+use crate::shims::unix::linux::epoll::{EpollReadyEvents, EvalContextExt as _};
 use crate::shims::unix::*;
 use crate::{concurrency::VClock, *};
 
@@ -60,8 +60,8 @@ impl FileDescription for Event {
     /// Read the counter in the buffer and return the counter if succeeded.
     fn read<'tcx>(
         &self,
+        self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        fd_id: FdId,
         bytes: &mut [u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -89,16 +89,8 @@ impl FileDescription for Event {
             self.counter.set(0);
             // When any of the event happened, we check and update the status of all supported event
             // types for current file description.
+            ecx.check_and_update_readiness(self_ref)?;
 
-            // We have to use our own FdID in contrast to every other file descriptor out there, because
-            // we are updating ourselves when writing and reading. Technically `Event` is like socketpair, but
-            // it does not create two separate file descriptors. Thus we can't re-borrow ourselves via
-            // `FileDescriptionRef::check_and_update_readiness` while already being mutably borrowed for read/write.
-            crate::shims::unix::linux::epoll::EvalContextExt::check_and_update_readiness(
-                ecx,
-                fd_id,
-                || self.get_epoll_ready_events(),
-            )?;
             return Ok(Ok(U64_ARRAY_SIZE));
         }
     }
@@ -117,8 +109,8 @@ impl FileDescription for Event {
     /// made to write the value 0xffffffffffffffff.
     fn write<'tcx>(
         &self,
+        self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        fd_id: FdId,
         bytes: &[u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -156,15 +148,8 @@ impl FileDescription for Event {
         };
         // When any of the event happened, we check and update the status of all supported event
         // types for current file description.
+        ecx.check_and_update_readiness(self_ref)?;
 
-        // Just like read() above, we use this internal method to not get the second borrow of the
-        // RefCell of this FileDescription. This is a special case, we should only use
-        // FileDescriptionRef::check_and_update_readiness in normal case.
-        crate::shims::unix::linux::epoll::EvalContextExt::check_and_update_readiness(
-            ecx,
-            fd_id,
-            || self.get_epoll_ready_events(),
-        )?;
         Ok(Ok(U64_ARRAY_SIZE))
     }
 }
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index fba63890dd275..0f13c8c35adcf 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -3,8 +3,8 @@ use std::collections::VecDeque;
 use std::io;
 use std::io::{Error, ErrorKind, Read};
 
-use crate::shims::unix::fd::{FdId, WeakFileDescriptionRef};
-use crate::shims::unix::linux::epoll::EpollReadyEvents;
+use crate::shims::unix::fd::{FileDescriptionRef, WeakFileDescriptionRef};
+use crate::shims::unix::linux::epoll::{EpollReadyEvents, EvalContextExt as _};
 use crate::shims::unix::*;
 use crate::{concurrency::VClock, *};
 
@@ -89,15 +89,15 @@ impl FileDescription for SocketPair {
             // Notify peer fd that closed has happened.
             // When any of the events happened, we check and update the status of all supported events
             // types of peer fd.
-            peer_fd.check_and_update_readiness(ecx)?;
+            ecx.check_and_update_readiness(&peer_fd)?;
         }
         Ok(Ok(()))
     }
 
     fn read<'tcx>(
         &self,
+        _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _fd_id: FdId,
         bytes: &mut [u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -150,7 +150,7 @@ impl FileDescription for SocketPair {
         // a read is successful. This might result in our epoll emulation providing more
         // notifications than the real system.
         if let Some(peer_fd) = self.peer_fd().upgrade() {
-            peer_fd.check_and_update_readiness(ecx)?;
+            ecx.check_and_update_readiness(&peer_fd)?;
         }
 
         return Ok(Ok(actual_read_size));
@@ -158,8 +158,8 @@ impl FileDescription for SocketPair {
 
     fn write<'tcx>(
         &self,
+        _self_ref: &FileDescriptionRef,
         _communicate_allowed: bool,
-        _fd_id: FdId,
         bytes: &[u8],
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<usize>> {
@@ -200,7 +200,7 @@ impl FileDescription for SocketPair {
         drop(writebuf);
 
         // Notification should be provided for peer fd as it became readable.
-        peer_fd.check_and_update_readiness(ecx)?;
+        ecx.check_and_update_readiness(&peer_fd)?;
 
         return Ok(Ok(actual_write_size));
     }

From a2a4f2bcb59115e5e7fbdeb1fbe1f261999b7bd6 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Fri, 16 Aug 2024 12:19:39 +0200
Subject: [PATCH 329/685] Migrate `validate_json.py` script to rust in
 `run-make/rustdoc-map-file` test

---
 src/tools/run-make-support/src/lib.rs         |  1 +
 tests/run-make/rustdoc-map-file/rmake.rs      | 50 +++++++++++++++++--
 .../rustdoc-map-file/validate_json.py         | 41 ---------------
 3 files changed, 48 insertions(+), 44 deletions(-)
 delete mode 100755 tests/run-make/rustdoc-map-file/validate_json.py

diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
index 4bef4f0500784..fc20fd3b2e86a 100644
--- a/src/tools/run-make-support/src/lib.rs
+++ b/src/tools/run-make-support/src/lib.rs
@@ -38,6 +38,7 @@ pub use bstr;
 pub use gimli;
 pub use object;
 pub use regex;
+pub use serde_json;
 pub use wasmparser;
 
 // Re-exports of external dependencies.
diff --git a/tests/run-make/rustdoc-map-file/rmake.rs b/tests/run-make/rustdoc-map-file/rmake.rs
index a4485165fd277..9b19279dee67b 100644
--- a/tests/run-make/rustdoc-map-file/rmake.rs
+++ b/tests/run-make/rustdoc-map-file/rmake.rs
@@ -1,4 +1,6 @@
-use run_make_support::{python_command, rustdoc};
+use run_make_support::path_helpers::read_dir_entries_recursive;
+use run_make_support::rfs::read_to_string;
+use run_make_support::{jzon, rustdoc};
 
 fn main() {
     let out_dir = "out";
@@ -8,6 +10,48 @@ fn main() {
         .arg("--generate-redirect-map")
         .out_dir(&out_dir)
         .run();
-    // FIXME (GuillaumeGomez): Port the python script to Rust as well.
-    python_command().arg("validate_json.py").arg(&out_dir).run();
+
+    let mut found_file = false;
+    read_dir_entries_recursive(&out_dir, |path| {
+        if !found_file
+            && path.is_file()
+            && path.file_name().map(|name| name == "redirect-map.json").unwrap_or(false)
+        {
+            found_file = true;
+            let generated = read_to_string(path);
+            let expected = read_to_string("expected.json");
+            let generated = jzon::parse(&generated).expect("failed to parse JSON");
+            let expected = jzon::parse(&expected).expect("failed to parse JSON");
+
+            let mut differences = Vec::new();
+            for (key, expected_value) in expected.entries() {
+                match generated.get(key) {
+                    Some(value) => {
+                        if expected_value != value {
+                            differences.push(format!("values for key `{key}` don't match"));
+                        }
+                    }
+                    None => differences.push(format!("missing key `{key}`")),
+                }
+            }
+            for (key, data) in generated.entries() {
+                if !expected.has_key(key) {
+                    differences
+                        .push(format!("Extra data not expected: key: `{key}`, data: `{data}`"));
+                }
+            }
+
+            if !differences.is_empty() {
+                eprintln!("Found differences in JSON files:");
+                for diff in differences {
+                    eprintln!("=> {diff}");
+                }
+                std::process::exit(1);
+            }
+        }
+    });
+
+    if !found_file {
+        panic!("`redirect-map.json` file was not found");
+    }
 }
diff --git a/tests/run-make/rustdoc-map-file/validate_json.py b/tests/run-make/rustdoc-map-file/validate_json.py
deleted file mode 100755
index 912dea3791bbf..0000000000000
--- a/tests/run-make/rustdoc-map-file/validate_json.py
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/env python
-
-import os
-import sys
-import json
-
-
-def find_redirect_map_file(folder, errors):
-    for root, _dirs, files in os.walk(folder):
-        for name in files:
-            if not name.endswith("redirect-map.json"):
-                continue
-            with open(os.path.join(root, name)) as f:
-                data = json.load(f)
-            with open("expected.json") as f:
-                expected = json.load(f)
-            for key in expected:
-                if expected[key] != data.get(key):
-                    errors.append("Expected `{}` for key `{}`, found: `{}`".format(
-                        expected[key], key, data.get(key)))
-                else:
-                    del data[key]
-            for key in data:
-                errors.append("Extra data not expected: key: `{}`, data: `{}`".format(
-                    key, data[key]))
-            return True
-    return False
-
-
-if len(sys.argv) != 2:
-    print("Expected doc directory to check!")
-    sys.exit(1)
-
-errors = []
-if not find_redirect_map_file(sys.argv[1], errors):
-    print("Didn't find the map file in `{}`...".format(sys.argv[1]))
-    sys.exit(1)
-for err in errors:
-    print("=> {}".format(err))
-if len(errors) != 0:
-    sys.exit(1)

From 6b1637c477f9f40821c68a9452f7435d9707948d Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Fri, 16 Aug 2024 15:09:04 +0200
Subject: [PATCH 330/685] Reexport `serde_json` crate from run-make-support to
 give it access to `run-make` tests

---
 Cargo.lock                               |  1 +
 src/tools/run-make-support/Cargo.toml    |  1 +
 tests/run-make/rustdoc-map-file/rmake.rs | 75 ++++++++++++------------
 3 files changed, 38 insertions(+), 39 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1aa0b2ea4a398..0b546d6e5eee0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3149,6 +3149,7 @@ dependencies = [
  "gimli 0.31.0",
  "object 0.36.2",
  "regex",
+ "serde_json",
  "similar",
  "wasmparser 0.214.0",
 ]
diff --git a/src/tools/run-make-support/Cargo.toml b/src/tools/run-make-support/Cargo.toml
index c4d5446a2481e..eae6022b803fd 100644
--- a/src/tools/run-make-support/Cargo.toml
+++ b/src/tools/run-make-support/Cargo.toml
@@ -11,3 +11,4 @@ wasmparser = { version = "0.214", default-features = false, features = ["std"] }
 regex = "1.8" # 1.8 to avoid memchr 2.6.0, as 2.5.0 is pinned in the workspace
 gimli = "0.31.0"
 build_helper = { path = "../build_helper" }
+serde_json = "1.0"
diff --git a/tests/run-make/rustdoc-map-file/rmake.rs b/tests/run-make/rustdoc-map-file/rmake.rs
index 9b19279dee67b..d7e3510fe31e0 100644
--- a/tests/run-make/rustdoc-map-file/rmake.rs
+++ b/tests/run-make/rustdoc-map-file/rmake.rs
@@ -1,57 +1,54 @@
-use run_make_support::path_helpers::read_dir_entries_recursive;
+// This test ensures that all items from `foo` are correctly generated into the `redirect-map.json`
+// file with `--generate-redirect-map` rustdoc option.
+
+use std::path::Path;
+
 use run_make_support::rfs::read_to_string;
-use run_make_support::{jzon, rustdoc};
+use run_make_support::{path, rustdoc, serde_json};
 
 fn main() {
     let out_dir = "out";
+    let crate_name = "foo";
     rustdoc()
         .input("foo.rs")
+        .crate_name(crate_name)
         .arg("-Zunstable-options")
         .arg("--generate-redirect-map")
         .out_dir(&out_dir)
         .run();
 
-    let mut found_file = false;
-    read_dir_entries_recursive(&out_dir, |path| {
-        if !found_file
-            && path.is_file()
-            && path.file_name().map(|name| name == "redirect-map.json").unwrap_or(false)
-        {
-            found_file = true;
-            let generated = read_to_string(path);
-            let expected = read_to_string("expected.json");
-            let generated = jzon::parse(&generated).expect("failed to parse JSON");
-            let expected = jzon::parse(&expected).expect("failed to parse JSON");
+    let generated = read_to_string(path(out_dir).join(crate_name).join("redirect-map.json"));
+    let expected = read_to_string("expected.json");
+    let generated: serde_json::Value =
+        serde_json::from_str(&generated).expect("failed to parse JSON");
+    let expected: serde_json::Value =
+        serde_json::from_str(&expected).expect("failed to parse JSON");
+    let expected = expected.as_object().unwrap();
 
-            let mut differences = Vec::new();
-            for (key, expected_value) in expected.entries() {
-                match generated.get(key) {
-                    Some(value) => {
-                        if expected_value != value {
-                            differences.push(format!("values for key `{key}` don't match"));
-                        }
-                    }
-                    None => differences.push(format!("missing key `{key}`")),
-                }
-            }
-            for (key, data) in generated.entries() {
-                if !expected.has_key(key) {
-                    differences
-                        .push(format!("Extra data not expected: key: `{key}`, data: `{data}`"));
+    let mut differences = Vec::new();
+    for (key, expected_value) in expected.iter() {
+        match generated.get(key) {
+            Some(value) => {
+                if expected_value != value {
+                    differences.push(format!(
+                        "values for key `{key}` don't match: `{expected_value:?}` != `{value:?}`"
+                    ));
                 }
             }
-
-            if !differences.is_empty() {
-                eprintln!("Found differences in JSON files:");
-                for diff in differences {
-                    eprintln!("=> {diff}");
-                }
-                std::process::exit(1);
-            }
+            None => differences.push(format!("missing key `{key}`")),
+        }
+    }
+    for (key, data) in generated.as_object().unwrap().iter() {
+        if !expected.contains_key(key) {
+            differences.push(format!("Extra data not expected: key: `{key}`, data: `{data}`"));
         }
-    });
+    }
 
-    if !found_file {
-        panic!("`redirect-map.json` file was not found");
+    if !differences.is_empty() {
+        eprintln!("Found differences in JSON files:");
+        for diff in differences {
+            eprintln!("=> {diff}");
+        }
+        panic!("Found differences in JSON files");
     }
 }

From c6815c04cb0761f6568168affd5f7b34398194f2 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 11 Aug 2024 16:49:06 -0400
Subject: [PATCH 331/685] Re-enable debuginfo tests on freebsd

---
 tests/debuginfo/pretty-huge-vec.rs          | 1 -
 tests/debuginfo/pretty-std-collections.rs   | 1 -
 tests/debuginfo/pretty-std.rs               | 1 -
 tests/debuginfo/pretty-uninitialized-vec.rs | 1 -
 4 files changed, 4 deletions(-)

diff --git a/tests/debuginfo/pretty-huge-vec.rs b/tests/debuginfo/pretty-huge-vec.rs
index f4b5345b66d77..dcf3521175d4c 100644
--- a/tests/debuginfo/pretty-huge-vec.rs
+++ b/tests/debuginfo/pretty-huge-vec.rs
@@ -1,5 +1,4 @@
 //@ ignore-windows failing on win32 bot
-//@ ignore-freebsd: gdb package too new
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
 //@ min-gdb-version: 8.1
diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs
index 7f518a886d700..3d5a30d19a9ce 100644
--- a/tests/debuginfo/pretty-std-collections.rs
+++ b/tests/debuginfo/pretty-std-collections.rs
@@ -1,5 +1,4 @@
 //@ ignore-windows failing on win32 bot
-//@ ignore-freebsd: gdb package too new
 //@ ignore-android: FIXME(#10381)
 //@ ignore-windows-gnu: #128981
 //@ compile-flags:-g
diff --git a/tests/debuginfo/pretty-std.rs b/tests/debuginfo/pretty-std.rs
index cb5c825bb7217..933be9772343c 100644
--- a/tests/debuginfo/pretty-std.rs
+++ b/tests/debuginfo/pretty-std.rs
@@ -1,5 +1,4 @@
 // ignore-tidy-linelength
-//@ ignore-freebsd: gdb package too new
 //@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
diff --git a/tests/debuginfo/pretty-uninitialized-vec.rs b/tests/debuginfo/pretty-uninitialized-vec.rs
index 225b4a6d53452..5206ff23fd5ba 100644
--- a/tests/debuginfo/pretty-uninitialized-vec.rs
+++ b/tests/debuginfo/pretty-uninitialized-vec.rs
@@ -1,5 +1,4 @@
 //@ ignore-windows failing on win32 bot
-//@ ignore-freebsd: gdb package too new
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
 //@ min-gdb-version: 8.1

From b4ab820e5e20dfca8f3242ac2547f8abf169e30e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 16 Aug 2024 16:54:02 +0200
Subject: [PATCH 332/685] epoll test cleanup

---
 .../miri/tests/pass-dep/libc/libc-epoll.rs    | 176 ++++++------------
 1 file changed, 58 insertions(+), 118 deletions(-)

diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index 95fdf2f603507..364a784574a75 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -5,20 +5,24 @@ use std::convert::TryInto;
 use std::mem::MaybeUninit;
 
 fn main() {
+    test_epoll_socketpair();
+    test_epoll_socketpair_both_sides();
+    test_socketpair_read();
+    test_epoll_eventfd();
+
     test_event_overwrite();
     test_not_fully_closed_fd();
     test_closed_fd();
-    test_epoll_socketpair_special_case();
     test_two_epoll_instance();
     test_epoll_ctl_mod();
-    test_epoll_socketpair();
-    test_epoll_eventfd();
     test_epoll_ctl_del();
     test_pointer();
     test_two_same_fd_in_same_epoll_instance();
-    test_socketpair_read();
 }
 
+// Using `as` cast since `EPOLLET` wraps around
+const EPOLL_IN_OUT_ET: u32 = (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET) as _;
+
 #[track_caller]
 fn check_epoll_wait<const N: usize>(
     epfd: i32,
@@ -58,21 +62,17 @@ fn test_epoll_socketpair() {
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let mut res =
-        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
     assert_eq!(res, 0);
 
     // Write to fd[0]
     let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
 
-    // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET
-    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLRDHUP).unwrap() | epollet;
+    // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET|EPOLLRDHUP
     let mut ev = libc::epoll_event {
-        events: u32::try_from(flags).unwrap(),
+        events: (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET | libc::EPOLLRDHUP) as _,
         u64: u64::try_from(fds[1]).unwrap(),
     };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
@@ -100,23 +100,17 @@ fn test_epoll_ctl_mod() {
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let mut res =
-        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
     assert_eq!(res, 0);
 
     // Write to fd[0].
     let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
 
     // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET.
-    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
-    let epollet = libc::EPOLLET as u32;
-    let mut flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
-    let mut ev = libc::epoll_event {
-        events: u32::try_from(flags).unwrap(),
-        u64: u64::try_from(fds[1]).unwrap(),
-    };
+    // (Not using checked cast as EPOLLET wraps around.)
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fds[1]).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
     assert_ne!(res, -1);
 
@@ -126,9 +120,8 @@ fn test_epoll_ctl_mod() {
     assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
 
     // Test EPOLLRDHUP.
-    flags |= u32::try_from(libc::EPOLLRDHUP).unwrap();
     let mut ev = libc::epoll_event {
-        events: u32::try_from(flags).unwrap(),
+        events: (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET | libc::EPOLLRDHUP) as _,
         u64: u64::try_from(fds[1]).unwrap(),
     };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_MOD, fds[1], &mut ev) };
@@ -151,23 +144,16 @@ fn test_epoll_ctl_del() {
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let mut res =
-        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
     assert_eq!(res, 0);
 
     // Write to fd[0]
     let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
 
     // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET
-    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
-    let mut ev = libc::epoll_event {
-        events: u32::try_from(flags).unwrap(),
-        u64: u64::try_from(fds[1]).unwrap(),
-    };
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fds[1]).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
     assert_ne!(res, -1);
 
@@ -185,22 +171,16 @@ fn test_two_epoll_instance() {
 
     // Create a socketpair instance.
     let mut fds = [-1, -1];
-    let mut res =
-        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
     assert_eq!(res, 0);
 
     // Write to the socketpair.
     let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
 
     // Register one side of the socketpair with EPOLLIN | EPOLLOUT | EPOLLET.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
-    let mut ev = libc::epoll_event {
-        events: u32::try_from(flags).unwrap(),
-        u64: u64::try_from(fds[1]).unwrap(),
-    };
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fds[1]).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd1, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
     assert_ne!(res, -1);
     let res = unsafe { libc::epoll_ctl(epfd2, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
@@ -230,17 +210,15 @@ fn test_two_same_fd_in_same_epoll_instance() {
     assert_ne!(newfd, -1);
 
     // Register both fd to the same epoll instance.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
-    let mut ev = libc::epoll_event { events: u32::try_from(flags).unwrap(), u64: 5 as u64 };
-    let mut res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: 5 as u64 };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
     assert_ne!(res, -1);
-    res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, newfd, &mut ev) };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, newfd, &mut ev) };
     assert_ne!(res, -1);
 
     // Write to the socketpair.
     let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
 
     //Two notification should be received.
@@ -259,9 +237,7 @@ fn test_epoll_eventfd() {
 
     // Write to the eventfd instance.
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
-    let res: i32 = unsafe {
-        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
-    };
+    let res = unsafe { libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8) };
     assert_eq!(res, 8);
 
     // Create an epoll instance.
@@ -269,13 +245,7 @@ fn test_epoll_eventfd() {
     assert_ne!(epfd, -1);
 
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
-    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
-    let mut ev = libc::epoll_event {
-        events: u32::try_from(flags).unwrap(),
-        u64: u64::try_from(fd).unwrap(),
-    };
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fd).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
     assert_ne!(res, -1);
 
@@ -296,20 +266,15 @@ fn test_pointer() {
     assert_eq!(res, 0);
 
     // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET
-    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLRDHUP).unwrap() | epollet;
     let data = MaybeUninit::<u64>::uninit().as_ptr();
-    let mut ev = libc::epoll_event {
-        events: u32::try_from(flags).unwrap(),
-        u64: data.expose_provenance() as u64,
-    };
+    let mut ev =
+        libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: data.expose_provenance() as u64 };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
     assert_ne!(res, -1);
 }
 
 // When read/write happened on one side of the socketpair, only the other side will be notified.
-fn test_epoll_socketpair_special_case() {
+fn test_epoll_socketpair_both_sides() {
     // Create an epoll instance.
     let epfd = unsafe { libc::epoll_create1(0) };
     assert_ne!(epfd, -1);
@@ -320,18 +285,16 @@ fn test_epoll_socketpair_special_case() {
     assert_eq!(res, 0);
 
     // Register both fd to the same epoll instance.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
-    let mut ev = libc::epoll_event { events: u32::try_from(flags).unwrap(), u64: fds[0] as u64 };
-    let mut res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[0], &mut ev) };
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fds[0] as u64 };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[0], &mut ev) };
     assert_ne!(res, -1);
-    let mut ev = libc::epoll_event { events: u32::try_from(flags).unwrap(), u64: fds[1] as u64 };
-    res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fds[1] as u64 };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
     assert_ne!(res, -1);
 
     // Write to fds[1].
     let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
 
     //Two notification should be received.
@@ -346,9 +309,7 @@ fn test_epoll_socketpair_special_case() {
 
     // Read from fds[0].
     let mut buf: [u8; 5] = [0; 5];
-    res = unsafe {
-        libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
     assert_eq!(res, 5);
     assert_eq!(buf, "abcde".as_bytes());
 
@@ -370,21 +331,13 @@ fn test_closed_fd() {
     let fd = unsafe { libc::eventfd(0, flags) };
 
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
-    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
-    let mut ev = libc::epoll_event {
-        events: u32::try_from(flags).unwrap(),
-        u64: u64::try_from(fd).unwrap(),
-    };
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fd).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
     assert_ne!(res, -1);
 
     // Write to the eventfd instance.
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
-    let res: i32 = unsafe {
-        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
-    };
+    let res = unsafe { libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8) };
     assert_eq!(res, 8);
 
     // Close the eventfd.
@@ -415,13 +368,7 @@ fn test_not_fully_closed_fd() {
     assert_ne!(newfd, -1);
 
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
-    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
-    let mut ev = libc::epoll_event {
-        events: u32::try_from(flags).unwrap(),
-        u64: u64::try_from(fd).unwrap(),
-    };
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fd).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
     assert_ne!(res, -1);
 
@@ -436,9 +383,7 @@ fn test_not_fully_closed_fd() {
 
     // Write to the eventfd instance to produce notification.
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
-    let res: i32 = unsafe {
-        libc::write(newfd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
-    };
+    let res = unsafe { libc::write(newfd, sized_8_data.as_ptr() as *const libc::c_void, 8) };
     assert_eq!(res, 8);
 
     // Close the dupped fd.
@@ -458,9 +403,7 @@ fn test_event_overwrite() {
 
     // Write to the eventfd instance.
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
-    let res: i32 = unsafe {
-        libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8).try_into().unwrap()
-    };
+    let res = unsafe { libc::write(fd, sized_8_data.as_ptr() as *const libc::c_void, 8) };
     assert_eq!(res, 8);
 
     // Create an epoll instance.
@@ -468,11 +411,8 @@ fn test_event_overwrite() {
     assert_ne!(epfd, -1);
 
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
-    // EPOLLET is negative number for i32 so casting is needed to do proper bitwise OR for u32.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
     let mut ev = libc::epoll_event {
-        events: u32::try_from(flags).unwrap(),
+        events: (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET) as _,
         u64: u64::try_from(fd).unwrap(),
     };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
@@ -480,7 +420,7 @@ fn test_event_overwrite() {
 
     // Read from the eventfd instance.
     let mut buf: [u8; 8] = [0; 8];
-    let res: i32 = unsafe { libc::read(fd, buf.as_mut_ptr().cast(), 8).try_into().unwrap() };
+    let res = unsafe { libc::read(fd, buf.as_mut_ptr().cast(), 8) };
     assert_eq!(res, 8);
 
     // Check result from epoll_wait.
@@ -502,18 +442,22 @@ fn test_socketpair_read() {
     assert_eq!(res, 0);
 
     // Register both fd to the same epoll instance.
-    let epollet = libc::EPOLLET as u32;
-    let flags = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap() | epollet;
-    let mut ev = libc::epoll_event { events: u32::try_from(flags).unwrap(), u64: fds[0] as u64 };
-    let mut res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[0], &mut ev) };
+    let mut ev = libc::epoll_event {
+        events: (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET) as _,
+        u64: fds[0] as u64,
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[0], &mut ev) };
     assert_ne!(res, -1);
-    let mut ev = libc::epoll_event { events: u32::try_from(flags).unwrap(), u64: fds[1] as u64 };
-    res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    let mut ev = libc::epoll_event {
+        events: (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET) as _,
+        u64: fds[1] as u64,
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
     assert_ne!(res, -1);
 
     // Write 5 bytes to fds[1].
     let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
 
     //Two notification should be received.
@@ -528,9 +472,7 @@ fn test_socketpair_read() {
 
     // Read 3 bytes from fds[0].
     let mut buf: [u8; 3] = [0; 3];
-    res = unsafe {
-        libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
     assert_eq!(res, 3);
     assert_eq!(buf, "abc".as_bytes());
 
@@ -542,9 +484,7 @@ fn test_socketpair_read() {
 
     // Read until the buffer is empty.
     let mut buf: [u8; 2] = [0; 2];
-    res = unsafe {
-        libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
     assert_eq!(res, 2);
     assert_eq!(buf, "de".as_bytes());
 

From edd1efb136f93d8e29bf15610f6bca2f919d4ad7 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 16 Aug 2024 16:55:45 +0200
Subject: [PATCH 333/685] comment and test regarding notifications on writes
 that dont change readiness

---
 src/tools/miri/src/shims/unix/linux/epoll.rs     |  5 ++++-
 src/tools/miri/src/shims/unix/socket.rs          |  1 +
 src/tools/miri/tests/pass-dep/libc/libc-epoll.rs | 12 ++++++++++++
 3 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index 1ec2dbe233e2d..ce91712fb2798 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -35,6 +35,7 @@ impl EpollEventInstance {
         EpollEventInstance { events, data }
     }
 }
+
 /// EpollEventInterest registers the file description information to an epoll
 /// instance during a successful `epoll_ctl` call. It also stores additional
 /// information needed to check and update readiness state for `epoll_wait`.
@@ -434,7 +435,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
     /// For a specific file description, get its ready events and update
     /// the corresponding ready list. This function is called whenever a file description
-    /// is registered with epoll, or when its readiness *might* have changed.
+    /// is registered with epoll, or the buffer it reads from / writes to changed.
+    /// This *will* report an event if anyone is subscribed to it, without any further
+    /// filtering, so do not call this function when an FD didn't have anything happen to it!
     fn check_and_update_readiness(&self, fd_ref: &FileDescriptionRef) -> InterpResult<'tcx, ()> {
         let this = self.eval_context_ref();
         let id = fd_ref.get_id();
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index 0f13c8c35adcf..cdc9dd0429b40 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -200,6 +200,7 @@ impl FileDescription for SocketPair {
         drop(writebuf);
 
         // Notification should be provided for peer fd as it became readable.
+        // The kernel does this even if the fd was already readable before, so we follow suit.
         ecx.check_and_update_readiness(&peer_fd)?;
 
         return Ok(Ok(actual_write_size));
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index 364a784574a75..c27a6a83a0542 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -83,6 +83,18 @@ fn test_epoll_socketpair() {
     let expected_value = u64::try_from(fds[1]).unwrap();
     assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
 
+    // Check that this is indeed using "ET" (edge-trigger) semantics: a second epoll should return nothing.
+    assert!(check_epoll_wait::<8>(epfd, vec![]));
+
+    // Write some more to fd[0].
+    let data = "abcde".as_bytes().as_ptr();
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
+    assert_eq!(res, 5);
+
+    // This did not change the readiness of fd[1]. And yet, we're seeing the event reported
+    // again by the kernel, so Miri does the same.
+    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+
     // Close the peer socketpair.
     let res = unsafe { libc::close(fds[0]) };
     assert_eq!(res, 0);

From 9184eb54eab8d3968d107d24db65cb16d3e27cab Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 16 Aug 2024 16:58:49 +0200
Subject: [PATCH 334/685] more epoll test cleanup

---
 .../miri/tests/pass-dep/libc/libc-epoll.rs    | 54 +++++++++----------
 1 file changed, 25 insertions(+), 29 deletions(-)

diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index c27a6a83a0542..f8bf1bacff3eb 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -24,10 +24,7 @@ fn main() {
 const EPOLL_IN_OUT_ET: u32 = (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET) as _;
 
 #[track_caller]
-fn check_epoll_wait<const N: usize>(
-    epfd: i32,
-    mut expected_notifications: Vec<(u32, u64)>,
-) -> bool {
+fn check_epoll_wait<const N: usize>(epfd: i32, expected_notifications: &[(u32, u64)]) -> bool {
     let epoll_event = libc::epoll_event { events: 0, u64: 0 };
     let mut array: [libc::epoll_event; N] = [epoll_event; N];
     let maxsize = N;
@@ -39,8 +36,9 @@ fn check_epoll_wait<const N: usize>(
     assert_eq!(res, expected_notifications.len().try_into().unwrap());
     let slice = unsafe { std::slice::from_raw_parts(array_ptr, res.try_into().unwrap()) };
     let mut return_events = slice.iter();
+    let mut expected_notifications = expected_notifications.iter();
     while let Some(return_event) = return_events.next() {
-        if let Some(notification) = expected_notifications.pop() {
+        if let Some(notification) = expected_notifications.next() {
             let event = return_event.events;
             let data = return_event.u64;
             assert_eq!(event, notification.0);
@@ -49,10 +47,8 @@ fn check_epoll_wait<const N: usize>(
             return false;
         }
     }
-    if !expected_notifications.is_empty() {
-        return false;
-    }
-    return true;
+    // There shouldn't be any more expected.
+    return expected_notifications.next().is_none();
 }
 
 fn test_epoll_socketpair() {
@@ -81,10 +77,10 @@ fn test_epoll_socketpair() {
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 
     // Check that this is indeed using "ET" (edge-trigger) semantics: a second epoll should return nothing.
-    assert!(check_epoll_wait::<8>(epfd, vec![]));
+    assert!(check_epoll_wait::<8>(epfd, &[]));
 
     // Write some more to fd[0].
     let data = "abcde".as_bytes().as_ptr();
@@ -93,7 +89,7 @@ fn test_epoll_socketpair() {
 
     // This did not change the readiness of fd[1]. And yet, we're seeing the event reported
     // again by the kernel, so Miri does the same.
-    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 
     // Close the peer socketpair.
     let res = unsafe { libc::close(fds[0]) };
@@ -102,7 +98,7 @@ fn test_epoll_socketpair() {
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 }
 
 fn test_epoll_ctl_mod() {
@@ -129,7 +125,7 @@ fn test_epoll_ctl_mod() {
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 
     // Test EPOLLRDHUP.
     let mut ev = libc::epoll_event {
@@ -146,7 +142,7 @@ fn test_epoll_ctl_mod() {
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 }
 
 fn test_epoll_ctl_del() {
@@ -170,7 +166,7 @@ fn test_epoll_ctl_del() {
     assert_ne!(res, -1);
 
     // Test EPOLL_CTL_DEL.
-    assert!(check_epoll_wait::<0>(epfd, vec![]));
+    assert!(check_epoll_wait::<0>(epfd, &[]));
 }
 
 // This test is for one fd registered under two different epoll instance.
@@ -201,8 +197,8 @@ fn test_two_epoll_instance() {
     // Notification should be received from both instance of epoll.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
-    assert!(check_epoll_wait::<8>(epfd1, vec![(expected_event, expected_value)]));
-    assert!(check_epoll_wait::<8>(epfd2, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd1, &[(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd2, &[(expected_event, expected_value)]));
 }
 
 // This test is for two same file description registered under the same epoll instance through dup.
@@ -238,7 +234,7 @@ fn test_two_same_fd_in_same_epoll_instance() {
     let expected_value = 5 as u64;
     assert!(check_epoll_wait::<8>(
         epfd,
-        vec![(expected_event, expected_value), (expected_event, expected_value)]
+        &[(expected_event, expected_value), (expected_event, expected_value)]
     ));
 }
 
@@ -264,7 +260,7 @@ fn test_epoll_eventfd() {
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fd).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 }
 
 fn test_pointer() {
@@ -316,7 +312,7 @@ fn test_epoll_socketpair_both_sides() {
     let expected_value1 = fds[1] as u64;
     assert!(check_epoll_wait::<8>(
         epfd,
-        vec![(expected_event1, expected_value1), (expected_event0, expected_value0)]
+        &[(expected_event0, expected_value0), (expected_event1, expected_value1)]
     ));
 
     // Read from fds[0].
@@ -328,7 +324,7 @@ fn test_epoll_socketpair_both_sides() {
     // Notification should be provided for fds[1].
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = fds[1] as u64;
-    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 }
 
 // When file description is fully closed, epoll_wait should not provide any notification for
@@ -357,7 +353,7 @@ fn test_closed_fd() {
     assert_eq!(res, 0);
 
     // No notification should be provided because the file description is closed.
-    assert!(check_epoll_wait::<8>(epfd, vec![]));
+    assert!(check_epoll_wait::<8>(epfd, &[]));
 }
 
 // When a certain file descriptor registered with epoll is closed, but the underlying file description
@@ -391,7 +387,7 @@ fn test_not_fully_closed_fd() {
     // Notification should still be provided because the file description is not closed.
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = fd as u64;
-    assert!(check_epoll_wait::<1>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<1>(epfd, &[(expected_event, expected_value)]));
 
     // Write to the eventfd instance to produce notification.
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
@@ -403,7 +399,7 @@ fn test_not_fully_closed_fd() {
     assert_eq!(res, 0);
 
     // No notification should be provided.
-    assert!(check_epoll_wait::<1>(epfd, vec![]));
+    assert!(check_epoll_wait::<1>(epfd, &[]));
 }
 
 // Each time a notification is provided, it should reflect the file description's readiness
@@ -438,7 +434,7 @@ fn test_event_overwrite() {
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fd).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 }
 
 // An epoll notification will be provided for every succesful read in a socketpair.
@@ -479,7 +475,7 @@ fn test_socketpair_read() {
     let expected_value1 = fds[1] as u64;
     assert!(check_epoll_wait::<8>(
         epfd,
-        vec![(expected_event1, expected_value1), (expected_event0, expected_value0)]
+        &[(expected_event0, expected_value0), (expected_event1, expected_value1)]
     ));
 
     // Read 3 bytes from fds[0].
@@ -492,7 +488,7 @@ fn test_socketpair_read() {
     // But in real system, no notification will be provided here.
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = fds[1] as u64;
-    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 
     // Read until the buffer is empty.
     let mut buf: [u8; 2] = [0; 2];
@@ -504,5 +500,5 @@ fn test_socketpair_read() {
     // In real system, notification will be provided too.
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = fds[1] as u64;
-    assert!(check_epoll_wait::<8>(epfd, vec![(expected_event, expected_value)]));
+    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 }

From c0373616d098fecd38b14b5e42f7d202964b363d Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Fri, 16 Aug 2024 15:28:42 +0000
Subject: [PATCH 335/685] Fix code snippet in from_str_radix_10 docs

---
 clippy_lints/src/from_str_radix_10.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/from_str_radix_10.rs b/clippy_lints/src/from_str_radix_10.rs
index 6ab7bbc2dfc0c..e5fa67d696427 100644
--- a/clippy_lints/src/from_str_radix_10.rs
+++ b/clippy_lints/src/from_str_radix_10.rs
@@ -22,8 +22,8 @@ declare_clippy_lint! {
     ///
     /// ### Known problems
     ///
-    /// This lint may suggest using (&<expression>).parse() instead of <expression>.parse() directly
-    /// in some cases, which is correct but adds unnecessary complexity to the code.
+    /// This lint may suggest using `(&<expression>).parse()` instead of `<expression>.parse()`
+    /// directly in some cases, which is correct but adds unnecessary complexity to the code.
     ///
     /// ### Example
     /// ```ignore

From 883e4773b30f652e83326df99dc0ec7d652e1f94 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 16 Aug 2024 17:06:37 +0200
Subject: [PATCH 336/685] explain the behavior on closed peers

---
 src/tools/miri/src/shims/unix/linux/epoll.rs     | 12 +++++++-----
 src/tools/miri/src/shims/unix/socket.rs          | 10 ++++------
 src/tools/miri/tests/pass-dep/libc/libc-epoll.rs |  1 +
 3 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index ce91712fb2798..d529a9b63e683 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -433,11 +433,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         Ok(Scalar::from_i32(num_of_events))
     }
 
-    /// For a specific file description, get its ready events and update
-    /// the corresponding ready list. This function is called whenever a file description
-    /// is registered with epoll, or the buffer it reads from / writes to changed.
-    /// This *will* report an event if anyone is subscribed to it, without any further
-    /// filtering, so do not call this function when an FD didn't have anything happen to it!
+    /// For a specific file description, get its ready events and update the corresponding ready
+    /// list. This function should be called whenever an event causes more bytes or an EOF to become
+    /// newly readable from an FD, and whenever more bytes can be written to an FD or no more future
+    /// writes are possible.
+    ///
+    /// This *will* report an event if anyone is subscribed to it, without any further filtering, so
+    /// do not call this function when an FD didn't have anything happen to it!
     fn check_and_update_readiness(&self, fd_ref: &FileDescriptionRef) -> InterpResult<'tcx, ()> {
         let this = self.eval_context_ref();
         let id = fd_ref.get_id();
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index cdc9dd0429b40..75d4d0dbbe497 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -71,9 +71,9 @@ impl FileDescription for SocketPair {
         } else {
             // Peer FD has been closed.
             epoll_ready_events.epollrdhup = true;
-            // This is an edge case. Whenever epollrdhup is triggered, epollin and epollout will be
-            // added even though there is no data in the buffer.
-            // FIXME: Figure out why. This looks like a bug.
+            // Since the peer is closed, even if no data is available reads will return EOF and
+            // writes will return EPIPE. In other words, they won't block, so we mark this as ready
+            // for read and write.
             epoll_ready_events.epollin = true;
             epoll_ready_events.epollout = true;
         }
@@ -86,9 +86,7 @@ impl FileDescription for SocketPair {
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<()>> {
         if let Some(peer_fd) = self.peer_fd().upgrade() {
-            // Notify peer fd that closed has happened.
-            // When any of the events happened, we check and update the status of all supported events
-            // types of peer fd.
+            // Notify peer fd that close has happened, since that can unblock reads and writes.
             ecx.check_and_update_readiness(&peer_fd)?;
         }
         Ok(Ok(()))
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index f8bf1bacff3eb..841761e53dd56 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -96,6 +96,7 @@ fn test_epoll_socketpair() {
     assert_eq!(res, 0);
 
     // Check result from epoll_wait.
+    // We expect to get a read, write, HUP notification from the close since closing an FD always unblocks reads and writes on its peer.
     let expected_event = u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
     assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));

From e6ac503ec19c6c356cfbb9b5f47aee1af4ce5626 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Fri, 16 Aug 2024 10:43:34 -0700
Subject: [PATCH 337/685] Stabilize std::thread::Builder::spawn_unchecked

---
 compiler/rustc_interface/src/lib.rs | 1 -
 library/std/src/thread/mod.rs       | 3 +--
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler/rustc_interface/src/lib.rs b/compiler/rustc_interface/src/lib.rs
index e37b30749ab30..3492df69b8d32 100644
--- a/compiler/rustc_interface/src/lib.rs
+++ b/compiler/rustc_interface/src/lib.rs
@@ -1,7 +1,6 @@
 // tidy-alphabetical-start
 #![feature(decl_macro)]
 #![feature(let_chains)]
-#![feature(thread_spawn_unchecked)]
 #![feature(try_blocks)]
 // tidy-alphabetical-end
 
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index 88b31cd78a661..e29c28f3c7ec2 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -412,7 +412,6 @@ impl Builder {
     /// # Examples
     ///
     /// ```
-    /// #![feature(thread_spawn_unchecked)]
     /// use std::thread;
     ///
     /// let builder = thread::Builder::new();
@@ -433,7 +432,7 @@ impl Builder {
     /// ```
     ///
     /// [`io::Result`]: crate::io::Result
-    #[unstable(feature = "thread_spawn_unchecked", issue = "55132")]
+    #[stable(feature = "thread_spawn_unchecked", since = "CURRENT_RUSTC_VERSION")]
     pub unsafe fn spawn_unchecked<F, T>(self, f: F) -> io::Result<JoinHandle<T>>
     where
         F: FnOnce() -> T,

From 09511078810a88116fad8fcc7a6e84ce182b825b Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Sat, 17 Aug 2024 02:08:31 +0800
Subject: [PATCH 338/685] Add epoll EPOLLHUP flag support

---
 src/tools/miri/src/shims/unix/linux/epoll.rs  | 20 +++++++++++++++++--
 src/tools/miri/src/shims/unix/socket.rs       |  5 +++--
 .../miri/tests/pass-dep/libc/libc-epoll.rs    |  6 ++++--
 3 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index d529a9b63e683..a47d9fe0826dd 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -69,17 +69,21 @@ pub struct EpollReadyEvents {
     /// Stream socket peer closed connection, or shut down writing
     /// half of connection.
     pub epollrdhup: bool,
+    /// For stream socket, this event merely indicates that the peer
+    /// closed its end of the channel.
+    pub epollhup: bool,
 }
 
 impl EpollReadyEvents {
     pub fn new() -> Self {
-        EpollReadyEvents { epollin: false, epollout: false, epollrdhup: false }
+        EpollReadyEvents { epollin: false, epollout: false, epollrdhup: false, epollhup: false }
     }
 
     pub fn get_event_bitmask<'tcx>(&self, ecx: &MiriInterpCx<'tcx>) -> u32 {
         let epollin = ecx.eval_libc_u32("EPOLLIN");
         let epollout = ecx.eval_libc_u32("EPOLLOUT");
         let epollrdhup = ecx.eval_libc_u32("EPOLLRDHUP");
+        let epollhup = ecx.eval_libc_u32("EPOLLHUP");
 
         let mut bitmask = 0;
         if self.epollin {
@@ -91,6 +95,9 @@ impl EpollReadyEvents {
         if self.epollrdhup {
             bitmask |= epollrdhup;
         }
+        if self.epollhup {
+            bitmask |= epollhup;
+        }
         bitmask
     }
 }
@@ -217,6 +224,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let epollout = this.eval_libc_u32("EPOLLOUT");
         let epollrdhup = this.eval_libc_u32("EPOLLRDHUP");
         let epollet = this.eval_libc_u32("EPOLLET");
+        let epollhup = this.eval_libc_u32("EPOLLHUP");
 
         // Fail on unsupported operations.
         if op & epoll_ctl_add != epoll_ctl_add
@@ -244,11 +252,16 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         if op == epoll_ctl_add || op == epoll_ctl_mod {
             // Read event bitmask and data from epoll_event passed by caller.
-            let events = this.read_scalar(&this.project_field(&event, 0)?)?.to_u32()?;
+            let mut events = this.read_scalar(&this.project_field(&event, 0)?)?.to_u32()?;
             let data = this.read_scalar(&this.project_field(&event, 1)?)?.to_u64()?;
 
             // Unset the flag we support to discover if any unsupported flags are used.
             let mut flags = events;
+            // epoll_wait(2) will always wait for epollhup; it is not
+            // necessary to set it in events when calling epoll_ctl().
+            // So we will always set this event type.
+            events |= epollhup;
+
             if events & epollet != epollet {
                 // We only support edge-triggered notification for now.
                 throw_unsup_format!("epoll_ctl: epollet flag must be included.");
@@ -264,6 +277,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             if flags & epollrdhup == epollrdhup {
                 flags &= !epollrdhup;
             }
+            if flags & epollhup == epollhup {
+                flags &= !epollhup;
+            }
             if flags != 0 {
                 throw_unsup_format!(
                     "epoll_ctl: encountered unknown unsupported flags {:#x}",
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index 75d4d0dbbe497..cf3f65f69b21d 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -49,8 +49,8 @@ impl FileDescription for SocketPair {
     }
 
     fn get_epoll_ready_events<'tcx>(&self) -> InterpResult<'tcx, EpollReadyEvents> {
-        // We only check the status of EPOLLIN, EPOLLOUT and EPOLLRDHUP flags. If other event flags
-        // need to be supported in the future, the check should be added here.
+        // We only check the status of EPOLLIN, EPOLLOUT, EPOLLHUP and EPOLLRDHUP flags.
+        // If other event flags need to be supported in the future, the check should be added here.
 
         let mut epoll_ready_events = EpollReadyEvents::new();
 
@@ -76,6 +76,7 @@ impl FileDescription for SocketPair {
             // for read and write.
             epoll_ready_events.epollin = true;
             epoll_ready_events.epollout = true;
+            epoll_ready_events.epollhup = true;
         }
         Ok(epoll_ready_events)
     }
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index 841761e53dd56..8d7d559c6aa31 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -97,7 +97,8 @@ fn test_epoll_socketpair() {
 
     // Check result from epoll_wait.
     // We expect to get a read, write, HUP notification from the close since closing an FD always unblocks reads and writes on its peer.
-    let expected_event = u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_event =
+        u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLHUP).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
     assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 }
@@ -141,7 +142,8 @@ fn test_epoll_ctl_mod() {
     assert_eq!(res, 0);
 
     // Check result from epoll_wait.
-    let expected_event = u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT).unwrap();
+    let expected_event =
+        u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLHUP).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
     assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
 }

From 833af65f38c4674e3ae6d886174e65f0fcabab3d Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 7 Aug 2024 13:01:34 -0400
Subject: [PATCH 339/685] Use FnSig instead of raw FnDecl for
 ForeignItemKind::Fn

---
 compiler/rustc_ast_lowering/src/delegation.rs |  2 +-
 compiler/rustc_ast_lowering/src/item.rs       | 24 +++++---
 compiler/rustc_hir/src/hir.rs                 | 39 +++++++-----
 compiler/rustc_hir/src/intravisit.rs          |  4 +-
 .../rustc_hir_analysis/src/check/check.rs     |  4 +-
 .../rustc_hir_analysis/src/check/intrinsic.rs |  2 +-
 .../rustc_hir_analysis/src/check/wfcheck.rs   |  4 +-
 compiler/rustc_hir_analysis/src/collect.rs    |  6 +-
 .../src/collect/resolve_bound_vars.rs         |  2 +-
 compiler/rustc_hir_pretty/src/lib.rs          | 11 +---
 compiler/rustc_lint/src/types.rs              |  9 ++-
 compiler/rustc_middle/src/hir/map/mod.rs      | 10 ++--
 compiler/rustc_middle/src/hir/mod.rs          |  2 +-
 .../ui/extern/extern-main-issue-86110.stderr  |  2 +-
 .../safe-intrinsic-mismatch.effects.stderr    |  4 +-
 .../safe-intrinsic-mismatch.stock.stderr      |  4 +-
 tests/ui/issues/issue-16725.stderr            |  2 +-
 tests/ui/lint/clashing-extern-fn.stderr       | 60 +++++++++----------
 tests/ui/lint/issue-1866.stderr               |  4 +-
 .../ui/lint/lint-attr-everywhere-late.stderr  |  8 +--
 tests/ui/lint/lint-missing-doc.stderr         |  2 +-
 tests/ui/lint/unreachable_pub.stderr          |  2 +-
 .../ui/privacy/private-in-public-warn.stderr  |  4 +-
 23 files changed, 113 insertions(+), 98 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index 300bfa101c6bd..9c073130827c8 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -189,7 +189,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> hir::FnSig<'hir> {
         let header = if let Some(local_sig_id) = sig_id.as_local() {
             match self.resolver.delegation_fn_sigs.get(&local_sig_id) {
-                Some(sig) => self.lower_fn_header(sig.header),
+                Some(sig) => self.lower_fn_header(sig.header, hir::Safety::Safe),
                 None => self.generate_header_error(),
             }
         } else {
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 7af3945d3f99d..f6065259d8d21 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -237,7 +237,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         });
                     let sig = hir::FnSig {
                         decl,
-                        header: this.lower_fn_header(*header),
+                        header: this.lower_fn_header(*header, hir::Safety::Safe),
                         span: this.lower_span(*fn_sig_span),
                     };
                     hir::ItemKind::Fn(sig, generics, body_id)
@@ -668,7 +668,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ForeignItemKind::Fn(box Fn { sig, generics, .. }) => {
                     let fdec = &sig.decl;
                     let itctx = ImplTraitContext::Universal;
-                    let (generics, (fn_dec, fn_args)) =
+                    let (generics, (decl, fn_args)) =
                         self.lower_generics(generics, Const::No, false, i.id, itctx, |this| {
                             (
                                 // Disallow `impl Trait` in foreign items.
@@ -682,9 +682,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
                                 this.lower_fn_params_to_names(fdec),
                             )
                         });
-                    let safety = self.lower_safety(sig.header.safety, hir::Safety::Unsafe);
 
-                    hir::ForeignItemKind::Fn(fn_dec, fn_args, generics, safety)
+                    // Unmarked safety in unsafe block defaults to unsafe.
+                    let header = self.lower_fn_header(sig.header, hir::Safety::Unsafe);
+
+                    hir::ForeignItemKind::Fn(
+                        hir::FnSig { header, decl, span: self.lower_span(sig.span) },
+                        fn_args,
+                        generics,
+                    )
                 }
                 ForeignItemKind::Static(box StaticItem { ty, mutability, expr: _, safety }) => {
                     let ty = self
@@ -1390,7 +1396,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         coroutine_kind: Option<CoroutineKind>,
         parent_constness: Const,
     ) -> (&'hir hir::Generics<'hir>, hir::FnSig<'hir>) {
-        let header = self.lower_fn_header(sig.header);
+        let header = self.lower_fn_header(sig.header, hir::Safety::Safe);
         // Don't pass along the user-provided constness of trait associated functions; we don't want to
         // synthesize a host effect param for them. We reject `const` on them during AST validation.
         let constness =
@@ -1403,14 +1409,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
         (generics, hir::FnSig { header, decl, span: self.lower_span(sig.span) })
     }
 
-    pub(super) fn lower_fn_header(&mut self, h: FnHeader) -> hir::FnHeader {
+    pub(super) fn lower_fn_header(
+        &mut self,
+        h: FnHeader,
+        default_safety: hir::Safety,
+    ) -> hir::FnHeader {
         let asyncness = if let Some(CoroutineKind::Async { span, .. }) = h.coroutine_kind {
             hir::IsAsync::Async(span)
         } else {
             hir::IsAsync::NotAsync
         };
         hir::FnHeader {
-            safety: self.lower_safety(h.safety, hir::Safety::Safe),
+            safety: self.lower_safety(h.safety, default_safety),
             asyncness: asyncness,
             constness: self.lower_constness(h.constness),
             abi: self.lower_extern(h.ext),
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 33e8432596be1..6599e70346117 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -3586,7 +3586,7 @@ impl ForeignItem<'_> {
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub enum ForeignItemKind<'hir> {
     /// A foreign function.
-    Fn(&'hir FnDecl<'hir>, &'hir [Ident], &'hir Generics<'hir>, Safety),
+    Fn(FnSig<'hir>, &'hir [Ident], &'hir Generics<'hir>),
     /// A foreign static item (`static ext: u8`).
     Static(&'hir Ty<'hir>, Mutability, Safety),
     /// A foreign type.
@@ -3645,7 +3645,10 @@ impl<'hir> OwnerNode<'hir> {
         match self {
             OwnerNode::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. })
             | OwnerNode::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. })
-            | OwnerNode::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig),
+            | OwnerNode::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. })
+            | OwnerNode::ForeignItem(ForeignItem {
+                kind: ForeignItemKind::Fn(fn_sig, _, _), ..
+            }) => Some(fn_sig),
             _ => None,
         }
     }
@@ -3654,11 +3657,10 @@ impl<'hir> OwnerNode<'hir> {
         match self {
             OwnerNode::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. })
             | OwnerNode::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. })
-            | OwnerNode::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig.decl),
-            OwnerNode::ForeignItem(ForeignItem {
-                kind: ForeignItemKind::Fn(fn_decl, _, _, _),
-                ..
-            }) => Some(fn_decl),
+            | OwnerNode::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. })
+            | OwnerNode::ForeignItem(ForeignItem {
+                kind: ForeignItemKind::Fn(fn_sig, _, _), ..
+            }) => Some(fn_sig.decl),
             _ => None,
         }
     }
@@ -3846,11 +3848,13 @@ impl<'hir> Node<'hir> {
         match self {
             Node::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. })
             | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. })
-            | Node::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig.decl),
-            Node::Expr(Expr { kind: ExprKind::Closure(Closure { fn_decl, .. }), .. })
-            | Node::ForeignItem(ForeignItem {
-                kind: ForeignItemKind::Fn(fn_decl, _, _, _), ..
-            }) => Some(fn_decl),
+            | Node::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. })
+            | Node::ForeignItem(ForeignItem { kind: ForeignItemKind::Fn(fn_sig, _, _), .. }) => {
+                Some(fn_sig.decl)
+            }
+            Node::Expr(Expr { kind: ExprKind::Closure(Closure { fn_decl, .. }), .. }) => {
+                Some(fn_decl)
+            }
             _ => None,
         }
     }
@@ -3874,7 +3878,10 @@ impl<'hir> Node<'hir> {
         match self {
             Node::TraitItem(TraitItem { kind: TraitItemKind::Fn(fn_sig, _), .. })
             | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(fn_sig, _), .. })
-            | Node::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. }) => Some(fn_sig),
+            | Node::Item(Item { kind: ItemKind::Fn(fn_sig, _, _), .. })
+            | Node::ForeignItem(ForeignItem { kind: ForeignItemKind::Fn(fn_sig, _, _), .. }) => {
+                Some(fn_sig)
+            }
             _ => None,
         }
     }
@@ -3949,7 +3956,7 @@ impl<'hir> Node<'hir> {
     pub fn generics(self) -> Option<&'hir Generics<'hir>> {
         match self {
             Node::ForeignItem(ForeignItem {
-                kind: ForeignItemKind::Fn(_, _, generics, _), ..
+                kind: ForeignItemKind::Fn(_, _, generics), ..
             })
             | Node::TraitItem(TraitItem { generics, .. })
             | Node::ImplItem(ImplItem { generics, .. }) => Some(generics),
@@ -4039,8 +4046,8 @@ mod size_asserts {
     static_assert_size!(Expr<'_>, 64);
     static_assert_size!(ExprKind<'_>, 48);
     static_assert_size!(FnDecl<'_>, 40);
-    static_assert_size!(ForeignItem<'_>, 72);
-    static_assert_size!(ForeignItemKind<'_>, 40);
+    static_assert_size!(ForeignItem<'_>, 88);
+    static_assert_size!(ForeignItemKind<'_>, 56);
     static_assert_size!(GenericArg<'_>, 16);
     static_assert_size!(GenericBound<'_>, 48);
     static_assert_size!(Generics<'_>, 56);
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index dd501f8417e64..a54596e3088dc 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -611,9 +611,9 @@ pub fn walk_foreign_item<'v, V: Visitor<'v>>(
     try_visit!(visitor.visit_ident(foreign_item.ident));
 
     match foreign_item.kind {
-        ForeignItemKind::Fn(ref function_declaration, param_names, ref generics, _) => {
+        ForeignItemKind::Fn(ref sig, param_names, ref generics) => {
             try_visit!(visitor.visit_generics(generics));
-            try_visit!(visitor.visit_fn_decl(function_declaration));
+            try_visit!(visitor.visit_fn_decl(sig.decl));
             walk_list!(visitor, visit_ident, param_names.iter().copied());
         }
         ForeignItemKind::Static(ref typ, _, _) => {
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 2e778fd375961..0135cdf1e9002 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -804,8 +804,8 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
 
                         let item = tcx.hir().foreign_item(item.id);
                         match &item.kind {
-                            hir::ForeignItemKind::Fn(fn_decl, _, _, _) => {
-                                require_c_abi_if_c_variadic(tcx, fn_decl, abi, item.span);
+                            hir::ForeignItemKind::Fn(sig, _, _) => {
+                                require_c_abi_if_c_variadic(tcx, sig.decl, abi, item.span);
                             }
                             hir::ForeignItemKind::Static(..) => {
                                 check_static_inhabited(tcx, def_id);
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index 4b45ced30c579..c2b2f08132ed8 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -30,7 +30,7 @@ fn equate_intrinsic_type<'tcx>(
     let (generics, span) = match tcx.hir_node_by_def_id(def_id) {
         hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, generics, _), .. })
         | hir::Node::ForeignItem(hir::ForeignItem {
-            kind: hir::ForeignItemKind::Fn(.., generics, _),
+            kind: hir::ForeignItemKind::Fn(_, _, generics),
             ..
         }) => (tcx.generics_of(def_id), generics.span),
         _ => {
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index d3b928fc17c5b..bdf2914fc50c6 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -350,8 +350,8 @@ fn check_foreign_item<'tcx>(
     );
 
     match item.kind {
-        hir::ForeignItemKind::Fn(decl, ..) => {
-            check_item_fn(tcx, def_id, item.ident, item.span, decl)
+        hir::ForeignItemKind::Fn(sig, ..) => {
+            check_item_fn(tcx, def_id, item.ident, item.span, sig.decl)
         }
         hir::ForeignItemKind::Static(ty, ..) => {
             check_item_type(tcx, def_id, ty.span, UnsizedHandling::AllowIfForeignTail)
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index 91fa066ec6a1d..f75954c9edfb7 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -1440,11 +1440,9 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_, ty::PolyFn
             icx.lowerer().lower_fn_ty(hir_id, header.safety, header.abi, decl, Some(generics), None)
         }
 
-        ForeignItem(&hir::ForeignItem {
-            kind: ForeignItemKind::Fn(fn_decl, _, _, safety), ..
-        }) => {
+        ForeignItem(&hir::ForeignItem { kind: ForeignItemKind::Fn(sig, _, _), .. }) => {
             let abi = tcx.hir().get_foreign_abi(hir_id);
-            compute_sig_of_foreign_fn_decl(tcx, def_id, fn_decl, abi, safety)
+            compute_sig_of_foreign_fn_decl(tcx, def_id, sig.decl, abi, sig.header.safety)
         }
 
         Ctor(data) | Variant(hir::Variant { data, .. }) if data.ctor().is_some() => {
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
index e11d3c9c48b4e..ae0c70d232685 100644
--- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
+++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -604,7 +604,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
 
     fn visit_foreign_item(&mut self, item: &'tcx hir::ForeignItem<'tcx>) {
         match item.kind {
-            hir::ForeignItemKind::Fn(_, _, generics, _) => {
+            hir::ForeignItemKind::Fn(_, _, generics) => {
                 self.visit_early_late(item.hir_id(), generics, |this| {
                     intravisit::walk_foreign_item(this, item);
                 })
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 089cee2fa0dec..cff21173f7982 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -352,16 +352,11 @@ impl<'a> State<'a> {
         self.maybe_print_comment(item.span.lo());
         self.print_outer_attributes(self.attrs(item.hir_id()));
         match item.kind {
-            hir::ForeignItemKind::Fn(decl, arg_names, generics, safety) => {
+            hir::ForeignItemKind::Fn(sig, arg_names, generics) => {
                 self.head("");
                 self.print_fn(
-                    decl,
-                    hir::FnHeader {
-                        safety,
-                        constness: hir::Constness::NotConst,
-                        abi: Abi::Rust,
-                        asyncness: hir::IsAsync::NotAsync,
-                    },
+                    sig.decl,
+                    sig.header,
                     Some(item.ident.name),
                     generics,
                     arg_names,
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index 54bf73a40dd52..cb7a07116ced8 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -1734,13 +1734,16 @@ impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDeclarations {
         let abi = cx.tcx.hir().get_foreign_abi(it.hir_id());
 
         match it.kind {
-            hir::ForeignItemKind::Fn(decl, _, _, _) if !vis.is_internal_abi(abi) => {
-                vis.check_foreign_fn(it.owner_id.def_id, decl);
+            hir::ForeignItemKind::Fn(sig, _, _) => {
+                if vis.is_internal_abi(abi) {
+                    vis.check_fn(it.owner_id.def_id, sig.decl)
+                } else {
+                    vis.check_foreign_fn(it.owner_id.def_id, sig.decl);
+                }
             }
             hir::ForeignItemKind::Static(ty, _, _) if !vis.is_internal_abi(abi) => {
                 vis.check_foreign_static(it.owner_id, ty.span);
             }
-            hir::ForeignItemKind::Fn(decl, _, _, _) => vis.check_fn(it.owner_id.def_id, decl),
             hir::ForeignItemKind::Static(..) | hir::ForeignItemKind::Type => (),
         }
     }
diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs
index edab6b5ebde84..ce489099ed2ae 100644
--- a/compiler/rustc_middle/src/hir/map/mod.rs
+++ b/compiler/rustc_middle/src/hir/map/mod.rs
@@ -826,6 +826,11 @@ impl<'hir> Map<'hir> {
             })
             | Node::ImplItem(ImplItem {
                 kind: ImplItemKind::Fn(sig, ..), span: outer_span, ..
+            })
+            | Node::ForeignItem(ForeignItem {
+                kind: ForeignItemKind::Fn(sig, ..),
+                span: outer_span,
+                ..
             }) => {
                 // Ensure that the returned span has the item's SyntaxContext, and not the
                 // SyntaxContext of the visibility.
@@ -884,10 +889,7 @@ impl<'hir> Map<'hir> {
             },
             Node::Variant(variant) => named_span(variant.span, variant.ident, None),
             Node::ImplItem(item) => named_span(item.span, item.ident, Some(item.generics)),
-            Node::ForeignItem(item) => match item.kind {
-                ForeignItemKind::Fn(decl, _, _, _) => until_within(item.span, decl.output.span()),
-                _ => named_span(item.span, item.ident, None),
-            },
+            Node::ForeignItem(item) => named_span(item.span, item.ident, None),
             Node::Ctor(_) => return self.span(self.tcx.parent_hir_id(hir_id)),
             Node::Expr(Expr {
                 kind: ExprKind::Closure(Closure { fn_decl_span, .. }),
diff --git a/compiler/rustc_middle/src/hir/mod.rs b/compiler/rustc_middle/src/hir/mod.rs
index fa521ab9f2fa9..596d9f077372e 100644
--- a/compiler/rustc_middle/src/hir/mod.rs
+++ b/compiler/rustc_middle/src/hir/mod.rs
@@ -202,7 +202,7 @@ pub fn provide(providers: &mut Providers) {
             ..
         })
         | Node::ForeignItem(&ForeignItem {
-            kind: ForeignItemKind::Fn(_, idents, _, _),
+            kind: ForeignItemKind::Fn(_, idents, _),
             ..
         }) = tcx.hir_node(tcx.local_def_id_to_hir_id(def_id))
         {
diff --git a/tests/ui/extern/extern-main-issue-86110.stderr b/tests/ui/extern/extern-main-issue-86110.stderr
index 8a3262fbcc7be..d69f4e617680a 100644
--- a/tests/ui/extern/extern-main-issue-86110.stderr
+++ b/tests/ui/extern/extern-main-issue-86110.stderr
@@ -2,7 +2,7 @@ error: the `main` function cannot be declared in an `extern` block
   --> $DIR/extern-main-issue-86110.rs:4:5
    |
 LL |     fn main();
-   |     ^^^^^^^^^
+   |     ^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/intrinsics/safe-intrinsic-mismatch.effects.stderr b/tests/ui/intrinsics/safe-intrinsic-mismatch.effects.stderr
index d9a4960feec4d..55983a445a4ca 100644
--- a/tests/ui/intrinsics/safe-intrinsic-mismatch.effects.stderr
+++ b/tests/ui/intrinsics/safe-intrinsic-mismatch.effects.stderr
@@ -7,13 +7,13 @@ error: intrinsic safety mismatch between list of intrinsics within the compiler
   --> $DIR/safe-intrinsic-mismatch.rs:11:5
    |
 LL |     fn size_of<T>() -> usize;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: intrinsic safety mismatch between list of intrinsics within the compiler and core library intrinsics for intrinsic `size_of`
   --> $DIR/safe-intrinsic-mismatch.rs:11:5
    |
 LL |     fn size_of<T>() -> usize;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
diff --git a/tests/ui/intrinsics/safe-intrinsic-mismatch.stock.stderr b/tests/ui/intrinsics/safe-intrinsic-mismatch.stock.stderr
index 6864c0f36ded0..c59e357b27526 100644
--- a/tests/ui/intrinsics/safe-intrinsic-mismatch.stock.stderr
+++ b/tests/ui/intrinsics/safe-intrinsic-mismatch.stock.stderr
@@ -2,13 +2,13 @@ error: intrinsic safety mismatch between list of intrinsics within the compiler
   --> $DIR/safe-intrinsic-mismatch.rs:11:5
    |
 LL |     fn size_of<T>() -> usize;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: intrinsic safety mismatch between list of intrinsics within the compiler and core library intrinsics for intrinsic `size_of`
   --> $DIR/safe-intrinsic-mismatch.rs:11:5
    |
 LL |     fn size_of<T>() -> usize;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
diff --git a/tests/ui/issues/issue-16725.stderr b/tests/ui/issues/issue-16725.stderr
index a4a406b3d4ba9..dcb7d58b0f961 100644
--- a/tests/ui/issues/issue-16725.stderr
+++ b/tests/ui/issues/issue-16725.stderr
@@ -8,7 +8,7 @@ note: the function `bar` is defined here
   --> $DIR/auxiliary/issue-16725.rs:2:5
    |
 LL |     fn bar();
-   |     ^^^^^^^^
+   |     ^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/clashing-extern-fn.stderr b/tests/ui/lint/clashing-extern-fn.stderr
index 43c8cdead9f41..f75ff6d05a15c 100644
--- a/tests/ui/lint/clashing-extern-fn.stderr
+++ b/tests/ui/lint/clashing-extern-fn.stderr
@@ -21,10 +21,10 @@ warning: `clash` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:14:13
    |
 LL |             fn clash(x: u8);
-   |             --------------- `clash` previously declared here
+   |             ---------------- `clash` previously declared here
 ...
 LL |             fn clash(x: u64);
-   |             ^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn(u8)`
               found `unsafe extern "C" fn(u64)`
@@ -41,7 +41,7 @@ LL |     #[link_name = "extern_link_name"]
    |     --------------------------------- `extern_link_name` previously declared here
 ...
 LL |         fn extern_link_name(x: u32);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn(i16)`
               found `unsafe extern "C" fn(u32)`
@@ -50,7 +50,7 @@ warning: `some_other_extern_link_name` redeclares `some_other_new_name` with a d
   --> $DIR/clashing-extern-fn.rs:55:9
    |
 LL |     fn some_other_new_name(x: i16);
-   |     ------------------------------ `some_other_new_name` previously declared here
+   |     ------------------------------- `some_other_new_name` previously declared here
 ...
 LL |         #[link_name = "some_other_new_name"]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
@@ -74,10 +74,10 @@ warning: `different_mod` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:72:9
    |
 LL |         fn different_mod(x: u8);
-   |         ----------------------- `different_mod` previously declared here
+   |         ------------------------ `different_mod` previously declared here
 ...
 LL |         fn different_mod(x: u64);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn(u8)`
               found `unsafe extern "C" fn(u64)`
@@ -86,10 +86,10 @@ warning: `variadic_decl` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:82:9
    |
 LL |     fn variadic_decl(x: u8, ...);
-   |     ---------------------------- `variadic_decl` previously declared here
+   |     ----------------------------- `variadic_decl` previously declared here
 ...
 LL |         fn variadic_decl(x: u8);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn(u8, ...)`
               found `unsafe extern "C" fn(u8)`
@@ -98,10 +98,10 @@ warning: `weigh_banana` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:142:13
    |
 LL |             fn weigh_banana(count: *const Banana) -> u64;
-   |             -------------------------------------------- `weigh_banana` previously declared here
+   |             --------------------------------------------- `weigh_banana` previously declared here
 ...
 LL |             fn weigh_banana(count: *const Banana) -> u64;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn(*const one::Banana) -> u64`
               found `unsafe extern "C" fn(*const three::Banana) -> u64`
@@ -110,10 +110,10 @@ warning: `draw_point` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:171:13
    |
 LL |             fn draw_point(p: Point);
-   |             ----------------------- `draw_point` previously declared here
+   |             ------------------------ `draw_point` previously declared here
 ...
 LL |             fn draw_point(p: Point);
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn(sameish_members::a::Point)`
               found `unsafe extern "C" fn(sameish_members::b::Point)`
@@ -122,10 +122,10 @@ warning: `origin` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:197:13
    |
 LL |             fn origin() -> Point3;
-   |             --------------------- `origin` previously declared here
+   |             ---------------------- `origin` previously declared here
 ...
 LL |             fn origin() -> Point3;
-   |             ^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn() -> same_sized_members_clash::a::Point3`
               found `unsafe extern "C" fn() -> same_sized_members_clash::b::Point3`
@@ -134,10 +134,10 @@ warning: `transparent_incorrect` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:220:13
    |
 LL |             fn transparent_incorrect() -> T;
-   |             ------------------------------- `transparent_incorrect` previously declared here
+   |             -------------------------------- `transparent_incorrect` previously declared here
 ...
 LL |             fn transparent_incorrect() -> isize;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn() -> T`
               found `unsafe extern "C" fn() -> isize`
@@ -146,10 +146,10 @@ warning: `missing_return_type` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:259:13
    |
 LL |             fn missing_return_type() -> usize;
-   |             --------------------------------- `missing_return_type` previously declared here
+   |             ---------------------------------- `missing_return_type` previously declared here
 ...
 LL |             fn missing_return_type();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn() -> usize`
               found `unsafe extern "C" fn()`
@@ -158,10 +158,10 @@ warning: `non_zero_usize` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:277:13
    |
 LL |             fn non_zero_usize() -> core::num::NonZero<usize>;
-   |             ------------------------------------------------ `non_zero_usize` previously declared here
+   |             ------------------------------------------------- `non_zero_usize` previously declared here
 ...
 LL |             fn non_zero_usize() -> usize;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn() -> NonZero<usize>`
               found `unsafe extern "C" fn() -> usize`
@@ -170,10 +170,10 @@ warning: `non_null_ptr` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:279:13
    |
 LL |             fn non_null_ptr() -> core::ptr::NonNull<usize>;
-   |             ---------------------------------------------- `non_null_ptr` previously declared here
+   |             ----------------------------------------------- `non_null_ptr` previously declared here
 ...
 LL |             fn non_null_ptr() -> *const usize;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn() -> NonNull<usize>`
               found `unsafe extern "C" fn() -> *const usize`
@@ -182,10 +182,10 @@ warning: `option_non_zero_usize_incorrect` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:373:13
    |
 LL |             fn option_non_zero_usize_incorrect() -> usize;
-   |             --------------------------------------------- `option_non_zero_usize_incorrect` previously declared here
+   |             ---------------------------------------------- `option_non_zero_usize_incorrect` previously declared here
 ...
 LL |             fn option_non_zero_usize_incorrect() -> isize;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn() -> usize`
               found `unsafe extern "C" fn() -> isize`
@@ -194,10 +194,10 @@ warning: `option_non_null_ptr_incorrect` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:375:13
    |
 LL |             fn option_non_null_ptr_incorrect() -> *const usize;
-   |             -------------------------------------------------- `option_non_null_ptr_incorrect` previously declared here
+   |             --------------------------------------------------- `option_non_null_ptr_incorrect` previously declared here
 ...
 LL |             fn option_non_null_ptr_incorrect() -> *const isize;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn() -> *const usize`
               found `unsafe extern "C" fn() -> *const isize`
@@ -206,10 +206,10 @@ warning: `hidden_niche_transparent_no_niche` redeclared with a different signatu
   --> $DIR/clashing-extern-fn.rs:429:13
    |
 LL |             fn hidden_niche_transparent_no_niche() -> usize;
-   |             ----------------------------------------------- `hidden_niche_transparent_no_niche` previously declared here
+   |             ------------------------------------------------ `hidden_niche_transparent_no_niche` previously declared here
 ...
 LL |             fn hidden_niche_transparent_no_niche() -> Option<TransparentNoNiche>;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn() -> usize`
               found `unsafe extern "C" fn() -> Option<TransparentNoNiche>`
@@ -218,10 +218,10 @@ warning: `hidden_niche_unsafe_cell` redeclared with a different signature
   --> $DIR/clashing-extern-fn.rs:433:13
    |
 LL |             fn hidden_niche_unsafe_cell() -> usize;
-   |             -------------------------------------- `hidden_niche_unsafe_cell` previously declared here
+   |             --------------------------------------- `hidden_niche_unsafe_cell` previously declared here
 ...
 LL |             fn hidden_niche_unsafe_cell() -> Option<UnsafeCell<NonZero<usize>>>;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn() -> usize`
               found `unsafe extern "C" fn() -> Option<UnsafeCell<NonZero<usize>>>`
diff --git a/tests/ui/lint/issue-1866.stderr b/tests/ui/lint/issue-1866.stderr
index 36d323825a4de..d19a134966831 100644
--- a/tests/ui/lint/issue-1866.stderr
+++ b/tests/ui/lint/issue-1866.stderr
@@ -2,10 +2,10 @@ warning: `rust_task_is_unwinding` redeclared with a different signature
   --> $DIR/issue-1866.rs:23:13
    |
 LL |             pub fn rust_task_is_unwinding(rt: *const rust_task) -> bool;
-   |             ----------------------------------------------------------- `rust_task_is_unwinding` previously declared here
+   |             ------------------------------------------------------------ `rust_task_is_unwinding` previously declared here
 ...
 LL |             pub fn rust_task_is_unwinding(rt: *const rust_task) -> bool;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn(*const usize) -> bool`
               found `unsafe extern "C" fn(*const bool) -> bool`
diff --git a/tests/ui/lint/lint-attr-everywhere-late.stderr b/tests/ui/lint/lint-attr-everywhere-late.stderr
index ddc31905afbcf..1937b618236b0 100644
--- a/tests/ui/lint/lint-attr-everywhere-late.stderr
+++ b/tests/ui/lint/lint-attr-everywhere-late.stderr
@@ -406,10 +406,10 @@ error: `clashing1` redeclared with a different signature
   --> $DIR/lint-attr-everywhere-late.rs:123:5
    |
 LL |         fn clashing1();
-   |         -------------- `clashing1` previously declared here
+   |         --------------- `clashing1` previously declared here
 ...
 LL |     fn clashing1(_: i32);
-   |     ^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |     ^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn()`
               found `unsafe extern "C" fn(i32)`
@@ -423,10 +423,10 @@ error: `clashing2` redeclared with a different signature
   --> $DIR/lint-attr-everywhere-late.rs:128:5
    |
 LL |         fn clashing2();
-   |         -------------- `clashing2` previously declared here
+   |         --------------- `clashing2` previously declared here
 ...
 LL |     fn clashing2(_: i32);
-   |     ^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
+   |     ^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn()`
               found `unsafe extern "C" fn(i32)`
diff --git a/tests/ui/lint/lint-missing-doc.stderr b/tests/ui/lint/lint-missing-doc.stderr
index 4e9ee4f276962..5165ccc3fd062 100644
--- a/tests/ui/lint/lint-missing-doc.stderr
+++ b/tests/ui/lint/lint-missing-doc.stderr
@@ -116,7 +116,7 @@ error: missing documentation for a function
   --> $DIR/lint-missing-doc.rs:196:5
    |
 LL |     pub fn extern_fn_undocumented(f: f32) -> f32;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a static
   --> $DIR/lint-missing-doc.rs:201:5
diff --git a/tests/ui/lint/unreachable_pub.stderr b/tests/ui/lint/unreachable_pub.stderr
index 705a537a3f1c4..65f45fbd81689 100644
--- a/tests/ui/lint/unreachable_pub.stderr
+++ b/tests/ui/lint/unreachable_pub.stderr
@@ -130,7 +130,7 @@ warning: unreachable `pub` item
   --> $DIR/unreachable_pub.rs:48:9
    |
 LL |         pub fn catalyze() -> bool;
-   |         ---^^^^^^^^^^^^^^^^^^^^^^
+   |         ---^^^^^^^^^^^^^^^^^^^^^^^
    |         |
    |         help: consider restricting its visibility: `pub(crate)`
    |
diff --git a/tests/ui/privacy/private-in-public-warn.stderr b/tests/ui/privacy/private-in-public-warn.stderr
index 3f7b8c281e706..3743879ffa616 100644
--- a/tests/ui/privacy/private-in-public-warn.stderr
+++ b/tests/ui/privacy/private-in-public-warn.stderr
@@ -100,7 +100,7 @@ error: type `types::Priv` is more private than the item `types::ef1`
   --> $DIR/private-in-public-warn.rs:28:9
    |
 LL |         pub fn ef1(arg: Priv);
-   |         ^^^^^^^^^^^^^^^^^^^^^ function `types::ef1` is reachable at visibility `pub(crate)`
+   |         ^^^^^^^^^^^^^^^^^^^^^^ function `types::ef1` is reachable at visibility `pub(crate)`
    |
 note: but type `types::Priv` is only usable at visibility `pub(self)`
   --> $DIR/private-in-public-warn.rs:9:5
@@ -112,7 +112,7 @@ error: type `types::Priv` is more private than the item `types::ef2`
   --> $DIR/private-in-public-warn.rs:29:9
    |
 LL |         pub fn ef2() -> Priv;
-   |         ^^^^^^^^^^^^^^^^^^^^ function `types::ef2` is reachable at visibility `pub(crate)`
+   |         ^^^^^^^^^^^^^^^^^^^^^ function `types::ef2` is reachable at visibility `pub(crate)`
    |
 note: but type `types::Priv` is only usable at visibility `pub(self)`
   --> $DIR/private-in-public-warn.rs:9:5

From d850f85055b1d46278e29be39d9b4b938e90f199 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 7 Aug 2024 13:08:24 -0400
Subject: [PATCH 340/685] Don't ICE on Fn trait error for foreign fn

---
 .../traits/fulfillment_errors.rs              |  4 ++
 .../foreign/foreign-safe-fn-arg-mismatch.rs   | 13 ++++++
 .../foreign-safe-fn-arg-mismatch.stderr       | 44 +++++++++++++++++++
 3 files changed, 61 insertions(+)
 create mode 100644 tests/ui/foreign/foreign-safe-fn-arg-mismatch.rs
 create mode 100644 tests/ui/foreign/foreign-safe-fn-arg-mismatch.stderr

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 326a0e4e35ce8..79ba9840130e4 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -2729,6 +2729,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(ref sig, _), .. })
             | Node::TraitItem(&hir::TraitItem {
                 kind: hir::TraitItemKind::Fn(ref sig, _), ..
+            })
+            | Node::ForeignItem(&hir::ForeignItem {
+                kind: hir::ForeignItemKind::Fn(ref sig, _, _),
+                ..
             }) => (
                 sig.span,
                 None,
diff --git a/tests/ui/foreign/foreign-safe-fn-arg-mismatch.rs b/tests/ui/foreign/foreign-safe-fn-arg-mismatch.rs
new file mode 100644
index 0000000000000..bb1052b15e9d1
--- /dev/null
+++ b/tests/ui/foreign/foreign-safe-fn-arg-mismatch.rs
@@ -0,0 +1,13 @@
+// Make sure we don't ICE when a foreign fn doesn't implement `Fn` due to arg mismatch.
+
+unsafe extern "Rust" {
+    pub safe fn foo();
+    pub safe fn bar(x: u32);
+}
+
+fn test(_: impl Fn(i32)) {}
+
+fn main() {
+    test(foo); //~ ERROR function is expected to take 1 argument, but it takes 0 arguments
+    test(bar); //~ ERROR type mismatch in function arguments
+}
diff --git a/tests/ui/foreign/foreign-safe-fn-arg-mismatch.stderr b/tests/ui/foreign/foreign-safe-fn-arg-mismatch.stderr
new file mode 100644
index 0000000000000..73ccecff5ab8c
--- /dev/null
+++ b/tests/ui/foreign/foreign-safe-fn-arg-mismatch.stderr
@@ -0,0 +1,44 @@
+error[E0593]: function is expected to take 1 argument, but it takes 0 arguments
+  --> $DIR/foreign-safe-fn-arg-mismatch.rs:11:10
+   |
+LL |     pub safe fn foo();
+   |     ------------------ takes 0 arguments
+...
+LL |     test(foo);
+   |     ---- ^^^ expected function that takes 1 argument
+   |     |
+   |     required by a bound introduced by this call
+   |
+note: required by a bound in `test`
+  --> $DIR/foreign-safe-fn-arg-mismatch.rs:8:17
+   |
+LL | fn test(_: impl Fn(i32)) {}
+   |                 ^^^^^^^ required by this bound in `test`
+
+error[E0631]: type mismatch in function arguments
+  --> $DIR/foreign-safe-fn-arg-mismatch.rs:12:10
+   |
+LL |     pub safe fn bar(x: u32);
+   |     ------------------------ found signature defined here
+...
+LL |     test(bar);
+   |     ---- ^^^ expected due to this
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = note: expected function signature `fn(i32) -> _`
+              found function signature `fn(u32) -> _`
+note: required by a bound in `test`
+  --> $DIR/foreign-safe-fn-arg-mismatch.rs:8:17
+   |
+LL | fn test(_: impl Fn(i32)) {}
+   |                 ^^^^^^^ required by this bound in `test`
+help: consider wrapping the function in a closure
+   |
+LL |     test(|arg0: i32| bar(/* u32 */));
+   |          +++++++++++    +++++++++++
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0593, E0631.
+For more information about an error, try `rustc --explain E0593`.

From 84633f47f671f6c084d83070c6dc97d812de1758 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 7 Aug 2024 13:35:21 -0400
Subject: [PATCH 341/685] Simplify cleaning foreign fns in rustdoc

---
 src/librustdoc/clean/mod.rs                        | 14 ++++----------
 .../multiple-declarations.stderr                   |  2 +-
 .../rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr |  2 +-
 3 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 53757349a9b2c..db81b4c4282a1 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -3094,16 +3094,10 @@ fn clean_maybe_renamed_foreign_item<'tcx>(
     let def_id = item.owner_id.to_def_id();
     cx.with_param_env(def_id, |cx| {
         let kind = match item.kind {
-            hir::ForeignItemKind::Fn(decl, names, generics, safety) => {
-                let (generics, decl) = enter_impl_trait(cx, |cx| {
-                    // NOTE: generics must be cleaned before args
-                    let generics = clean_generics(generics, cx);
-                    let args = clean_args_from_types_and_names(cx, decl.inputs, names);
-                    let decl = clean_fn_decl_with_args(cx, decl, None, args);
-                    (generics, decl)
-                });
-                ForeignFunctionItem(Box::new(Function { decl, generics }), safety)
-            }
+            hir::ForeignItemKind::Fn(sig, names, generics) => ForeignFunctionItem(
+                clean_function(cx, &sig, generics, FunctionArgs::Names(names)),
+                sig.header.safety,
+            ),
             hir::ForeignItemKind::Static(ty, mutability, safety) => ForeignStaticItem(
                 Static { type_: Box::new(clean_ty(ty, cx)), mutability, expr: None },
                 safety,
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 7866af594449f..b766b5c8dd831 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/multiple-declarations.stderr
@@ -2,7 +2,7 @@ error: multiple declarations of external function `f` from library `foo.dll` hav
   --> $DIR/multiple-declarations.rs:13:9
    |
 LL |         fn f(x: i32);
-   |         ^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^
 
 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 d7c7344b596db..ef022404e7f67 100644
--- a/tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr
+++ b/tests/ui/rfcs/rfc-2627-raw-dylib/unsupported-abi.stderr
@@ -2,7 +2,7 @@ error: ABI not supported by `#[link(kind = "raw-dylib")]` on this architecture
   --> $DIR/unsupported-abi.rs:6:5
    |
 LL |     fn f(x: i32);
-   |     ^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 

From 29017e45a1c85afe457765a5d4c77e4fcdebb4f6 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Fri, 16 Aug 2024 12:42:02 -0700
Subject: [PATCH 342/685] mir/pretty: use `Option` instead of `Either<Once,
 Empty>`

`Either` is wasteful for a one-or-none iterator, especially since `Once`
is already an `option::IntoIter` internally. We don't really need any of
the iterator mechanisms in this case, just a single conditional insert.
---
 compiler/rustc_middle/src/mir/pretty.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index f2d8781413096..5dd0e69cf1fe6 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1418,21 +1418,19 @@ pub fn write_allocations<'tcx>(
         alloc.inner().provenance().ptrs().values().map(|p| p.alloc_id())
     }
 
-    fn alloc_ids_from_const_val(val: ConstValue<'_>) -> impl Iterator<Item = AllocId> + '_ {
+    fn alloc_id_from_const_val(val: ConstValue<'_>) -> Option<AllocId> {
         match val {
-            ConstValue::Scalar(interpret::Scalar::Ptr(ptr, _)) => {
-                Either::Left(std::iter::once(ptr.provenance.alloc_id()))
-            }
-            ConstValue::Scalar(interpret::Scalar::Int { .. }) => Either::Right(std::iter::empty()),
-            ConstValue::ZeroSized => Either::Right(std::iter::empty()),
+            ConstValue::Scalar(interpret::Scalar::Ptr(ptr, _)) => Some(ptr.provenance.alloc_id()),
+            ConstValue::Scalar(interpret::Scalar::Int { .. }) => None,
+            ConstValue::ZeroSized => None,
             ConstValue::Slice { .. } => {
                 // `u8`/`str` slices, shouldn't contain pointers that we want to print.
-                Either::Right(std::iter::empty())
+                None
             }
             ConstValue::Indirect { alloc_id, .. } => {
                 // FIXME: we don't actually want to print all of these, since some are printed nicely directly as values inline in MIR.
                 // Really we'd want `pretty_print_const_value` to decide which allocations to print, instead of having a separate visitor.
-                Either::Left(std::iter::once(alloc_id))
+                Some(alloc_id)
             }
         }
     }
@@ -1443,7 +1441,9 @@ pub fn write_allocations<'tcx>(
             match c.const_ {
                 Const::Ty(_, _) | Const::Unevaluated(..) => {}
                 Const::Val(val, _) => {
-                    self.0.extend(alloc_ids_from_const_val(val));
+                    if let Some(id) = alloc_id_from_const_val(val) {
+                        self.0.insert(id);
+                    }
                 }
             }
         }

From ed6315b3fef4ebd9aee053d407eb746c3b1d58bf Mon Sep 17 00:00:00 2001
From: Boxy <rust@boxyuwu.dev>
Date: Fri, 16 Aug 2024 20:53:02 +0100
Subject: [PATCH 343/685] Rewrite `get_fn_id_for_return_block`

---
 compiler/rustc_middle/src/hir/map/mod.rs      |  64 +++++-----
 tests/crashes/128810.rs                       |  25 ----
 ..._body_owner_parent_found_in_diagnostics.rs |  34 ++++++
 ...y_owner_parent_found_in_diagnostics.stderr | 113 ++++++++++++++++++
 tests/ui/typeck/const-in-fn-call-generics.rs  |  16 +++
 .../typeck/const-in-fn-call-generics.stderr   |   9 ++
 6 files changed, 199 insertions(+), 62 deletions(-)
 delete mode 100644 tests/crashes/128810.rs
 create mode 100644 tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs
 create mode 100644 tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr
 create mode 100644 tests/ui/typeck/const-in-fn-call-generics.rs
 create mode 100644 tests/ui/typeck/const-in-fn-call-generics.stderr

diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs
index edab6b5ebde84..da08027d66b19 100644
--- a/compiler/rustc_middle/src/hir/map/mod.rs
+++ b/compiler/rustc_middle/src/hir/map/mod.rs
@@ -554,53 +554,43 @@ impl<'hir> Map<'hir> {
     /// }
     /// ```
     pub fn get_fn_id_for_return_block(self, id: HirId) -> Option<HirId> {
-        let mut iter = self.parent_iter(id).peekable();
-        let mut ignore_tail = false;
-        if let Node::Expr(Expr { kind: ExprKind::Ret(_), .. }) = self.tcx.hir_node(id) {
-            // When dealing with `return` statements, we don't care about climbing only tail
-            // expressions.
-            ignore_tail = true;
-        }
+        let enclosing_body_owner = self.tcx.local_def_id_to_hir_id(self.enclosing_body_owner(id));
+
+        // Return `None` if the `id` expression is not the returned value of the enclosing body
+        let mut iter = [id].into_iter().chain(self.parent_id_iter(id)).peekable();
+        while let Some(cur_id) = iter.next() {
+            if enclosing_body_owner == cur_id {
+                break;
+            }
+
+            // A return statement is always the value returned from the enclosing body regardless of
+            // what the parent expressions are.
+            if let Node::Expr(Expr { kind: ExprKind::Ret(_), .. }) = self.tcx.hir_node(cur_id) {
+                break;
+            }
 
-        let mut prev_hir_id = None;
-        while let Some((hir_id, node)) = iter.next() {
-            if let (Some((_, next_node)), false) = (iter.peek(), ignore_tail) {
-                match next_node {
-                    Node::Block(Block { expr: None, .. }) => return None,
-                    // The current node is not the tail expression of its parent.
-                    Node::Block(Block { expr: Some(e), .. }) if hir_id != e.hir_id => return None,
+            // If the current expression's value doesnt get used as the parent expressions value then return `None`
+            if let Some(&parent_id) = iter.peek() {
+                match self.tcx.hir_node(parent_id) {
+                    // The current node is not the tail expression of the block expression parent expr.
+                    Node::Block(Block { expr: Some(e), .. }) if cur_id != e.hir_id => return None,
                     Node::Block(Block { expr: Some(e), .. })
                         if matches!(e.kind, ExprKind::If(_, _, None)) =>
                     {
                         return None;
                     }
+
+                    // The current expression's value does not pass up through these parent expressions
+                    Node::Block(Block { expr: None, .. })
+                    | Node::Expr(Expr { kind: ExprKind::Loop(..), .. })
+                    | Node::LetStmt(..) => return None,
+
                     _ => {}
                 }
             }
-            match node {
-                Node::Item(_)
-                | Node::ForeignItem(_)
-                | Node::TraitItem(_)
-                | Node::Expr(Expr { kind: ExprKind::Closure(_), .. })
-                | Node::ImplItem(_)
-                    // The input node `id` must be enclosed in the method's body as opposed
-                    // to some other place such as its return type (fixes #114918).
-                    // We verify that indirectly by checking that the previous node is the
-                    // current node's body
-                    if node.body_id().map(|b| b.hir_id) == prev_hir_id =>  {
-                        return Some(hir_id)
-                }
-                // Ignore `return`s on the first iteration
-                Node::Expr(Expr { kind: ExprKind::Loop(..) | ExprKind::Ret(..), .. })
-                | Node::LetStmt(_) => {
-                    return None;
-                }
-                _ => {}
-            }
-
-            prev_hir_id = Some(hir_id);
         }
-        None
+
+        Some(enclosing_body_owner)
     }
 
     /// Retrieves the `OwnerId` for `id`'s parent item, or `id` itself if no
diff --git a/tests/crashes/128810.rs b/tests/crashes/128810.rs
deleted file mode 100644
index 68214ff010c99..0000000000000
--- a/tests/crashes/128810.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-//@ known-bug: rust-lang/rust#128810
-
-#![feature(fn_delegation)]
-
-use std::marker::PhantomData;
-
-pub struct InvariantRef<'a, T: ?Sized>(&'a T, PhantomData<&'a mut &'a T>);
-
-impl<'a> InvariantRef<'a, ()> {
-    pub const NEW: Self = InvariantRef::new(&());
-}
-
-trait Trait {
-    fn foo(&self) -> u8 { 0 }
-    fn bar(&self) -> u8 { 1 }
-    fn meh(&self) -> u8 { 2 }
-}
-
-struct Z(u8);
-
-impl Trait for Z {
-    reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
-}
-
-fn main() { }
diff --git a/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs
new file mode 100644
index 0000000000000..0a7ec5ab5c1be
--- /dev/null
+++ b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.rs
@@ -0,0 +1,34 @@
+#![feature(fn_delegation)]
+#![allow(incomplete_features)]
+
+use std::marker::PhantomData;
+
+pub struct InvariantRef<'a, T: ?Sized>(&'a T, PhantomData<&'a mut &'a T>);
+
+impl<'a> InvariantRef<'a, ()> {
+    pub const NEW: Self = InvariantRef::new(&());
+    //~^ ERROR: no function or associated item named `new` found
+}
+
+trait Trait {
+    fn foo(&self) -> u8 { 0 }
+    fn bar(&self) -> u8 { 1 }
+    fn meh(&self) -> u8 { 2 }
+}
+
+struct Z(u8);
+
+impl Trait for Z {
+    reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+    //~^ ERROR: use of undeclared lifetime name `'a`
+    //~| ERROR: use of undeclared lifetime name `'a`
+    //~| ERROR: use of undeclared lifetime name `'a`
+    //~| ERROR: the trait bound `u8: Trait` is not satisfied
+    //~| ERROR: the trait bound `u8: Trait` is not satisfied
+    //~| ERROR: the trait bound `u8: Trait` is not satisfied
+    //~| ERROR: mismatched types
+    //~| ERROR: mismatched types
+    //~| ERROR: mismatched types
+}
+
+fn main() { }
diff --git a/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr
new file mode 100644
index 0000000000000..2ce3b388073c4
--- /dev/null
+++ b/tests/ui/delegation/correct_body_owner_parent_found_in_diagnostics.stderr
@@ -0,0 +1,113 @@
+error[E0261]: use of undeclared lifetime name `'a`
+  --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:68
+   |
+LL |     reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+   |                                                                    ^^ undeclared lifetime
+   |
+help: consider introducing lifetime `'a` here
+   |
+LL |     reuse <u8 as Trait>::{foo'a, , bar, meh} { &const { InvariantRef::<'a>::NEW } }
+   |                              +++
+help: consider introducing lifetime `'a` here
+   |
+LL | impl<'a> Trait for Z {
+   |     ++++
+
+error[E0261]: use of undeclared lifetime name `'a`
+  --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:68
+   |
+LL |     reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+   |                                                                    ^^ undeclared lifetime
+   |
+help: consider introducing lifetime `'a` here
+   |
+LL |     reuse <u8 as Trait>::{foo, bar'a, , meh} { &const { InvariantRef::<'a>::NEW } }
+   |                                   +++
+help: consider introducing lifetime `'a` here
+   |
+LL | impl<'a> Trait for Z {
+   |     ++++
+
+error[E0261]: use of undeclared lifetime name `'a`
+  --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:68
+   |
+LL |     reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+   |                                                                    ^^ undeclared lifetime
+   |
+help: consider introducing lifetime `'a` here
+   |
+LL |     reuse <u8 as Trait>::{foo, bar, meh'a, } { &const { InvariantRef::<'a>::NEW } }
+   |                                        +++
+help: consider introducing lifetime `'a` here
+   |
+LL | impl<'a> Trait for Z {
+   |     ++++
+
+error[E0599]: no function or associated item named `new` found for struct `InvariantRef` in the current scope
+  --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:9:41
+   |
+LL | pub struct InvariantRef<'a, T: ?Sized>(&'a T, PhantomData<&'a mut &'a T>);
+   | -------------------------------------- function or associated item `new` not found for this struct
+...
+LL |     pub const NEW: Self = InvariantRef::new(&());
+   |                                         ^^^ function or associated item not found in `InvariantRef<'_, _>`
+
+error[E0308]: mismatched types
+  --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:53
+   |
+LL |     reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+   |                                                     ^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `InvariantRef<'_, ()>`
+   |
+   = note: expected type `u8`
+            found struct `InvariantRef<'_, ()>`
+
+error[E0277]: the trait bound `u8: Trait` is not satisfied
+  --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:12
+   |
+LL |     reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+   |            ^^ the trait `Trait` is not implemented for `u8`
+   |
+   = help: the trait `Trait` is implemented for `Z`
+
+error[E0308]: mismatched types
+  --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:53
+   |
+LL |     reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+   |                                                     ^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `InvariantRef<'_, ()>`
+   |
+   = note: expected type `u8`
+            found struct `InvariantRef<'_, ()>`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0277]: the trait bound `u8: Trait` is not satisfied
+  --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:12
+   |
+LL |     reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+   |            ^^ the trait `Trait` is not implemented for `u8`
+   |
+   = help: the trait `Trait` is implemented for `Z`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0308]: mismatched types
+  --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:53
+   |
+LL |     reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+   |                                                     ^^^^^^^^^^^^^^^^^^^^^^^ expected `u8`, found `InvariantRef<'_, ()>`
+   |
+   = note: expected type `u8`
+            found struct `InvariantRef<'_, ()>`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0277]: the trait bound `u8: Trait` is not satisfied
+  --> $DIR/correct_body_owner_parent_found_in_diagnostics.rs:22:12
+   |
+LL |     reuse <u8 as Trait>::{foo, bar, meh} { &const { InvariantRef::<'a>::NEW } }
+   |            ^^ the trait `Trait` is not implemented for `u8`
+   |
+   = help: the trait `Trait` is implemented for `Z`
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 10 previous errors
+
+Some errors have detailed explanations: E0261, E0277, E0308, E0599.
+For more information about an error, try `rustc --explain E0261`.
diff --git a/tests/ui/typeck/const-in-fn-call-generics.rs b/tests/ui/typeck/const-in-fn-call-generics.rs
new file mode 100644
index 0000000000000..675dbcc305475
--- /dev/null
+++ b/tests/ui/typeck/const-in-fn-call-generics.rs
@@ -0,0 +1,16 @@
+fn generic<const N: u32>() {}
+
+trait Collate<const A: u32> {
+    type Pass;
+    fn collate(self) -> Self::Pass;
+}
+
+impl<const B: u32> Collate<B> for i32 {
+    type Pass = ();
+    fn collate(self) -> Self::Pass {
+        generic::<{ true }>()
+        //~^ ERROR: mismatched types
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/typeck/const-in-fn-call-generics.stderr b/tests/ui/typeck/const-in-fn-call-generics.stderr
new file mode 100644
index 0000000000000..12dd454188cac
--- /dev/null
+++ b/tests/ui/typeck/const-in-fn-call-generics.stderr
@@ -0,0 +1,9 @@
+error[E0308]: mismatched types
+  --> $DIR/const-in-fn-call-generics.rs:11:21
+   |
+LL |         generic::<{ true }>()
+   |                     ^^^^ expected `u32`, found `bool`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.

From 8bc120af8286caae68742f8d9943681c5691effb Mon Sep 17 00:00:00 2001
From: Artem Agvanian <nartagva@amazon.com>
Date: Fri, 16 Aug 2024 14:28:06 -0700
Subject: [PATCH 344/685] Add an ability to convert between `Span` and
 `visit::Location`

---
 compiler/stable_mir/src/mir/visit.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/compiler/stable_mir/src/mir/visit.rs b/compiler/stable_mir/src/mir/visit.rs
index 50d7bae21db72..f391a0f444a30 100644
--- a/compiler/stable_mir/src/mir/visit.rs
+++ b/compiler/stable_mir/src/mir/visit.rs
@@ -465,6 +465,12 @@ impl Location {
     }
 }
 
+impl From<Span> for Location {
+    fn from(span: Span) -> Self {
+        Location(span)
+    }
+}
+
 /// Reference to a place used to represent a partial projection.
 pub struct PlaceRef<'a> {
     pub local: Local,

From 12e638978814d84e4e09b172f784d5f16759d8e1 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 15 Aug 2024 16:22:01 -0400
Subject: [PATCH 345/685] bootstrap: improve error recovery flags to curl

alternative to #128459

fixes #110178
---
 src/bootstrap/bootstrap.py         |  8 +++++++-
 src/bootstrap/src/core/download.rs | 31 ++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
index 4e8e0fd2532f1..5ea4b4882a975 100644
--- a/src/bootstrap/bootstrap.py
+++ b/src/bootstrap/bootstrap.py
@@ -79,6 +79,8 @@ def get(base, url, path, checksums, verbose=False):
                 eprint("removing", temp_path)
             os.unlink(temp_path)
 
+def curl_version():
+    return float(re.match(bytes("^curl ([0-9]+\\.[0-9]+)", "utf8"), require(["curl", "-V"]))[1])
 
 def download(path, url, probably_big, verbose):
     for _ in range(4):
@@ -107,11 +109,15 @@ def _download(path, url, probably_big, verbose, exception):
         # If curl is not present on Win32, we should not sys.exit
         #   but raise `CalledProcessError` or `OSError` instead
         require(["curl", "--version"], exception=platform_is_win32())
-        run(["curl", option,
+        extra_flags = []
+        if curl_version() > 7.70:
+            extra_flags = [ "--retry-all-errors" ]
+        run(["curl", option] + extra_flags + [
             "-L", # Follow redirect.
             "-y", "30", "-Y", "10",    # timeout if speed is < 10 bytes/sec for > 30 seconds
             "--connect-timeout", "30",  # timeout if cannot connect within 30 seconds
             "-o", path,
+            "--continue-at", "-",
             "--retry", "3", "-SRf", url],
             verbose=verbose,
             exception=True, # Will raise RuntimeError on failure
diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index 4d1aea3cd956a..ed7637e8ee097 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -21,6 +21,31 @@ fn try_run(config: &Config, cmd: &mut Command) -> Result<(), ()> {
     config.try_run(cmd)
 }
 
+fn extract_curl_version(out: &[u8]) -> f32 {
+    let out = &out[5..];
+    let Some(i) = out.iter().position(|&x| x == b' ') else { return 0.0 };
+    let out = &out[..i];
+    let Some(k) = out.iter().rev().position(|&x| x == b'.') else { return 0.0 };
+    let out = &out[..out.len()-k-1];
+    std::str::from_utf8(out).unwrap().parse().unwrap_or(0.0)
+}
+
+#[test]
+fn test_extract_curl_version() {
+    assert_eq!(extract_curl_version(b"\
+        curl 8.4.0 (x86_64-pc-linux-gnu) libcurl/8.4.0 \
+        OpenSSL/3.0.13 zlib/1.3 brotli/1.1.0 zstd/1.5.5 libidn2/2.3.4 \
+        libssh2/1.11.0 nghttp2/1.57.0"), 8.4);
+}
+
+fn curl_version() -> f32 {
+    let mut curl = Command::new("curl");
+    curl.arg("-V");
+    let Ok(out) = curl.output() else { return 0.0 };
+    let out = out.stdout;
+    extract_curl_version(&out)
+}
+
 /// Generic helpers that are useful anywhere in bootstrap.
 impl Config {
     pub fn is_verbose(&self) -> bool {
@@ -219,6 +244,8 @@ impl Config {
             "30", // timeout if cannot connect within 30 seconds
             "-o",
             tempfile.to_str().unwrap(),
+            "--continue-at",
+            "-",
             "--retry",
             "3",
             "-SRf",
@@ -229,6 +256,10 @@ impl Config {
         } else {
             curl.arg("--progress-bar");
         }
+        // --retry-all-errors was added in 7.71.0, don't use it if curl is old.
+        if dbg!(curl_version()) > 7.70 {
+            curl.arg("--retry-all-errors");
+        }
         curl.arg(url);
         if !self.check_run(&mut curl) {
             if self.build.contains("windows-msvc") {

From 9bc7cea412b31be0faf1fc1e65f39b9b952a43e6 Mon Sep 17 00:00:00 2001
From: beetrees <b@beetr.ee>
Date: Fri, 16 Aug 2024 23:42:10 +0100
Subject: [PATCH 346/685] Fix `is_val_statically_known` for floats

---
 compiler/rustc_codegen_llvm/src/context.rs   |  2 +
 compiler/rustc_codegen_llvm/src/intrinsic.rs | 22 ++++--
 tests/codegen/is_val_statically_known.rs     | 81 +++++++++++++++++++-
 3 files changed, 96 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index dd3f39eceadb6..1fd9f9e811671 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -1000,8 +1000,10 @@ impl<'ll> CodegenCx<'ll, '_> {
         ifn!("llvm.is.constant.i64", fn(t_i64) -> i1);
         ifn!("llvm.is.constant.i128", fn(t_i128) -> i1);
         ifn!("llvm.is.constant.isize", fn(t_isize) -> i1);
+        ifn!("llvm.is.constant.f16", fn(t_f16) -> i1);
         ifn!("llvm.is.constant.f32", fn(t_f32) -> i1);
         ifn!("llvm.is.constant.f64", fn(t_f64) -> i1);
+        ifn!("llvm.is.constant.f128", fn(t_f128) -> i1);
         ifn!("llvm.is.constant.ptr", fn(ptr) -> i1);
 
         ifn!("llvm.expect.i1", fn(i1, i1) -> i1);
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index f5558723d11bf..abfe38d4c0cc6 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -192,14 +192,22 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
             }
             sym::is_val_statically_known => {
                 let intrinsic_type = args[0].layout.immediate_llvm_type(self.cx);
-                match self.type_kind(intrinsic_type) {
-                    TypeKind::Pointer | TypeKind::Integer | TypeKind::Float | TypeKind::Double => {
-                        self.call_intrinsic(
-                            &format!("llvm.is.constant.{:?}", intrinsic_type),
-                            &[args[0].immediate()],
-                        )
+                let kind = self.type_kind(intrinsic_type);
+                let intrinsic_name = match kind {
+                    TypeKind::Pointer | TypeKind::Integer => {
+                        Some(format!("llvm.is.constant.{intrinsic_type:?}"))
                     }
-                    _ => self.const_bool(false),
+                    // LLVM float types' intrinsic names differ from their type names.
+                    TypeKind::Half => Some(format!("llvm.is.constant.f16")),
+                    TypeKind::Float => Some(format!("llvm.is.constant.f32")),
+                    TypeKind::Double => Some(format!("llvm.is.constant.f64")),
+                    TypeKind::FP128 => Some(format!("llvm.is.constant.f128")),
+                    _ => None,
+                };
+                if let Some(intrinsic_name) = intrinsic_name {
+                    self.call_intrinsic(&intrinsic_name, &[args[0].immediate()])
+                } else {
+                    self.const_bool(false)
                 }
             }
             sym::unlikely => self
diff --git a/tests/codegen/is_val_statically_known.rs b/tests/codegen/is_val_statically_known.rs
index 6af4f353a481c..fe432d3bcc4de 100644
--- a/tests/codegen/is_val_statically_known.rs
+++ b/tests/codegen/is_val_statically_known.rs
@@ -1,6 +1,7 @@
 //@ compile-flags: --crate-type=lib -Zmerge-functions=disabled -O
 
 #![feature(core_intrinsics)]
+#![feature(f16, f128)]
 
 use std::intrinsics::is_val_statically_known;
 
@@ -49,7 +50,7 @@ pub fn _bool_false(b: bool) -> i32 {
 
 #[inline]
 pub fn _iref(a: &u8) -> i32 {
-    if unsafe { is_val_statically_known(a) } { 5 } else { 4 }
+    if is_val_statically_known(a) { 5 } else { 4 }
 }
 
 // CHECK-LABEL: @_iref_borrow(
@@ -68,7 +69,7 @@ pub fn _iref_arg(a: &u8) -> i32 {
 
 #[inline]
 pub fn _slice_ref(a: &[u8]) -> i32 {
-    if unsafe { is_val_statically_known(a) } { 7 } else { 6 }
+    if is_val_statically_known(a) { 7 } else { 6 }
 }
 
 // CHECK-LABEL: @_slice_ref_borrow(
@@ -84,3 +85,79 @@ pub fn _slice_ref_arg(a: &[u8]) -> i32 {
     // CHECK: ret i32 6
     _slice_ref(a)
 }
+
+#[inline]
+pub fn _f16(a: f16) -> i32 {
+    if is_val_statically_known(a) { 1 } else { 0 }
+}
+
+// CHECK-LABEL: @_f16_true(
+#[no_mangle]
+pub fn _f16_true() -> i32 {
+    // CHECK: ret i32 1
+    _f16(1.0)
+}
+
+// CHECK-LABEL: @_f16_false(
+#[no_mangle]
+pub fn _f16_false(a: f16) -> i32 {
+    // CHECK: ret i32 0
+    _f16(a)
+}
+
+#[inline]
+pub fn _f32(a: f32) -> i32 {
+    if is_val_statically_known(a) { 1 } else { 0 }
+}
+
+// CHECK-LABEL: @_f32_true(
+#[no_mangle]
+pub fn _f32_true() -> i32 {
+    // CHECK: ret i32 1
+    _f32(1.0)
+}
+
+// CHECK-LABEL: @_f32_false(
+#[no_mangle]
+pub fn _f32_false(a: f32) -> i32 {
+    // CHECK: ret i32 0
+    _f32(a)
+}
+
+#[inline]
+pub fn _f64(a: f64) -> i32 {
+    if is_val_statically_known(a) { 1 } else { 0 }
+}
+
+// CHECK-LABEL: @_f64_true(
+#[no_mangle]
+pub fn _f64_true() -> i32 {
+    // CHECK: ret i32 1
+    _f64(1.0)
+}
+
+// CHECK-LABEL: @_f64_false(
+#[no_mangle]
+pub fn _f64_false(a: f64) -> i32 {
+    // CHECK: ret i32 0
+    _f64(a)
+}
+
+#[inline]
+pub fn _f128(a: f128) -> i32 {
+    if is_val_statically_known(a) { 1 } else { 0 }
+}
+
+// CHECK-LABEL: @_f128_true(
+#[no_mangle]
+pub fn _f128_true() -> i32 {
+    // CHECK: ret i32 1
+    _f128(1.0)
+}
+
+// CHECK-LABEL: @_f128_false(
+#[no_mangle]
+pub fn _f128_false(a: f128) -> i32 {
+    // CHECK: ret i32 0
+    _f128(a)
+}

From 70320c1936e2cdf0dd4f79c6539b32dd928d4cc2 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 11 Aug 2024 14:25:00 -0400
Subject: [PATCH 347/685] Enable more debuginfo tests on Windows

---
 tests/debuginfo/drop-locations.rs           | 1 -
 tests/debuginfo/embedded-visualizer.rs      | 2 +-
 tests/debuginfo/empty-string.rs             | 2 +-
 tests/debuginfo/issue-12886.rs              | 3 +--
 tests/debuginfo/macro-stepping.rs           | 1 -
 tests/debuginfo/numeric-types.rs            | 2 +-
 tests/debuginfo/pretty-huge-vec.rs          | 2 +-
 tests/debuginfo/pretty-slices.rs            | 2 +-
 tests/debuginfo/pretty-std-collections.rs   | 1 -
 tests/debuginfo/pretty-uninitialized-vec.rs | 2 +-
 tests/debuginfo/thread-names.rs             | 2 +-
 11 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/tests/debuginfo/drop-locations.rs b/tests/debuginfo/drop-locations.rs
index 0777313d19804..2db087dda7967 100644
--- a/tests/debuginfo/drop-locations.rs
+++ b/tests/debuginfo/drop-locations.rs
@@ -1,4 +1,3 @@
-//@ ignore-windows
 //@ ignore-android
 //@ min-lldb-version: 310
 //@ ignore-test: #128971
diff --git a/tests/debuginfo/embedded-visualizer.rs b/tests/debuginfo/embedded-visualizer.rs
index 69afd273f7735..959dbba7fd73c 100644
--- a/tests/debuginfo/embedded-visualizer.rs
+++ b/tests/debuginfo/embedded-visualizer.rs
@@ -1,7 +1,7 @@
 //@ compile-flags:-g
 //@ min-gdb-version: 8.1
 //@ ignore-lldb
-//@ ignore-windows-gnu // emit_debug_gdb_scripts is disabled on Windows
+//@ ignore-windows-gnu: #128981
 
 // === CDB TESTS ==================================================================================
 
diff --git a/tests/debuginfo/empty-string.rs b/tests/debuginfo/empty-string.rs
index 35b68ed91c0fc..eac3448bfd510 100644
--- a/tests/debuginfo/empty-string.rs
+++ b/tests/debuginfo/empty-string.rs
@@ -1,4 +1,4 @@
-//@ ignore-windows failing on win32 bot
+//@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
 //@ min-gdb-version: 8.1
diff --git a/tests/debuginfo/issue-12886.rs b/tests/debuginfo/issue-12886.rs
index c6cf0dd4e05e3..48250e885374d 100644
--- a/tests/debuginfo/issue-12886.rs
+++ b/tests/debuginfo/issue-12886.rs
@@ -1,4 +1,3 @@
-//@ ignore-windows failing on 64-bit bots FIXME #17638
 //@ ignore-lldb
 //@ ignore-aarch64
 
@@ -6,7 +5,7 @@
 
 // gdb-command:run
 // gdb-command:next
-// gdb-check:[...]24[...]let s = Some(5).unwrap(); // #break
+// gdb-check:[...]23[...]let s = Some(5).unwrap(); // #break
 // gdb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/macro-stepping.rs b/tests/debuginfo/macro-stepping.rs
index 3edac3c7832f9..35bb6de4fef38 100644
--- a/tests/debuginfo/macro-stepping.rs
+++ b/tests/debuginfo/macro-stepping.rs
@@ -1,4 +1,3 @@
-//@ ignore-windows
 //@ ignore-android
 //@ ignore-aarch64
 //@ min-lldb-version: 1800
diff --git a/tests/debuginfo/numeric-types.rs b/tests/debuginfo/numeric-types.rs
index 98bc31e88557a..6f45b69e5e34c 100644
--- a/tests/debuginfo/numeric-types.rs
+++ b/tests/debuginfo/numeric-types.rs
@@ -1,7 +1,7 @@
 //@ compile-flags:-g
 
 //@ min-gdb-version: 8.1
-//@ ignore-windows-gnu // emit_debug_gdb_scripts is disabled on Windows
+//@ ignore-windows-gnu: #128981
 
 // Tests the visualizations for `NonZero<T>`, `Wrapping<T>` and
 // `Atomic{Bool,I8,I16,I32,I64,Isize,U8,U16,U32,U64,Usize}` located in `libcore.natvis`.
diff --git a/tests/debuginfo/pretty-huge-vec.rs b/tests/debuginfo/pretty-huge-vec.rs
index dcf3521175d4c..b88e5db1acb8c 100644
--- a/tests/debuginfo/pretty-huge-vec.rs
+++ b/tests/debuginfo/pretty-huge-vec.rs
@@ -1,4 +1,4 @@
-//@ ignore-windows failing on win32 bot
+//@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
 //@ min-gdb-version: 8.1
diff --git a/tests/debuginfo/pretty-slices.rs b/tests/debuginfo/pretty-slices.rs
index 9defa344be03e..44335f5c83b3f 100644
--- a/tests/debuginfo/pretty-slices.rs
+++ b/tests/debuginfo/pretty-slices.rs
@@ -1,5 +1,5 @@
 //@ ignore-android: FIXME(#10381)
-//@ ignore-windows
+//@ ignore-windows-gnu: #128981
 //@ compile-flags:-g
 
 // gdb-command: run
diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs
index 3d5a30d19a9ce..3ec00886e2f40 100644
--- a/tests/debuginfo/pretty-std-collections.rs
+++ b/tests/debuginfo/pretty-std-collections.rs
@@ -1,4 +1,3 @@
-//@ ignore-windows failing on win32 bot
 //@ ignore-android: FIXME(#10381)
 //@ ignore-windows-gnu: #128981
 //@ compile-flags:-g
diff --git a/tests/debuginfo/pretty-uninitialized-vec.rs b/tests/debuginfo/pretty-uninitialized-vec.rs
index 5206ff23fd5ba..ddb751161d8ce 100644
--- a/tests/debuginfo/pretty-uninitialized-vec.rs
+++ b/tests/debuginfo/pretty-uninitialized-vec.rs
@@ -1,4 +1,4 @@
-//@ ignore-windows failing on win32 bot
+//@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
 //@ min-gdb-version: 8.1
diff --git a/tests/debuginfo/thread-names.rs b/tests/debuginfo/thread-names.rs
index 6b3b0c7f4b231..265b9271cf306 100644
--- a/tests/debuginfo/thread-names.rs
+++ b/tests/debuginfo/thread-names.rs
@@ -4,7 +4,7 @@
 //@[macos] only-macos
 //@[win] only-windows
 //@ ignore-sgx
-//@ ignore-windows-gnu
+//@ ignore-windows-gnu: gdb on windows-gnu does not print thread names
 
 // === GDB TESTS ==================================================================================
 //

From 6c201561acd30972e850fc069341bd84ee3d26ae Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Fri, 16 Aug 2024 21:18:24 -0400
Subject: [PATCH 348/685] Update cargo

---
 src/tools/cargo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/cargo b/src/tools/cargo
index 2f738d617c6ea..ba8b39413c74d 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 2f738d617c6ead388f899802dd1a7fd66858a691
+Subproject commit ba8b39413c74d08494f94a7542fe79aa636e1661

From c8ae02fb842fcd4b2f3a75e279bd61c141552c55 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 16 Aug 2024 21:33:44 -0400
Subject: [PATCH 349/685] CFI: Erase regions when projecting ADT to its
 transparent non-1zst field

---
 .../cfi/typeid/itanium_cxx_abi/transform.rs    |  2 +-
 .../sanitizer/cfi/transparent-has-regions.rs   | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/sanitizer/cfi/transparent-has-regions.rs

diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
index e628c17aca3cb..dcbd6a11e878d 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
@@ -146,7 +146,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> for TransformTy<'tcx> {
                         !is_zst
                     });
                     if let Some(field) = field {
-                        let ty0 = self.tcx.type_of(field.did).instantiate(self.tcx, args);
+                        let ty0 = self.tcx.erase_regions(field.ty(self.tcx, args));
                         // Generalize any repr(transparent) user-defined type that is either a
                         // pointer or reference, and either references itself or any other type that
                         // contains or references itself, to avoid a reference cycle.
diff --git a/tests/ui/sanitizer/cfi/transparent-has-regions.rs b/tests/ui/sanitizer/cfi/transparent-has-regions.rs
new file mode 100644
index 0000000000000..b70e1ea179121
--- /dev/null
+++ b/tests/ui/sanitizer/cfi/transparent-has-regions.rs
@@ -0,0 +1,18 @@
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Ccodegen-units=1 -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi
+//@ no-prefer-dynamic
+//@ only-x86_64-unknown-linux-gnu
+//@ build-pass
+
+pub trait Trait {}
+
+impl Trait for i32 {}
+
+#[repr(transparent)]
+struct BoxedTrait(Box<dyn Trait + 'static>);
+
+fn hello(x: BoxedTrait) {}
+
+fn main() {
+    hello(BoxedTrait(Box::new(1)));
+}

From b3ec296f3d918efdbe4db02dbd7fbc7fea1641a1 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 16 Aug 2024 23:25:18 -0400
Subject: [PATCH 350/685] autoformat and remove unit test

---
 src/bootstrap/src/core/download.rs | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index ed7637e8ee097..2bde05501fcfc 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -26,18 +26,10 @@ fn extract_curl_version(out: &[u8]) -> f32 {
     let Some(i) = out.iter().position(|&x| x == b' ') else { return 0.0 };
     let out = &out[..i];
     let Some(k) = out.iter().rev().position(|&x| x == b'.') else { return 0.0 };
-    let out = &out[..out.len()-k-1];
+    let out = &out[..out.len() - k - 1];
     std::str::from_utf8(out).unwrap().parse().unwrap_or(0.0)
 }
 
-#[test]
-fn test_extract_curl_version() {
-    assert_eq!(extract_curl_version(b"\
-        curl 8.4.0 (x86_64-pc-linux-gnu) libcurl/8.4.0 \
-        OpenSSL/3.0.13 zlib/1.3 brotli/1.1.0 zstd/1.5.5 libidn2/2.3.4 \
-        libssh2/1.11.0 nghttp2/1.57.0"), 8.4);
-}
-
 fn curl_version() -> f32 {
     let mut curl = Command::new("curl");
     curl.arg("-V");

From f9a7d6ec6fefb417a59347aeb81e7b3eec09a3e7 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Sat, 17 Aug 2024 12:02:23 +0800
Subject: [PATCH 351/685] Move epoll_ready_events.epollhup = true up

---
 src/tools/miri/src/shims/unix/socket.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index cf3f65f69b21d..f7c168c58b975 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -71,12 +71,12 @@ impl FileDescription for SocketPair {
         } else {
             // Peer FD has been closed.
             epoll_ready_events.epollrdhup = true;
+            epoll_ready_events.epollhup = true;
             // Since the peer is closed, even if no data is available reads will return EOF and
             // writes will return EPIPE. In other words, they won't block, so we mark this as ready
             // for read and write.
             epoll_ready_events.epollin = true;
             epoll_ready_events.epollout = true;
-            epoll_ready_events.epollhup = true;
         }
         Ok(epoll_ready_events)
     }

From 23b57e8994892748039ec22279070b2434ea9687 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Sat, 17 Aug 2024 04:54:54 +0000
Subject: [PATCH 352/685] 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 d88a4ccc85bd2..c3f4f4b5d8220 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-e9c965df7b75ab5b1ae8f9a2680839ac1a1a3880
+f24a6ba06f4190d8ec4f22d1baa800e64b1900cb

From 3c8dad152bc1e3baca25e5b7b6b7ea6eccef060a Mon Sep 17 00:00:00 2001
From: Shina <53410646+s7tya@users.noreply.github.com>
Date: Sat, 17 Aug 2024 15:03:20 +0900
Subject: [PATCH 353/685] Emit an error for invalid use of the linkage
 attribute

---
 compiler/rustc_passes/messages.ftl      |  4 ++
 compiler/rustc_passes/src/check_attr.rs | 15 ++++++-
 compiler/rustc_passes/src/errors.rs     |  9 ++++
 tests/ui/attributes/linkage.rs          | 42 +++++++++++++++++++
 tests/ui/attributes/linkage.stderr      | 55 +++++++++++++++++++++++++
 5 files changed, 124 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/attributes/linkage.rs
 create mode 100644 tests/ui/attributes/linkage.stderr

diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 59c9d1e49f5b3..86ce552ad16d9 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -427,6 +427,10 @@ passes_link_section =
     .warn = {-passes_previously_accepted}
     .label = not a function or static
 
+passes_linkage =
+    attribute should be applied to a function or static
+    .label = not a function definition or static
+
 passes_macro_export =
     `#[macro_export]` only has an effect on macro definitions
 
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index c8d4c190113b2..e16509261404f 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -243,6 +243,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 [sym::coroutine, ..] => {
                     self.check_coroutine(attr, target);
                 }
+                [sym::linkage, ..] => self.check_linkage(attr, span, target),
                 [
                     // ok
                     sym::allow
@@ -256,7 +257,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | sym::cfi_encoding // FIXME(cfi_encoding)
                     | sym::may_dangle // FIXME(dropck_eyepatch)
                     | sym::pointee // FIXME(derive_smart_pointer)
-                    | sym::linkage // FIXME(linkage)
                     | sym::omit_gdb_pretty_printer_section // FIXME(omit_gdb_pretty_printer_section)
                     | sym::used // handled elsewhere to restrict to static items
                     | sym::repr // handled elsewhere to restrict to type decls items
@@ -2349,6 +2349,19 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
         }
     }
+
+    fn check_linkage(&self, attr: &Attribute, span: Span, target: Target) {
+        match target {
+            Target::Fn
+            | Target::Method(..)
+            | Target::Static
+            | Target::ForeignStatic
+            | Target::ForeignFn => {}
+            _ => {
+                self.dcx().emit_err(errors::Linkage { attr_span: attr.span, span });
+            }
+        }
+    }
 }
 
 impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 36dfc40e7628b..3a043e0e3c196 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -643,6 +643,15 @@ pub struct CoroutineOnNonClosure {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_linkage)]
+pub struct Linkage {
+    #[primary_span]
+    pub attr_span: Span,
+    #[label]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_empty_confusables)]
 pub(crate) struct EmptyConfusables {
diff --git a/tests/ui/attributes/linkage.rs b/tests/ui/attributes/linkage.rs
new file mode 100644
index 0000000000000..0d5ce699fa808
--- /dev/null
+++ b/tests/ui/attributes/linkage.rs
@@ -0,0 +1,42 @@
+#![feature(linkage)]
+#![feature(stmt_expr_attributes)]
+#![deny(unused_attributes)]
+#![allow(dead_code)]
+
+#[linkage = "weak"] //~ ERROR attribute should be applied to a function or static
+type InvalidTy = ();
+
+#[linkage = "weak"] //~ ERROR attribute should be applied to a function or static
+mod invalid_module {}
+
+#[linkage = "weak"] //~ ERROR attribute should be applied to a function or static
+struct F;
+
+#[linkage = "weak"] //~ ERROR attribute should be applied to a function or static
+impl F {
+    #[linkage = "weak"]
+    fn valid(&self) {}
+}
+
+#[linkage = "weak"]
+fn f() {
+    #[linkage = "weak"]
+    {
+        1
+    };
+    //~^^^^ ERROR attribute should be applied to a function or static
+}
+
+extern "C" {
+    #[linkage = "weak"]
+    static A: *const ();
+
+    #[linkage = "weak"]
+    fn bar();
+}
+
+fn main() {
+    let _ = #[linkage = "weak"]
+    (|| 1);
+    //~^^ ERROR attribute should be applied to a function or static
+}
diff --git a/tests/ui/attributes/linkage.stderr b/tests/ui/attributes/linkage.stderr
new file mode 100644
index 0000000000000..d5595529f400a
--- /dev/null
+++ b/tests/ui/attributes/linkage.stderr
@@ -0,0 +1,55 @@
+error: attribute should be applied to a function or static
+  --> $DIR/linkage.rs:6:1
+   |
+LL | #[linkage = "weak"]
+   | ^^^^^^^^^^^^^^^^^^^
+LL | type InvalidTy = ();
+   | -------------------- not a function definition or static
+
+error: attribute should be applied to a function or static
+  --> $DIR/linkage.rs:9:1
+   |
+LL | #[linkage = "weak"]
+   | ^^^^^^^^^^^^^^^^^^^
+LL | mod invalid_module {}
+   | --------------------- not a function definition or static
+
+error: attribute should be applied to a function or static
+  --> $DIR/linkage.rs:12:1
+   |
+LL | #[linkage = "weak"]
+   | ^^^^^^^^^^^^^^^^^^^
+LL | struct F;
+   | --------- not a function definition or static
+
+error: attribute should be applied to a function or static
+  --> $DIR/linkage.rs:15:1
+   |
+LL |   #[linkage = "weak"]
+   |   ^^^^^^^^^^^^^^^^^^^
+LL | / impl F {
+LL | |     #[linkage = "weak"]
+LL | |     fn valid(&self) {}
+LL | | }
+   | |_- not a function definition or static
+
+error: attribute should be applied to a function or static
+  --> $DIR/linkage.rs:23:5
+   |
+LL |       #[linkage = "weak"]
+   |       ^^^^^^^^^^^^^^^^^^^
+LL | /     {
+LL | |         1
+LL | |     };
+   | |_____- not a function definition or static
+
+error: attribute should be applied to a function or static
+  --> $DIR/linkage.rs:39:13
+   |
+LL |     let _ = #[linkage = "weak"]
+   |             ^^^^^^^^^^^^^^^^^^^
+LL |     (|| 1);
+   |     ------ not a function definition or static
+
+error: aborting due to 6 previous errors
+

From 3116db669c4e80ffdae5a34a8dd9bcfba4b1a9be Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 17 Aug 2024 17:56:00 +1000
Subject: [PATCH 354/685] Port `run-make/libtest-json/validate_json.py` to Rust

This is a trivial Python script that simply tries to parse each line of stdin
(i.e. the test process output) as JSON, to verify that the overall output is
JSON Lines.

We can perform the same check directly in `rmake.rs` using `serde_json`.
---
 tests/run-make/libtest-json/rmake.rs         | 15 +++++++++++++--
 tests/run-make/libtest-json/validate_json.py |  8 --------
 2 files changed, 13 insertions(+), 10 deletions(-)
 delete mode 100755 tests/run-make/libtest-json/validate_json.py

diff --git a/tests/run-make/libtest-json/rmake.rs b/tests/run-make/libtest-json/rmake.rs
index acbd88dc46cb9..c31f4a79b641f 100644
--- a/tests/run-make/libtest-json/rmake.rs
+++ b/tests/run-make/libtest-json/rmake.rs
@@ -3,7 +3,7 @@
 //@ ignore-cross-compile
 //@ needs-unwind (test file contains #[should_panic] test)
 
-use run_make_support::{cmd, diff, python_command, rustc};
+use run_make_support::{cmd, diff, rustc, serde_json};
 
 fn main() {
     rustc().arg("--test").input("f.rs").run();
@@ -21,7 +21,18 @@ fn run_tests(extra_args: &[&str], expected_file: &str) {
         .run_fail();
     let test_stdout = &cmd_out.stdout_utf8();
 
-    python_command().arg("validate_json.py").stdin(test_stdout).run();
+    // Verify that the test process output is JSON Lines, i.e. each line is valid JSON.
+    for (line, n) in test_stdout.lines().zip(1..) {
+        if let Err(e) = serde_json::from_str::<serde_json::Value>(line) {
+            panic!(
+                "could not parse JSON on line {n}: {e}\n\
+                \n\
+                === STDOUT ===\n\
+                {test_stdout}\
+                =============="
+            );
+        }
+    }
 
     diff()
         .expected_file(expected_file)
diff --git a/tests/run-make/libtest-json/validate_json.py b/tests/run-make/libtest-json/validate_json.py
deleted file mode 100755
index 657f732f2bffd..0000000000000
--- a/tests/run-make/libtest-json/validate_json.py
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-import json
-
-# Try to decode line in order to ensure it is a valid JSON document
-for line in sys.stdin:
-    json.loads(line)

From 53e1a2ee46cbcf84a61464bf62d9543be2c1ce8b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 16 Aug 2024 23:08:29 +0200
Subject: [PATCH 355/685] disable problematic float-conv tests in i586 targets

also fix typo in const-float-bits-conv
---
 tests/ui/consts/const-float-bits-conv.rs | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/tests/ui/consts/const-float-bits-conv.rs b/tests/ui/consts/const-float-bits-conv.rs
index 74df901394788..aad750c4c975b 100644
--- a/tests/ui/consts/const-float-bits-conv.rs
+++ b/tests/ui/consts/const-float-bits-conv.rs
@@ -23,6 +23,11 @@ macro_rules! const_assert {
     };
 }
 
+fn has_broken_floats() -> bool {
+    // i586 targets are broken due to <https://github.com/rust-lang/rust/issues/114479>.
+    std::env::var("TARGET").is_ok_and(|v| v.contains("i586"))
+}
+
 fn f32() {
     const_assert!((1f32).to_bits(), 0x3f800000);
     const_assert!(u32::from_be_bytes(1f32.to_be_bytes()), 0x3f800000);
@@ -41,14 +46,15 @@ fn f32() {
 
     // Check that NaNs roundtrip their bits regardless of signalingness
     // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
-    // ...actually, let's just check that these break. :D
     const MASKED_NAN1: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA;
     const MASKED_NAN2: u32 = f32::NAN.to_bits() ^ 0x0055_5555;
 
     const_assert!(f32::from_bits(MASKED_NAN1).is_nan());
-    const_assert!(f32::from_bits(MASKED_NAN1).is_nan());
+    const_assert!(f32::from_bits(MASKED_NAN2).is_nan());
     const_assert!(f32::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1);
-    const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
+    if !has_broken_floats() {
+        const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
+    }
 }
 
 fn f64() {
@@ -69,14 +75,15 @@ fn f64() {
 
     // Check that NaNs roundtrip their bits regardless of signalingness
     // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
-    // ...actually, let's just check that these break. :D
     const MASKED_NAN1: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA;
     const MASKED_NAN2: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555;
 
     const_assert!(f64::from_bits(MASKED_NAN1).is_nan());
-    const_assert!(f64::from_bits(MASKED_NAN1).is_nan());
+    const_assert!(f64::from_bits(MASKED_NAN2).is_nan());
     const_assert!(f64::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1);
-    const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
+    if !has_broken_floats() {
+        const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
+    }
 }
 
 fn main() {

From 5f33085a7f574b95609da59b2d4164238d7782f0 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 17 Aug 2024 10:25:58 +0200
Subject: [PATCH 356/685] more clear NAN names and fix broken_floats logic

Co-authored-by: Jubilee <46493976+workingjubilee@users.noreply.github.com>
---
 tests/ui/consts/const-float-bits-conv.rs | 26 +++++++++++++-----------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/tests/ui/consts/const-float-bits-conv.rs b/tests/ui/consts/const-float-bits-conv.rs
index aad750c4c975b..45e8ea570ed73 100644
--- a/tests/ui/consts/const-float-bits-conv.rs
+++ b/tests/ui/consts/const-float-bits-conv.rs
@@ -46,14 +46,15 @@ fn f32() {
 
     // Check that NaNs roundtrip their bits regardless of signalingness
     // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
-    const MASKED_NAN1: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA;
-    const MASKED_NAN2: u32 = f32::NAN.to_bits() ^ 0x0055_5555;
+    // NOTE: These names assume `f{BITS}::NAN` is a quiet NAN and IEEE754-2008's NaN rules apply!
+    const QUIET_NAN: u32 = f32::NAN.to_bits() ^ 0x002A_AAAA;
+    const SIGNALING_NAN: u32 = f32::NAN.to_bits() ^ 0x0055_5555;
 
-    const_assert!(f32::from_bits(MASKED_NAN1).is_nan());
-    const_assert!(f32::from_bits(MASKED_NAN2).is_nan());
-    const_assert!(f32::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1);
+    const_assert!(f32::from_bits(QUIET_NAN).is_nan());
+    const_assert!(f32::from_bits(SIGNALING_NAN).is_nan());
+    const_assert!(f32::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
     if !has_broken_floats() {
-        const_assert!(f32::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
+        const_assert!(f32::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
     }
 }
 
@@ -75,14 +76,15 @@ fn f64() {
 
     // Check that NaNs roundtrip their bits regardless of signalingness
     // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
-    const MASKED_NAN1: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA;
-    const MASKED_NAN2: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555;
+    // NOTE: These names assume `f{BITS}::NAN` is a quiet NAN and IEEE754-2008's NaN rules apply!
+    const QUIET_NAN: u64 = f64::NAN.to_bits() ^ 0x0005_5555_5555_5555;
+    const SIGNALING_NAN: u64 = f64::NAN.to_bits() ^ 0x000A_AAAA_AAAA_AAAA;
 
-    const_assert!(f64::from_bits(MASKED_NAN1).is_nan());
-    const_assert!(f64::from_bits(MASKED_NAN2).is_nan());
-    const_assert!(f64::from_bits(MASKED_NAN1).to_bits(), MASKED_NAN1);
+    const_assert!(f64::from_bits(QUIET_NAN).is_nan());
+    const_assert!(f64::from_bits(SIGNALING_NAN).is_nan());
+    const_assert!(f64::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
     if !has_broken_floats() {
-        const_assert!(f64::from_bits(MASKED_NAN2).to_bits(), MASKED_NAN2);
+        const_assert!(f64::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
     }
 }
 

From cab81d3fa96268472a121d8920fc59a9caa483df Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 17 Aug 2024 10:36:46 +0200
Subject: [PATCH 357/685] extend comments on HUP vs RDHUP

---
 src/tools/miri/src/shims/unix/linux/epoll.rs | 3 +++
 src/tools/miri/src/shims/unix/socket.rs      | 3 ++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index a47d9fe0826dd..53f27868aeb95 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -71,6 +71,9 @@ pub struct EpollReadyEvents {
     pub epollrdhup: bool,
     /// For stream socket, this event merely indicates that the peer
     /// closed its end of the channel.
+    /// Unlike epollrdhup, this should only be set when the stream is fully closed.
+    /// epollrdhup also gets set when only the write half is closed, which is possible
+    /// via `shutdown(_, SHUT_WR)`.
     pub epollhup: bool,
 }
 
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/socket.rs
index f7c168c58b975..3f2adb6e79c47 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/socket.rs
@@ -69,7 +69,8 @@ impl FileDescription for SocketPair {
                 epoll_ready_events.epollout = true;
             }
         } else {
-            // Peer FD has been closed.
+            // Peer FD has been closed. This always sets both the RDHUP and HUP flags
+            // as we do not support `shutdown` that could be used to partially close the stream.
             epoll_ready_events.epollrdhup = true;
             epoll_ready_events.epollhup = true;
             // Since the peer is closed, even if no data is available reads will return EOF and

From 99d742e9b0b7191543567faa67a04c65a4d1bcaf Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Fri, 16 Aug 2024 22:34:50 +0200
Subject: [PATCH 358/685] implement pipe and pipe2

---
 .../miri/src/shims/unix/foreign_items.rs      |  15 ++-
 src/tools/miri/src/shims/unix/linux/epoll.rs  |   5 +-
 src/tools/miri/src/shims/unix/mod.rs          |   4 +-
 .../unix/{socket.rs => unnamed_socket.rs}     | 104 +++++++++++++----
 .../miri/tests/pass-dep/libc/libc-pipe.rs     | 106 ++++++++++++++++++
 .../tests/pass-dep/libc/libc-socketpair.rs    |  20 +++-
 6 files changed, 223 insertions(+), 31 deletions(-)
 rename src/tools/miri/src/shims/unix/{socket.rs => unnamed_socket.rs} (74%)
 create mode 100644 src/tools/miri/tests/pass-dep/libc/libc-pipe.rs

diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 6c35281ecf2fb..273a99b31164b 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -288,14 +288,25 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(result, dest)?;
             }
 
-            // Sockets
+            // Unnamed sockets and pipes
             "socketpair" => {
                 let [domain, type_, protocol, sv] =
                     this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
-
                 let result = this.socketpair(domain, type_, protocol, sv)?;
                 this.write_scalar(result, dest)?;
             }
+            "pipe" => {
+                let [pipefd] =
+                    this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
+                let result = this.pipe2(pipefd, /*flags*/ None)?;
+                this.write_scalar(result, dest)?;
+            }
+            "pipe2" => {
+                let [pipefd, flags] =
+                    this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
+                let result = this.pipe2(pipefd, Some(flags))?;
+                this.write_scalar(result, dest)?;
+            }
 
             // Time
             "gettimeofday" => {
diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index 53f27868aeb95..127817d5bbe3b 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -62,9 +62,10 @@ pub struct EpollEventInterest {
 
 /// EpollReadyEvents reflects the readiness of a file description.
 pub struct EpollReadyEvents {
-    /// The associated file is available for read(2) operations.
+    /// The associated file is available for read(2) operations, in the sense that a read will not block.
+    /// (I.e., returning EOF is considered "ready".)
     pub epollin: bool,
-    /// The associated file is available for write(2) operations.
+    /// The associated file is available for write(2) operations, in the sense that a write will not block.
     pub epollout: bool,
     /// Stream socket peer closed connection, or shut down writing
     /// half of connection.
diff --git a/src/tools/miri/src/shims/unix/mod.rs b/src/tools/miri/src/shims/unix/mod.rs
index 8cfa659d90a34..7da6d7b02a2a0 100644
--- a/src/tools/miri/src/shims/unix/mod.rs
+++ b/src/tools/miri/src/shims/unix/mod.rs
@@ -4,9 +4,9 @@ mod env;
 mod fd;
 mod fs;
 mod mem;
-mod socket;
 mod sync;
 mod thread;
+mod unnamed_socket;
 
 mod android;
 mod freebsd;
@@ -23,9 +23,9 @@ pub use env::EvalContextExt as _;
 pub use fd::EvalContextExt as _;
 pub use fs::EvalContextExt as _;
 pub use mem::EvalContextExt as _;
-pub use socket::EvalContextExt as _;
 pub use sync::EvalContextExt as _;
 pub use thread::EvalContextExt as _;
+pub use unnamed_socket::EvalContextExt as _;
 
 // Make up some constants.
 const UID: u32 = 1000;
diff --git a/src/tools/miri/src/shims/unix/socket.rs b/src/tools/miri/src/shims/unix/unnamed_socket.rs
similarity index 74%
rename from src/tools/miri/src/shims/unix/socket.rs
rename to src/tools/miri/src/shims/unix/unnamed_socket.rs
index 3f2adb6e79c47..f8553e67992e3 100644
--- a/src/tools/miri/src/shims/unix/socket.rs
+++ b/src/tools/miri/src/shims/unix/unnamed_socket.rs
@@ -1,3 +1,7 @@
+//! This implements "anonymous" sockets, that do not correspond to anything on the host system and
+//! are entirely implemented inside Miri.
+//! We also use the same infrastructure to implement unnamed pipes.
+
 use std::cell::{OnceCell, RefCell};
 use std::collections::VecDeque;
 use std::io;
@@ -16,8 +20,9 @@ const MAX_SOCKETPAIR_BUFFER_CAPACITY: usize = 212992;
 /// Pair of connected sockets.
 #[derive(Debug)]
 struct SocketPair {
-    /// The buffer we are reading from.
-    readbuf: RefCell<Buffer>,
+    /// The buffer we are reading from, or `None` if this is the writing end of a pipe.
+    /// (In that case, the peer FD will be the reading end of that pipe.)
+    readbuf: Option<RefCell<Buffer>>,
     /// The `SocketPair` file descriptor that is our "peer", and that holds the buffer we are
     /// writing to. This is a weak reference because the other side may be closed before us; all
     /// future writes will then trigger EPIPE.
@@ -55,17 +60,25 @@ impl FileDescription for SocketPair {
         let mut epoll_ready_events = EpollReadyEvents::new();
 
         // Check if it is readable.
-        let readbuf = self.readbuf.borrow();
-        if !readbuf.buf.is_empty() {
+        if let Some(readbuf) = &self.readbuf {
+            if !readbuf.borrow().buf.is_empty() {
+                epoll_ready_events.epollin = true;
+            }
+        } else {
+            // Without a read buffer, reading never blocks, so we are always ready.
             epoll_ready_events.epollin = true;
         }
 
         // Check if is writable.
         if let Some(peer_fd) = self.peer_fd().upgrade() {
-            let writebuf = &peer_fd.downcast::<SocketPair>().unwrap().readbuf.borrow();
-            let data_size = writebuf.buf.len();
-            let available_space = MAX_SOCKETPAIR_BUFFER_CAPACITY.strict_sub(data_size);
-            if available_space != 0 {
+            if let Some(writebuf) = &peer_fd.downcast::<SocketPair>().unwrap().readbuf {
+                let data_size = writebuf.borrow().buf.len();
+                let available_space = MAX_SOCKETPAIR_BUFFER_CAPACITY.strict_sub(data_size);
+                if available_space != 0 {
+                    epoll_ready_events.epollout = true;
+                }
+            } else {
+                // Without a write buffer, writing never blocks.
                 epoll_ready_events.epollout = true;
             }
         } else {
@@ -108,7 +121,12 @@ impl FileDescription for SocketPair {
             return Ok(Ok(0));
         }
 
-        let mut readbuf = self.readbuf.borrow_mut();
+        let Some(readbuf) = &self.readbuf else {
+            // FIXME: This should return EBADF, but there's no nice way to do that as there's no
+            // corresponding ErrorKind variant.
+            throw_unsup_format!("reading from the write end of a pipe");
+        };
+        let mut readbuf = readbuf.borrow_mut();
         if readbuf.buf.is_empty() {
             if self.peer_fd().upgrade().is_none() {
                 // Socketpair with no peer and empty buffer.
@@ -176,7 +194,13 @@ impl FileDescription for SocketPair {
             // closed.
             return Ok(Err(Error::from(ErrorKind::BrokenPipe)));
         };
-        let mut writebuf = peer_fd.downcast::<SocketPair>().unwrap().readbuf.borrow_mut();
+
+        let Some(writebuf) = &peer_fd.downcast::<SocketPair>().unwrap().readbuf else {
+            // FIXME: This should return EBADF, but there's no nice way to do that as there's no
+            // corresponding ErrorKind variant.
+            throw_unsup_format!("writing to the reading end of a pipe");
+        };
+        let mut writebuf = writebuf.borrow_mut();
         let data_size = writebuf.buf.len();
         let available_space = MAX_SOCKETPAIR_BUFFER_CAPACITY.strict_sub(data_size);
         if available_space == 0 {
@@ -227,12 +251,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let mut is_sock_nonblock = false;
 
-        // Parse and remove the type flags that we support. If type != 0 after removing,
-        // unsupported flags are used.
-        if type_ & this.eval_libc_i32("SOCK_STREAM") == this.eval_libc_i32("SOCK_STREAM") {
-            type_ &= !(this.eval_libc_i32("SOCK_STREAM"));
-        }
-
+        // Parse and remove the type flags that we support.
         // SOCK_NONBLOCK only exists on Linux.
         if this.tcx.sess.target.os == "linux" {
             if type_ & this.eval_libc_i32("SOCK_NONBLOCK") == this.eval_libc_i32("SOCK_NONBLOCK") {
@@ -253,7 +272,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                                  and AF_LOCAL are allowed",
                 domain
             );
-        } else if type_ != 0 {
+        } else if type_ != this.eval_libc_i32("SOCK_STREAM") {
             throw_unsup_format!(
                 "socketpair: type {:#x} is unsupported, only SOCK_STREAM, \
                                  SOCK_CLOEXEC and SOCK_NONBLOCK are allowed",
@@ -269,12 +288,12 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // Generate file descriptions.
         let fds = &mut this.machine.fds;
         let fd0 = fds.new_ref(SocketPair {
-            readbuf: RefCell::new(Buffer::new()),
+            readbuf: Some(RefCell::new(Buffer::new())),
             peer_fd: OnceCell::new(),
             is_nonblock: is_sock_nonblock,
         });
         let fd1 = fds.new_ref(SocketPair {
-            readbuf: RefCell::new(Buffer::new()),
+            readbuf: Some(RefCell::new(Buffer::new())),
             peer_fd: OnceCell::new(),
             is_nonblock: is_sock_nonblock,
         });
@@ -295,4 +314,51 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         Ok(Scalar::from_i32(0))
     }
+
+    fn pipe2(
+        &mut self,
+        pipefd: &OpTy<'tcx>,
+        flags: Option<&OpTy<'tcx>>,
+    ) -> InterpResult<'tcx, Scalar> {
+        let this = self.eval_context_mut();
+
+        let pipefd = this.deref_pointer(pipefd)?;
+        let flags = match flags {
+            Some(flags) => this.read_scalar(flags)?.to_i32()?,
+            None => 0,
+        };
+
+        // As usual we ignore CLOEXEC.
+        let cloexec = this.eval_libc_i32("O_CLOEXEC");
+        if flags != 0 && flags != cloexec {
+            throw_unsup_format!("unsupported flags in `pipe2`");
+        }
+
+        // Generate file descriptions.
+        // pipefd[0] refers to the read end of the pipe.
+        let fds = &mut this.machine.fds;
+        let fd0 = fds.new_ref(SocketPair {
+            readbuf: Some(RefCell::new(Buffer::new())),
+            peer_fd: OnceCell::new(),
+            is_nonblock: false,
+        });
+        let fd1 =
+            fds.new_ref(SocketPair { readbuf: None, peer_fd: OnceCell::new(), is_nonblock: false });
+
+        // Make the file descriptions point to each other.
+        fd0.downcast::<SocketPair>().unwrap().peer_fd.set(fd1.downgrade()).unwrap();
+        fd1.downcast::<SocketPair>().unwrap().peer_fd.set(fd0.downgrade()).unwrap();
+
+        // Insert the file description to the fd table, generating the file descriptors.
+        let pipefd0 = fds.insert(fd0);
+        let pipefd1 = fds.insert(fd1);
+
+        // Return file descriptors to the caller.
+        let pipefd0 = Scalar::from_int(pipefd0, pipefd.layout.size);
+        let pipefd1 = Scalar::from_int(pipefd1, pipefd.layout.size);
+        this.write_scalar(pipefd0, &pipefd)?;
+        this.write_scalar(pipefd1, &pipefd.offset(pipefd.layout.size, pipefd.layout, this)?)?;
+
+        Ok(Scalar::from_i32(0))
+    }
 }
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs b/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs
new file mode 100644
index 0000000000000..a57cad124b61d
--- /dev/null
+++ b/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs
@@ -0,0 +1,106 @@
+//@ignore-target-windows: No libc pipe on Windows
+// test_race depends on a deterministic schedule.
+//@compile-flags: -Zmiri-preemption-rate=0
+use std::thread;
+fn main() {
+    test_pipe();
+    test_pipe_threaded();
+    test_race();
+}
+
+fn test_pipe() {
+    let mut fds = [-1, -1];
+    let mut res = unsafe { libc::pipe(fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Read size == data available in buffer.
+    let data = "12345".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
+    let mut buf3: [u8; 5] = [0; 5];
+    res = unsafe {
+        libc::read(fds[0], buf3.as_mut_ptr().cast(), buf3.len() as libc::size_t).try_into().unwrap()
+    };
+    assert_eq!(res, 5);
+    assert_eq!(buf3, "12345".as_bytes());
+
+    // Read size > data available in buffer.
+    let data = "123".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 3).try_into().unwrap() };
+    assert_eq!(res, 3);
+    let mut buf4: [u8; 5] = [0; 5];
+    res = unsafe {
+        libc::read(fds[0], buf4.as_mut_ptr().cast(), buf4.len() as libc::size_t).try_into().unwrap()
+    };
+    assert_eq!(res, 3);
+    assert_eq!(&buf4[0..3], "123".as_bytes());
+}
+
+fn test_pipe_threaded() {
+    let mut fds = [-1, -1];
+    let mut res = unsafe { libc::pipe(fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    let thread1 = thread::spawn(move || {
+        let mut buf: [u8; 5] = [0; 5];
+        let res: i64 = unsafe {
+            libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t)
+                .try_into()
+                .unwrap()
+        };
+        assert_eq!(res, 5);
+        assert_eq!(buf, "abcde".as_bytes());
+    });
+    // FIXME: we should yield here once blocking is implemented.
+    //thread::yield_now();
+    let data = "abcde".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
+    thread1.join().unwrap();
+
+    // Read and write from different direction
+    let thread2 = thread::spawn(move || {
+        // FIXME: we should yield here once blocking is implemented.
+        //thread::yield_now();
+        let data = "12345".as_bytes().as_ptr();
+        let res: i64 =
+            unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+        assert_eq!(res, 5);
+    });
+    // FIXME: we should not yield here once blocking is implemented.
+    thread::yield_now();
+    let mut buf: [u8; 5] = [0; 5];
+    res = unsafe {
+        libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+    };
+    assert_eq!(res, 5);
+    assert_eq!(buf, "12345".as_bytes());
+    thread2.join().unwrap();
+}
+
+fn test_race() {
+    static mut VAL: u8 = 0;
+    let mut fds = [-1, -1];
+    let mut res = unsafe { libc::pipe(fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+    let thread1 = thread::spawn(move || {
+        let mut buf: [u8; 1] = [0; 1];
+        // write() from the main thread will occur before the read() here
+        // because preemption is disabled and the main thread yields after write().
+        let res: i32 = unsafe {
+            libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t)
+                .try_into()
+                .unwrap()
+        };
+        assert_eq!(res, 1);
+        assert_eq!(buf, "a".as_bytes());
+        // The read above establishes a happens-before so it is now safe to access this global variable.
+        unsafe { assert_eq!(VAL, 1) };
+    });
+    unsafe { VAL = 1 };
+    let data = "a".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 1).try_into().unwrap() };
+    assert_eq!(res, 1);
+    thread::yield_now();
+    thread1.join().unwrap();
+}
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs b/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
index 324c0127ee976..254be89d48273 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
@@ -66,9 +66,6 @@ fn test_socketpair_threaded() {
         unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
     assert_eq!(res, 0);
 
-    let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
-    assert_eq!(res, 5);
     let thread1 = thread::spawn(move || {
         let mut buf: [u8; 5] = [0; 5];
         let res: i64 = unsafe {
@@ -79,23 +76,33 @@ fn test_socketpair_threaded() {
         assert_eq!(res, 5);
         assert_eq!(buf, "abcde".as_bytes());
     });
+    // FIXME: we should yield here once blocking is implemented.
+    //thread::yield_now();
+    let data = "abcde".as_bytes().as_ptr();
+    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
     thread1.join().unwrap();
 
     // Read and write from different direction
     let thread2 = thread::spawn(move || {
+        // FIXME: we should yield here once blocking is implemented.
+        //thread::yield_now();
         let data = "12345".as_bytes().as_ptr();
         let res: i64 =
-            unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+            unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
         assert_eq!(res, 5);
     });
-    thread2.join().unwrap();
+    // FIXME: we should not yield here once blocking is implemented.
+    thread::yield_now();
     let mut buf: [u8; 5] = [0; 5];
     res = unsafe {
-        libc::read(fds[1], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+        libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
     };
     assert_eq!(res, 5);
     assert_eq!(buf, "12345".as_bytes());
+    thread2.join().unwrap();
 }
+
 fn test_race() {
     static mut VAL: u8 = 0;
     let mut fds = [-1, -1];
@@ -113,6 +120,7 @@ fn test_race() {
         };
         assert_eq!(res, 1);
         assert_eq!(buf, "a".as_bytes());
+        // The read above establishes a happens-before so it is now safe to access this global variable.
         unsafe { assert_eq!(VAL, 1) };
     });
     unsafe { VAL = 1 };

From 5402be8f99ac9960ef0cf1cf83aef0857e180506 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 17 Aug 2024 10:51:05 +0200
Subject: [PATCH 359/685] socketpair: test behavior when one end got closed

---
 .../tests/pass-dep/libc/libc-socketpair.rs    | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs b/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
index 254be89d48273..873c39a208eec 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
@@ -58,6 +58,26 @@ fn test_socketpair() {
     };
     assert_eq!(res, 3);
     assert_eq!(&buf4[0..3], "123".as_bytes());
+
+    // Test when happens when we close one end, with some data in the buffer.
+    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 3).try_into().unwrap() };
+    assert_eq!(res, 3);
+    unsafe { libc::close(fds[0]) };
+    // Reading the other end should return that data, then EOF.
+    let mut buf: [u8; 5] = [0; 5];
+    res = unsafe {
+        libc::read(fds[1], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+    };
+    assert_eq!(res, 3);
+    assert_eq!(&buf[0..3], "123".as_bytes());
+    res = unsafe {
+        libc::read(fds[1], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
+    };
+    assert_eq!(res, 0); // 0-sized read: EOF.
+    // Writing the other end should emit EPIPE.
+    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 1).try_into().unwrap() };
+    assert_eq!(res, -1);
+    assert_eq!(std::io::Error::last_os_error().raw_os_error(), Some(libc::EPIPE));
 }
 
 fn test_socketpair_threaded() {

From 5d59bdefb44181c596917da27cfc6b8ff3b67505 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 17 Aug 2024 10:53:33 +0200
Subject: [PATCH 360/685] test cleanup

---
 .../miri/tests/pass-dep/libc/libc-pipe.rs     | 29 ++++------
 .../tests/pass-dep/libc/libc-socketpair.rs    | 56 +++++++------------
 2 files changed, 30 insertions(+), 55 deletions(-)

diff --git a/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs b/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs
index a57cad124b61d..5dff612bd8930 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-pipe.rs
@@ -10,35 +10,31 @@ fn main() {
 
 fn test_pipe() {
     let mut fds = [-1, -1];
-    let mut res = unsafe { libc::pipe(fds.as_mut_ptr()) };
+    let res = unsafe { libc::pipe(fds.as_mut_ptr()) };
     assert_eq!(res, 0);
 
     // Read size == data available in buffer.
     let data = "12345".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
     let mut buf3: [u8; 5] = [0; 5];
-    res = unsafe {
-        libc::read(fds[0], buf3.as_mut_ptr().cast(), buf3.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[0], buf3.as_mut_ptr().cast(), buf3.len() as libc::size_t) };
     assert_eq!(res, 5);
     assert_eq!(buf3, "12345".as_bytes());
 
     // Read size > data available in buffer.
     let data = "123".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 3).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 3) };
     assert_eq!(res, 3);
     let mut buf4: [u8; 5] = [0; 5];
-    res = unsafe {
-        libc::read(fds[0], buf4.as_mut_ptr().cast(), buf4.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[0], buf4.as_mut_ptr().cast(), buf4.len() as libc::size_t) };
     assert_eq!(res, 3);
     assert_eq!(&buf4[0..3], "123".as_bytes());
 }
 
 fn test_pipe_threaded() {
     let mut fds = [-1, -1];
-    let mut res = unsafe { libc::pipe(fds.as_mut_ptr()) };
+    let res = unsafe { libc::pipe(fds.as_mut_ptr()) };
     assert_eq!(res, 0);
 
     let thread1 = thread::spawn(move || {
@@ -54,7 +50,7 @@ fn test_pipe_threaded() {
     // FIXME: we should yield here once blocking is implemented.
     //thread::yield_now();
     let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
     thread1.join().unwrap();
 
@@ -63,16 +59,13 @@ fn test_pipe_threaded() {
         // FIXME: we should yield here once blocking is implemented.
         //thread::yield_now();
         let data = "12345".as_bytes().as_ptr();
-        let res: i64 =
-            unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+        let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5) };
         assert_eq!(res, 5);
     });
     // FIXME: we should not yield here once blocking is implemented.
     thread::yield_now();
     let mut buf: [u8; 5] = [0; 5];
-    res = unsafe {
-        libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
     assert_eq!(res, 5);
     assert_eq!(buf, "12345".as_bytes());
     thread2.join().unwrap();
@@ -81,7 +74,7 @@ fn test_pipe_threaded() {
 fn test_race() {
     static mut VAL: u8 = 0;
     let mut fds = [-1, -1];
-    let mut res = unsafe { libc::pipe(fds.as_mut_ptr()) };
+    let res = unsafe { libc::pipe(fds.as_mut_ptr()) };
     assert_eq!(res, 0);
     let thread1 = thread::spawn(move || {
         let mut buf: [u8; 1] = [0; 1];
@@ -99,7 +92,7 @@ fn test_race() {
     });
     unsafe { VAL = 1 };
     let data = "a".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 1).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 1) };
     assert_eq!(res, 1);
     thread::yield_now();
     thread1.join().unwrap();
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs b/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
index 873c39a208eec..15e040116debc 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
@@ -10,80 +10,66 @@ fn main() {
 
 fn test_socketpair() {
     let mut fds = [-1, -1];
-    let mut res =
-        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
     assert_eq!(res, 0);
 
     // Read size == data available in buffer.
     let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
     let mut buf: [u8; 5] = [0; 5];
-    res = unsafe {
-        libc::read(fds[1], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[1], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
     assert_eq!(res, 5);
     assert_eq!(buf, "abcde".as_bytes());
 
     // Read size > data available in buffer.
     let data = "abc".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 3).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 3) };
     assert_eq!(res, 3);
     let mut buf2: [u8; 5] = [0; 5];
-    res = unsafe {
-        libc::read(fds[1], buf2.as_mut_ptr().cast(), buf2.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[1], buf2.as_mut_ptr().cast(), buf2.len() as libc::size_t) };
     assert_eq!(res, 3);
     assert_eq!(&buf2[0..3], "abc".as_bytes());
 
     // Test read and write from another direction.
     // Read size == data available in buffer.
     let data = "12345".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
     let mut buf3: [u8; 5] = [0; 5];
-    res = unsafe {
-        libc::read(fds[0], buf3.as_mut_ptr().cast(), buf3.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[0], buf3.as_mut_ptr().cast(), buf3.len() as libc::size_t) };
     assert_eq!(res, 5);
     assert_eq!(buf3, "12345".as_bytes());
 
     // Read size > data available in buffer.
     let data = "123".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 3).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 3) };
     assert_eq!(res, 3);
     let mut buf4: [u8; 5] = [0; 5];
-    res = unsafe {
-        libc::read(fds[0], buf4.as_mut_ptr().cast(), buf4.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[0], buf4.as_mut_ptr().cast(), buf4.len() as libc::size_t) };
     assert_eq!(res, 3);
     assert_eq!(&buf4[0..3], "123".as_bytes());
 
     // Test when happens when we close one end, with some data in the buffer.
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 3).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 3) };
     assert_eq!(res, 3);
     unsafe { libc::close(fds[0]) };
     // Reading the other end should return that data, then EOF.
     let mut buf: [u8; 5] = [0; 5];
-    res = unsafe {
-        libc::read(fds[1], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[1], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
     assert_eq!(res, 3);
     assert_eq!(&buf[0..3], "123".as_bytes());
-    res = unsafe {
-        libc::read(fds[1], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[1], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
     assert_eq!(res, 0); // 0-sized read: EOF.
     // Writing the other end should emit EPIPE.
-    res = unsafe { libc::write(fds[1], data as *const libc::c_void, 1).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 1) };
     assert_eq!(res, -1);
     assert_eq!(std::io::Error::last_os_error().raw_os_error(), Some(libc::EPIPE));
 }
 
 fn test_socketpair_threaded() {
     let mut fds = [-1, -1];
-    let mut res =
-        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
     assert_eq!(res, 0);
 
     let thread1 = thread::spawn(move || {
@@ -99,7 +85,7 @@ fn test_socketpair_threaded() {
     // FIXME: we should yield here once blocking is implemented.
     //thread::yield_now();
     let data = "abcde".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
     thread1.join().unwrap();
 
@@ -108,16 +94,13 @@ fn test_socketpair_threaded() {
         // FIXME: we should yield here once blocking is implemented.
         //thread::yield_now();
         let data = "12345".as_bytes().as_ptr();
-        let res: i64 =
-            unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+        let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5) };
         assert_eq!(res, 5);
     });
     // FIXME: we should not yield here once blocking is implemented.
     thread::yield_now();
     let mut buf: [u8; 5] = [0; 5];
-    res = unsafe {
-        libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t).try_into().unwrap()
-    };
+    let res = unsafe { libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
     assert_eq!(res, 5);
     assert_eq!(buf, "12345".as_bytes());
     thread2.join().unwrap();
@@ -126,8 +109,7 @@ fn test_socketpair_threaded() {
 fn test_race() {
     static mut VAL: u8 = 0;
     let mut fds = [-1, -1];
-    let mut res =
-        unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
     assert_eq!(res, 0);
     let thread1 = thread::spawn(move || {
         let mut buf: [u8; 1] = [0; 1];
@@ -145,7 +127,7 @@ fn test_race() {
     });
     unsafe { VAL = 1 };
     let data = "a".as_bytes().as_ptr();
-    res = unsafe { libc::write(fds[0], data as *const libc::c_void, 1).try_into().unwrap() };
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 1) };
     assert_eq!(res, 1);
     thread::yield_now();
     thread1.join().unwrap();

From 02a11668a3604867a131a32e7bf24239c35f87f4 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 17 Aug 2024 11:31:56 +0200
Subject: [PATCH 361/685] SocketPair -> AnonSocket, because a single FD is not
 a pair

---
 .../miri/src/shims/unix/unnamed_socket.rs     | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/unnamed_socket.rs b/src/tools/miri/src/shims/unix/unnamed_socket.rs
index f8553e67992e3..5f4640a2d840c 100644
--- a/src/tools/miri/src/shims/unix/unnamed_socket.rs
+++ b/src/tools/miri/src/shims/unix/unnamed_socket.rs
@@ -17,13 +17,13 @@ use crate::{concurrency::VClock, *};
 /// be configured in the real system.
 const MAX_SOCKETPAIR_BUFFER_CAPACITY: usize = 212992;
 
-/// Pair of connected sockets.
+/// One end of a pair of connected unnamed sockets.
 #[derive(Debug)]
-struct SocketPair {
+struct AnonSocket {
     /// The buffer we are reading from, or `None` if this is the writing end of a pipe.
     /// (In that case, the peer FD will be the reading end of that pipe.)
     readbuf: Option<RefCell<Buffer>>,
-    /// The `SocketPair` file descriptor that is our "peer", and that holds the buffer we are
+    /// The `AnonSocket` file descriptor that is our "peer", and that holds the buffer we are
     /// writing to. This is a weak reference because the other side may be closed before us; all
     /// future writes will then trigger EPIPE.
     peer_fd: OnceCell<WeakFileDescriptionRef>,
@@ -42,13 +42,13 @@ impl Buffer {
     }
 }
 
-impl SocketPair {
+impl AnonSocket {
     fn peer_fd(&self) -> &WeakFileDescriptionRef {
         self.peer_fd.get().unwrap()
     }
 }
 
-impl FileDescription for SocketPair {
+impl FileDescription for AnonSocket {
     fn name(&self) -> &'static str {
         "socketpair"
     }
@@ -71,7 +71,7 @@ impl FileDescription for SocketPair {
 
         // Check if is writable.
         if let Some(peer_fd) = self.peer_fd().upgrade() {
-            if let Some(writebuf) = &peer_fd.downcast::<SocketPair>().unwrap().readbuf {
+            if let Some(writebuf) = &peer_fd.downcast::<AnonSocket>().unwrap().readbuf {
                 let data_size = writebuf.borrow().buf.len();
                 let available_space = MAX_SOCKETPAIR_BUFFER_CAPACITY.strict_sub(data_size);
                 if available_space != 0 {
@@ -195,7 +195,7 @@ impl FileDescription for SocketPair {
             return Ok(Err(Error::from(ErrorKind::BrokenPipe)));
         };
 
-        let Some(writebuf) = &peer_fd.downcast::<SocketPair>().unwrap().readbuf else {
+        let Some(writebuf) = &peer_fd.downcast::<AnonSocket>().unwrap().readbuf else {
             // FIXME: This should return EBADF, but there's no nice way to do that as there's no
             // corresponding ErrorKind variant.
             throw_unsup_format!("writing to the reading end of a pipe");
@@ -287,20 +287,20 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // Generate file descriptions.
         let fds = &mut this.machine.fds;
-        let fd0 = fds.new_ref(SocketPair {
+        let fd0 = fds.new_ref(AnonSocket {
             readbuf: Some(RefCell::new(Buffer::new())),
             peer_fd: OnceCell::new(),
             is_nonblock: is_sock_nonblock,
         });
-        let fd1 = fds.new_ref(SocketPair {
+        let fd1 = fds.new_ref(AnonSocket {
             readbuf: Some(RefCell::new(Buffer::new())),
             peer_fd: OnceCell::new(),
             is_nonblock: is_sock_nonblock,
         });
 
         // Make the file descriptions point to each other.
-        fd0.downcast::<SocketPair>().unwrap().peer_fd.set(fd1.downgrade()).unwrap();
-        fd1.downcast::<SocketPair>().unwrap().peer_fd.set(fd0.downgrade()).unwrap();
+        fd0.downcast::<AnonSocket>().unwrap().peer_fd.set(fd1.downgrade()).unwrap();
+        fd1.downcast::<AnonSocket>().unwrap().peer_fd.set(fd0.downgrade()).unwrap();
 
         // Insert the file description to the fd table, generating the file descriptors.
         let sv0 = fds.insert(fd0);
@@ -337,17 +337,17 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // Generate file descriptions.
         // pipefd[0] refers to the read end of the pipe.
         let fds = &mut this.machine.fds;
-        let fd0 = fds.new_ref(SocketPair {
+        let fd0 = fds.new_ref(AnonSocket {
             readbuf: Some(RefCell::new(Buffer::new())),
             peer_fd: OnceCell::new(),
             is_nonblock: false,
         });
         let fd1 =
-            fds.new_ref(SocketPair { readbuf: None, peer_fd: OnceCell::new(), is_nonblock: false });
+            fds.new_ref(AnonSocket { readbuf: None, peer_fd: OnceCell::new(), is_nonblock: false });
 
         // Make the file descriptions point to each other.
-        fd0.downcast::<SocketPair>().unwrap().peer_fd.set(fd1.downgrade()).unwrap();
-        fd1.downcast::<SocketPair>().unwrap().peer_fd.set(fd0.downgrade()).unwrap();
+        fd0.downcast::<AnonSocket>().unwrap().peer_fd.set(fd1.downgrade()).unwrap();
+        fd1.downcast::<AnonSocket>().unwrap().peer_fd.set(fd0.downgrade()).unwrap();
 
         // Insert the file description to the fd table, generating the file descriptors.
         let pipefd0 = fds.insert(fd0);

From 465df5656f4910f7183449682070d6bd23a570d8 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 17 Aug 2024 10:41:59 +0200
Subject: [PATCH 362/685] epoll test: further clean up check_epoll_wait

---
 .../miri/tests/pass-dep/libc/libc-epoll.rs    | 78 +++++++++----------
 1 file changed, 37 insertions(+), 41 deletions(-)

diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index 8d7d559c6aa31..8326353451fa5 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -24,7 +24,7 @@ fn main() {
 const EPOLL_IN_OUT_ET: u32 = (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET) as _;
 
 #[track_caller]
-fn check_epoll_wait<const N: usize>(epfd: i32, expected_notifications: &[(u32, u64)]) -> bool {
+fn check_epoll_wait<const N: usize>(epfd: i32, expected_notifications: &[(u32, u64)]) {
     let epoll_event = libc::epoll_event { events: 0, u64: 0 };
     let mut array: [libc::epoll_event; N] = [epoll_event; N];
     let maxsize = N;
@@ -33,22 +33,18 @@ fn check_epoll_wait<const N: usize>(epfd: i32, expected_notifications: &[(u32, u
     if res < 0 {
         panic!("epoll_wait failed: {}", std::io::Error::last_os_error());
     }
-    assert_eq!(res, expected_notifications.len().try_into().unwrap());
+    assert_eq!(
+        res,
+        expected_notifications.len().try_into().unwrap(),
+        "got wrong number of notifications"
+    );
     let slice = unsafe { std::slice::from_raw_parts(array_ptr, res.try_into().unwrap()) };
-    let mut return_events = slice.iter();
-    let mut expected_notifications = expected_notifications.iter();
-    while let Some(return_event) = return_events.next() {
-        if let Some(notification) = expected_notifications.next() {
-            let event = return_event.events;
-            let data = return_event.u64;
-            assert_eq!(event, notification.0);
-            assert_eq!(data, notification.1);
-        } else {
-            return false;
-        }
+    for (return_event, expected_event) in slice.iter().zip(expected_notifications.iter()) {
+        let event = return_event.events;
+        let data = return_event.u64;
+        assert_eq!(event, expected_event.0, "got wrong events");
+        assert_eq!(data, expected_event.1, "got wrong data");
     }
-    // There shouldn't be any more expected.
-    return expected_notifications.next().is_none();
 }
 
 fn test_epoll_socketpair() {
@@ -77,10 +73,10 @@ fn test_epoll_socketpair() {
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 
     // Check that this is indeed using "ET" (edge-trigger) semantics: a second epoll should return nothing.
-    assert!(check_epoll_wait::<8>(epfd, &[]));
+    check_epoll_wait::<8>(epfd, &[]);
 
     // Write some more to fd[0].
     let data = "abcde".as_bytes().as_ptr();
@@ -89,7 +85,7 @@ fn test_epoll_socketpair() {
 
     // This did not change the readiness of fd[1]. And yet, we're seeing the event reported
     // again by the kernel, so Miri does the same.
-    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 
     // Close the peer socketpair.
     let res = unsafe { libc::close(fds[0]) };
@@ -100,7 +96,7 @@ fn test_epoll_socketpair() {
     let expected_event =
         u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLHUP).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
 
 fn test_epoll_ctl_mod() {
@@ -127,7 +123,7 @@ fn test_epoll_ctl_mod() {
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 
     // Test EPOLLRDHUP.
     let mut ev = libc::epoll_event {
@@ -145,7 +141,7 @@ fn test_epoll_ctl_mod() {
     let expected_event =
         u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLHUP).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
 
 fn test_epoll_ctl_del() {
@@ -169,7 +165,7 @@ fn test_epoll_ctl_del() {
     assert_ne!(res, -1);
 
     // Test EPOLL_CTL_DEL.
-    assert!(check_epoll_wait::<0>(epfd, &[]));
+    check_epoll_wait::<0>(epfd, &[]);
 }
 
 // This test is for one fd registered under two different epoll instance.
@@ -200,8 +196,8 @@ fn test_two_epoll_instance() {
     // Notification should be received from both instance of epoll.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
-    assert!(check_epoll_wait::<8>(epfd1, &[(expected_event, expected_value)]));
-    assert!(check_epoll_wait::<8>(epfd2, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd1, &[(expected_event, expected_value)]);
+    check_epoll_wait::<8>(epfd2, &[(expected_event, expected_value)]);
 }
 
 // This test is for two same file description registered under the same epoll instance through dup.
@@ -235,10 +231,10 @@ fn test_two_same_fd_in_same_epoll_instance() {
     //Two notification should be received.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = 5 as u64;
-    assert!(check_epoll_wait::<8>(
+    check_epoll_wait::<8>(
         epfd,
-        &[(expected_event, expected_value), (expected_event, expected_value)]
-    ));
+        &[(expected_event, expected_value), (expected_event, expected_value)],
+    );
 }
 
 fn test_epoll_eventfd() {
@@ -263,7 +259,7 @@ fn test_epoll_eventfd() {
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fd).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
 
 fn test_pointer() {
@@ -313,10 +309,10 @@ fn test_epoll_socketpair_both_sides() {
     let expected_value0 = fds[0] as u64;
     let expected_event1 = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value1 = fds[1] as u64;
-    assert!(check_epoll_wait::<8>(
+    check_epoll_wait::<8>(
         epfd,
-        &[(expected_event0, expected_value0), (expected_event1, expected_value1)]
-    ));
+        &[(expected_event0, expected_value0), (expected_event1, expected_value1)],
+    );
 
     // Read from fds[0].
     let mut buf: [u8; 5] = [0; 5];
@@ -327,7 +323,7 @@ fn test_epoll_socketpair_both_sides() {
     // Notification should be provided for fds[1].
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = fds[1] as u64;
-    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
 
 // When file description is fully closed, epoll_wait should not provide any notification for
@@ -356,7 +352,7 @@ fn test_closed_fd() {
     assert_eq!(res, 0);
 
     // No notification should be provided because the file description is closed.
-    assert!(check_epoll_wait::<8>(epfd, &[]));
+    check_epoll_wait::<8>(epfd, &[]);
 }
 
 // When a certain file descriptor registered with epoll is closed, but the underlying file description
@@ -390,7 +386,7 @@ fn test_not_fully_closed_fd() {
     // Notification should still be provided because the file description is not closed.
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = fd as u64;
-    assert!(check_epoll_wait::<1>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<1>(epfd, &[(expected_event, expected_value)]);
 
     // Write to the eventfd instance to produce notification.
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
@@ -402,7 +398,7 @@ fn test_not_fully_closed_fd() {
     assert_eq!(res, 0);
 
     // No notification should be provided.
-    assert!(check_epoll_wait::<1>(epfd, &[]));
+    check_epoll_wait::<1>(epfd, &[]);
 }
 
 // Each time a notification is provided, it should reflect the file description's readiness
@@ -437,7 +433,7 @@ fn test_event_overwrite() {
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fd).unwrap();
-    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
 
 // An epoll notification will be provided for every succesful read in a socketpair.
@@ -476,10 +472,10 @@ fn test_socketpair_read() {
     let expected_value0 = fds[0] as u64;
     let expected_event1 = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value1 = fds[1] as u64;
-    assert!(check_epoll_wait::<8>(
+    check_epoll_wait::<8>(
         epfd,
-        &[(expected_event0, expected_value0), (expected_event1, expected_value1)]
-    ));
+        &[(expected_event0, expected_value0), (expected_event1, expected_value1)],
+    );
 
     // Read 3 bytes from fds[0].
     let mut buf: [u8; 3] = [0; 3];
@@ -491,7 +487,7 @@ fn test_socketpair_read() {
     // But in real system, no notification will be provided here.
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = fds[1] as u64;
-    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 
     // Read until the buffer is empty.
     let mut buf: [u8; 2] = [0; 2];
@@ -503,5 +499,5 @@ fn test_socketpair_read() {
     // In real system, notification will be provided too.
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = fds[1] as u64;
-    assert!(check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]));
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }

From 321d40f060bccd79ea6878abc67bda5d10b65e5f Mon Sep 17 00:00:00 2001
From: Alona Enraght-Moony <code@alona.page>
Date: Sat, 17 Aug 2024 10:44:23 +0000
Subject: [PATCH 363/685] rustdoc-json: Clean up serialization and printing.

---
 src/librustdoc/json/mod.rs | 42 +++++++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 19 deletions(-)

diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs
index a424faaf99986..e2860292aa3ba 100644
--- a/src/librustdoc/json/mod.rs
+++ b/src/librustdoc/json/mod.rs
@@ -39,8 +39,10 @@ pub(crate) struct JsonRenderer<'tcx> {
     /// A mapping of IDs that contains all local items for this crate which gets output as a top
     /// level field of the JSON blob.
     index: Rc<RefCell<FxHashMap<types::Id, types::Item>>>,
-    /// The directory where the blob will be written to.
-    out_path: Option<PathBuf>,
+    /// The directory where the JSON blob should be written to.
+    ///
+    /// If this is `None`, the blob will be printed to `stdout` instead.
+    out_dir: Option<PathBuf>,
     cache: Rc<Cache>,
     imported_items: DefIdSet,
 }
@@ -101,18 +103,20 @@ impl<'tcx> JsonRenderer<'tcx> {
             .unwrap_or_default()
     }
 
-    fn write<T: Write>(
+    fn serialize_and_write<T: Write>(
         &self,
-        output: types::Crate,
+        output_crate: types::Crate,
         mut writer: BufWriter<T>,
         path: &str,
     ) -> Result<(), Error> {
-        self.tcx
-            .sess
-            .time("rustdoc_json_serialization", || serde_json::ser::to_writer(&mut writer, &output))
-            .unwrap();
-        try_err!(writer.flush(), path);
-        Ok(())
+        self.sess().time("rustdoc_json_serialize_and_write", || {
+            try_err!(
+                serde_json::ser::to_writer(&mut writer, &output_crate).map_err(|e| e.to_string()),
+                path
+            );
+            try_err!(writer.flush(), path);
+            Ok(())
+        })
     }
 }
 
@@ -137,7 +141,7 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
             JsonRenderer {
                 tcx,
                 index: Rc::new(RefCell::new(FxHashMap::default())),
-                out_path: if options.output_to_stdout { None } else { Some(options.output) },
+                out_dir: if options.output_to_stdout { None } else { Some(options.output) },
                 cache: Rc::new(cache),
                 imported_items,
             },
@@ -237,7 +241,7 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
         let index = (*self.index).clone().into_inner();
 
         debug!("Constructing Output");
-        let output = types::Crate {
+        let output_crate = types::Crate {
             root: types::Id(format!("0:0:{}", e.name(self.tcx).as_u32())),
             crate_version: self.cache.crate_version.clone(),
             includes_private: self.cache.document_private,
@@ -278,20 +282,20 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
                 .collect(),
             format_version: types::FORMAT_VERSION,
         };
-        if let Some(ref out_path) = self.out_path {
-            let out_dir = out_path.clone();
+        if let Some(ref out_dir) = self.out_dir {
             try_err!(create_dir_all(&out_dir), out_dir);
 
-            let mut p = out_dir;
-            p.push(output.index.get(&output.root).unwrap().name.clone().unwrap());
+            let mut p = out_dir.clone();
+            p.push(output_crate.index.get(&output_crate.root).unwrap().name.clone().unwrap());
             p.set_extension("json");
-            self.write(
-                output,
+
+            self.serialize_and_write(
+                output_crate,
                 BufWriter::new(try_err!(File::create(&p), p)),
                 &p.display().to_string(),
             )
         } else {
-            self.write(output, BufWriter::new(stdout()), "<stdout>")
+            self.serialize_and_write(output_crate, BufWriter::new(stdout().lock()), "<stdout>")
         }
     }
 

From 7bde314de8cef42a1848b48cd5084f5d6c26549f Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sat, 17 Aug 2024 13:24:38 +0200
Subject: [PATCH 364/685] Remove useless attributes in merged doctest generated
 code

---
 src/librustdoc/doctest/runner.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/librustdoc/doctest/runner.rs b/src/librustdoc/doctest/runner.rs
index b91333e5f8135..d49fa3ac5ac5a 100644
--- a/src/librustdoc/doctest/runner.rs
+++ b/src/librustdoc/doctest/runner.rs
@@ -75,7 +75,6 @@ impl DocTestRunner {
 #![allow(internal_features)]
 #![feature(test)]
 #![feature(rustc_attrs)]
-#![feature(coverage_attribute)]
 "
         .to_string();
 
@@ -135,7 +134,6 @@ mod __doctest_mod {{
 }}
 
 #[rustc_main]
-#[coverage(off)]
 fn main() -> std::process::ExitCode {{
 const TESTS: [test::TestDescAndFn; {nb_tests}] = [{ids}];
 let bin_marker = std::ffi::OsStr::new(__doctest_mod::BIN_OPTION);
@@ -235,11 +233,9 @@ fn main() {returns_result} {{
     writeln!(
         output,
         "
-#[rustc_test_marker = {test_name:?}]
 pub const TEST: test::TestDescAndFn = test::TestDescAndFn::new_doctest(
 {test_name:?}, {ignore}, {file:?}, {line}, {no_run}, {should_panic},
 test::StaticTestFn(
-    #[coverage(off)]
     || {{{runner}}},
 ));
 }}",

From 194ade1267f2bb66cb53626679944e195850bdcf Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Sat, 17 Aug 2024 22:18:37 +1000
Subject: [PATCH 365/685] Remove a useless ref/id/ref round-trip from
 `pattern_from_hir`

This re-lookup of `&hir::Pat` by its ID appears to be an artifact of earlier
complexity that has since been removed from the compiler.
---
 compiler/rustc_mir_build/src/thir/cx/mod.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs
index 6120b1453cfab..5b5f97cb51410 100644
--- a/compiler/rustc_mir_build/src/thir/cx/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/mod.rs
@@ -8,7 +8,7 @@ use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::lang_items::LangItem;
-use rustc_hir::{HirId, Node};
+use rustc_hir::HirId;
 use rustc_middle::bug;
 use rustc_middle::middle::region;
 use rustc_middle::thir::*;
@@ -110,11 +110,7 @@ impl<'tcx> Cx<'tcx> {
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn pattern_from_hir(&mut self, p: &hir::Pat<'_>) -> Box<Pat<'tcx>> {
-        let p = match self.tcx.hir_node(p.hir_id) {
-            Node::Pat(p) => p,
-            node => bug!("pattern became {:?}", node),
-        };
+    fn pattern_from_hir(&mut self, p: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tcx>> {
         pat_from_hir(self.tcx, self.param_env, self.typeck_results(), p)
     }
 

From 9a9cf2fd4ce7adee14a90c3af2623902f29486fb Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Sat, 17 Aug 2024 12:29:28 +0000
Subject: [PATCH 366/685] Fix bootstrap test `detect_src_and_out` on Windows

---
 src/bootstrap/src/core/config/tests.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index 378d069672f5d..219c5a6ec914e 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -96,8 +96,8 @@ fn detect_src_and_out() {
     test(parse(""), None);
 
     {
-        let build_dir = if cfg!(windows) { Some("C:\\tmp") } else { Some("/tmp") };
-        test(parse("build.build-dir = \"/tmp\""), build_dir);
+        let build_dir = if cfg!(windows) { "C:\\tmp" } else { "/tmp" };
+        test(parse(&format!("build.build-dir = '{build_dir}'")), Some(build_dir));
     }
 }
 

From 8b642a1883c489c74befca5b75514767a1f80314 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 17 Aug 2024 14:49:35 +0200
Subject: [PATCH 367/685] make writes_through_immutable_pointer a hard error

---
 .../rustc_const_eval/src/const_eval/error.rs  |  8 ++-
 .../src/const_eval/machine.rs                 |  9 ++--
 compiler/rustc_const_eval/src/errors.rs       |  7 ---
 compiler/rustc_lint/src/lib.rs                |  3 +-
 compiler/rustc_lint_defs/src/builtin.rs       | 35 ------------
 .../const-eval/ub-write-through-immutable.rs  |  9 ++--
 .../ub-write-through-immutable.stderr         | 54 +++----------------
 7 files changed, 23 insertions(+), 102 deletions(-)

diff --git a/compiler/rustc_const_eval/src/const_eval/error.rs b/compiler/rustc_const_eval/src/const_eval/error.rs
index 00bbd9337f7e1..25b32785b7d3e 100644
--- a/compiler/rustc_const_eval/src/const_eval/error.rs
+++ b/compiler/rustc_const_eval/src/const_eval/error.rs
@@ -22,6 +22,7 @@ pub enum ConstEvalErrKind {
     RecursiveStatic,
     AssertFailure(AssertKind<ConstInt>),
     Panic { msg: Symbol, line: u32, col: u32, file: Symbol },
+    WriteThroughImmutablePointer,
 }
 
 impl MachineStopType for ConstEvalErrKind {
@@ -35,12 +36,16 @@ impl MachineStopType for ConstEvalErrKind {
             Panic { .. } => const_eval_panic,
             RecursiveStatic => const_eval_recursive_static,
             AssertFailure(x) => x.diagnostic_message(),
+            WriteThroughImmutablePointer => const_eval_write_through_immutable_pointer,
         }
     }
     fn add_args(self: Box<Self>, adder: &mut dyn FnMut(DiagArgName, DiagArgValue)) {
         use ConstEvalErrKind::*;
         match *self {
-            RecursiveStatic | ConstAccessesMutGlobal | ModifiedGlobal => {}
+            RecursiveStatic
+            | ConstAccessesMutGlobal
+            | ModifiedGlobal
+            | WriteThroughImmutablePointer => {}
             AssertFailure(kind) => kind.add_args(adder),
             Panic { msg, line, col, file } => {
                 adder("msg".into(), msg.into_diag_arg());
@@ -159,6 +164,7 @@ where
 
 /// Emit a lint from a const-eval situation, with a backtrace.
 // Even if this is unused, please don't remove it -- chances are we will need to emit a lint during const-eval again in the future!
+#[allow(unused)]
 pub(super) fn lint<'tcx, L>(
     tcx: TyCtxtAt<'tcx>,
     machine: &CompileTimeMachine<'tcx>,
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index a075bdc191181..f010e5cfbb700 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -12,7 +12,6 @@ use rustc_middle::query::TyCtxtAt;
 use rustc_middle::ty::layout::{FnAbiOf, TyAndLayout};
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_middle::{bug, mir};
-use rustc_session::lint::builtin::WRITES_THROUGH_IMMUTABLE_POINTER;
 use rustc_span::symbol::{sym, Symbol};
 use rustc_span::Span;
 use rustc_target::abi::{Align, Size};
@@ -729,8 +728,8 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
     }
 
     fn before_memory_write(
-        tcx: TyCtxtAt<'tcx>,
-        machine: &mut Self,
+        _tcx: TyCtxtAt<'tcx>,
+        _machine: &mut Self,
         _alloc_extra: &mut Self::AllocExtra,
         (_alloc_id, immutable): (AllocId, bool),
         range: AllocRange,
@@ -741,9 +740,7 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
         }
         // Reject writes through immutable pointers.
         if immutable {
-            super::lint(tcx, machine, WRITES_THROUGH_IMMUTABLE_POINTER, |frames| {
-                crate::errors::WriteThroughImmutablePointer { frames }
-            });
+            return Err(ConstEvalErrKind::WriteThroughImmutablePointer.into());
         }
         // Everything else is fine.
         Ok(())
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index 7afb92c08ec9a..ec344543c5c92 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -407,13 +407,6 @@ pub struct ConstEvalError {
     pub frame_notes: Vec<FrameNote>,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(const_eval_write_through_immutable_pointer)]
-pub struct WriteThroughImmutablePointer {
-    #[subdiagnostic]
-    pub frames: Vec<FrameNote>,
-}
-
 #[derive(Diagnostic)]
 #[diag(const_eval_nullary_intrinsic_fail)]
 pub struct NullaryIntrinsicError {
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 4f3933d461bbd..547f7eb8e2a53 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -569,7 +569,8 @@ fn register_builtins(store: &mut LintStore) {
         "byte_slice_in_packed_struct_with_derive",
         "converted into hard error, see issue #107457 \
          <https://github.com/rust-lang/rust/issues/107457> for more information",
-    )
+    );
+    store.register_removed("writes_through_immutable_pointer", "converted into hard error");
 }
 
 fn register_internals(store: &mut LintStore) {
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index c731b03a87590..3c0181a5e6ecc 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -142,7 +142,6 @@ declare_lint_pass! {
         USELESS_DEPRECATED,
         WARNINGS,
         WASM_C_ABI,
-        WRITES_THROUGH_IMMUTABLE_POINTER,
         // tidy-alphabetical-end
     ]
 }
@@ -4696,40 +4695,6 @@ declare_lint! {
     };
 }
 
-declare_lint! {
-    /// The `writes_through_immutable_pointer` lint detects writes through pointers derived from
-    /// shared references.
-    ///
-    /// ### Example
-    ///
-    /// ```rust,compile_fail
-    /// #![feature(const_mut_refs)]
-    /// const WRITE_AFTER_CAST: () = unsafe {
-    ///     let mut x = 0;
-    ///     let ptr = &x as *const i32 as *mut i32;
-    ///     *ptr = 0;
-    /// };
-    /// ```
-    ///
-    /// {{produces}}
-    ///
-    /// ### Explanation
-    ///
-    /// Shared references are immutable (when there is no `UnsafeCell` involved),
-    /// and writing through them or through pointers derived from them is Undefined Behavior.
-    /// The compiler recently learned to detect such Undefined Behavior during compile-time
-    /// evaluation, and in the future this will raise a hard error.
-    ///
-    /// [future-incompatible]: ../index.md#future-incompatible-lints
-    pub WRITES_THROUGH_IMMUTABLE_POINTER,
-    Warn,
-    "shared references are immutable, and pointers derived from them must not be written to",
-    @future_incompatible = FutureIncompatibleInfo {
-        reason: FutureIncompatibilityReason::FutureReleaseErrorReportInDeps,
-        reference: "issue #X <https://github.com/rust-lang/rust/issues/X>",
-    };
-}
-
 declare_lint! {
     /// The `private_macro_use` lint detects private macros that are imported
     /// with `#[macro_use]`.
diff --git a/tests/ui/consts/const-eval/ub-write-through-immutable.rs b/tests/ui/consts/const-eval/ub-write-through-immutable.rs
index 945367f182308..9860b8fde4af8 100644
--- a/tests/ui/consts/const-eval/ub-write-through-immutable.rs
+++ b/tests/ui/consts/const-eval/ub-write-through-immutable.rs
@@ -1,6 +1,5 @@
 //! Ensure we catch UB due to writing through a shared reference.
 #![feature(const_mut_refs, const_refs_to_cell)]
-#![deny(writes_through_immutable_pointer)]
 #![allow(invalid_reference_casting)]
 
 use std::mem;
@@ -9,15 +8,15 @@ use std::cell::UnsafeCell;
 const WRITE_AFTER_CAST: () = unsafe {
     let mut x = 0;
     let ptr = &x as *const i32 as *mut i32;
-    *ptr = 0; //~ERROR: writes_through_immutable_pointer
-    //~^ previously accepted
+    *ptr = 0; //~ERROR: evaluation of constant value failed
+    //~| immutable
 };
 
 const WRITE_AFTER_TRANSMUTE: () = unsafe {
     let mut x = 0;
     let ptr: *mut i32 = mem::transmute(&x);
-    *ptr = 0; //~ERROR: writes_through_immutable_pointer
-    //~^ previously accepted
+    *ptr = 0; //~ERROR: evaluation of constant value failed
+    //~| immutable
 };
 
 // it's okay when there is interior mutability;
diff --git a/tests/ui/consts/const-eval/ub-write-through-immutable.stderr b/tests/ui/consts/const-eval/ub-write-through-immutable.stderr
index 27eb2d2c0d152..dbcd35e0b8815 100644
--- a/tests/ui/consts/const-eval/ub-write-through-immutable.stderr
+++ b/tests/ui/consts/const-eval/ub-write-through-immutable.stderr
@@ -1,55 +1,15 @@
-error: writing through a pointer that was derived from a shared (immutable) reference
-  --> $DIR/ub-write-through-immutable.rs:12:5
+error[E0080]: evaluation of constant value failed
+  --> $DIR/ub-write-through-immutable.rs:11:5
    |
 LL |     *ptr = 0;
-   |     ^^^^^^^^
-   |
-   = 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 #X <https://github.com/rust-lang/rust/issues/X>
-note: the lint level is defined here
-  --> $DIR/ub-write-through-immutable.rs:3:9
-   |
-LL | #![deny(writes_through_immutable_pointer)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^ writing through a pointer that was derived from a shared (immutable) reference
 
-error: writing through a pointer that was derived from a shared (immutable) reference
-  --> $DIR/ub-write-through-immutable.rs:19:5
+error[E0080]: evaluation of constant value failed
+  --> $DIR/ub-write-through-immutable.rs:18:5
    |
 LL |     *ptr = 0;
-   |     ^^^^^^^^
-   |
-   = 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 #X <https://github.com/rust-lang/rust/issues/X>
+   |     ^^^^^^^^ writing through a pointer that was derived from a shared (immutable) reference
 
 error: aborting due to 2 previous errors
 
-Future incompatibility report: Future breakage diagnostic:
-error: writing through a pointer that was derived from a shared (immutable) reference
-  --> $DIR/ub-write-through-immutable.rs:12:5
-   |
-LL |     *ptr = 0;
-   |     ^^^^^^^^
-   |
-   = 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 #X <https://github.com/rust-lang/rust/issues/X>
-note: the lint level is defined here
-  --> $DIR/ub-write-through-immutable.rs:3:9
-   |
-LL | #![deny(writes_through_immutable_pointer)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Future breakage diagnostic:
-error: writing through a pointer that was derived from a shared (immutable) reference
-  --> $DIR/ub-write-through-immutable.rs:19:5
-   |
-LL |     *ptr = 0;
-   |     ^^^^^^^^
-   |
-   = 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 #X <https://github.com/rust-lang/rust/issues/X>
-note: the lint level is defined here
-  --> $DIR/ub-write-through-immutable.rs:3:9
-   |
-LL | #![deny(writes_through_immutable_pointer)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
+For more information about this error, try `rustc --explain E0080`.

From 34e8245e4c68e5d2da7b4137291d370c7c119752 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 17 Aug 2024 16:38:19 +0200
Subject: [PATCH 368/685] tls_leak_main_thread_allowed: make test check
 target_thread_local

---
 .../pass/tls/tls_leak_main_thread_allowed.rs  | 23 +++++++++++--------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/tools/miri/tests/pass/tls/tls_leak_main_thread_allowed.rs b/src/tools/miri/tests/pass/tls/tls_leak_main_thread_allowed.rs
index 7732e3f921774..341b2280e0109 100644
--- a/src/tools/miri/tests/pass/tls/tls_leak_main_thread_allowed.rs
+++ b/src/tools/miri/tests/pass/tls/tls_leak_main_thread_allowed.rs
@@ -1,5 +1,4 @@
-//@ignore-target-windows: Windows uses a different mechanism for `thread_local!`
-#![feature(thread_local)]
+#![feature(thread_local, cfg_target_thread_local)]
 
 use std::cell::Cell;
 
@@ -8,16 +7,20 @@ use std::cell::Cell;
 //
 // The test covers both TLS statics and the TLS macro.
 pub fn main() {
-    thread_local! {
-        static TLS_KEY: Cell<Option<&'static i32>> = Cell::new(None);
-    }
-
-    TLS_KEY.with(|cell| {
-        cell.set(Some(Box::leak(Box::new(123))));
-    });
-
     #[thread_local]
     static TLS: Cell<Option<&'static i32>> = Cell::new(None);
 
     TLS.set(Some(Box::leak(Box::new(123))));
+
+    // We can only ignore leaks on targets that use `#[thread_local]` statics to implement
+    // `thread_local!`. Ignore the test on targest that don't.
+    if cfg!(target_thread_local) {
+        thread_local! {
+            static TLS_KEY: Cell<Option<&'static i32>> = Cell::new(None);
+        }
+
+        TLS_KEY.with(|cell| {
+            cell.set(Some(Box::leak(Box::new(123))));
+        });
+    }
 }

From bd4ef64a60f2c49b9ca2ea6fe394364177033ae6 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 17 Aug 2024 16:44:05 +0200
Subject: [PATCH 369/685] run TLS tests on Solarish

---
 src/tools/miri/ci/ci.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tools/miri/ci/ci.sh b/src/tools/miri/ci/ci.sh
index 3e90ecc5c0397..1f66b6fa776d9 100755
--- a/src/tools/miri/ci/ci.sh
+++ b/src/tools/miri/ci/ci.sh
@@ -150,8 +150,8 @@ case $HOST_TARGET in
     UNIX="panic/panic panic/unwind concurrency/simple atomic libc-mem libc-misc libc-random env num_cpus" # the things that are very similar across all Unixes, and hence easily supported there
     TEST_TARGET=x86_64-unknown-freebsd run_tests_minimal $BASIC $UNIX threadname libc-time fs
     TEST_TARGET=i686-unknown-freebsd   run_tests_minimal $BASIC $UNIX threadname libc-time fs
-    TEST_TARGET=x86_64-unknown-illumos run_tests_minimal $BASIC $UNIX threadname pthread-sync available-parallelism libc-time
-    TEST_TARGET=x86_64-pc-solaris      run_tests_minimal $BASIC $UNIX threadname pthread-sync available-parallelism libc-time
+    TEST_TARGET=x86_64-unknown-illumos run_tests_minimal $BASIC $UNIX threadname pthread-sync available-parallelism libc-time tls
+    TEST_TARGET=x86_64-pc-solaris      run_tests_minimal $BASIC $UNIX threadname pthread-sync available-parallelism libc-time tls
     TEST_TARGET=aarch64-linux-android  run_tests_minimal $BASIC $UNIX
     TEST_TARGET=wasm32-wasip2          run_tests_minimal empty_main wasm heap_alloc libc-mem
     TEST_TARGET=wasm32-unknown-unknown run_tests_minimal empty_main wasm

From 7c811203cd3e3f0bcdaedb6b51a81be2765bc635 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 17 Aug 2024 17:38:27 +0200
Subject: [PATCH 370/685] simplify synchronization object creation logic

---
 src/tools/miri/src/concurrency/init_once.rs |  26 +----
 src/tools/miri/src/concurrency/sync.rs      | 103 +++++---------------
 2 files changed, 27 insertions(+), 102 deletions(-)

diff --git a/src/tools/miri/src/concurrency/init_once.rs b/src/tools/miri/src/concurrency/init_once.rs
index 9145ef32c525b..c23e5737280e7 100644
--- a/src/tools/miri/src/concurrency/init_once.rs
+++ b/src/tools/miri/src/concurrency/init_once.rs
@@ -26,27 +26,6 @@ pub(super) struct InitOnce {
     clock: VClock,
 }
 
-impl<'tcx> EvalContextExtPriv<'tcx> for crate::MiriInterpCx<'tcx> {}
-trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
-    /// Provides the closure with the next InitOnceId. Creates that InitOnce if the closure returns None,
-    /// otherwise returns the value from the closure.
-    #[inline]
-    fn init_once_get_or_create<F>(&mut self, existing: F) -> InterpResult<'tcx, InitOnceId>
-    where
-        F: FnOnce(&mut MiriInterpCx<'tcx>, InitOnceId) -> InterpResult<'tcx, Option<InitOnceId>>,
-    {
-        let this = self.eval_context_mut();
-        let next_index = this.machine.sync.init_onces.next_index();
-        if let Some(old) = existing(this, next_index)? {
-            Ok(old)
-        } else {
-            let new_index = this.machine.sync.init_onces.push(Default::default());
-            assert_eq!(next_index, new_index);
-            Ok(new_index)
-        }
-    }
-}
-
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     fn init_once_get_or_create_id(
@@ -56,9 +35,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         offset: u64,
     ) -> InterpResult<'tcx, InitOnceId> {
         let this = self.eval_context_mut();
-        this.init_once_get_or_create(|ecx, next_id| {
-            ecx.get_or_create_id(next_id, lock_op, lock_layout, offset)
-        })
+        this.get_or_create_id(lock_op, lock_layout, offset, |ecx| &mut ecx.machine.sync.init_onces)?
+            .ok_or_else(|| err_ub_format!("init_once has invalid ID").into())
     }
 
     #[inline]
diff --git a/src/tools/miri/src/concurrency/sync.rs b/src/tools/miri/src/concurrency/sync.rs
index d0c9a4600e85e..d972831c7689f 100644
--- a/src/tools/miri/src/concurrency/sync.rs
+++ b/src/tools/miri/src/concurrency/sync.rs
@@ -164,25 +164,29 @@ pub struct SynchronizationObjects {
 impl<'tcx> EvalContextExtPriv<'tcx> for crate::MiriInterpCx<'tcx> {}
 pub(super) trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
     /// Lazily initialize the ID of this Miri sync structure.
-    /// ('0' indicates uninit.)
+    /// If memory stores '0', that indicates uninit and we generate a new instance.
+    /// Returns `None` if memory stores a non-zero invalid ID.
+    ///
+    /// `get_objs` must return the `IndexVec` that stores all the objects of this type.
     #[inline]
-    fn get_or_create_id<Id: SyncId>(
+    fn get_or_create_id<Id: SyncId + Idx, T: Default>(
         &mut self,
-        next_id: Id,
         lock_op: &OpTy<'tcx>,
         lock_layout: TyAndLayout<'tcx>,
         offset: u64,
+        get_objs: impl for<'a> Fn(&'a mut MiriInterpCx<'tcx>) -> &'a mut IndexVec<Id, T>,
     ) -> InterpResult<'tcx, Option<Id>> {
         let this = self.eval_context_mut();
         let value_place =
             this.deref_pointer_and_offset(lock_op, offset, lock_layout, this.machine.layouts.u32)?;
+        let next_index = get_objs(this).next_index();
 
         // Since we are lazy, this update has to be atomic.
         let (old, success) = this
             .atomic_compare_exchange_scalar(
                 &value_place,
                 &ImmTy::from_uint(0u32, this.machine.layouts.u32),
-                Scalar::from_u32(next_id.to_u32()),
+                Scalar::from_u32(next_index.to_u32()),
                 AtomicRwOrd::Relaxed, // deliberately *no* synchronization
                 AtomicReadOrd::Relaxed,
                 false,
@@ -190,74 +194,20 @@ pub(super) trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
             .to_scalar_pair();
 
         Ok(if success.to_bool().expect("compare_exchange's second return value is a bool") {
-            // Caller of the closure needs to allocate next_id
-            None
-        } else {
-            Some(Id::from_u32(old.to_u32().expect("layout is u32")))
-        })
-    }
-
-    /// Provides the closure with the next MutexId. Creates that mutex if the closure returns None,
-    /// otherwise returns the value from the closure.
-    #[inline]
-    fn mutex_get_or_create<F>(&mut self, existing: F) -> InterpResult<'tcx, MutexId>
-    where
-        F: FnOnce(&mut MiriInterpCx<'tcx>, MutexId) -> InterpResult<'tcx, Option<MutexId>>,
-    {
-        let this = self.eval_context_mut();
-        let next_index = this.machine.sync.mutexes.next_index();
-        if let Some(old) = existing(this, next_index)? {
-            if this.machine.sync.mutexes.get(old).is_none() {
-                throw_ub_format!("mutex has invalid ID");
-            }
-            Ok(old)
-        } else {
-            let new_index = this.machine.sync.mutexes.push(Default::default());
+            // We set the in-memory ID to `next_index`, now also create this object in the machine
+            // state.
+            let new_index = get_objs(this).push(T::default());
             assert_eq!(next_index, new_index);
-            Ok(new_index)
-        }
-    }
-
-    /// Provides the closure with the next RwLockId. Creates that RwLock if the closure returns None,
-    /// otherwise returns the value from the closure.
-    #[inline]
-    fn rwlock_get_or_create<F>(&mut self, existing: F) -> InterpResult<'tcx, RwLockId>
-    where
-        F: FnOnce(&mut MiriInterpCx<'tcx>, RwLockId) -> InterpResult<'tcx, Option<RwLockId>>,
-    {
-        let this = self.eval_context_mut();
-        let next_index = this.machine.sync.rwlocks.next_index();
-        if let Some(old) = existing(this, next_index)? {
-            if this.machine.sync.rwlocks.get(old).is_none() {
-                throw_ub_format!("rwlock has invalid ID");
-            }
-            Ok(old)
+            Some(new_index)
         } else {
-            let new_index = this.machine.sync.rwlocks.push(Default::default());
-            assert_eq!(next_index, new_index);
-            Ok(new_index)
-        }
-    }
-
-    /// Provides the closure with the next CondvarId. Creates that Condvar if the closure returns None,
-    /// otherwise returns the value from the closure.
-    #[inline]
-    fn condvar_get_or_create<F>(&mut self, existing: F) -> InterpResult<'tcx, CondvarId>
-    where
-        F: FnOnce(&mut MiriInterpCx<'tcx>, CondvarId) -> InterpResult<'tcx, Option<CondvarId>>,
-    {
-        let this = self.eval_context_mut();
-        let next_index = this.machine.sync.condvars.next_index();
-        if let Some(old) = existing(this, next_index)? {
-            if this.machine.sync.condvars.get(old).is_none() {
-                throw_ub_format!("condvar has invalid ID");
+            let id = Id::from_u32(old.to_u32().expect("layout is u32"));
+            if get_objs(this).get(id).is_none() {
+                // The in-memory ID is invalid.
+                None
+            } else {
+                Some(id)
             }
-            Ok(old)
-        } else {
-            let new_index = this.machine.sync.condvars.push(Default::default());
-            assert_eq!(next_index, new_index);
-            Ok(new_index)
-        }
+        })
     }
 
     fn condvar_reacquire_mutex(
@@ -293,9 +243,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         offset: u64,
     ) -> InterpResult<'tcx, MutexId> {
         let this = self.eval_context_mut();
-        this.mutex_get_or_create(|ecx, next_id| {
-            ecx.get_or_create_id(next_id, lock_op, lock_layout, offset)
-        })
+        this.get_or_create_id(lock_op, lock_layout, offset, |ecx| &mut ecx.machine.sync.mutexes)?
+            .ok_or_else(|| err_ub_format!("mutex has invalid ID").into())
     }
 
     fn rwlock_get_or_create_id(
@@ -305,9 +254,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         offset: u64,
     ) -> InterpResult<'tcx, RwLockId> {
         let this = self.eval_context_mut();
-        this.rwlock_get_or_create(|ecx, next_id| {
-            ecx.get_or_create_id(next_id, lock_op, lock_layout, offset)
-        })
+        this.get_or_create_id(lock_op, lock_layout, offset, |ecx| &mut ecx.machine.sync.rwlocks)?
+            .ok_or_else(|| err_ub_format!("rwlock has invalid ID").into())
     }
 
     fn condvar_get_or_create_id(
@@ -317,9 +265,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         offset: u64,
     ) -> InterpResult<'tcx, CondvarId> {
         let this = self.eval_context_mut();
-        this.condvar_get_or_create(|ecx, next_id| {
-            ecx.get_or_create_id(next_id, lock_op, lock_layout, offset)
-        })
+        this.get_or_create_id(lock_op, lock_layout, offset, |ecx| &mut ecx.machine.sync.condvars)?
+            .ok_or_else(|| err_ub_format!("condvar has invalid ID").into())
     }
 
     #[inline]

From eae5b5c6e7d5804f7c0a6080444709b3c77b3443 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 12 Jul 2024 06:12:24 -0400
Subject: [PATCH 371/685] Stabilize opaque type precise capturing

---
 compiler/rustc_ast_passes/src/feature_gate.rs |  1 -
 compiler/rustc_feature/src/accepted.rs        |  2 ++
 compiler/rustc_feature/src/unstable.rs        |  2 --
 compiler/rustc_hir/src/hir.rs                 |  1 -
 .../rustc_lint/src/impl_trait_overcaptures.rs |  7 +-----
 compiler/rustc_parse/src/parser/ty.rs         |  1 -
 .../impl-trait-precise-capturing.rs           |  2 --
 tests/rustdoc/impl-trait-precise-capturing.rs |  1 -
 .../feature-gate-precise-capturing.rs         |  4 ----
 .../feature-gate-precise-capturing.stderr     | 13 ----------
 .../call_method_ambiguous.next.stderr         |  2 +-
 tests/ui/impl-trait/call_method_ambiguous.rs  |  2 --
 tests/ui/impl-trait/precise-capturing/apit.rs |  2 --
 .../impl-trait/precise-capturing/apit.stderr  |  2 +-
 .../precise-capturing/bad-lifetimes.rs        |  2 --
 .../precise-capturing/bad-lifetimes.stderr    |  8 +++----
 .../precise-capturing/bad-params.rs           |  2 --
 .../precise-capturing/bad-params.stderr       |  8 +++----
 .../precise-capturing/bound-modifiers.rs      |  2 --
 .../precise-capturing/bound-modifiers.stderr  | 24 +++++++++----------
 .../precise-capturing/capture-parent-arg.rs   |  2 --
 .../capture-parent-arg.stderr                 |  4 ++--
 .../duplicated-use.real.stderr                |  2 +-
 .../precise-capturing/duplicated-use.rs       |  2 --
 .../impl-trait/precise-capturing/dyn-use.rs   |  2 --
 .../precise-capturing/dyn-use.stderr          |  2 +-
 .../ui/impl-trait/precise-capturing/elided.rs |  2 --
 .../forgot-to-capture-const.rs                |  2 --
 .../forgot-to-capture-const.stderr            |  2 +-
 .../forgot-to-capture-lifetime.rs             |  2 --
 .../forgot-to-capture-lifetime.stderr         |  4 ++--
 .../forgot-to-capture-type.rs                 |  2 --
 .../forgot-to-capture-type.stderr             |  6 ++---
 .../precise-capturing/higher-ranked.rs        |  2 +-
 .../illegal-positions.real.stderr             | 18 +++++++-------
 .../precise-capturing/illegal-positions.rs    |  2 --
 .../impl-trait/precise-capturing/ordering.rs  |  2 --
 .../precise-capturing/ordering.stderr         |  8 +++----
 .../impl-trait/precise-capturing/outlives.rs  |  2 +-
 .../precise-capturing/overcaptures-2024.fixed |  3 +--
 .../precise-capturing/overcaptures-2024.rs    |  3 +--
 .../overcaptures-2024.stderr                  | 18 +++++++-------
 .../precise-capturing/redundant.normal.stderr |  4 ++--
 .../precise-capturing/redundant.rpitit.stderr |  4 ++--
 .../impl-trait/precise-capturing/redundant.rs |  2 --
 .../ui/impl-trait/precise-capturing/rpitit.rs |  2 --
 .../precise-capturing/rpitit.stderr           |  8 +++----
 .../precise-capturing/self-capture.rs         |  2 --
 .../precise-capturing/self-capture.stderr     |  2 +-
 49 files changed, 70 insertions(+), 134 deletions(-)
 delete mode 100644 tests/ui/feature-gates/feature-gate-precise-capturing.rs
 delete mode 100644 tests/ui/feature-gates/feature-gate-precise-capturing.stderr

diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 3ceb8e0711a21..39ddc62df9a63 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -557,7 +557,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     gate_all!(fn_delegation, "functions delegation is not yet fully implemented");
     gate_all!(postfix_match, "postfix match is experimental");
     gate_all!(mut_ref, "mutable by-reference bindings are experimental");
-    gate_all!(precise_capturing, "precise captures on `impl Trait` are experimental");
     gate_all!(global_registration, "global registration is experimental");
     gate_all!(unsafe_attributes, "`#[unsafe()]` markers for attributes are experimental");
     gate_all!(return_type_notation, "return type notation is experimental");
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 03b40e28f8b4b..d02ffe134cd34 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -309,6 +309,8 @@ declare_features! (
     (accepted, param_attrs, "1.39.0", Some(60406)),
     /// Allows parentheses in patterns.
     (accepted, pattern_parentheses, "1.31.0", Some(51087)),
+    /// Allows `use<'a, 'b, A, B>` in `impl Trait + use<...>` for precise capture of generic args.
+    (accepted, precise_capturing, "CURRENT_RUSTC_VERSION", Some(123432)),
     /// Allows procedural macros in `proc-macro` crates.
     (accepted, proc_macro, "1.29.0", Some(38356)),
     /// Allows multi-segment paths in attributes and derives.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 24f691ea7fa20..7a09891168173 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -561,8 +561,6 @@ declare_features! (
     (unstable, patchable_function_entry, "1.81.0", Some(123115)),
     /// Allows postfix match `expr.match { ... }`
     (unstable, postfix_match, "1.79.0", Some(121618)),
-    /// Allows `use<'a, 'b, A, B>` in `impl Trait + use<...>` for precise capture of generic args.
-    (unstable, precise_capturing, "1.79.0", Some(123432)),
     /// Allows macro attributes on expressions, statements and non-inline modules.
     (unstable, proc_macro_hygiene, "1.30.0", Some(54727)),
     /// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions.
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 33e8432596be1..a2f8bdab7bd4b 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -2773,7 +2773,6 @@ impl PreciseCapturingArg<'_> {
 /// resolution to. Lifetimes don't have this problem, and for them, it's actually
 /// kind of detrimental to use a custom node type versus just using [`Lifetime`],
 /// since resolve_bound_vars operates on `Lifetime`s.
-// FIXME(precise_capturing): Investigate storing this as a path instead?
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct PreciseCapturingNonLifetimeArg {
     pub hir_id: HirId,
diff --git a/compiler/rustc_lint/src/impl_trait_overcaptures.rs b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
index e914169f4c373..990fb2d16f9dd 100644
--- a/compiler/rustc_lint/src/impl_trait_overcaptures.rs
+++ b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
@@ -27,8 +27,6 @@ declare_lint! {
     /// ### Example
     ///
     /// ```rust,compile_fail
-    /// # #![feature(precise_capturing)]
-    /// # #![allow(incomplete_features)]
     /// # #![deny(impl_trait_overcaptures)]
     /// # use std::fmt::Display;
     /// let mut x = vec![];
@@ -56,7 +54,6 @@ declare_lint! {
     pub IMPL_TRAIT_OVERCAPTURES,
     Allow,
     "`impl Trait` will capture more lifetimes than possibly intended in edition 2024",
-    @feature_gate = precise_capturing;
     //@future_incompatible = FutureIncompatibleInfo {
     //    reason: FutureIncompatibilityReason::EditionSemanticsChange(Edition::Edition2024),
     //    reference: "<FIXME>",
@@ -75,8 +72,7 @@ declare_lint! {
     /// ### Example
     ///
     /// ```rust,compile_fail
-    /// # #![feature(precise_capturing, lifetime_capture_rules_2024)]
-    /// # #![allow(incomplete_features)]
+    /// # #![feature(lifetime_capture_rules_2024)]
     /// # #![deny(impl_trait_redundant_captures)]
     /// fn test<'a>(x: &'a i32) -> impl Sized + use<'a> { x }
     /// ```
@@ -90,7 +86,6 @@ declare_lint! {
     pub IMPL_TRAIT_REDUNDANT_CAPTURES,
     Warn,
     "redundant precise-capturing `use<...>` syntax on an `impl Trait`",
-    @feature_gate = precise_capturing;
 }
 
 declare_lint_pass!(
diff --git a/compiler/rustc_parse/src/parser/ty.rs b/compiler/rustc_parse/src/parser/ty.rs
index a8e8270673afb..52f0b1c1b04aa 100644
--- a/compiler/rustc_parse/src/parser/ty.rs
+++ b/compiler/rustc_parse/src/parser/ty.rs
@@ -851,7 +851,6 @@ impl<'a> Parser<'a> {
             // lifetimes and ident params (including SelfUpper). These are validated later
             // for order, duplication, and whether they actually reference params.
             let use_span = self.prev_token.span;
-            self.psess.gated_spans.gate(sym::precise_capturing, use_span);
             let (args, args_span) = self.parse_precise_capturing_args()?;
             GenericBound::Use(args, use_span.to(args_span))
         } else {
diff --git a/tests/rustdoc-json/impl-trait-precise-capturing.rs b/tests/rustdoc-json/impl-trait-precise-capturing.rs
index f9fee788ffe6e..0c116a1029019 100644
--- a/tests/rustdoc-json/impl-trait-precise-capturing.rs
+++ b/tests/rustdoc-json/impl-trait-precise-capturing.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 //@ is "$.index[*][?(@.name=='hello')].inner.function.decl.output.impl_trait[1].use[0]" \"\'a\"
 //@ is "$.index[*][?(@.name=='hello')].inner.function.decl.output.impl_trait[1].use[1]" \"T\"
 //@ is "$.index[*][?(@.name=='hello')].inner.function.decl.output.impl_trait[1].use[2]" \"N\"
diff --git a/tests/rustdoc/impl-trait-precise-capturing.rs b/tests/rustdoc/impl-trait-precise-capturing.rs
index a964a1f8518f5..3ec8c5780139a 100644
--- a/tests/rustdoc/impl-trait-precise-capturing.rs
+++ b/tests/rustdoc/impl-trait-precise-capturing.rs
@@ -1,7 +1,6 @@
 //@ aux-build:precise-capturing.rs
 
 #![crate_name = "foo"]
-#![feature(precise_capturing)]
 
 extern crate precise_capturing;
 
diff --git a/tests/ui/feature-gates/feature-gate-precise-capturing.rs b/tests/ui/feature-gates/feature-gate-precise-capturing.rs
deleted file mode 100644
index 47a21539d3779..0000000000000
--- a/tests/ui/feature-gates/feature-gate-precise-capturing.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-fn hello() -> impl Sized + use<> {}
-//~^ ERROR precise captures on `impl Trait` are experimental
-
-fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-precise-capturing.stderr b/tests/ui/feature-gates/feature-gate-precise-capturing.stderr
deleted file mode 100644
index 04365408880d7..0000000000000
--- a/tests/ui/feature-gates/feature-gate-precise-capturing.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0658]: precise captures on `impl Trait` are experimental
-  --> $DIR/feature-gate-precise-capturing.rs:1:28
-   |
-LL | fn hello() -> impl Sized + use<> {}
-   |                            ^^^
-   |
-   = note: see issue #123432 <https://github.com/rust-lang/rust/issues/123432> for more information
-   = help: add `#![feature(precise_capturing)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/impl-trait/call_method_ambiguous.next.stderr b/tests/ui/impl-trait/call_method_ambiguous.next.stderr
index a1f9a8b40a899..5251555f57421 100644
--- a/tests/ui/impl-trait/call_method_ambiguous.next.stderr
+++ b/tests/ui/impl-trait/call_method_ambiguous.next.stderr
@@ -1,5 +1,5 @@
 error[E0282]: type annotations needed
-  --> $DIR/call_method_ambiguous.rs:28:13
+  --> $DIR/call_method_ambiguous.rs:26:13
    |
 LL |         let mut iter = foo(n - 1, m);
    |             ^^^^^^^^
diff --git a/tests/ui/impl-trait/call_method_ambiguous.rs b/tests/ui/impl-trait/call_method_ambiguous.rs
index 4dac605d6b812..8fd6f727b73f6 100644
--- a/tests/ui/impl-trait/call_method_ambiguous.rs
+++ b/tests/ui/impl-trait/call_method_ambiguous.rs
@@ -2,8 +2,6 @@
 //@[next] compile-flags: -Znext-solver
 //@[current] run-pass
 
-#![feature(precise_capturing)]
-
 trait Get {
     fn get(&mut self) -> u32;
 }
diff --git a/tests/ui/impl-trait/precise-capturing/apit.rs b/tests/ui/impl-trait/precise-capturing/apit.rs
index 64c15d6df96c8..447d8fdf2cd76 100644
--- a/tests/ui/impl-trait/precise-capturing/apit.rs
+++ b/tests/ui/impl-trait/precise-capturing/apit.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 fn hello(_: impl Sized + use<>) {}
 //~^ ERROR `use<...>` precise capturing syntax not allowed in argument-position `impl Trait`
 
diff --git a/tests/ui/impl-trait/precise-capturing/apit.stderr b/tests/ui/impl-trait/precise-capturing/apit.stderr
index 1d6225a1ff8d2..7573e0838ab46 100644
--- a/tests/ui/impl-trait/precise-capturing/apit.stderr
+++ b/tests/ui/impl-trait/precise-capturing/apit.stderr
@@ -1,5 +1,5 @@
 error: `use<...>` precise capturing syntax not allowed in argument-position `impl Trait`
-  --> $DIR/apit.rs:3:26
+  --> $DIR/apit.rs:1:26
    |
 LL | fn hello(_: impl Sized + use<>) {}
    |                          ^^^^^
diff --git a/tests/ui/impl-trait/precise-capturing/bad-lifetimes.rs b/tests/ui/impl-trait/precise-capturing/bad-lifetimes.rs
index d2d4570c570eb..161fe23c89995 100644
--- a/tests/ui/impl-trait/precise-capturing/bad-lifetimes.rs
+++ b/tests/ui/impl-trait/precise-capturing/bad-lifetimes.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 fn no_elided_lt() -> impl Sized + use<'_> {}
 //~^ ERROR missing lifetime specifier
 //~| ERROR expected lifetime parameter in `use<...>` precise captures list, found `'_`
diff --git a/tests/ui/impl-trait/precise-capturing/bad-lifetimes.stderr b/tests/ui/impl-trait/precise-capturing/bad-lifetimes.stderr
index 550996ab5e57c..a8acecf10c7b2 100644
--- a/tests/ui/impl-trait/precise-capturing/bad-lifetimes.stderr
+++ b/tests/ui/impl-trait/precise-capturing/bad-lifetimes.stderr
@@ -1,5 +1,5 @@
 error[E0106]: missing lifetime specifier
-  --> $DIR/bad-lifetimes.rs:3:39
+  --> $DIR/bad-lifetimes.rs:1:39
    |
 LL | fn no_elided_lt() -> impl Sized + use<'_> {}
    |                                       ^^ expected named lifetime parameter
@@ -11,7 +11,7 @@ LL | fn no_elided_lt() -> impl Sized + use<'static> {}
    |                                       ~~~~~~~
 
 error[E0261]: use of undeclared lifetime name `'missing`
-  --> $DIR/bad-lifetimes.rs:10:37
+  --> $DIR/bad-lifetimes.rs:8:37
    |
 LL | fn missing_lt() -> impl Sized + use<'missing> {}
    |              -                      ^^^^^^^^ undeclared lifetime
@@ -19,13 +19,13 @@ LL | fn missing_lt() -> impl Sized + use<'missing> {}
    |              help: consider introducing lifetime `'missing` here: `<'missing>`
 
 error: expected lifetime parameter in `use<...>` precise captures list, found `'_`
-  --> $DIR/bad-lifetimes.rs:3:39
+  --> $DIR/bad-lifetimes.rs:1:39
    |
 LL | fn no_elided_lt() -> impl Sized + use<'_> {}
    |                                       ^^
 
 error: expected lifetime parameter in `use<...>` precise captures list, found `'static`
-  --> $DIR/bad-lifetimes.rs:7:36
+  --> $DIR/bad-lifetimes.rs:5:36
    |
 LL | fn static_lt() -> impl Sized + use<'static> {}
    |                                    ^^^^^^^
diff --git a/tests/ui/impl-trait/precise-capturing/bad-params.rs b/tests/ui/impl-trait/precise-capturing/bad-params.rs
index 08eee67c0e579..17b517abd74e4 100644
--- a/tests/ui/impl-trait/precise-capturing/bad-params.rs
+++ b/tests/ui/impl-trait/precise-capturing/bad-params.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 fn missing() -> impl Sized + use<T> {}
 //~^ ERROR cannot find type `T` in this scope
 
diff --git a/tests/ui/impl-trait/precise-capturing/bad-params.stderr b/tests/ui/impl-trait/precise-capturing/bad-params.stderr
index e104f115aa3f2..06ccf35694811 100644
--- a/tests/ui/impl-trait/precise-capturing/bad-params.stderr
+++ b/tests/ui/impl-trait/precise-capturing/bad-params.stderr
@@ -1,5 +1,5 @@
 error[E0412]: cannot find type `T` in this scope
-  --> $DIR/bad-params.rs:3:34
+  --> $DIR/bad-params.rs:1:34
    |
 LL | fn missing() -> impl Sized + use<T> {}
    |                                  ^ not found in this scope
@@ -10,7 +10,7 @@ LL | fn missing<T>() -> impl Sized + use<T> {}
    |           +++
 
 error[E0411]: cannot find type `Self` in this scope
-  --> $DIR/bad-params.rs:6:39
+  --> $DIR/bad-params.rs:4:39
    |
 LL | fn missing_self() -> impl Sized + use<Self> {}
    |    ------------                       ^^^^ `Self` is only available in impls, traits, and type definitions
@@ -18,7 +18,7 @@ LL | fn missing_self() -> impl Sized + use<Self> {}
    |    `Self` not allowed in a function
 
 error: `Self` can't be captured in `use<...>` precise captures list, since it is an alias
-  --> $DIR/bad-params.rs:11:48
+  --> $DIR/bad-params.rs:9:48
    |
 LL | impl MyType {
    | ----------- `Self` is not a generic argument, but an alias to the type of the implementation
@@ -26,7 +26,7 @@ LL |     fn self_is_not_param() -> impl Sized + use<Self> {}
    |                                                ^^^^
 
 error: expected type or const parameter in `use<...>` precise captures list, found function
-  --> $DIR/bad-params.rs:15:32
+  --> $DIR/bad-params.rs:13:32
    |
 LL | fn hello() -> impl Sized + use<hello> {}
    |                                ^^^^^
diff --git a/tests/ui/impl-trait/precise-capturing/bound-modifiers.rs b/tests/ui/impl-trait/precise-capturing/bound-modifiers.rs
index 15f2188262869..4769581466898 100644
--- a/tests/ui/impl-trait/precise-capturing/bound-modifiers.rs
+++ b/tests/ui/impl-trait/precise-capturing/bound-modifiers.rs
@@ -1,7 +1,5 @@
 //@ edition: 2021
 
-#![feature(precise_capturing)]
-
 fn polarity() -> impl Sized + ?use<> {}
 //~^ ERROR expected identifier, found keyword `use`
 //~| ERROR cannot find trait `r#use` in this scope
diff --git a/tests/ui/impl-trait/precise-capturing/bound-modifiers.stderr b/tests/ui/impl-trait/precise-capturing/bound-modifiers.stderr
index 4602225e7b922..aaebfe2a86e55 100644
--- a/tests/ui/impl-trait/precise-capturing/bound-modifiers.stderr
+++ b/tests/ui/impl-trait/precise-capturing/bound-modifiers.stderr
@@ -1,53 +1,53 @@
 error: expected identifier, found keyword `use`
-  --> $DIR/bound-modifiers.rs:5:32
+  --> $DIR/bound-modifiers.rs:3:32
    |
 LL | fn polarity() -> impl Sized + ?use<> {}
    |                                ^^^ expected identifier, found keyword
 
 error: expected identifier, found keyword `use`
-  --> $DIR/bound-modifiers.rs:11:38
+  --> $DIR/bound-modifiers.rs:9:38
    |
 LL | fn asyncness() -> impl Sized + async use<> {}
    |                                      ^^^ expected identifier, found keyword
 
 error: expected identifier, found keyword `use`
-  --> $DIR/bound-modifiers.rs:16:38
+  --> $DIR/bound-modifiers.rs:14:38
    |
 LL | fn constness() -> impl Sized + const use<> {}
    |                                      ^^^ expected identifier, found keyword
 
 error: expected identifier, found keyword `use`
-  --> $DIR/bound-modifiers.rs:21:37
+  --> $DIR/bound-modifiers.rs:19:37
    |
 LL | fn binder() -> impl Sized + for<'a> use<> {}
    |                                     ^^^ expected identifier, found keyword
 
 error[E0405]: cannot find trait `r#use` in this scope
-  --> $DIR/bound-modifiers.rs:5:32
+  --> $DIR/bound-modifiers.rs:3:32
    |
 LL | fn polarity() -> impl Sized + ?use<> {}
    |                                ^^^ not found in this scope
 
 error[E0405]: cannot find trait `r#use` in this scope
-  --> $DIR/bound-modifiers.rs:11:38
+  --> $DIR/bound-modifiers.rs:9:38
    |
 LL | fn asyncness() -> impl Sized + async use<> {}
    |                                      ^^^ not found in this scope
 
 error[E0405]: cannot find trait `r#use` in this scope
-  --> $DIR/bound-modifiers.rs:16:38
+  --> $DIR/bound-modifiers.rs:14:38
    |
 LL | fn constness() -> impl Sized + const use<> {}
    |                                      ^^^ not found in this scope
 
 error[E0405]: cannot find trait `r#use` in this scope
-  --> $DIR/bound-modifiers.rs:21:37
+  --> $DIR/bound-modifiers.rs:19:37
    |
 LL | fn binder() -> impl Sized + for<'a> use<> {}
    |                                     ^^^ not found in this scope
 
 error[E0658]: async closures are unstable
-  --> $DIR/bound-modifiers.rs:11:32
+  --> $DIR/bound-modifiers.rs:9:32
    |
 LL | fn asyncness() -> impl Sized + async use<> {}
    |                                ^^^^^
@@ -58,7 +58,7 @@ LL | fn asyncness() -> impl Sized + async use<> {}
    = help: to use an async block, remove the `||`: `async {`
 
 error[E0658]: const trait impls are experimental
-  --> $DIR/bound-modifiers.rs:16:32
+  --> $DIR/bound-modifiers.rs:14:32
    |
 LL | fn constness() -> impl Sized + const use<> {}
    |                                ^^^^^
@@ -68,13 +68,13 @@ LL | fn constness() -> impl Sized + const use<> {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 warning: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/bound-modifiers.rs:5:31
+  --> $DIR/bound-modifiers.rs:3:31
    |
 LL | fn polarity() -> impl Sized + ?use<> {}
    |                               ^^^^^^
 
 warning: relaxing a default bound only does something for `?Sized`; all other traits are not bound by default
-  --> $DIR/bound-modifiers.rs:5:31
+  --> $DIR/bound-modifiers.rs:3:31
    |
 LL | fn polarity() -> impl Sized + ?use<> {}
    |                               ^^^^^^
diff --git a/tests/ui/impl-trait/precise-capturing/capture-parent-arg.rs b/tests/ui/impl-trait/precise-capturing/capture-parent-arg.rs
index 82b953bfed4b4..c41f136b96f10 100644
--- a/tests/ui/impl-trait/precise-capturing/capture-parent-arg.rs
+++ b/tests/ui/impl-trait/precise-capturing/capture-parent-arg.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 trait Tr {
     type Assoc;
 }
diff --git a/tests/ui/impl-trait/precise-capturing/capture-parent-arg.stderr b/tests/ui/impl-trait/precise-capturing/capture-parent-arg.stderr
index b521ee0a90237..f02b8d7c85087 100644
--- a/tests/ui/impl-trait/precise-capturing/capture-parent-arg.stderr
+++ b/tests/ui/impl-trait/precise-capturing/capture-parent-arg.stderr
@@ -1,5 +1,5 @@
 error: `impl Trait` captures lifetime parameter, but it is not mentioned in `use<...>` precise captures list
-  --> $DIR/capture-parent-arg.rs:27:31
+  --> $DIR/capture-parent-arg.rs:25:31
    |
 LL | impl<'a> W<'a> {
    |      -- this lifetime parameter is captured
@@ -7,7 +7,7 @@ LL |     fn bad1() -> impl Into<<W<'a> as Tr>::Assoc> + use<> {}
    |                  -------------^^------------------------ lifetime captured due to being mentioned in the bounds of the `impl Trait`
 
 error: `impl Trait` captures lifetime parameter, but it is not mentioned in `use<...>` precise captures list
-  --> $DIR/capture-parent-arg.rs:33:18
+  --> $DIR/capture-parent-arg.rs:31:18
    |
 LL | impl<'a> W<'a> {
    |      -- this lifetime parameter is captured
diff --git a/tests/ui/impl-trait/precise-capturing/duplicated-use.real.stderr b/tests/ui/impl-trait/precise-capturing/duplicated-use.real.stderr
index d8edd672b48c6..95132c611e51b 100644
--- a/tests/ui/impl-trait/precise-capturing/duplicated-use.real.stderr
+++ b/tests/ui/impl-trait/precise-capturing/duplicated-use.real.stderr
@@ -1,5 +1,5 @@
 error: duplicate `use<...>` precise capturing syntax
-  --> $DIR/duplicated-use.rs:7:32
+  --> $DIR/duplicated-use.rs:5:32
    |
 LL | fn hello<'a>() -> impl Sized + use<'a> + use<'a> {}
    |                                ^^^^^^^   ------- second `use<...>` here
diff --git a/tests/ui/impl-trait/precise-capturing/duplicated-use.rs b/tests/ui/impl-trait/precise-capturing/duplicated-use.rs
index bfbdcdbf311d3..b5632dc157766 100644
--- a/tests/ui/impl-trait/precise-capturing/duplicated-use.rs
+++ b/tests/ui/impl-trait/precise-capturing/duplicated-use.rs
@@ -1,8 +1,6 @@
 //@ revisions: real pre_expansion
 //@[pre_expansion] check-pass
 
-#![feature(precise_capturing)]
-
 #[cfg(real)]
 fn hello<'a>() -> impl Sized + use<'a> + use<'a> {}
 //[real]~^ ERROR duplicate `use<...>` precise capturing syntax
diff --git a/tests/ui/impl-trait/precise-capturing/dyn-use.rs b/tests/ui/impl-trait/precise-capturing/dyn-use.rs
index ce7a0f3c7b211..fb2f83e2d21cf 100644
--- a/tests/ui/impl-trait/precise-capturing/dyn-use.rs
+++ b/tests/ui/impl-trait/precise-capturing/dyn-use.rs
@@ -1,4 +1,2 @@
-#![feature(precise_capturing)]
-
 fn dyn() -> &'static dyn use<> { &() }
 //~^ ERROR expected one of `!`, `(`, `::`, `<`, `where`, or `{`, found keyword `use`
diff --git a/tests/ui/impl-trait/precise-capturing/dyn-use.stderr b/tests/ui/impl-trait/precise-capturing/dyn-use.stderr
index 5519633de1f7b..d8903fc412910 100644
--- a/tests/ui/impl-trait/precise-capturing/dyn-use.stderr
+++ b/tests/ui/impl-trait/precise-capturing/dyn-use.stderr
@@ -1,5 +1,5 @@
 error: expected one of `!`, `(`, `::`, `<`, `where`, or `{`, found keyword `use`
-  --> $DIR/dyn-use.rs:3:26
+  --> $DIR/dyn-use.rs:1:26
    |
 LL | fn dyn() -> &'static dyn use<> { &() }
    |                          ^^^ expected one of `!`, `(`, `::`, `<`, `where`, or `{`
diff --git a/tests/ui/impl-trait/precise-capturing/elided.rs b/tests/ui/impl-trait/precise-capturing/elided.rs
index 34d1ba620dce1..472bac9d722dd 100644
--- a/tests/ui/impl-trait/precise-capturing/elided.rs
+++ b/tests/ui/impl-trait/precise-capturing/elided.rs
@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(precise_capturing)]
-
 fn elided(x: &()) -> impl Sized + use<'_> { x }
 
 fn main() {}
diff --git a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-const.rs b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-const.rs
index 26d29e456eaa2..2bf2e5fef18f5 100644
--- a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-const.rs
+++ b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-const.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 fn constant<const C: usize>() -> impl Sized + use<> {}
 //~^ ERROR `impl Trait` must mention all const parameters in scope
 
diff --git a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-const.stderr b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-const.stderr
index 989ed136d4c37..e8fab0a8ad6c9 100644
--- a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-const.stderr
+++ b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-const.stderr
@@ -1,5 +1,5 @@
 error: `impl Trait` must mention all const parameters in scope in `use<...>`
-  --> $DIR/forgot-to-capture-const.rs:3:34
+  --> $DIR/forgot-to-capture-const.rs:1:34
    |
 LL | fn constant<const C: usize>() -> impl Sized + use<> {}
    |             --------------       ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-lifetime.rs b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-lifetime.rs
index f18dbca6c5efc..64bac0c8acaad 100644
--- a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-lifetime.rs
+++ b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-lifetime.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 fn lifetime_in_bounds<'a>(x: &'a ()) -> impl Into<&'a ()> + use<> { x }
 //~^ ERROR `impl Trait` captures lifetime parameter, but it is not mentioned in `use<...>` precise captures list
 
diff --git a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-lifetime.stderr b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-lifetime.stderr
index 979c0ca6d7b6e..907ed00f8c049 100644
--- a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-lifetime.stderr
+++ b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-lifetime.stderr
@@ -1,5 +1,5 @@
 error: `impl Trait` captures lifetime parameter, but it is not mentioned in `use<...>` precise captures list
-  --> $DIR/forgot-to-capture-lifetime.rs:3:52
+  --> $DIR/forgot-to-capture-lifetime.rs:1:52
    |
 LL | fn lifetime_in_bounds<'a>(x: &'a ()) -> impl Into<&'a ()> + use<> { x }
    |                       --                -----------^^------------
@@ -8,7 +8,7 @@ LL | fn lifetime_in_bounds<'a>(x: &'a ()) -> impl Into<&'a ()> + use<> { x }
    |                       this lifetime parameter is captured
 
 error[E0700]: hidden type for `impl Sized` captures lifetime that does not appear in bounds
-  --> $DIR/forgot-to-capture-lifetime.rs:6:62
+  --> $DIR/forgot-to-capture-lifetime.rs:4:62
    |
 LL | fn lifetime_in_hidden<'a>(x: &'a ()) -> impl Sized + use<> { x }
    |                       --                ------------------   ^
diff --git a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-type.rs b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-type.rs
index 0028a45cbf3f2..9d68819f657db 100644
--- a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-type.rs
+++ b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-type.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 fn type_param<T>() -> impl Sized + use<> {}
 //~^ ERROR `impl Trait` must mention all type parameters in scope
 
diff --git a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-type.stderr b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-type.stderr
index 89bd4df443106..d9be9d543e450 100644
--- a/tests/ui/impl-trait/precise-capturing/forgot-to-capture-type.stderr
+++ b/tests/ui/impl-trait/precise-capturing/forgot-to-capture-type.stderr
@@ -1,5 +1,5 @@
 error: `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
-  --> $DIR/forgot-to-capture-type.rs:7:30
+  --> $DIR/forgot-to-capture-type.rs:5:30
    |
 LL |     fn bar() -> impl Sized + use<>;
    |                              ^^^^^
@@ -7,7 +7,7 @@ LL |     fn bar() -> impl Sized + use<>;
    = note: currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
 
 error: `impl Trait` must mention all type parameters in scope in `use<...>`
-  --> $DIR/forgot-to-capture-type.rs:3:23
+  --> $DIR/forgot-to-capture-type.rs:1:23
    |
 LL | fn type_param<T>() -> impl Sized + use<> {}
    |               -       ^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | fn type_param<T>() -> impl Sized + use<> {}
    = note: currently, all type parameters are required to be mentioned in the precise captures list
 
 error: `impl Trait` must mention the `Self` type of the trait in `use<...>`
-  --> $DIR/forgot-to-capture-type.rs:7:17
+  --> $DIR/forgot-to-capture-type.rs:5:17
    |
 LL | trait Foo {
    | --------- `Self` type parameter is implicitly captured by this `impl Trait`
diff --git a/tests/ui/impl-trait/precise-capturing/higher-ranked.rs b/tests/ui/impl-trait/precise-capturing/higher-ranked.rs
index 21ac19640bcdf..3dc8523e9635d 100644
--- a/tests/ui/impl-trait/precise-capturing/higher-ranked.rs
+++ b/tests/ui/impl-trait/precise-capturing/higher-ranked.rs
@@ -2,7 +2,7 @@
 
 // Show how precise captures allow us to skip capturing a higher-ranked lifetime
 
-#![feature(lifetime_capture_rules_2024, precise_capturing)]
+#![feature(lifetime_capture_rules_2024)]
 
 trait Trait<'a> {
     type Item;
diff --git a/tests/ui/impl-trait/precise-capturing/illegal-positions.real.stderr b/tests/ui/impl-trait/precise-capturing/illegal-positions.real.stderr
index 2b234bcb6a50f..95eb49daf28d8 100644
--- a/tests/ui/impl-trait/precise-capturing/illegal-positions.real.stderr
+++ b/tests/ui/impl-trait/precise-capturing/illegal-positions.real.stderr
@@ -1,53 +1,53 @@
 error: `use<...>` precise capturing syntax not allowed in supertrait bounds
-  --> $DIR/illegal-positions.rs:8:12
+  --> $DIR/illegal-positions.rs:6:12
    |
 LL | trait Foo: use<> {
    |            ^^^^^
 
 error: `use<...>` precise capturing syntax not allowed in bounds
-  --> $DIR/illegal-positions.rs:10:33
+  --> $DIR/illegal-positions.rs:8:33
    |
 LL |     type Assoc: use<> where (): use<>;
    |                                 ^^^^^
 
 error: `use<...>` precise capturing syntax not allowed in bounds
-  --> $DIR/illegal-positions.rs:10:17
+  --> $DIR/illegal-positions.rs:8:17
    |
 LL |     type Assoc: use<> where (): use<>;
    |                 ^^^^^
 
 error: `use<...>` precise capturing syntax not allowed in bounds
-  --> $DIR/illegal-positions.rs:16:11
+  --> $DIR/illegal-positions.rs:14:11
    |
 LL | fn fun<T: use<>>(_: impl use<>) where (): use<> {}
    |           ^^^^^
 
 error: `use<...>` precise capturing syntax not allowed in bounds
-  --> $DIR/illegal-positions.rs:16:43
+  --> $DIR/illegal-positions.rs:14:43
    |
 LL | fn fun<T: use<>>(_: impl use<>) where (): use<> {}
    |                                           ^^^^^
 
 error: at least one trait must be specified
-  --> $DIR/illegal-positions.rs:16:21
+  --> $DIR/illegal-positions.rs:14:21
    |
 LL | fn fun<T: use<>>(_: impl use<>) where (): use<> {}
    |                     ^^^^^^^^^^
 
 error: `use<...>` precise capturing syntax not allowed in `dyn` trait object bounds
-  --> $DIR/illegal-positions.rs:23:25
+  --> $DIR/illegal-positions.rs:21:25
    |
 LL | fn dynamic() -> Box<dyn use<>> {}
    |                         ^^^^^
 
 error: `use<...>` precise capturing syntax not allowed in argument-position `impl Trait`
-  --> $DIR/illegal-positions.rs:16:26
+  --> $DIR/illegal-positions.rs:14:26
    |
 LL | fn fun<T: use<>>(_: impl use<>) where (): use<> {}
    |                          ^^^^^
 
 error[E0224]: at least one trait is required for an object type
-  --> $DIR/illegal-positions.rs:23:21
+  --> $DIR/illegal-positions.rs:21:21
    |
 LL | fn dynamic() -> Box<dyn use<>> {}
    |                     ^^^^^^^^^
diff --git a/tests/ui/impl-trait/precise-capturing/illegal-positions.rs b/tests/ui/impl-trait/precise-capturing/illegal-positions.rs
index 681458e25f801..d446a50d92d3b 100644
--- a/tests/ui/impl-trait/precise-capturing/illegal-positions.rs
+++ b/tests/ui/impl-trait/precise-capturing/illegal-positions.rs
@@ -2,8 +2,6 @@
 //@[pre_expansion] check-pass
 //@ edition: 2021
 
-#![feature(precise_capturing)]
-
 #[cfg(real)]
 trait Foo: use<> {
     //[real]~^ ERROR `use<...>` precise capturing syntax not allowed
diff --git a/tests/ui/impl-trait/precise-capturing/ordering.rs b/tests/ui/impl-trait/precise-capturing/ordering.rs
index eb570a120cc46..20638e0a623ea 100644
--- a/tests/ui/impl-trait/precise-capturing/ordering.rs
+++ b/tests/ui/impl-trait/precise-capturing/ordering.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 fn lt<'a>() -> impl Sized + use<'a, 'a> {}
 //~^ ERROR cannot capture parameter `'a` twice
 
diff --git a/tests/ui/impl-trait/precise-capturing/ordering.stderr b/tests/ui/impl-trait/precise-capturing/ordering.stderr
index ecd47159059b4..05dec2d5c5ac9 100644
--- a/tests/ui/impl-trait/precise-capturing/ordering.stderr
+++ b/tests/ui/impl-trait/precise-capturing/ordering.stderr
@@ -1,23 +1,23 @@
 error: cannot capture parameter `'a` twice
-  --> $DIR/ordering.rs:3:33
+  --> $DIR/ordering.rs:1:33
    |
 LL | fn lt<'a>() -> impl Sized + use<'a, 'a> {}
    |                                 ^^  -- parameter captured again here
 
 error: cannot capture parameter `T` twice
-  --> $DIR/ordering.rs:6:32
+  --> $DIR/ordering.rs:4:32
    |
 LL | fn ty<T>() -> impl Sized + use<T, T> {}
    |                                ^  - parameter captured again here
 
 error: cannot capture parameter `N` twice
-  --> $DIR/ordering.rs:9:45
+  --> $DIR/ordering.rs:7:45
    |
 LL | fn ct<const N: usize>() -> impl Sized + use<N, N> {}
    |                                             ^  - parameter captured again here
 
 error: lifetime parameter `'a` must be listed before non-lifetime parameters
-  --> $DIR/ordering.rs:12:45
+  --> $DIR/ordering.rs:10:45
    |
 LL | fn ordering<'a, T>() -> impl Sized + use<T, 'a> {}
    |                                          -  ^^
diff --git a/tests/ui/impl-trait/precise-capturing/outlives.rs b/tests/ui/impl-trait/precise-capturing/outlives.rs
index 26ac922b5b9d7..f86a61be1e078 100644
--- a/tests/ui/impl-trait/precise-capturing/outlives.rs
+++ b/tests/ui/impl-trait/precise-capturing/outlives.rs
@@ -2,7 +2,7 @@
 
 // Show that precise captures allow us to skip a lifetime param for outlives
 
-#![feature(lifetime_capture_rules_2024, precise_capturing)]
+#![feature(lifetime_capture_rules_2024)]
 
 fn hello<'a: 'a, 'b: 'b>() -> impl Sized + use<'a> { }
 
diff --git a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.fixed b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.fixed
index 5ac296a9cbdf0..6bca8ef12ecc3 100644
--- a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.fixed
+++ b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.fixed
@@ -1,7 +1,6 @@
 //@ run-rustfix
 
-#![feature(precise_capturing)]
-#![allow(unused, incomplete_features)]
+#![allow(unused)]
 #![deny(impl_trait_overcaptures)]
 
 fn named<'a>(x: &'a i32) -> impl Sized + use<> { *x }
diff --git a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.rs b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.rs
index e4b7828d60ffd..5b6726b49e025 100644
--- a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.rs
+++ b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.rs
@@ -1,7 +1,6 @@
 //@ run-rustfix
 
-#![feature(precise_capturing)]
-#![allow(unused, incomplete_features)]
+#![allow(unused)]
 #![deny(impl_trait_overcaptures)]
 
 fn named<'a>(x: &'a i32) -> impl Sized { *x }
diff --git a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.stderr b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.stderr
index f8bb7f099af9e..fec640aa83aa9 100644
--- a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.stderr
+++ b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.stderr
@@ -1,17 +1,17 @@
 error: `impl Sized` will capture more lifetimes than possibly intended in edition 2024
-  --> $DIR/overcaptures-2024.rs:7:29
+  --> $DIR/overcaptures-2024.rs:6:29
    |
 LL | fn named<'a>(x: &'a i32) -> impl Sized { *x }
    |                             ^^^^^^^^^^
    |
 note: specifically, this lifetime is in scope but not mentioned in the type's bounds
-  --> $DIR/overcaptures-2024.rs:7:10
+  --> $DIR/overcaptures-2024.rs:6:10
    |
 LL | fn named<'a>(x: &'a i32) -> impl Sized { *x }
    |          ^^
    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
 note: the lint level is defined here
-  --> $DIR/overcaptures-2024.rs:5:9
+  --> $DIR/overcaptures-2024.rs:4:9
    |
 LL | #![deny(impl_trait_overcaptures)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^
@@ -21,13 +21,13 @@ LL | fn named<'a>(x: &'a i32) -> impl Sized + use<> { *x }
    |                                        +++++++
 
 error: `impl Sized` will capture more lifetimes than possibly intended in edition 2024
-  --> $DIR/overcaptures-2024.rs:10:25
+  --> $DIR/overcaptures-2024.rs:9:25
    |
 LL | fn implicit(x: &i32) -> impl Sized { *x }
    |                         ^^^^^^^^^^
    |
 note: specifically, this lifetime is in scope but not mentioned in the type's bounds
-  --> $DIR/overcaptures-2024.rs:10:16
+  --> $DIR/overcaptures-2024.rs:9:16
    |
 LL | fn implicit(x: &i32) -> impl Sized { *x }
    |                ^
@@ -38,13 +38,13 @@ LL | fn implicit(x: &i32) -> impl Sized + use<> { *x }
    |                                    +++++++
 
 error: `impl Sized + '_` will capture more lifetimes than possibly intended in edition 2024
-  --> $DIR/overcaptures-2024.rs:15:33
+  --> $DIR/overcaptures-2024.rs:14:33
    |
 LL |     fn hello(&self, x: &i32) -> impl Sized + '_ { self }
    |                                 ^^^^^^^^^^^^^^^
    |
 note: specifically, this lifetime is in scope but not mentioned in the type's bounds
-  --> $DIR/overcaptures-2024.rs:15:24
+  --> $DIR/overcaptures-2024.rs:14:24
    |
 LL |     fn hello(&self, x: &i32) -> impl Sized + '_ { self }
    |                        ^
@@ -55,13 +55,13 @@ LL |     fn hello(&self, x: &i32) -> impl Sized + '_ + use<'_> { self }
    |                                                 +++++++++
 
 error: `impl Sized` will capture more lifetimes than possibly intended in edition 2024
-  --> $DIR/overcaptures-2024.rs:26:47
+  --> $DIR/overcaptures-2024.rs:25:47
    |
 LL | fn hrtb() -> impl for<'a> Higher<'a, Output = impl Sized> {}
    |                                               ^^^^^^^^^^
    |
 note: specifically, this lifetime is in scope but not mentioned in the type's bounds
-  --> $DIR/overcaptures-2024.rs:26:23
+  --> $DIR/overcaptures-2024.rs:25:23
    |
 LL | fn hrtb() -> impl for<'a> Higher<'a, Output = impl Sized> {}
    |                       ^^
diff --git a/tests/ui/impl-trait/precise-capturing/redundant.normal.stderr b/tests/ui/impl-trait/precise-capturing/redundant.normal.stderr
index 44bc9f7daad8d..d1bcbaa33ae2b 100644
--- a/tests/ui/impl-trait/precise-capturing/redundant.normal.stderr
+++ b/tests/ui/impl-trait/precise-capturing/redundant.normal.stderr
@@ -1,5 +1,5 @@
 warning: all possible in-scope parameters are already captured, so `use<...>` syntax is redundant
-  --> $DIR/redundant.rs:7:19
+  --> $DIR/redundant.rs:5:19
    |
 LL | fn hello<'a>() -> impl Sized + use<'a> {}
    |                   ^^^^^^^^^^^^^-------
@@ -9,7 +9,7 @@ LL | fn hello<'a>() -> impl Sized + use<'a> {}
    = note: `#[warn(impl_trait_redundant_captures)]` on by default
 
 warning: all possible in-scope parameters are already captured, so `use<...>` syntax is redundant
-  --> $DIR/redundant.rs:12:27
+  --> $DIR/redundant.rs:10:27
    |
 LL |     fn inherent(&self) -> impl Sized + use<'_> {}
    |                           ^^^^^^^^^^^^^-------
diff --git a/tests/ui/impl-trait/precise-capturing/redundant.rpitit.stderr b/tests/ui/impl-trait/precise-capturing/redundant.rpitit.stderr
index 9aa73353126cd..213888356e572 100644
--- a/tests/ui/impl-trait/precise-capturing/redundant.rpitit.stderr
+++ b/tests/ui/impl-trait/precise-capturing/redundant.rpitit.stderr
@@ -1,5 +1,5 @@
 error: `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
-  --> $DIR/redundant.rs:18:35
+  --> $DIR/redundant.rs:16:35
    |
 LL |     fn in_trait() -> impl Sized + use<'a, Self>;
    |                                   ^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     fn in_trait() -> impl Sized + use<'a, Self>;
    = note: currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
 
 error: `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
-  --> $DIR/redundant.rs:23:35
+  --> $DIR/redundant.rs:21:35
    |
 LL |     fn in_trait() -> impl Sized + use<'a> {}
    |                                   ^^^^^^^
diff --git a/tests/ui/impl-trait/precise-capturing/redundant.rs b/tests/ui/impl-trait/precise-capturing/redundant.rs
index ef4f05bd7e458..4a08ffb61be03 100644
--- a/tests/ui/impl-trait/precise-capturing/redundant.rs
+++ b/tests/ui/impl-trait/precise-capturing/redundant.rs
@@ -2,8 +2,6 @@
 //@ revisions: normal rpitit
 //@[normal] check-pass
 
-#![feature(precise_capturing)]
-
 fn hello<'a>() -> impl Sized + use<'a> {}
 //[normal]~^ WARN all possible in-scope parameters are already captured
 
diff --git a/tests/ui/impl-trait/precise-capturing/rpitit.rs b/tests/ui/impl-trait/precise-capturing/rpitit.rs
index 4eb053573e1f2..feeeb1461e827 100644
--- a/tests/ui/impl-trait/precise-capturing/rpitit.rs
+++ b/tests/ui/impl-trait/precise-capturing/rpitit.rs
@@ -5,8 +5,6 @@
 // To fix this soundly, we need to make sure that all the trait header args
 // remain captured, since they affect trait selection.
 
-#![feature(precise_capturing)]
-
 trait Foo<'a> {
     fn hello() -> impl PartialEq + use<Self>;
 }
diff --git a/tests/ui/impl-trait/precise-capturing/rpitit.stderr b/tests/ui/impl-trait/precise-capturing/rpitit.stderr
index 45eceef2f494b..5a120df9f047a 100644
--- a/tests/ui/impl-trait/precise-capturing/rpitit.stderr
+++ b/tests/ui/impl-trait/precise-capturing/rpitit.stderr
@@ -1,5 +1,5 @@
 error: `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
-  --> $DIR/rpitit.rs:11:36
+  --> $DIR/rpitit.rs:9:36
    |
 LL |     fn hello() -> impl PartialEq + use<Self>;
    |                                    ^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     fn hello() -> impl PartialEq + use<Self>;
    = note: currently, return-position `impl Trait` in traits and trait implementations capture all lifetimes in scope
 
 error: `impl Trait` captures lifetime parameter, but it is not mentioned in `use<...>` precise captures list
-  --> $DIR/rpitit.rs:11:19
+  --> $DIR/rpitit.rs:9:19
    |
 LL | trait Foo<'a> {
    |           -- this lifetime parameter is captured
@@ -15,7 +15,7 @@ LL |     fn hello() -> impl PartialEq + use<Self>;
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ lifetime captured due to being mentioned in the bounds of the `impl Trait`
 
 error: lifetime may not live long enough
-  --> $DIR/rpitit.rs:15:5
+  --> $DIR/rpitit.rs:13:5
    |
 LL |   fn test<'a, 'b, T: for<'r> Foo<'r>>() {
    |           --  -- lifetime `'b` defined here
@@ -30,7 +30,7 @@ LL | |     );
    = help: consider adding the following bound: `'a: 'b`
 
 error: lifetime may not live long enough
-  --> $DIR/rpitit.rs:15:5
+  --> $DIR/rpitit.rs:13:5
    |
 LL |   fn test<'a, 'b, T: for<'r> Foo<'r>>() {
    |           --  -- lifetime `'b` defined here
diff --git a/tests/ui/impl-trait/precise-capturing/self-capture.rs b/tests/ui/impl-trait/precise-capturing/self-capture.rs
index 07bb417f9f7f1..a61a7f06edc1d 100644
--- a/tests/ui/impl-trait/precise-capturing/self-capture.rs
+++ b/tests/ui/impl-trait/precise-capturing/self-capture.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 trait Foo {
     fn bar<'a>() -> impl Sized + use<Self>;
     //~^ ERROR `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
diff --git a/tests/ui/impl-trait/precise-capturing/self-capture.stderr b/tests/ui/impl-trait/precise-capturing/self-capture.stderr
index 351de86dd5fa6..c1974600f30c5 100644
--- a/tests/ui/impl-trait/precise-capturing/self-capture.stderr
+++ b/tests/ui/impl-trait/precise-capturing/self-capture.stderr
@@ -1,5 +1,5 @@
 error: `use<...>` precise capturing syntax is currently not allowed in return-position `impl Trait` in traits
-  --> $DIR/self-capture.rs:4:34
+  --> $DIR/self-capture.rs:2:34
    |
 LL |     fn bar<'a>() -> impl Sized + use<Self>;
    |                                  ^^^^^^^^^

From 84044cd50f3db13defbd96e6720da62140679a25 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Fri, 12 Jul 2024 22:10:29 -0400
Subject: [PATCH 372/685] Bless test fallout

---
 .../src/error_reporting/infer/region.rs       | 22 ++--------
 .../ret-impl-trait-one.stderr                 |  6 +--
 .../alias-liveness/opaque-type-param.stderr   |  5 +++
 .../generic_const_exprs/issue-109141.stderr   |  6 +--
 ...re-gate-lifetime-capture-rules-2024.stderr |  6 +--
 .../rpit-hidden-erased-unsoundness.stderr     |  6 +--
 .../rpit-hide-lifetime-for-swap.stderr        |  6 +--
 tests/ui/impl-trait/hidden-lifetimes.stderr   | 12 +++---
 .../in-trait/cannot-capture-intersection.rs   |  2 -
 .../cannot-capture-intersection.stderr        |  2 +-
 .../must_outlive_least_region_or_bound.stderr | 18 ++++-----
 .../ui/impl-trait/nested-return-type4.stderr  | 10 ++---
 .../hidden-type-suggestion.rs                 |  2 -
 .../hidden-type-suggestion.stderr             | 16 ++++----
 .../impl-trait/region-escape-via-bound.stderr |  6 +--
 .../static-return-lifetime-infered.stderr     | 12 +++---
 tests/ui/lifetimes/issue-105227.fixed         | 26 ------------
 tests/ui/lifetimes/issue-105227.rs            | 16 ++++----
 tests/ui/lifetimes/issue-105227.stderr        | 33 +++++++--------
 tests/ui/nll/issue-73159-rpit-static.stderr   |  5 +++
 .../min-choice-reject-ambiguous.stderr        |  6 +--
 .../nested-impl-trait-fail.stderr             | 40 ++++++-------------
 ...insensitive-scopes-issue-116657.nll.stderr |  6 +--
 ...sitive-scopes-issue-116657.polonius.stderr |  6 +--
 .../ty-outlives/impl-trait-captures.stderr    |  6 +--
 ...types_pin_lifetime_impl_trait-async.stderr |  6 +--
 ..._self_types_pin_lifetime_impl_trait.stderr |  6 +--
 .../missing-lifetimes-in-signature.stderr     |  6 +--
 .../different_args_considered_equal2.stderr   |  5 ---
 .../imply_bounds_from_bounds_param.stderr     |  6 +--
 30 files changed, 124 insertions(+), 186 deletions(-)
 delete mode 100644 tests/ui/lifetimes/issue-105227.fixed

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
index 3cee8ff5f4c07..877a8a23d7f2b 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
@@ -17,8 +17,8 @@ use rustc_span::{BytePos, ErrorGuaranteed, Span, Symbol};
 use rustc_type_ir::Upcast as _;
 
 use super::nice_region_error::find_anon_type;
-use super::{nice_region_error, ObligationCauseAsDiagArg};
-use crate::error_reporting::infer::ObligationCauseExt as _;
+use super::ObligationCauseAsDiagArg;
+use crate::error_reporting::infer::ObligationCauseExt;
 use crate::error_reporting::TypeErrCtxt;
 use crate::errors::{
     self, note_and_explain, FulfillReqLifetime, LfBoundNotSatisfied, OutlivesBound,
@@ -1212,22 +1212,8 @@ pub fn unexpected_hidden_region_diagnostic<'a, 'tcx>(
                 hidden_region,
                 "",
             );
-            if let Some(reg_info) = tcx.is_suitable_region(generic_param_scope, hidden_region) {
-                if infcx.tcx.features().precise_capturing {
-                    suggest_precise_capturing(tcx, opaque_ty_key.def_id, hidden_region, &mut err);
-                } else {
-                    let fn_returns = tcx.return_type_impl_or_dyn_traits(reg_info.def_id);
-                    nice_region_error::suggest_new_region_bound(
-                        tcx,
-                        &mut err,
-                        fn_returns,
-                        hidden_region.to_string(),
-                        None,
-                        format!("captures `{hidden_region}`"),
-                        None,
-                        Some(reg_info.def_id),
-                    )
-                }
+            if let Some(_) = tcx.is_suitable_region(generic_param_scope, hidden_region) {
+                suggest_precise_capturing(tcx, opaque_ty_key.def_id, hidden_region, &mut err);
             }
         }
         ty::RePlaceholder(_) => {
diff --git a/tests/ui/async-await/multiple-lifetimes/ret-impl-trait-one.stderr b/tests/ui/async-await/multiple-lifetimes/ret-impl-trait-one.stderr
index 5ae1d78a92b78..167b5ee4425f8 100644
--- a/tests/ui/async-await/multiple-lifetimes/ret-impl-trait-one.stderr
+++ b/tests/ui/async-await/multiple-lifetimes/ret-impl-trait-one.stderr
@@ -26,10 +26,10 @@ LL | |     (a, b)
 LL | | }
    | |_^
    |
-help: to declare that `impl Trait<'a>` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | async fn async_ret_impl_trait1<'a, 'b>(a: &'a u8, b: &'b u8) -> impl Trait<'a> + 'b {
-   |                                                                                ++++
+LL | async fn async_ret_impl_trait1<'a, 'b>(a: &'a u8, b: &'b u8) -> impl Trait<'a> + use<'a, 'b> {
+   |                                                                                +++++++++++++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/borrowck/alias-liveness/opaque-type-param.stderr b/tests/ui/borrowck/alias-liveness/opaque-type-param.stderr
index 73de58649536a..1a32d1200571c 100644
--- a/tests/ui/borrowck/alias-liveness/opaque-type-param.stderr
+++ b/tests/ui/borrowck/alias-liveness/opaque-type-param.stderr
@@ -7,6 +7,11 @@ LL | fn foo<'a>(s: &'a str) -> impl Trait + 'static {
    |        hidden type `impl Trait + 'static` captures the lifetime `'a` as defined here
 LL |     bar(s)
    |     ^^^^^^
+   |
+help: add a `use<...>` bound to explicitly capture `'a`
+   |
+LL | fn foo<'a>(s: &'a str) -> impl Trait + 'static + use<'a> {
+   |                                                +++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/generic_const_exprs/issue-109141.stderr b/tests/ui/const-generics/generic_const_exprs/issue-109141.stderr
index 7a9572d000d5a..24f3ed7cdf15e 100644
--- a/tests/ui/const-generics/generic_const_exprs/issue-109141.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/issue-109141.stderr
@@ -30,10 +30,10 @@ LL |     fn a(&self) -> impl Iterator {
 LL |         self.0.iter_mut()
    |         ^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Iterator` captures `'_`, you can add an explicit `'_` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL |     fn a(&self) -> impl Iterator + '_ {
-   |                                  ++++
+LL |     fn a(&self) -> impl Iterator + use<'_> {
+   |                                  +++++++++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/feature-gates/feature-gate-lifetime-capture-rules-2024.stderr b/tests/ui/feature-gates/feature-gate-lifetime-capture-rules-2024.stderr
index 173e3dc02cc89..d0b18df6a5e47 100644
--- a/tests/ui/feature-gates/feature-gate-lifetime-capture-rules-2024.stderr
+++ b/tests/ui/feature-gates/feature-gate-lifetime-capture-rules-2024.stderr
@@ -8,10 +8,10 @@ LL | fn foo(x: &Vec<i32>) -> impl Sized {
 LL |     x
    |     ^
    |
-help: to declare that `impl Sized` captures `'_`, you can add an explicit `'_` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL | fn foo(x: &Vec<i32>) -> impl Sized + '_ {
-   |                                    ++++
+LL | fn foo(x: &Vec<i32>) -> impl Sized + use<'_> {
+   |                                    +++++++++
 
 error: aborting due to 1 previous error
 
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 825682c52f9f3..a2d00edbb6d95 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
@@ -8,10 +8,10 @@ LL | fn step2<'a, 'b: 'a>() -> impl Sized + 'a {
 LL |     step1::<'a, 'b>()
    |     ^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Sized + 'a` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | fn step2<'a, 'b: 'a>() -> impl Sized + 'a + 'b {
-   |                                           ++++
+LL | fn step2<'a, 'b: 'a>() -> impl Sized + 'a + use<'a, 'b> {
+   |                                           +++++++++++++
 
 error: aborting due to 1 previous error
 
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 b87e31acc1253..a1e92e5338469 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
@@ -8,10 +8,10 @@ LL | fn hide<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a {
 LL |     x
    |     ^
    |
-help: to declare that `impl Swap + 'a` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | fn hide<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + 'b {
-   |                                                                          ++++
+LL | fn hide<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + use<'a, 'b, T> {
+   |                                                                          ++++++++++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/hidden-lifetimes.stderr b/tests/ui/impl-trait/hidden-lifetimes.stderr
index bc8f559fdee9e..70d8c816ecb44 100644
--- a/tests/ui/impl-trait/hidden-lifetimes.stderr
+++ b/tests/ui/impl-trait/hidden-lifetimes.stderr
@@ -8,10 +8,10 @@ LL | fn hide_ref<'a, 'b, T: 'static>(x: &'a mut &'b T) -> impl Swap + 'a {
 LL |     x
    |     ^
    |
-help: to declare that `impl Swap + 'a` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | fn hide_ref<'a, 'b, T: 'static>(x: &'a mut &'b T) -> impl Swap + 'a + 'b {
-   |                                                                     ++++
+LL | fn hide_ref<'a, 'b, T: 'static>(x: &'a mut &'b T) -> impl Swap + 'a + use<'a, 'b, T> {
+   |                                                                     ++++++++++++++++
 
 error[E0700]: hidden type for `impl Swap + 'a` captures lifetime that does not appear in bounds
   --> $DIR/hidden-lifetimes.rs:46:5
@@ -23,10 +23,10 @@ LL | fn hide_rc_refcell<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl S
 LL |     x
    |     ^
    |
-help: to declare that `impl Swap + 'a` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | fn hide_rc_refcell<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + 'b {
-   |                                                                                     ++++
+LL | fn hide_rc_refcell<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + use<'a, 'b, T> {
+   |                                                                                     ++++++++++++++++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/impl-trait/in-trait/cannot-capture-intersection.rs b/tests/ui/impl-trait/in-trait/cannot-capture-intersection.rs
index d7b62436d2d34..e00214fe8e06b 100644
--- a/tests/ui/impl-trait/in-trait/cannot-capture-intersection.rs
+++ b/tests/ui/impl-trait/in-trait/cannot-capture-intersection.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 use std::future::Future;
 use std::pin::Pin;
 
diff --git a/tests/ui/impl-trait/in-trait/cannot-capture-intersection.stderr b/tests/ui/impl-trait/in-trait/cannot-capture-intersection.stderr
index 92ef66c55043c..a8f5bfc94c1cd 100644
--- a/tests/ui/impl-trait/in-trait/cannot-capture-intersection.stderr
+++ b/tests/ui/impl-trait/in-trait/cannot-capture-intersection.stderr
@@ -1,5 +1,5 @@
 error[E0700]: hidden type for `impl Future<Output = i32>` captures lifetime that does not appear in bounds
-  --> $DIR/cannot-capture-intersection.rs:24:9
+  --> $DIR/cannot-capture-intersection.rs:22:9
    |
 LL |     fn foo<'a, 'b>(&'a self, x: &'b i32) -> impl Future<Output = i32> {
    |                                             ------------------------- opaque type defined here
diff --git a/tests/ui/impl-trait/must_outlive_least_region_or_bound.stderr b/tests/ui/impl-trait/must_outlive_least_region_or_bound.stderr
index 273f51ddbe35c..f620bf6dc389c 100644
--- a/tests/ui/impl-trait/must_outlive_least_region_or_bound.stderr
+++ b/tests/ui/impl-trait/must_outlive_least_region_or_bound.stderr
@@ -7,10 +7,10 @@ LL | fn elided(x: &i32) -> impl Copy { x }
    |              |        opaque type defined here
    |              hidden type `&i32` captures the anonymous lifetime defined here
    |
-help: to declare that `impl Copy` captures `'_`, you can add an explicit `'_` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL | fn elided(x: &i32) -> impl Copy + '_ { x }
-   |                                 ++++
+LL | fn elided(x: &i32) -> impl Copy + use<'_> { x }
+   |                                 +++++++++
 
 error[E0700]: hidden type for `impl Copy` captures lifetime that does not appear in bounds
   --> $DIR/must_outlive_least_region_or_bound.rs:6:44
@@ -21,10 +21,10 @@ LL | fn explicit<'a>(x: &'a i32) -> impl Copy { x }
    |             |                  opaque type defined here
    |             hidden type `&'a i32` captures the lifetime `'a` as defined here
    |
-help: to declare that `impl Copy` captures `'a`, you can add an explicit `'a` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'a`
    |
-LL | fn explicit<'a>(x: &'a i32) -> impl Copy + 'a { x }
-   |                                          ++++
+LL | fn explicit<'a>(x: &'a i32) -> impl Copy + use<'a> { x }
+   |                                          +++++++++
 
 error: lifetime may not live long enough
   --> $DIR/must_outlive_least_region_or_bound.rs:9:46
@@ -108,10 +108,10 @@ LL | fn move_lifetime_into_fn<'a, 'b>(x: &'a u32, y: &'b u32) -> impl Fn(&'a u32
 LL |     move |_| println!("{}", y)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Fn(&'a u32)` captures `'b`, you can add an explicit `'b` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'b`
    |
-LL | fn move_lifetime_into_fn<'a, 'b>(x: &'a u32, y: &'b u32) -> impl Fn(&'a u32) + 'b {
-   |                                                                              ++++
+LL | fn move_lifetime_into_fn<'a, 'b>(x: &'a u32, y: &'b u32) -> impl Fn(&'a u32) + use<'a, 'b> {
+   |                                                                              +++++++++++++
 
 error[E0310]: the parameter type `T` may not live long enough
   --> $DIR/must_outlive_least_region_or_bound.rs:47:5
diff --git a/tests/ui/impl-trait/nested-return-type4.stderr b/tests/ui/impl-trait/nested-return-type4.stderr
index f1e3b97be0283..407800eff1894 100644
--- a/tests/ui/impl-trait/nested-return-type4.stderr
+++ b/tests/ui/impl-trait/nested-return-type4.stderr
@@ -8,14 +8,10 @@ LL | fn test<'s: 's>(s: &'s str) -> impl std::future::Future<Output = impl Sized
 LL |     async move { let _s = s; }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Future<Output = impl Sized>` captures `'s`, you can add an explicit `'s` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'s`
    |
-LL | fn test<'s: 's>(s: &'s str) -> impl std::future::Future<Output = impl Sized> + 's {
-   |                                                                              ++++
-help: to declare that `impl Sized` captures `'s`, you can add an explicit `'s` lifetime bound
-   |
-LL | fn test<'s: 's>(s: &'s str) -> impl std::future::Future<Output = impl Sized + 's> {
-   |                                                                             ++++
+LL | fn test<'s: 's>(s: &'s str) -> impl std::future::Future<Output = impl Sized> + use<'s> {
+   |                                                                              +++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/precise-capturing/hidden-type-suggestion.rs b/tests/ui/impl-trait/precise-capturing/hidden-type-suggestion.rs
index b50780643f1cc..d34c613559611 100644
--- a/tests/ui/impl-trait/precise-capturing/hidden-type-suggestion.rs
+++ b/tests/ui/impl-trait/precise-capturing/hidden-type-suggestion.rs
@@ -1,5 +1,3 @@
-#![feature(precise_capturing)]
-
 fn lifetime<'a, 'b>(x: &'a ()) -> impl Sized + use<'b> {
 //~^ HELP add `'a` to the `use<...>` bound
     x
diff --git a/tests/ui/impl-trait/precise-capturing/hidden-type-suggestion.stderr b/tests/ui/impl-trait/precise-capturing/hidden-type-suggestion.stderr
index 1007a835894e1..b0c4cc2fea0e7 100644
--- a/tests/ui/impl-trait/precise-capturing/hidden-type-suggestion.stderr
+++ b/tests/ui/impl-trait/precise-capturing/hidden-type-suggestion.stderr
@@ -1,5 +1,5 @@
 error[E0700]: hidden type for `impl Sized` captures lifetime that does not appear in bounds
-  --> $DIR/hidden-type-suggestion.rs:5:5
+  --> $DIR/hidden-type-suggestion.rs:3:5
    |
 LL | fn lifetime<'a, 'b>(x: &'a ()) -> impl Sized + use<'b> {
    |             --                    -------------------- opaque type defined here
@@ -15,7 +15,7 @@ LL | fn lifetime<'a, 'b>(x: &'a ()) -> impl Sized + use<'b, 'a> {
    |                                                      ++++
 
 error[E0700]: hidden type for `impl Sized` captures lifetime that does not appear in bounds
-  --> $DIR/hidden-type-suggestion.rs:11:5
+  --> $DIR/hidden-type-suggestion.rs:9:5
    |
 LL | fn param<'a, T>(x: &'a ()) -> impl Sized + use<T> {
    |          --                   ------------------- opaque type defined here
@@ -31,7 +31,7 @@ LL | fn param<'a, T>(x: &'a ()) -> impl Sized + use<'a, T> {
    |                                                +++
 
 error[E0700]: hidden type for `impl Sized` captures lifetime that does not appear in bounds
-  --> $DIR/hidden-type-suggestion.rs:17:5
+  --> $DIR/hidden-type-suggestion.rs:15:5
    |
 LL | fn empty<'a>(x: &'a ()) -> impl Sized + use<> {
    |          --                ------------------ opaque type defined here
@@ -47,7 +47,7 @@ LL | fn empty<'a>(x: &'a ()) -> impl Sized + use<'a> {
    |                                             ++
 
 error[E0700]: hidden type for `impl Captures<'captured>` captures lifetime that does not appear in bounds
-  --> $DIR/hidden-type-suggestion.rs:26:5
+  --> $DIR/hidden-type-suggestion.rs:24:5
    |
 LL | fn missing<'a, 'captured, 'not_captured, Captured>(x: &'a ()) -> impl Captures<'captured> {
    |            --                                                    ------------------------ opaque type defined here
@@ -63,7 +63,7 @@ LL | fn missing<'a, 'captured, 'not_captured, Captured>(x: &'a ()) -> impl Captu
    |                                                                                           ++++++++++++++++++++++++++++++
 
 error[E0700]: hidden type for `impl Sized` captures lifetime that does not appear in bounds
-  --> $DIR/hidden-type-suggestion.rs:32:5
+  --> $DIR/hidden-type-suggestion.rs:30:5
    |
 LL | fn no_params_yet(_: impl Sized, y: &()) -> impl Sized {
    |                                    ---     ---------- opaque type defined here
@@ -74,7 +74,7 @@ LL |     y
    |     ^
    |
 note: you could use a `use<...>` bound to explicitly capture `'_`, but argument-position `impl Trait`s are not nameable
-  --> $DIR/hidden-type-suggestion.rs:30:21
+  --> $DIR/hidden-type-suggestion.rs:28:21
    |
 LL | fn no_params_yet(_: impl Sized, y: &()) -> impl Sized {
    |                     ^^^^^^^^^^
@@ -84,7 +84,7 @@ LL | fn no_params_yet<T: Sized>(_: T, y: &()) -> impl Sized + use<'_, T> {
    |                 ++++++++++    ~                        ++++++++++++
 
 error[E0700]: hidden type for `impl Sized` captures lifetime that does not appear in bounds
-  --> $DIR/hidden-type-suggestion.rs:38:5
+  --> $DIR/hidden-type-suggestion.rs:36:5
    |
 LL | fn yes_params_yet<'a, T>(_: impl Sized, y: &'a ()) -> impl Sized {
    |                   --                                  ---------- opaque type defined here
@@ -95,7 +95,7 @@ LL |     y
    |     ^
    |
 note: you could use a `use<...>` bound to explicitly capture `'a`, but argument-position `impl Trait`s are not nameable
-  --> $DIR/hidden-type-suggestion.rs:36:29
+  --> $DIR/hidden-type-suggestion.rs:34:29
    |
 LL | fn yes_params_yet<'a, T>(_: impl Sized, y: &'a ()) -> impl Sized {
    |                             ^^^^^^^^^^
diff --git a/tests/ui/impl-trait/region-escape-via-bound.stderr b/tests/ui/impl-trait/region-escape-via-bound.stderr
index 43f0eeeb55838..0518231cfe984 100644
--- a/tests/ui/impl-trait/region-escape-via-bound.stderr
+++ b/tests/ui/impl-trait/region-escape-via-bound.stderr
@@ -9,10 +9,10 @@ LL | fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y>
 LL |     x
    |     ^
    |
-help: to declare that `impl Trait<'y>` captures `'x`, you can add an explicit `'x` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'x`
    |
-LL | fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> + 'x
-   |                                                    ++++
+LL | fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> + use<'y, 'x>
+   |                                                    +++++++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/impl-trait/static-return-lifetime-infered.stderr b/tests/ui/impl-trait/static-return-lifetime-infered.stderr
index 4be244068d226..21e3187d01912 100644
--- a/tests/ui/impl-trait/static-return-lifetime-infered.stderr
+++ b/tests/ui/impl-trait/static-return-lifetime-infered.stderr
@@ -8,10 +8,10 @@ LL |     fn iter_values_anon(&self) -> impl Iterator<Item=u32> {
 LL |         self.x.iter().map(|a| a.0)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Iterator<Item = u32>` captures `'_`, you can add an explicit `'_` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL |     fn iter_values_anon(&self) -> impl Iterator<Item=u32> + '_ {
-   |                                                           ++++
+LL |     fn iter_values_anon(&self) -> impl Iterator<Item=u32> + use<'_> {
+   |                                                           +++++++++
 
 error[E0700]: hidden type for `impl Iterator<Item = u32>` captures lifetime that does not appear in bounds
   --> $DIR/static-return-lifetime-infered.rs:11:9
@@ -23,10 +23,10 @@ LL |     fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> {
 LL |         self.x.iter().map(|a| a.0)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Iterator<Item = u32>` captures `'a`, you can add an explicit `'a` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'a`
    |
-LL |     fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> + 'a {
-   |                                                             ++++
+LL |     fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> + use<'a> {
+   |                                                             +++++++++
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/lifetimes/issue-105227.fixed b/tests/ui/lifetimes/issue-105227.fixed
deleted file mode 100644
index ef64e1e654169..0000000000000
--- a/tests/ui/lifetimes/issue-105227.fixed
+++ /dev/null
@@ -1,26 +0,0 @@
-// Regression test for issue #105227.
-
-//@ run-rustfix
-#![allow(warnings)]
-fn chars0<'a>(v :(&'a  str, &'a str)) -> impl Iterator<Item = char> + 'a  {
-//~^ HELP to declare that `impl Iterator<Item = char>` captures `'_`, you can introduce a named lifetime parameter `'a`
-    v.0.chars().chain(v.1.chars())
-    //~^ ERROR hidden type for `impl Iterator<Item = char>` captures lifetime that does not appear in bounds
-}
-
-fn chars1<'a>(v0 : &'a  str, v1 : &'a str) -> impl Iterator<Item = char> + 'a  {
-//~^ HELP to declare that `impl Iterator<Item = char>` captures `'_`, you can introduce a named lifetime parameter `'a`
-    v0.chars().chain(v1.chars())
-    //~^ ERROR hidden type for `impl Iterator<Item = char>` captures lifetime that does not appear in bound
-}
-
-fn chars2<'b>(v0 : &'b str, v1 : &'b str, v2 : &'b str) ->
-//~^ HELP to declare that `impl Iterator<Item = char>` captures `'_`, you can use the named lifetime parameter `'b`
-    (impl Iterator<Item = char> + 'b , &'b str)
-{
-    (v0.chars().chain(v1.chars()), v2)
-    //~^ ERROR hidden type for `impl Iterator<Item = char>` captures lifetime that does not appear in bound
-}
-
-fn main() {
-}
diff --git a/tests/ui/lifetimes/issue-105227.rs b/tests/ui/lifetimes/issue-105227.rs
index f37765ffafa1b..8a0a49e8f0c48 100644
--- a/tests/ui/lifetimes/issue-105227.rs
+++ b/tests/ui/lifetimes/issue-105227.rs
@@ -1,23 +1,23 @@
 // Regression test for issue #105227.
 
-//@ run-rustfix
-#![allow(warnings)]
+// FIXME(precise_capturing): Add rustfix here after dealing w/ elided lifetimes
+
+#![allow(unused)]
+
 fn chars0(v :(& str, &str)) -> impl Iterator<Item = char> {
-//~^ HELP to declare that `impl Iterator<Item = char>` captures `'_`, you can introduce a named lifetime parameter `'a`
+    //~^ HELP add a `use<...>` bound
     v.0.chars().chain(v.1.chars())
     //~^ ERROR hidden type for `impl Iterator<Item = char>` captures lifetime that does not appear in bounds
 }
 
 fn chars1(v0 : & str, v1 : &str) -> impl Iterator<Item = char> {
-//~^ HELP to declare that `impl Iterator<Item = char>` captures `'_`, you can introduce a named lifetime parameter `'a`
+    //~^ HELP add a `use<...>` bound
     v0.chars().chain(v1.chars())
     //~^ ERROR hidden type for `impl Iterator<Item = char>` captures lifetime that does not appear in bound
 }
 
-fn chars2<'b>(v0 : &str, v1 : &'_ str, v2 : &'b str) ->
-//~^ HELP to declare that `impl Iterator<Item = char>` captures `'_`, you can use the named lifetime parameter `'b`
-    (impl Iterator<Item = char>, &'b str)
-{
+fn chars2<'b>(v0 : &str, v1 : &'_ str, v2 : &'b str) -> (impl Iterator<Item = char>, &'b str) {
+    //~^ HELP add a `use<...>` bound
     (v0.chars().chain(v1.chars()), v2)
     //~^ ERROR hidden type for `impl Iterator<Item = char>` captures lifetime that does not appear in bound
 }
diff --git a/tests/ui/lifetimes/issue-105227.stderr b/tests/ui/lifetimes/issue-105227.stderr
index b514db461b478..35c05f2885479 100644
--- a/tests/ui/lifetimes/issue-105227.stderr
+++ b/tests/ui/lifetimes/issue-105227.stderr
@@ -1,5 +1,5 @@
 error[E0700]: hidden type for `impl Iterator<Item = char>` captures lifetime that does not appear in bounds
-  --> $DIR/issue-105227.rs:7:5
+  --> $DIR/issue-105227.rs:9:5
    |
 LL | fn chars0(v :(& str, &str)) -> impl Iterator<Item = char> {
    |               -----            -------------------------- opaque type defined here
@@ -9,13 +9,13 @@ LL |
 LL |     v.0.chars().chain(v.1.chars())
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Iterator<Item = char>` captures `'_`, you can introduce a named lifetime parameter `'a`
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL | fn chars0<'a>(v :(&'a  str, &'a str)) -> impl Iterator<Item = char> + 'a  {
-   |          ++++      ++        ++                                     ++++
+LL | fn chars0(v :(& str, &str)) -> impl Iterator<Item = char> + use<'_> {
+   |                                                           +++++++++
 
 error[E0700]: hidden type for `impl Iterator<Item = char>` captures lifetime that does not appear in bounds
-  --> $DIR/issue-105227.rs:13:5
+  --> $DIR/issue-105227.rs:15:5
    |
 LL | fn chars1(v0 : & str, v1 : &str) -> impl Iterator<Item = char> {
    |                -----                -------------------------- opaque type defined here
@@ -25,29 +25,26 @@ LL |
 LL |     v0.chars().chain(v1.chars())
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Iterator<Item = char>` captures `'_`, you can introduce a named lifetime parameter `'a`
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL | fn chars1<'a>(v0 : &'a  str, v1 : &'a str) -> impl Iterator<Item = char> + 'a  {
-   |          ++++       ++             ++                                    ++++
+LL | fn chars1(v0 : & str, v1 : &str) -> impl Iterator<Item = char> + use<'_> {
+   |                                                                +++++++++
 
 error[E0700]: hidden type for `impl Iterator<Item = char>` captures lifetime that does not appear in bounds
   --> $DIR/issue-105227.rs:21:5
    |
-LL | fn chars2<'b>(v0 : &str, v1 : &'_ str, v2 : &'b str) ->
-   |                    ---- hidden type `std::iter::Chain<Chars<'_>, Chars<'_>>` captures the anonymous lifetime defined here
+LL | fn chars2<'b>(v0 : &str, v1 : &'_ str, v2 : &'b str) -> (impl Iterator<Item = char>, &'b str) {
+   |                    ----                                  -------------------------- opaque type defined here
+   |                    |
+   |                    hidden type `std::iter::Chain<Chars<'_>, Chars<'_>>` captures the anonymous lifetime defined here
 LL |
-LL |     (impl Iterator<Item = char>, &'b str)
-   |      -------------------------- opaque type defined here
-LL | {
 LL |     (v0.chars().chain(v1.chars()), v2)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl Iterator<Item = char>` captures `'_`, you can use the named lifetime parameter `'b`
-   |
-LL ~ fn chars2<'b>(v0 : &'b str, v1 : &'b str, v2 : &'b str) ->
-LL |
-LL ~     (impl Iterator<Item = char> + 'b , &'b str)
+help: add a `use<...>` bound to explicitly capture `'_`
    |
+LL | fn chars2<'b>(v0 : &str, v1 : &'_ str, v2 : &'b str) -> (impl Iterator<Item = char> + use<'_>, &'b str) {
+   |                                                                                     +++++++++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/nll/issue-73159-rpit-static.stderr b/tests/ui/nll/issue-73159-rpit-static.stderr
index 472db30fbeb10..7c564b84a566c 100644
--- a/tests/ui/nll/issue-73159-rpit-static.stderr
+++ b/tests/ui/nll/issue-73159-rpit-static.stderr
@@ -7,6 +7,11 @@ LL |     fn make_it(&self) -> impl Iterator<Item = u8> {
    |                          ------------------------ opaque type defined here
 LL |         self.0.iter().copied()
    |         ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: add a `use<...>` bound to explicitly capture `'a`
+   |
+LL |     fn make_it(&self) -> impl Iterator<Item = u8> + use<'a> {
+   |                                                   +++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/nll/member-constraints/min-choice-reject-ambiguous.stderr b/tests/ui/nll/member-constraints/min-choice-reject-ambiguous.stderr
index cab75e630a7c8..911ddd3dc805a 100644
--- a/tests/ui/nll/member-constraints/min-choice-reject-ambiguous.stderr
+++ b/tests/ui/nll/member-constraints/min-choice-reject-ambiguous.stderr
@@ -37,10 +37,10 @@ LL | fn test_ambiguous<'a, 'b, 'c>(s: &'a u8) -> impl Cap<'b> + Cap<'c>
 LL |     s
    |     ^
    |
-help: to declare that `impl Cap<'b> + Cap<'c>` captures `'a`, you can add an explicit `'a` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'a`
    |
-LL | fn test_ambiguous<'a, 'b, 'c>(s: &'a u8) -> impl Cap<'b> + Cap<'c> + 'a
-   |                                                                    ++++
+LL | fn test_ambiguous<'a, 'b, 'c>(s: &'a u8) -> impl Cap<'b> + Cap<'c> + use<'b, 'c, 'a>
+   |                                                                    +++++++++++++++++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/nll/member-constraints/nested-impl-trait-fail.stderr b/tests/ui/nll/member-constraints/nested-impl-trait-fail.stderr
index 483b5822b9d35..1a0611e715e19 100644
--- a/tests/ui/nll/member-constraints/nested-impl-trait-fail.stderr
+++ b/tests/ui/nll/member-constraints/nested-impl-trait-fail.stderr
@@ -9,14 +9,10 @@ LL | fn fail_early_bound<'s, 'a, 'b>(a: &'s u8) -> impl IntoIterator<Item = impl
 LL |     [a]
    |     ^^^
    |
-help: to declare that `impl IntoIterator<Item = impl Cap<'a> + Cap<'b>>` captures `'s`, you can add an explicit `'s` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'s`
    |
-LL | fn fail_early_bound<'s, 'a, 'b>(a: &'s u8) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b>> + 's
-   |                                                                                                ++++
-help: to declare that `impl Cap<'a> + Cap<'b>` captures `'s`, you can add an explicit `'s` lifetime bound
-   |
-LL | fn fail_early_bound<'s, 'a, 'b>(a: &'s u8) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b> + 's>
-   |                                                                                               ++++
+LL | fn fail_early_bound<'s, 'a, 'b>(a: &'s u8) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b>> + use<'a, 'b, 's>
+   |                                                                                                +++++++++++++++++
 
 error[E0700]: hidden type for `impl Cap<'a> + Cap<'b>` captures lifetime that does not appear in bounds
   --> $DIR/nested-impl-trait-fail.rs:17:5
@@ -29,14 +25,10 @@ LL | fn fail_early_bound<'s, 'a, 'b>(a: &'s u8) -> impl IntoIterator<Item = impl
 LL |     [a]
    |     ^^^
    |
-help: to declare that `impl IntoIterator<Item = impl Cap<'a> + Cap<'b>>` captures `'s`, you can add an explicit `'s` lifetime bound
-   |
-LL | fn fail_early_bound<'s, 'a, 'b>(a: &'s u8) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b>> + 's
-   |                                                                                                ++++
-help: to declare that `impl Cap<'a> + Cap<'b>` captures `'s`, you can add an explicit `'s` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'s`
    |
-LL | fn fail_early_bound<'s, 'a, 'b>(a: &'s u8) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b> + 's>
-   |                                                                                               ++++
+LL | fn fail_early_bound<'s, 'a, 'b>(a: &'s u8) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b> + use<'a, 'b, 's>>
+   |                                                                                               +++++++++++++++++
 
 error[E0700]: hidden type for `impl IntoIterator<Item = impl Cap<'a> + Cap<'b>>` captures lifetime that does not appear in bounds
   --> $DIR/nested-impl-trait-fail.rs:28:5
@@ -49,14 +41,10 @@ LL | ) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b>> {
 LL |     [a]
    |     ^^^
    |
-help: to declare that `impl IntoIterator<Item = impl Cap<'a> + Cap<'b>>` captures `'s`, you can add an explicit `'s` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'s`
    |
-LL | ) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b>> + 's {
-   |                                                       ++++
-help: to declare that `impl Cap<'a> + Cap<'b>` captures `'s`, you can add an explicit `'s` lifetime bound
-   |
-LL | ) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b> + 's> {
-   |                                                      ++++
+LL | ) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b>> + use<'a, 'b, 's> {
+   |                                                       +++++++++++++++++
 
 error[E0700]: hidden type for `impl Cap<'a> + Cap<'b>` captures lifetime that does not appear in bounds
   --> $DIR/nested-impl-trait-fail.rs:28:5
@@ -69,14 +57,10 @@ LL | ) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b>> {
 LL |     [a]
    |     ^^^
    |
-help: to declare that `impl IntoIterator<Item = impl Cap<'a> + Cap<'b>>` captures `'s`, you can add an explicit `'s` lifetime bound
-   |
-LL | ) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b>> + 's {
-   |                                                       ++++
-help: to declare that `impl Cap<'a> + Cap<'b>` captures `'s`, you can add an explicit `'s` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'s`
    |
-LL | ) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b> + 's> {
-   |                                                      ++++
+LL | ) -> impl IntoIterator<Item = impl Cap<'a> + Cap<'b> + use<'a, 'b, 's>> {
+   |                                                      +++++++++++++++++
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/nll/polonius/location-insensitive-scopes-issue-116657.nll.stderr b/tests/ui/nll/polonius/location-insensitive-scopes-issue-116657.nll.stderr
index 6f9b330316378..cdf394505a25b 100644
--- a/tests/ui/nll/polonius/location-insensitive-scopes-issue-116657.nll.stderr
+++ b/tests/ui/nll/polonius/location-insensitive-scopes-issue-116657.nll.stderr
@@ -25,10 +25,10 @@ LL | fn test<'a>(y: &'a mut i32) -> impl PlusOne {
 LL |     <&mut i32 as Callable>::call(y)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl PlusOne` captures `'a`, you can add an explicit `'a` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'a`
    |
-LL | fn test<'a>(y: &'a mut i32) -> impl PlusOne + 'a {
-   |                                             ++++
+LL | fn test<'a>(y: &'a mut i32) -> impl PlusOne + use<'a> {
+   |                                             +++++++++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/nll/polonius/location-insensitive-scopes-issue-116657.polonius.stderr b/tests/ui/nll/polonius/location-insensitive-scopes-issue-116657.polonius.stderr
index 6f9b330316378..cdf394505a25b 100644
--- a/tests/ui/nll/polonius/location-insensitive-scopes-issue-116657.polonius.stderr
+++ b/tests/ui/nll/polonius/location-insensitive-scopes-issue-116657.polonius.stderr
@@ -25,10 +25,10 @@ LL | fn test<'a>(y: &'a mut i32) -> impl PlusOne {
 LL |     <&mut i32 as Callable>::call(y)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl PlusOne` captures `'a`, you can add an explicit `'a` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'a`
    |
-LL | fn test<'a>(y: &'a mut i32) -> impl PlusOne + 'a {
-   |                                             ++++
+LL | fn test<'a>(y: &'a mut i32) -> impl PlusOne + use<'a> {
+   |                                             +++++++++
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/nll/ty-outlives/impl-trait-captures.stderr b/tests/ui/nll/ty-outlives/impl-trait-captures.stderr
index 48569d1446dd4..3ceefbc40660c 100644
--- a/tests/ui/nll/ty-outlives/impl-trait-captures.stderr
+++ b/tests/ui/nll/ty-outlives/impl-trait-captures.stderr
@@ -8,10 +8,10 @@ LL | fn foo<'a, T>(x: &T) -> impl Foo<'a> {
 LL |     x
    |     ^
    |
-help: to declare that `Opaque(DefId(0:13 ~ impl_trait_captures[aeb9]::foo::{opaque#0}), ['a/#0, T, 'a/#2])` captures `ReLateParam(DefId(0:8 ~ impl_trait_captures[aeb9]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[aeb9]::foo::'_), '_))`, you can add an explicit `ReLateParam(DefId(0:8 ~ impl_trait_captures[aeb9]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[aeb9]::foo::'_), '_))` lifetime bound
+help: add a `use<...>` bound to explicitly capture `ReLateParam(DefId(0:8 ~ impl_trait_captures[aeb9]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[aeb9]::foo::'_), '_))`
    |
-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::'_), '_)) {
-   |                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+LL | fn foo<'a, T>(x: &T) -> impl Foo<'a> + use<'a, ReLateParam(DefId(0:8 ~ impl_trait_captures[aeb9]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[aeb9]::foo::'_), '_)), T> {
+   |                                      +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 error: aborting due to 1 previous error
 
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 e04ec8bb3bca4..216b705348899 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
@@ -7,10 +7,10 @@ LL |     async fn f(self: Pin<&Self>) -> impl Clone { self }
    |                          |          opaque type defined here
    |                          hidden type `Pin<&Foo>` captures the anonymous lifetime defined here
    |
-help: to declare that `impl Clone` captures `'_`, you can add an explicit `'_` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL |     async fn f(self: Pin<&Self>) -> impl Clone + '_ { self }
-   |                                                ++++
+LL |     async fn f(self: Pin<&Self>) -> impl Clone + use<'_> { self }
+   |                                                +++++++++
 
 error: aborting due to 1 previous error
 
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 a2964881d58a7..7a2ce110a3897 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
@@ -7,10 +7,10 @@ LL |     fn f(self: Pin<&Self>) -> impl Clone { self }
    |                    |          opaque type defined here
    |                    hidden type `Pin<&Foo>` captures the anonymous lifetime defined here
    |
-help: to declare that `impl Clone` captures `'_`, you can add an explicit `'_` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL |     fn f(self: Pin<&Self>) -> impl Clone + '_ { self }
-   |                                          ++++
+LL |     fn f(self: Pin<&Self>) -> impl Clone + use<'_> { self }
+   |                                          +++++++++
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr
index 64af17c830e2e..88a18e9d06da2 100644
--- a/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr
+++ b/tests/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr
@@ -20,10 +20,10 @@ LL | |         *dest = g.get();
 LL | |     }
    | |_____^
    |
-help: to declare that `impl FnOnce()` captures `'_`, you can add an explicit `'_` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'_`
    |
-LL | fn foo<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
-   |                                                   ++++
+LL | fn foo<G, T>(g: G, dest: &mut T) -> impl FnOnce() + use<'_, G, T>
+   |                                                   +++++++++++++++
 
 error[E0311]: the parameter type `G` may not live long enough
   --> $DIR/missing-lifetimes-in-signature.rs:30:5
diff --git a/tests/ui/type-alias-impl-trait/different_args_considered_equal2.stderr b/tests/ui/type-alias-impl-trait/different_args_considered_equal2.stderr
index 1104c2c498a5a..213272f5f3451 100644
--- a/tests/ui/type-alias-impl-trait/different_args_considered_equal2.stderr
+++ b/tests/ui/type-alias-impl-trait/different_args_considered_equal2.stderr
@@ -9,11 +9,6 @@ LL | fn get_one<'a>(a: *mut &'a str) -> impl IntoIterator<Item = Opaque<'a>> {
 ...
 LL |         None::<Opaque<'static>>
    |         ^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: to declare that `impl IntoIterator<Item = Opaque<'a>>` captures `'a`, you can add an explicit `'a` lifetime bound
-   |
-LL | fn get_one<'a>(a: *mut &'a str) -> impl IntoIterator<Item = Opaque<'a>> + 'a {
-   |                                                                         ++++
 
 error: aborting due to 1 previous error
 
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 9bffa94fda165..0bf9dccfad85e 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
@@ -8,10 +8,10 @@ LL | fn test<'a>(y: &'a mut i32) -> impl PlusOne {
 LL |     <&'a mut i32 as Callable>::call(y)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that `impl PlusOne` captures `'a`, you can add an explicit `'a` lifetime bound
+help: add a `use<...>` bound to explicitly capture `'a`
    |
-LL | fn test<'a>(y: &'a mut i32) -> impl PlusOne + 'a {
-   |                                             ++++
+LL | fn test<'a>(y: &'a mut i32) -> impl PlusOne + use<'a> {
+   |                                             +++++++++
 
 error: aborting due to 1 previous error
 

From b2dd943d4be2f7f9f923146e2ff7b7bd46c59a3b Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 17 Aug 2024 12:50:12 -0400
Subject: [PATCH 373/685] Use cnum for extern crate data

---
 compiler/rustc_middle/src/query/mod.rs                    | 2 +-
 compiler/rustc_middle/src/ty/print/pretty.rs              | 8 +++-----
 compiler/rustc_middle/src/ty/util.rs                      | 2 +-
 compiler/rustc_passes/src/lang_items.rs                   | 4 ++--
 .../src/error_reporting/traits/fulfillment_errors.rs      | 2 +-
 5 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 92c8d265c09ec..75166624f95a4 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -1520,7 +1520,7 @@ rustc_queries! {
         separate_provide_extern
     }
 
-    query extern_crate(def_id: DefId) -> Option<&'tcx ExternCrate> {
+    query extern_crate(def_id: CrateNum) -> Option<&'tcx ExternCrate> {
         eval_always
         desc { "getting crate's ExternCrateData" }
         separate_provide_extern
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 56ddf146636c8..319fb7ef03bb3 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -451,7 +451,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
             // 2. For an extern inferred from a path or an indirect crate,
             //    where there is no explicit `extern crate`, we just prepend
             //    the crate name.
-            match self.tcx().extern_crate(def_id) {
+            match self.tcx().extern_crate(cnum) {
                 Some(&ExternCrate { src, dependency_of, span, .. }) => match (src, dependency_of) {
                     (ExternCrateSource::Extern(def_id), LOCAL_CRATE) => {
                         // NOTE(eddyb) the only reason `span` might be dummy,
@@ -3247,10 +3247,8 @@ fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, N
     let mut seen_defs: DefIdSet = Default::default();
 
     for &cnum in tcx.crates(()).iter() {
-        let def_id = cnum.as_def_id();
-
         // Ignore crates that are not direct dependencies.
-        match tcx.extern_crate(def_id) {
+        match tcx.extern_crate(cnum) {
             None => continue,
             Some(extern_crate) => {
                 if !extern_crate.is_direct() {
@@ -3259,7 +3257,7 @@ fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, N
             }
         }
 
-        queue.push(def_id);
+        queue.push(cnum.as_def_id());
     }
 
     // Iterate external crate defs but be mindful about visibility
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index b9bf17cbb5ce6..045c8ad39bee2 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -859,7 +859,7 @@ impl<'tcx> TyCtxt<'tcx> {
             // If `extern_crate` is `None`, then the crate was injected (e.g., by the allocator).
             // Treat that kind of crate as "indirect", since it's an implementation detail of
             // the language.
-            || self.extern_crate(key.as_def_id()).is_some_and(|e| e.is_direct())
+            || self.extern_crate(key).is_some_and(|e| e.is_direct())
     }
 
     /// Whether the item has a host effect param. This is different from `TyCtxt::is_const`,
diff --git a/compiler/rustc_passes/src/lang_items.rs b/compiler/rustc_passes/src/lang_items.rs
index 3f1be87a73f7f..71b0ebb0e2170 100644
--- a/compiler/rustc_passes/src/lang_items.rs
+++ b/compiler/rustc_passes/src/lang_items.rs
@@ -130,7 +130,7 @@ impl<'ast, 'tcx> LanguageItemCollector<'ast, 'tcx> {
             if first_defined_span.is_none() {
                 orig_crate_name = self.tcx.crate_name(original_def_id.krate);
                 if let Some(ExternCrate { dependency_of: inner_dependency_of, .. }) =
-                    self.tcx.extern_crate(original_def_id)
+                    self.tcx.extern_crate(original_def_id.krate)
                 {
                     orig_dependency_of = self.tcx.crate_name(*inner_dependency_of);
                 }
@@ -139,7 +139,7 @@ impl<'ast, 'tcx> LanguageItemCollector<'ast, 'tcx> {
             let duplicate = if item_span.is_some() {
                 Duplicate::Plain
             } else {
-                match self.tcx.extern_crate(item_def_id) {
+                match self.tcx.extern_crate(item_def_id.krate) {
                     Some(ExternCrate { dependency_of: inner_dependency_of, .. }) => {
                         dependency_of = self.tcx.crate_name(*inner_dependency_of);
                         Duplicate::CrateDepends
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 326a0e4e35ce8..347f5b9f93f7c 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -1668,7 +1668,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             let name = self.tcx.crate_name(trait_def_id.krate);
             let spans: Vec<_> = [trait_def_id, found_type]
                 .into_iter()
-                .filter_map(|def_id| self.tcx.extern_crate(def_id))
+                .filter_map(|def_id| self.tcx.extern_crate(def_id.krate))
                 .map(|data| {
                     let dependency = if data.dependency_of == LOCAL_CRATE {
                         "direct dependency of the current crate".to_string()

From 56eee8e870a286ab82a3707cb873e08735d0e510 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Sat, 17 Aug 2024 00:18:18 +0800
Subject: [PATCH 374/685] Apply test fix

- Fix epoll_ctl_del test
- Simplified epoll_ctl_mod test and add test_no_notification_for_unregister_flag
- Use assert_eq(0) for epoll_ctl
---
 .../miri/tests/pass-dep/libc/libc-epoll.rs    | 103 +++++++++++-------
 1 file changed, 65 insertions(+), 38 deletions(-)

diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index 8326353451fa5..71f0e832afb11 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -14,6 +14,7 @@ fn main() {
     test_not_fully_closed_fd();
     test_closed_fd();
     test_two_epoll_instance();
+    test_no_notification_for_unregister_flag();
     test_epoll_ctl_mod();
     test_epoll_ctl_del();
     test_pointer();
@@ -68,7 +69,7 @@ fn test_epoll_socketpair() {
         u64: u64::try_from(fds[1]).unwrap(),
     };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
@@ -99,6 +100,8 @@ fn test_epoll_socketpair() {
     check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
 
+// This test first registers a file description with a flag that does not lead to notification,
+// then EPOLL_CTL_MOD to add another flag that will lead to notification.
 fn test_epoll_ctl_mod() {
     // Create an epoll instance.
     let epfd = unsafe { libc::epoll_create1(0) };
@@ -109,37 +112,27 @@ fn test_epoll_ctl_mod() {
     let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
     assert_eq!(res, 0);
 
-    // Write to fd[0].
-    let data = "abcde".as_bytes().as_ptr();
-    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
-    assert_eq!(res, 5);
-
-    // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET.
-    // (Not using checked cast as EPOLLET wraps around.)
-    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fds[1]).unwrap() };
+    // Register fd[1] with EPOLLIN|EPOLLET.
+    let mut ev = libc::epoll_event {
+        events: (libc::EPOLLIN | libc::EPOLLET) as _,
+        u64: u64::try_from(fds[1]).unwrap(),
+    };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
-    // Check result from epoll_wait.
-    let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
-    let expected_value = u64::try_from(fds[1]).unwrap();
-    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+    // Check result from epoll_wait. No notification would be returned.
+    check_epoll_wait::<8>(epfd, &[]);
 
-    // Test EPOLLRDHUP.
+    // Use EPOLL_CTL_MOD to change to EPOLLOUT flag.
     let mut ev = libc::epoll_event {
-        events: (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET | libc::EPOLLRDHUP) as _,
+        events: (libc::EPOLLOUT | libc::EPOLLET) as _,
         u64: u64::try_from(fds[1]).unwrap(),
     };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_MOD, fds[1], &mut ev) };
-    assert_ne!(res, -1);
-
-    // Close the other side of the socketpair to invoke EPOLLRDHUP.
-    let res = unsafe { libc::close(fds[0]) };
     assert_eq!(res, 0);
 
-    // Check result from epoll_wait.
-    let expected_event =
-        u32::try_from(libc::EPOLLRDHUP | libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLHUP).unwrap();
+    // Check result from epoll_wait. EPOLLOUT notification is expected.
+    let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = u64::try_from(fds[1]).unwrap();
     check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
@@ -162,10 +155,12 @@ fn test_epoll_ctl_del() {
     // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fds[1]).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
     // Test EPOLL_CTL_DEL.
-    check_epoll_wait::<0>(epfd, &[]);
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_DEL, fds[1], &mut ev) };
+    assert_eq!(res, 0);
+    check_epoll_wait::<8>(epfd, &[]);
 }
 
 // This test is for one fd registered under two different epoll instance.
@@ -189,9 +184,9 @@ fn test_two_epoll_instance() {
     // Register one side of the socketpair with EPOLLIN | EPOLLOUT | EPOLLET.
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fds[1]).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd1, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
     let res = unsafe { libc::epoll_ctl(epfd2, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
     // Notification should be received from both instance of epoll.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
@@ -219,9 +214,9 @@ fn test_two_same_fd_in_same_epoll_instance() {
     // Register both fd to the same epoll instance.
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: 5 as u64 };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, newfd, &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
     // Write to the socketpair.
     let data = "abcde".as_bytes().as_ptr();
@@ -254,7 +249,7 @@ fn test_epoll_eventfd() {
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fd).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
     // Check result from epoll_wait.
     let expected_event = u32::try_from(libc::EPOLLIN | libc::EPOLLOUT).unwrap();
@@ -277,7 +272,7 @@ fn test_pointer() {
     let mut ev =
         libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: data.expose_provenance() as u64 };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 }
 
 // When read/write happened on one side of the socketpair, only the other side will be notified.
@@ -294,10 +289,10 @@ fn test_epoll_socketpair_both_sides() {
     // Register both fd to the same epoll instance.
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fds[0] as u64 };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[0], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fds[1] as u64 };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
     // Write to fds[1].
     let data = "abcde".as_bytes().as_ptr();
@@ -340,7 +335,7 @@ fn test_closed_fd() {
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fd).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
     // Write to the eventfd instance.
     let sized_8_data: [u8; 8] = 1_u64.to_ne_bytes();
@@ -377,7 +372,7 @@ fn test_not_fully_closed_fd() {
     // Register eventfd with EPOLLIN | EPOLLOUT | EPOLLET
     let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: u64::try_from(fd).unwrap() };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
     // Close the original fd that being used to register with epoll.
     let res = unsafe { libc::close(fd) };
@@ -423,7 +418,7 @@ fn test_event_overwrite() {
         u64: u64::try_from(fd).unwrap(),
     };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd, &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
     // Read from the eventfd instance.
     let mut buf: [u8; 8] = [0; 8];
@@ -454,13 +449,13 @@ fn test_socketpair_read() {
         u64: fds[0] as u64,
     };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[0], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
     let mut ev = libc::epoll_event {
         events: (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET) as _,
         u64: fds[1] as u64,
     };
     let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_ne!(res, -1);
+    assert_eq!(res, 0);
 
     // Write 5 bytes to fds[1].
     let data = "abcde".as_bytes().as_ptr();
@@ -501,3 +496,35 @@ fn test_socketpair_read() {
     let expected_value = fds[1] as u64;
     check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
+
+// This is to test whether flag that we don't register won't trigger notification.
+fn test_no_notification_for_unregister_flag() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Register fd[0] with EPOLLOUT|EPOLLET.
+    let mut ev = libc::epoll_event {
+        events: (libc::EPOLLOUT | libc::EPOLLET) as _,
+        u64: u64::try_from(fds[0]).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_eq!(res, 0);
+
+    // Write to fd[1].
+    let data = "abcde".as_bytes().as_ptr();
+    let res: i32 =
+        unsafe { libc::write(fds[1], data as *const libc::c_void, 5).try_into().unwrap() };
+    assert_eq!(res, 5);
+
+    // Check result from epoll_wait. Since we didn't register EPOLLIN flag, the notification won't
+    // contain EPOLLIN even though fds[0] is now readable.
+    let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value = u64::try_from(fds[0]).unwrap();
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+}

From 4f661302c6c5fee303248ea784eb66caa0b0e1cd Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 17 Aug 2024 18:09:28 +0000
Subject: [PATCH 375/685] Replace `span_suggestion_with_style` with `_verbose`

---
 .../src/casts/cast_possible_truncation.rs         |  6 ++----
 clippy_lints/src/casts/fn_to_numeric_cast_any.rs  |  5 ++---
 clippy_lints/src/create_dir.rs                    |  5 ++---
 clippy_lints/src/doc/lazy_continuation.rs         | 11 ++++-------
 clippy_lints/src/doc/markdown.rs                  | 15 +++------------
 clippy_lints/src/float_literal.rs                 |  8 +++-----
 .../src/functions/impl_trait_in_params.rs         | 11 +++++------
 clippy_lints/src/implicit_return.rs               | 13 +++----------
 clippy_lints/src/legacy_numeric_constants.rs      |  5 ++---
 clippy_lints/src/methods/get_unwrap.rs            |  3 +--
 10 files changed, 27 insertions(+), 55 deletions(-)

diff --git a/clippy_lints/src/casts/cast_possible_truncation.rs b/clippy_lints/src/casts/cast_possible_truncation.rs
index 102fe25fc67b0..5708aae3f3eca 100644
--- a/clippy_lints/src/casts/cast_possible_truncation.rs
+++ b/clippy_lints/src/casts/cast_possible_truncation.rs
@@ -4,7 +4,7 @@ use clippy_utils::expr_or_init;
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{get_discriminant_value, is_isize_or_usize};
-use rustc_errors::{Applicability, Diag, SuggestionStyle};
+use rustc_errors::{Applicability, Diag};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -190,12 +190,10 @@ fn offer_suggestion(
         format!("{cast_to_snip}::try_from({})", Sugg::hir(cx, cast_expr, ".."))
     };
 
-    diag.span_suggestion_with_style(
+    diag.span_suggestion_verbose(
         expr.span,
         "... or use `try_from` and handle the error accordingly",
         suggestion,
         Applicability::Unspecified,
-        // always show the suggestion in a separate line
-        SuggestionStyle::ShowAlways,
     );
 }
diff --git a/clippy_lints/src/casts/fn_to_numeric_cast_any.rs b/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
index 75de53f73ee7a..cb7267c2d1ce6 100644
--- a/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
+++ b/clippy_lints/src/casts/fn_to_numeric_cast_any.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
-use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::{self, Ty};
@@ -24,12 +24,11 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
             expr.span,
             format!("casting function pointer `{from_snippet}` to `{cast_to}`"),
             |diag| {
-                diag.span_suggestion_with_style(
+                diag.span_suggestion_verbose(
                     expr.span,
                     "did you mean to invoke the function?",
                     format!("{from_snippet}() as {cast_to}"),
                     applicability,
-                    SuggestionStyle::ShowAlways,
                 );
             },
         );
diff --git a/clippy_lints/src/create_dir.rs b/clippy_lints/src/create_dir.rs
index b49a977dbeaf1..24570d8f4401c 100644
--- a/clippy_lints/src/create_dir.rs
+++ b/clippy_lints/src/create_dir.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
-use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
@@ -46,7 +46,7 @@ impl LateLintPass<'_> for CreateDir {
                 "calling `std::fs::create_dir` where there may be a better way",
                 |diag| {
                     let mut app = Applicability::MaybeIncorrect;
-                    diag.span_suggestion_with_style(
+                    diag.span_suggestion_verbose(
                         expr.span,
                         "consider calling `std::fs::create_dir_all` instead",
                         format!(
@@ -54,7 +54,6 @@ impl LateLintPass<'_> for CreateDir {
                             snippet_with_applicability(cx, arg.span, "..", &mut app)
                         ),
                         app,
-                        SuggestionStyle::ShowAlways,
                     );
                 },
             );
diff --git a/clippy_lints/src/doc/lazy_continuation.rs b/clippy_lints/src/doc/lazy_continuation.rs
index bd1cc46e1850e..771bcac244187 100644
--- a/clippy_lints/src/doc/lazy_continuation.rs
+++ b/clippy_lints/src/doc/lazy_continuation.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use itertools::Itertools;
-use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_errors::Applicability;
 use rustc_lint::LateContext;
 use rustc_span::{BytePos, Span};
 use std::ops::Range;
@@ -59,12 +59,11 @@ pub(super) fn check(
                 && (doc_comment == "///" || doc_comment == "//!")
             {
                 // suggest filling in a blank line
-                diag.span_suggestion_with_style(
+                diag.span_suggestion_verbose(
                     line_break_span.shrink_to_lo(),
                     "if this should be its own paragraph, add a blank doc comment line",
                     format!("\n{doc_comment}"),
                     Applicability::MaybeIncorrect,
-                    SuggestionStyle::ShowAlways,
                 );
                 if ccount > 0 || blockquote_level > 0 {
                     diag.help("if this not intended to be a quote at all, escape it with `\\>`");
@@ -79,12 +78,11 @@ pub(super) fn check(
             if ccount == 0 && blockquote_level == 0 {
                 // simpler suggestion style for indentation
                 let indent = list_indentation - lcount;
-                diag.span_suggestion_with_style(
+                diag.span_suggestion_verbose(
                     span.shrink_to_hi(),
                     "indent this line",
                     std::iter::repeat(" ").take(indent).join(""),
                     Applicability::MaybeIncorrect,
-                    SuggestionStyle::ShowAlways,
                 );
                 diag.help("if this is supposed to be its own paragraph, add a blank line");
                 return;
@@ -107,12 +105,11 @@ pub(super) fn check(
                     suggested.push_str(text);
                 }
             }
-            diag.span_suggestion_with_style(
+            diag.span_suggestion_verbose(
                 span,
                 "add markers to start of line",
                 suggested,
                 Applicability::MachineApplicable,
-                SuggestionStyle::ShowAlways,
             );
             diag.help("if this not intended to be a quote at all, escape it with `\\>`");
         });
diff --git a/clippy_lints/src/doc/markdown.rs b/clippy_lints/src/doc/markdown.rs
index 237badb3f233c..8cdaba88e5095 100644
--- a/clippy_lints/src/doc/markdown.rs
+++ b/clippy_lints/src/doc/markdown.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::snippet_with_applicability;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_errors::Applicability;
 use rustc_lint::LateContext;
 use rustc_span::{BytePos, Pos, Span};
 use url::Url;
@@ -137,24 +137,15 @@ fn check_word(cx: &LateContext<'_>, word: &str, span: Span, code_level: isize, b
     }
 
     if has_underscore(word) || word.contains("::") || is_camel_case(word) || word.ends_with("()") {
-        let mut applicability = Applicability::MachineApplicable;
-
         span_lint_and_then(
             cx,
             DOC_MARKDOWN,
             span,
             "item in documentation is missing backticks",
             |diag| {
+                let mut applicability = Applicability::MachineApplicable;
                 let snippet = snippet_with_applicability(cx, span, "..", &mut applicability);
-                diag.span_suggestion_with_style(
-                    span,
-                    "try",
-                    format!("`{snippet}`"),
-                    applicability,
-                    // always show the suggestion in a separate line, since the
-                    // inline presentation adds another pair of backticks
-                    SuggestionStyle::ShowAlways,
-                );
+                diag.span_suggestion_verbose(span, "try", format!("`{snippet}`"), applicability);
             },
         );
     }
diff --git a/clippy_lints/src/float_literal.rs b/clippy_lints/src/float_literal.rs
index f095c1add91f8..012ad8e1a2298 100644
--- a/clippy_lints/src/float_literal.rs
+++ b/clippy_lints/src/float_literal.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::numeric_literal;
 use rustc_ast::ast::{self, LitFloatType, LitKind};
-use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, FloatTy};
@@ -117,12 +117,11 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
                             if type_suffix.is_none() {
                                 float_str.push_str(".0");
                             }
-                            diag.span_suggestion_with_style(
+                            diag.span_suggestion_verbose(
                                 expr.span,
                                 "consider changing the type or replacing it with",
                                 numeric_literal::format(&float_str, type_suffix, true),
                                 Applicability::MachineApplicable,
-                                SuggestionStyle::ShowAlways,
                             );
                         },
                     );
@@ -134,12 +133,11 @@ impl<'tcx> LateLintPass<'tcx> for FloatLiteral {
                     expr.span,
                     "float has excessive precision",
                     |diag| {
-                        diag.span_suggestion_with_style(
+                        diag.span_suggestion_verbose(
                             expr.span,
                             "consider changing the type or truncating it to",
                             numeric_literal::format(&float_str, type_suffix, true),
                             Applicability::MachineApplicable,
-                            SuggestionStyle::ShowAlways,
                         );
                     },
                 );
diff --git a/clippy_lints/src/functions/impl_trait_in_params.rs b/clippy_lints/src/functions/impl_trait_in_params.rs
index cf85c74e688d2..05e341e06fde4 100644
--- a/clippy_lints/src/functions/impl_trait_in_params.rs
+++ b/clippy_lints/src/functions/impl_trait_in_params.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_in_test;
 
+use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, GenericParam, Generics, HirId, ImplItem, ImplItemKind, TraitItem, TraitItemKind};
@@ -18,20 +19,18 @@ fn report(cx: &LateContext<'_>, param: &GenericParam<'_>, generics: &Generics<'_
         |diag| {
             if let Some(gen_span) = generics.span_for_param_suggestion() {
                 // If there's already a generic param with the same bound, do not lint **this** suggestion.
-                diag.span_suggestion_with_style(
+                diag.span_suggestion_verbose(
                     gen_span,
                     "add a type parameter",
                     format!(", {{ /* Generic name */ }}: {}", &param.name.ident().as_str()[5..]),
-                    rustc_errors::Applicability::HasPlaceholders,
-                    rustc_errors::SuggestionStyle::ShowAlways,
+                    Applicability::HasPlaceholders,
                 );
             } else {
-                diag.span_suggestion_with_style(
+                diag.span_suggestion_verbose(
                     generics.span,
                     "add a type parameter",
                     format!("<{{ /* Generic name */ }}: {}>", &param.name.ident().as_str()[5..]),
-                    rustc_errors::Applicability::HasPlaceholders,
-                    rustc_errors::SuggestionStyle::ShowAlways,
+                    Applicability::HasPlaceholders,
                 );
             }
         },
diff --git a/clippy_lints/src/implicit_return.rs b/clippy_lints/src/implicit_return.rs
index b926e1e62ba0c..ba06567b9572c 100644
--- a/clippy_lints/src/implicit_return.rs
+++ b/clippy_lints/src/implicit_return.rs
@@ -3,7 +3,7 @@ use clippy_utils::source::{snippet_with_applicability, snippet_with_context, wal
 use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{get_async_fn_body, is_async_fn, is_from_proc_macro};
 use core::ops::ControlFlow;
-use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Block, Body, Expr, ExprKind, FnDecl, FnRetTy, HirId};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -54,13 +54,7 @@ fn lint_return(cx: &LateContext<'_>, emission_place: HirId, span: Span) {
         |diag| {
             let mut app = Applicability::MachineApplicable;
             let snip = snippet_with_applicability(cx, span, "..", &mut app);
-            diag.span_suggestion_with_style(
-                span,
-                "add `return` as shown",
-                format!("return {snip}"),
-                app,
-                SuggestionStyle::ShowAlways,
-            );
+            diag.span_suggestion_verbose(span, "add `return` as shown", format!("return {snip}"), app);
         },
     );
 }
@@ -75,12 +69,11 @@ fn lint_break(cx: &LateContext<'_>, emission_place: HirId, break_span: Span, exp
         |diag| {
             let mut app = Applicability::MachineApplicable;
             let snip = snippet_with_context(cx, expr_span, break_span.ctxt(), "..", &mut app).0;
-            diag.span_suggestion_with_style(
+            diag.span_suggestion_verbose(
                 break_span,
                 "change `break` to `return` as shown",
                 format!("return {snip}"),
                 app,
-                SuggestionStyle::ShowAlways,
             );
         },
     );
diff --git a/clippy_lints/src/legacy_numeric_constants.rs b/clippy_lints/src/legacy_numeric_constants.rs
index 752e1326e3e05..ccab1e27d3b0c 100644
--- a/clippy_lints/src/legacy_numeric_constants.rs
+++ b/clippy_lints/src/legacy_numeric_constants.rs
@@ -3,7 +3,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::{get_parent_expr, is_from_proc_macro};
 use hir::def_id::DefId;
-use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{ExprKind, Item, ItemKind, QPath, UseKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -143,12 +143,11 @@ impl<'tcx> LateLintPass<'tcx> for LegacyNumericConstants {
             && !is_from_proc_macro(cx, expr)
         {
             span_lint_hir_and_then(cx, LEGACY_NUMERIC_CONSTANTS, expr.hir_id, span, msg, |diag| {
-                diag.span_suggestion_with_style(
+                diag.span_suggestion_verbose(
                     span,
                     "use the associated constant instead",
                     sugg,
                     Applicability::MaybeIncorrect,
-                    SuggestionStyle::ShowAlways,
                 );
             });
         }
diff --git a/clippy_lints/src/methods/get_unwrap.rs b/clippy_lints/src/methods/get_unwrap.rs
index c6285c87a2636..9daad1a8a949e 100644
--- a/clippy_lints/src/methods/get_unwrap.rs
+++ b/clippy_lints/src/methods/get_unwrap.rs
@@ -74,7 +74,7 @@ pub(super) fn check<'tcx>(
                 "&"
             };
 
-            diag.span_suggestion_with_style(
+            diag.span_suggestion_verbose(
                 span,
                 "using `[]` is clearer and more concise",
                 format!(
@@ -82,7 +82,6 @@ pub(super) fn check<'tcx>(
                     snippet_with_applicability(cx, recv.span, "..", &mut applicability)
                 ),
                 applicability,
-                rustc_errors::SuggestionStyle::ShowAlways,
             );
         },
     );

From ed46141081597395b5299f8c7aaeb489e0465407 Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 17 Aug 2024 18:10:46 +0000
Subject: [PATCH 376/685] Remove duplicate `type_diagnostic_name` function

---
 clippy_lints/src/eta_reduction.rs | 4 ++--
 clippy_utils/src/ty.rs            | 5 -----
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/clippy_lints/src/eta_reduction.rs b/clippy_lints/src/eta_reduction.rs
index 5a7226d590c4d..a77d09c378afe 100644
--- a/clippy_lints/src/eta_reduction.rs
+++ b/clippy_lints/src/eta_reduction.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::higher::VecArgs;
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::type_diagnostic_name;
+use clippy_utils::ty::get_type_diagnostic_name;
 use clippy_utils::usage::{local_used_after_expr, local_used_in};
 use clippy_utils::{get_path_from_caller_to_method_type, is_adjusted, path_to_local, path_to_local_id};
 use rustc_errors::Applicability;
@@ -139,7 +139,7 @@ fn check_clousure<'tcx>(cx: &LateContext<'tcx>, outer_receiver: Option<&Expr<'tc
         {
             let callee_ty_raw = typeck.expr_ty(callee);
             let callee_ty = callee_ty_raw.peel_refs();
-            if matches!(type_diagnostic_name(cx, callee_ty), Some(sym::Arc | sym::Rc))
+            if matches!(get_type_diagnostic_name(cx, callee_ty), Some(sym::Arc | sym::Rc))
                 || !check_inputs(typeck, body.params, None, args)
             {
                 return;
diff --git a/clippy_utils/src/ty.rs b/clippy_utils/src/ty.rs
index bd48990aea95f..a557a7f31ce80 100644
--- a/clippy_utils/src/ty.rs
+++ b/clippy_utils/src/ty.rs
@@ -455,11 +455,6 @@ pub fn is_type_lang_item(cx: &LateContext<'_>, ty: Ty<'_>, lang_item: LangItem)
     }
 }
 
-/// Gets the diagnostic name of the type, if it has one
-pub fn type_diagnostic_name(cx: &LateContext<'_>, ty: Ty<'_>) -> Option<Symbol> {
-    ty.ty_adt_def().and_then(|adt| cx.tcx.get_diagnostic_name(adt.did()))
-}
-
 /// Return `true` if the passed `typ` is `isize` or `usize`.
 pub fn is_isize_or_usize(typ: Ty<'_>) -> bool {
     matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))

From 9aa656df9f6c68d14e613e56e3a6afac2644957e Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 17 Aug 2024 18:17:53 +0000
Subject: [PATCH 377/685] Remove redundant doc comments

---
 clippy_lints/src/attrs/mod.rs                 |  2 --
 clippy_lints/src/cargo/common_metadata.rs     |  2 --
 .../src/cargo/multiple_crate_versions.rs      |  2 --
 clippy_lints/src/checked_conversions.rs       |  2 --
 clippy_lints/src/cognitive_complexity.rs      |  2 --
 clippy_lints/src/collapsible_if.rs            | 14 --------
 clippy_lints/src/else_if_without_else.rs      |  2 --
 clippy_lints/src/empty_enum.rs                |  2 --
 clippy_lints/src/enum_clike.rs                |  3 --
 clippy_lints/src/if_not_else.rs               |  3 --
 clippy_lints/src/indexing_slicing.rs          |  2 --
 clippy_lints/src/inherent_impl.rs             |  2 --
 clippy_lints/src/inline_fn_without_body.rs    |  2 --
 clippy_lints/src/int_plus_one.rs              |  2 --
 clippy_lints/src/item_name_repetitions.rs     |  2 --
 clippy_lints/src/items_after_statements.rs    |  2 --
 clippy_lints/src/large_enum_variant.rs        |  2 --
 clippy_lints/src/literal_representation.rs    |  3 --
 .../src/methods/is_digit_ascii_radix.rs       |  2 --
 clippy_lints/src/mutex_atomic.rs              |  4 ---
 clippy_lints/src/needless_bool.rs             |  4 ---
 clippy_lints/src/needless_continue.rs         | 35 -------------------
 clippy_lints/src/non_copy_const.rs            |  4 ---
 clippy_lints/src/ptr.rs                       |  2 --
 clippy_lints/src/size_of_in_element_count.rs  |  3 --
 clippy_lints/src/utils/author.rs              |  3 --
 26 files changed, 108 deletions(-)

diff --git a/clippy_lints/src/attrs/mod.rs b/clippy_lints/src/attrs/mod.rs
index 5d99001e5aa3f..3b14e9aee7fc0 100644
--- a/clippy_lints/src/attrs/mod.rs
+++ b/clippy_lints/src/attrs/mod.rs
@@ -1,5 +1,3 @@
-//! checks for attributes
-
 mod allow_attributes;
 mod allow_attributes_without_reason;
 mod blanket_clippy_restriction_lints;
diff --git a/clippy_lints/src/cargo/common_metadata.rs b/clippy_lints/src/cargo/common_metadata.rs
index 3af2d8c025684..fed0aa8b2758b 100644
--- a/clippy_lints/src/cargo/common_metadata.rs
+++ b/clippy_lints/src/cargo/common_metadata.rs
@@ -1,5 +1,3 @@
-//! lint on missing cargo common metadata
-
 use cargo_metadata::Metadata;
 use clippy_utils::diagnostics::span_lint;
 use rustc_lint::LateContext;
diff --git a/clippy_lints/src/cargo/multiple_crate_versions.rs b/clippy_lints/src/cargo/multiple_crate_versions.rs
index 2769463c8a53c..44cd1f7192fb1 100644
--- a/clippy_lints/src/cargo/multiple_crate_versions.rs
+++ b/clippy_lints/src/cargo/multiple_crate_versions.rs
@@ -1,5 +1,3 @@
-//! lint on multiple versions of a crate being used
-
 use cargo_metadata::{DependencyKind, Metadata, Node, Package, PackageId};
 use clippy_utils::diagnostics::span_lint;
 use itertools::Itertools;
diff --git a/clippy_lints/src/checked_conversions.rs b/clippy_lints/src/checked_conversions.rs
index 1711565fca891..dd7c34d1e4687 100644
--- a/clippy_lints/src/checked_conversions.rs
+++ b/clippy_lints/src/checked_conversions.rs
@@ -1,5 +1,3 @@
-//! lint on manually implemented checked conversions that could be transformed into `try_from`
-
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
diff --git a/clippy_lints/src/cognitive_complexity.rs b/clippy_lints/src/cognitive_complexity.rs
index 5fa0522e4e5f9..0099eefbc8dc1 100644
--- a/clippy_lints/src/cognitive_complexity.rs
+++ b/clippy_lints/src/cognitive_complexity.rs
@@ -1,5 +1,3 @@
-//! calculate cognitive complexity and warn about overly complex functions
-
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::{IntoSpan, SpanRangeExt};
diff --git a/clippy_lints/src/collapsible_if.rs b/clippy_lints/src/collapsible_if.rs
index f311c052ad6ee..e73bfc6ebf7a1 100644
--- a/clippy_lints/src/collapsible_if.rs
+++ b/clippy_lints/src/collapsible_if.rs
@@ -1,17 +1,3 @@
-//! Checks for if expressions that contain only an if expression.
-//!
-//! For example, the lint would catch:
-//!
-//! ```rust,ignore
-//! if x {
-//!     if y {
-//!         println!("Hello world");
-//!     }
-//! }
-//! ```
-//!
-//! This lint is **warn** by default
-
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
 use clippy_utils::source::{snippet, snippet_block, snippet_block_with_applicability};
 use clippy_utils::sugg::Sugg;
diff --git a/clippy_lints/src/else_if_without_else.rs b/clippy_lints/src/else_if_without_else.rs
index 02f9c2c36488d..5315f55ba3882 100644
--- a/clippy_lints/src/else_if_without_else.rs
+++ b/clippy_lints/src/else_if_without_else.rs
@@ -1,5 +1,3 @@
-//! Lint on if expressions with an else if, but without a final else branch.
-
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
diff --git a/clippy_lints/src/empty_enum.rs b/clippy_lints/src/empty_enum.rs
index 1869faab1d326..f4c55738cb83a 100644
--- a/clippy_lints/src/empty_enum.rs
+++ b/clippy_lints/src/empty_enum.rs
@@ -1,5 +1,3 @@
-//! lint when there is an enum with no variants
-
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
index e54cd248ead29..4755cefe784c5 100644
--- a/clippy_lints/src/enum_clike.rs
+++ b/clippy_lints/src/enum_clike.rs
@@ -1,6 +1,3 @@
-//! lint on C-like enums that are `repr(isize/usize)` and have values that
-//! don't fit into an `i32`
-
 use clippy_utils::consts::{mir_to_const, Constant};
 use clippy_utils::diagnostics::span_lint;
 use rustc_hir::{Item, ItemKind};
diff --git a/clippy_lints/src/if_not_else.rs b/clippy_lints/src/if_not_else.rs
index 0ebd8d0c237b6..120c5396a1cd5 100644
--- a/clippy_lints/src/if_not_else.rs
+++ b/clippy_lints/src/if_not_else.rs
@@ -1,6 +1,3 @@
-//! lint on if branches that could be swapped so no `!` operation is necessary
-//! on the condition
-
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_else_clause;
diff --git a/clippy_lints/src/indexing_slicing.rs b/clippy_lints/src/indexing_slicing.rs
index 3ac50b8f1fba5..22e9674714fe5 100644
--- a/clippy_lints/src/indexing_slicing.rs
+++ b/clippy_lints/src/indexing_slicing.rs
@@ -1,5 +1,3 @@
-//! lint on indexing and slicing operations
-
 use clippy_config::Conf;
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
diff --git a/clippy_lints/src/inherent_impl.rs b/clippy_lints/src/inherent_impl.rs
index 9eed7aa924339..d39f910f9936d 100644
--- a/clippy_lints/src/inherent_impl.rs
+++ b/clippy_lints/src/inherent_impl.rs
@@ -1,5 +1,3 @@
-//! lint on inherent implementations
-
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_lint_allowed;
 use rustc_data_structures::fx::FxHashMap;
diff --git a/clippy_lints/src/inline_fn_without_body.rs b/clippy_lints/src/inline_fn_without_body.rs
index 5657c58bb0a47..1b900f6be8e85 100644
--- a/clippy_lints/src/inline_fn_without_body.rs
+++ b/clippy_lints/src/inline_fn_without_body.rs
@@ -1,5 +1,3 @@
-//! checks for `#[inline]` on trait methods without bodies
-
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::sugg::DiagExt;
 use rustc_errors::Applicability;
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index b8e0eef7c7e9e..941caaab1f1bf 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -1,5 +1,3 @@
-//! lint on blocks unnecessarily using >= with a + 1 or - 1
-
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, LitKind};
diff --git a/clippy_lints/src/item_name_repetitions.rs b/clippy_lints/src/item_name_repetitions.rs
index 4d44bae02b87d..74bf82f58bdcf 100644
--- a/clippy_lints/src/item_name_repetitions.rs
+++ b/clippy_lints/src/item_name_repetitions.rs
@@ -1,5 +1,3 @@
-//! lint on enum variants that are prefixed or suffixed by the same characters
-
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_help, span_lint_hir};
 use clippy_utils::is_bool;
diff --git a/clippy_lints/src/items_after_statements.rs b/clippy_lints/src/items_after_statements.rs
index a88d8e24fda8d..4f066113aea33 100644
--- a/clippy_lints/src/items_after_statements.rs
+++ b/clippy_lints/src/items_after_statements.rs
@@ -1,5 +1,3 @@
-//! lint when items are used after statements
-
 use clippy_utils::diagnostics::span_lint_hir;
 use rustc_hir::{Block, ItemKind, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
diff --git a/clippy_lints/src/large_enum_variant.rs b/clippy_lints/src/large_enum_variant.rs
index 225d79aa71d68..2f027c1170728 100644
--- a/clippy_lints/src/large_enum_variant.rs
+++ b/clippy_lints/src/large_enum_variant.rs
@@ -1,5 +1,3 @@
-//! lint when there is a large size difference between variants on an enum
-
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet_with_applicability;
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index 259e4d6c08fb7..f51c593b2de9e 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -1,6 +1,3 @@
-//! Lints concerned with the grouping of digits with underscores in integral or
-//! floating-point literal expressions.
-
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::numeric_literal::{NumericLiteral, Radix};
diff --git a/clippy_lints/src/methods/is_digit_ascii_radix.rs b/clippy_lints/src/methods/is_digit_ascii_radix.rs
index 22d896433f07a..40b48ccca5d5d 100644
--- a/clippy_lints/src/methods/is_digit_ascii_radix.rs
+++ b/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -1,5 +1,3 @@
-//! Lint for `c.is_digit(10)`
-
 use super::IS_DIGIT_ASCII_RADIX;
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::consts::{ConstEvalCtxt, FullInt};
diff --git a/clippy_lints/src/mutex_atomic.rs b/clippy_lints/src/mutex_atomic.rs
index 853e476a006c6..3884149645883 100644
--- a/clippy_lints/src/mutex_atomic.rs
+++ b/clippy_lints/src/mutex_atomic.rs
@@ -1,7 +1,3 @@
-//! Checks for usage of mutex where an atomic value could be used
-//!
-//! This lint is **allow** by default
-
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_hir::Expr;
diff --git a/clippy_lints/src/needless_bool.rs b/clippy_lints/src/needless_bool.rs
index 9cb4fa41c73f1..df155a7a41257 100644
--- a/clippy_lints/src/needless_bool.rs
+++ b/clippy_lints/src/needless_bool.rs
@@ -1,7 +1,3 @@
-//! Checks for needless boolean results of if-else expressions
-//!
-//! This lint is **warn** by default
-
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
diff --git a/clippy_lints/src/needless_continue.rs b/clippy_lints/src/needless_continue.rs
index b97cb4579ca7b..ce97370d4d9fa 100644
--- a/clippy_lints/src/needless_continue.rs
+++ b/clippy_lints/src/needless_continue.rs
@@ -1,38 +1,3 @@
-//! Checks for continue statements in loops that are redundant.
-//!
-//! For example, the lint would catch
-//!
-//! ```rust
-//! let mut a = 1;
-//! let x = true;
-//!
-//! while a < 5 {
-//!     a = 6;
-//!     if x {
-//!         // ...
-//!     } else {
-//!         continue;
-//!     }
-//!     println!("Hello, world");
-//! }
-//! ```
-//!
-//! And suggest something like this:
-//!
-//! ```rust
-//! let mut a = 1;
-//! let x = true;
-//!
-//! while a < 5 {
-//!     a = 6;
-//!     if x {
-//!         // ...
-//!         println!("Hello, world");
-//!     }
-//! }
-//! ```
-//!
-//! This lint is **warn** by default.
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::source::{indent_of, snippet, snippet_block};
 use rustc_ast::ast;
diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index 6915cd4061551..e50562d8e4973 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -1,7 +1,3 @@
-//! Checks for usage of const which the type is not `Freeze` (`Cell`-free).
-//!
-//! This lint is **warn** by default.
-
 use std::ptr;
 
 use clippy_config::Conf;
diff --git a/clippy_lints/src/ptr.rs b/clippy_lints/src/ptr.rs
index 1e824681fa12f..125f694996c1c 100644
--- a/clippy_lints/src/ptr.rs
+++ b/clippy_lints/src/ptr.rs
@@ -1,5 +1,3 @@
-//! Checks for usage of  `&Vec[_]` and `&String`.
-
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::expr_sig;
diff --git a/clippy_lints/src/size_of_in_element_count.rs b/clippy_lints/src/size_of_in_element_count.rs
index 01f0e3cfadbd4..7750d8909d362 100644
--- a/clippy_lints/src/size_of_in_element_count.rs
+++ b/clippy_lints/src/size_of_in_element_count.rs
@@ -1,6 +1,3 @@
-//! Lint on use of `size_of` or `size_of_val` of T in an expression
-//! expecting a count of T
-
 use clippy_utils::diagnostics::span_lint_and_help;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
diff --git a/clippy_lints/src/utils/author.rs b/clippy_lints/src/utils/author.rs
index 316c1f32d3a2a..0cce45290cfe7 100644
--- a/clippy_lints/src/utils/author.rs
+++ b/clippy_lints/src/utils/author.rs
@@ -1,6 +1,3 @@
-//! A group of attributes that can be attached to Rust code in order
-//! to generate a clippy lint detecting said code automatically.
-
 use clippy_utils::{get_attr, higher};
 use rustc_ast::ast::{LitFloatType, LitKind};
 use rustc_ast::LitIntType;

From 6993752607f75165f6b2fd41e7d622648e1a313c Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Sat, 17 Aug 2024 18:42:21 +0000
Subject: [PATCH 378/685] Replace some iteration with
 `get_[type_]diagnostic_name`

---
 clippy_lints/src/collection_is_never_read.rs | 37 +++++++++-----------
 clippy_lints/src/functions/must_use.rs       |  8 ++---
 clippy_lints/src/infinite_iter.rs            | 33 ++++++++---------
 clippy_lints/src/manual_retain.rs            | 34 ++++++++----------
 clippy_lints/src/methods/needless_collect.rs |  9 ++---
 clippy_lints/src/mut_key.rs                  | 14 ++++----
 6 files changed, 60 insertions(+), 75 deletions(-)

diff --git a/clippy_lints/src/collection_is_never_read.rs b/clippy_lints/src/collection_is_never_read.rs
index eebda3ff76fd9..c6847411c75ab 100644
--- a/clippy_lints/src/collection_is_never_read.rs
+++ b/clippy_lints/src/collection_is_never_read.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint;
-use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
+use clippy_utils::ty::{get_type_diagnostic_name, is_type_lang_item};
 use clippy_utils::visitors::{for_each_expr, Visitable};
 use clippy_utils::{get_enclosing_block, path_to_local_id};
 use core::ops::ControlFlow;
@@ -7,7 +7,6 @@ use rustc_hir::{Body, ExprKind, HirId, LangItem, LetStmt, Node, PatKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
-use rustc_span::Symbol;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -44,24 +43,11 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(CollectionIsNeverRead => [COLLECTION_IS_NEVER_READ]);
 
-// Add `String` here when it is added to diagnostic items
-static COLLECTIONS: [Symbol; 9] = [
-    sym::BTreeMap,
-    sym::BTreeSet,
-    sym::BinaryHeap,
-    sym::HashMap,
-    sym::HashSet,
-    sym::LinkedList,
-    sym::Option,
-    sym::Vec,
-    sym::VecDeque,
-];
-
 impl<'tcx> LateLintPass<'tcx> for CollectionIsNeverRead {
     fn check_local(&mut self, cx: &LateContext<'tcx>, local: &'tcx LetStmt<'tcx>) {
         // Look for local variables whose type is a container. Search surrounding block for read access.
         if let PatKind::Binding(_, local_id, _, _) = local.pat.kind
-            && match_acceptable_type(cx, local, &COLLECTIONS)
+            && match_acceptable_type(cx, local)
             && let Some(enclosing_block) = get_enclosing_block(cx, local.hir_id)
             && has_no_read_access(cx, local_id, enclosing_block)
         {
@@ -70,11 +56,22 @@ impl<'tcx> LateLintPass<'tcx> for CollectionIsNeverRead {
     }
 }
 
-fn match_acceptable_type(cx: &LateContext<'_>, local: &LetStmt<'_>, collections: &[Symbol]) -> bool {
+fn match_acceptable_type(cx: &LateContext<'_>, local: &LetStmt<'_>) -> bool {
     let ty = cx.typeck_results().pat_ty(local.pat);
-    collections.iter().any(|&sym| is_type_diagnostic_item(cx, ty, sym))
-    // String type is a lang item but not a diagnostic item for now so we need a separate check
-        || is_type_lang_item(cx, ty, LangItem::String)
+    matches!(
+        get_type_diagnostic_name(cx, ty),
+        Some(
+            sym::BTreeMap
+                | sym::BTreeSet
+                | sym::BinaryHeap
+                | sym::HashMap
+                | sym::HashSet
+                | sym::LinkedList
+                | sym::Option
+                | sym::Vec
+                | sym::VecDeque
+        )
+    ) || is_type_lang_item(cx, ty, LangItem::String)
 }
 
 fn has_no_read_access<'tcx, T: Visitable<'tcx>>(cx: &LateContext<'tcx>, id: HirId, block: T) -> bool {
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index b179d7b52492c..b008ce6892100 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -8,7 +8,7 @@ use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::{sym, Span, Symbol};
+use rustc_span::{sym, Span};
 
 use clippy_utils::attrs::is_proc_macro;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
@@ -193,17 +193,13 @@ fn is_mutable_pat(cx: &LateContext<'_>, pat: &hir::Pat<'_>, tys: &mut DefIdSet)
     }
 }
 
-static KNOWN_WRAPPER_TYS: &[Symbol] = &[sym::Rc, sym::Arc];
-
 fn is_mutable_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, tys: &mut DefIdSet) -> bool {
     match *ty.kind() {
         // primitive types are never mutable
         ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
         ty::Adt(adt, args) => {
             tys.insert(adt.did()) && !ty.is_freeze(cx.tcx, cx.param_env)
-                || KNOWN_WRAPPER_TYS
-                    .iter()
-                    .any(|&sym| cx.tcx.is_diagnostic_item(sym, adt.did()))
+                || matches!(cx.tcx.get_diagnostic_name(adt.did()), Some(sym::Rc | sym::Arc))
                     && args.types().any(|ty| is_mutable_ty(cx, ty, tys))
         },
         ty::Tuple(args) => args.iter().any(|ty| is_mutable_ty(cx, ty, tys)),
diff --git a/clippy_lints/src/infinite_iter.rs b/clippy_lints/src/infinite_iter.rs
index 676d50c4951b1..71c317552ee1a 100644
--- a/clippy_lints/src/infinite_iter.rs
+++ b/clippy_lints/src/infinite_iter.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::higher;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use clippy_utils::ty::{get_type_diagnostic_name, implements_trait};
 use rustc_hir::{BorrowKind, Closure, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::symbol::{sym, Symbol};
+use rustc_span::symbol::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -210,18 +210,6 @@ const COMPLETING_METHODS: [(&str, usize); 12] = [
     ("product", 0),
 ];
 
-/// the paths of types that are known to be infinitely allocating
-const INFINITE_COLLECTORS: &[Symbol] = &[
-    sym::BinaryHeap,
-    sym::BTreeMap,
-    sym::BTreeSet,
-    sym::HashMap,
-    sym::HashSet,
-    sym::LinkedList,
-    sym::Vec,
-    sym::VecDeque,
-];
-
 fn complete_infinite_iter(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
     match expr.kind {
         ExprKind::MethodCall(method, receiver, args, _) => {
@@ -248,10 +236,19 @@ fn complete_infinite_iter(cx: &LateContext<'_>, expr: &Expr<'_>) -> Finiteness {
                 }
             } else if method.ident.name == sym!(collect) {
                 let ty = cx.typeck_results().expr_ty(expr);
-                if INFINITE_COLLECTORS
-                    .iter()
-                    .any(|diag_item| is_type_diagnostic_item(cx, ty, *diag_item))
-                {
+                if matches!(
+                    get_type_diagnostic_name(cx, ty),
+                    Some(
+                        sym::BinaryHeap
+                            | sym::BTreeMap
+                            | sym::BTreeSet
+                            | sym::HashMap
+                            | sym::HashSet
+                            | sym::LinkedList
+                            | sym::Vec
+                            | sym::VecDeque,
+                    )
+                ) {
                     return is_infinite(cx, receiver);
                 }
             }
diff --git a/clippy_lints/src/manual_retain.rs b/clippy_lints/src/manual_retain.rs
index d549470ed47e1..d4e53f8f74bd6 100644
--- a/clippy_lints/src/manual_retain.rs
+++ b/clippy_lints/src/manual_retain.rs
@@ -2,14 +2,14 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
-use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
+use clippy_utils::ty::{get_type_diagnostic_name, is_type_lang_item};
 use clippy_utils::{match_def_path, paths, SpanlessEq};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_hir::ExprKind::Assign;
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::{impl_lint_pass, RustcVersion};
+use rustc_session::impl_lint_pass;
 use rustc_span::symbol::sym;
 use rustc_span::Span;
 
@@ -20,16 +20,6 @@ const ACCEPTABLE_METHODS: [&[&str]; 5] = [
     &paths::SLICE_INTO,
     &paths::VEC_DEQUE_ITER,
 ];
-const ACCEPTABLE_TYPES: [(rustc_span::Symbol, Option<RustcVersion>); 7] = [
-    (sym::BinaryHeap, Some(msrvs::BINARY_HEAP_RETAIN)),
-    (sym::BTreeSet, Some(msrvs::BTREE_SET_RETAIN)),
-    (sym::BTreeMap, Some(msrvs::BTREE_MAP_RETAIN)),
-    (sym::HashSet, Some(msrvs::HASH_SET_RETAIN)),
-    (sym::HashMap, Some(msrvs::HASH_MAP_RETAIN)),
-    (sym::Vec, None),
-    (sym::VecDeque, None),
-];
-const MAP_TYPES: [rustc_span::Symbol; 2] = [sym::BTreeMap, sym::HashMap];
 
 declare_clippy_lint! {
     /// ### What it does
@@ -264,16 +254,22 @@ fn match_acceptable_def_path(cx: &LateContext<'_>, collect_def_id: DefId) -> boo
 }
 
 fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: &Msrv) -> bool {
-    let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
-    ACCEPTABLE_TYPES.iter().any(|(ty, acceptable_msrv)| {
-        is_type_diagnostic_item(cx, expr_ty, *ty)
-            && acceptable_msrv.map_or(true, |acceptable_msrv| msrv.meets(acceptable_msrv))
-    })
+    let ty = cx.typeck_results().expr_ty(expr).peel_refs();
+    let required = match get_type_diagnostic_name(cx, ty) {
+        Some(sym::BinaryHeap) => msrvs::BINARY_HEAP_RETAIN,
+        Some(sym::BTreeSet) => msrvs::BTREE_SET_RETAIN,
+        Some(sym::BTreeMap) => msrvs::BTREE_MAP_RETAIN,
+        Some(sym::HashSet) => msrvs::HASH_SET_RETAIN,
+        Some(sym::HashMap) => msrvs::HASH_MAP_RETAIN,
+        Some(sym::Vec | sym::VecDeque) => return true,
+        _ => return false,
+    };
+    msrv.meets(required)
 }
 
 fn match_map_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
-    let expr_ty = cx.typeck_results().expr_ty(expr).peel_refs();
-    MAP_TYPES.iter().any(|ty| is_type_diagnostic_item(cx, expr_ty, *ty))
+    let ty = cx.typeck_results().expr_ty(expr).peel_refs();
+    matches!(get_type_diagnostic_name(cx, ty), Some(sym::BTreeMap | sym::HashMap))
 }
 
 fn make_span_lint_and_sugg(cx: &LateContext<'_>, span: Span, sugg: String) {
diff --git a/clippy_lints/src/methods/needless_collect.rs b/clippy_lints/src/methods/needless_collect.rs
index 46b457daf7074..f61923e5bf569 100644
--- a/clippy_lints/src/methods/needless_collect.rs
+++ b/clippy_lints/src/methods/needless_collect.rs
@@ -2,7 +2,7 @@ use super::NEEDLESS_COLLECT;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{snippet, snippet_with_applicability};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::ty::{is_type_diagnostic_item, make_normalized_projection, make_projection};
+use clippy_utils::ty::{get_type_diagnostic_name, make_normalized_projection, make_projection};
 use clippy_utils::{
     can_move_expr_to_closure, fn_def_id, get_enclosing_block, higher, is_trait_method, path_to_local, path_to_local_id,
     CaptureKind,
@@ -88,9 +88,10 @@ pub(super) fn check<'tcx>(
         Node::LetStmt(l) => {
             if let PatKind::Binding(BindingMode::NONE | BindingMode::MUT, id, _, None) = l.pat.kind
                 && let ty = cx.typeck_results().expr_ty(collect_expr)
-                && [sym::Vec, sym::VecDeque, sym::BinaryHeap, sym::LinkedList]
-                    .into_iter()
-                    .any(|item| is_type_diagnostic_item(cx, ty, item))
+                && matches!(
+                    get_type_diagnostic_name(cx, ty),
+                    Some(sym::Vec | sym::VecDeque | sym::BinaryHeap | sym::LinkedList)
+                )
                 && let iter_ty = cx.typeck_results().expr_ty(iter_expr)
                 && let Some(block) = get_enclosing_block(cx, l.hir_id)
                 && let Some(iter_calls) = detect_iter_and_into_iters(block, id, cx, get_captured_ids(cx, iter_ty))
diff --git a/clippy_lints/src/mut_key.rs b/clippy_lints/src/mut_key.rs
index 83af9979b9e36..f52b3a6a5a160 100644
--- a/clippy_lints/src/mut_key.rs
+++ b/clippy_lints/src/mut_key.rs
@@ -125,14 +125,12 @@ impl<'tcx> MutableKeyType<'tcx> {
     // generics (because the compiler cannot ensure immutability for unknown types).
     fn check_ty_(&mut self, cx: &LateContext<'tcx>, span: Span, ty: Ty<'tcx>) {
         let ty = ty.peel_refs();
-        if let ty::Adt(def, args) = ty.kind() {
-            let is_keyed_type = [sym::HashMap, sym::BTreeMap, sym::HashSet, sym::BTreeSet]
-                .iter()
-                .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def.did()));
-            if !is_keyed_type {
-                return;
-            }
-
+        if let ty::Adt(def, args) = ty.kind()
+            && matches!(
+                cx.tcx.get_diagnostic_name(def.did()),
+                Some(sym::HashMap | sym::BTreeMap | sym::HashSet | sym::BTreeSet)
+            )
+        {
             let subst_ty = args.type_at(0);
             if self.interior_mut.is_interior_mut_ty(cx, subst_ty) {
                 span_lint(cx, MUTABLE_KEY_TYPE, span, "mutable key type");

From 0156eb57a152003c0c82552229747b3d04e1fddc Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Fri, 16 Aug 2024 19:32:22 +0000
Subject: [PATCH 379/685] Always use ar_archive_writer for import libs

---
 Cargo.lock                                    |  4 +-
 .../rustc_codegen_cranelift/src/archive.rs    | 83 +---------------
 compiler/rustc_codegen_cranelift/src/lib.rs   |  1 -
 compiler/rustc_codegen_llvm/messages.ftl      |  3 -
 .../rustc_codegen_llvm/src/back/archive.rs    | 94 +------------------
 compiler/rustc_codegen_llvm/src/errors.rs     |  7 --
 compiler/rustc_codegen_ssa/Cargo.toml         |  2 +-
 compiler/rustc_codegen_ssa/messages.ftl       |  3 +
 .../rustc_codegen_ssa/src/back/archive.rs     | 86 ++++++++++++++++-
 compiler/rustc_codegen_ssa/src/errors.rs      |  7 ++
 10 files changed, 100 insertions(+), 190 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1aa0b2ea4a398..ae5d3e12e3af9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -205,9 +205,9 @@ dependencies = [
 
 [[package]]
 name = "ar_archive_writer"
-version = "0.3.3"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f2bcb7cf51decfbbfc7ef476e28b0775b13e5eb1190f8b7df145cd53d4f4374"
+checksum = "de11a9d32db3327f981143bdf699ade4d637c6887b13b97e6e91a9154666963c"
 dependencies = [
  "object 0.36.2",
 ]
diff --git a/compiler/rustc_codegen_cranelift/src/archive.rs b/compiler/rustc_codegen_cranelift/src/archive.rs
index 5eedab4f2cbaa..c7725e49c9442 100644
--- a/compiler/rustc_codegen_cranelift/src/archive.rs
+++ b/compiler/rustc_codegen_cranelift/src/archive.rs
@@ -1,13 +1,6 @@
-use std::borrow::Borrow;
-use std::fs;
-use std::path::Path;
-
-use ar_archive_writer::{COFFShortExport, MachineTypes};
 use rustc_codegen_ssa::back::archive::{
-    create_mingw_dll_import_lib, ArArchiveBuilder, ArchiveBuilder, ArchiveBuilderBuilder,
-    DEFAULT_OBJECT_READER,
+    ArArchiveBuilder, ArchiveBuilder, ArchiveBuilderBuilder, DEFAULT_OBJECT_READER,
 };
-use rustc_codegen_ssa::common::is_mingw_gnu_toolchain;
 use rustc_session::Session;
 
 pub(crate) struct ArArchiveBuilderBuilder;
@@ -16,78 +9,4 @@ impl ArchiveBuilderBuilder for ArArchiveBuilderBuilder {
     fn new_archive_builder<'a>(&self, sess: &'a Session) -> Box<dyn ArchiveBuilder + 'a> {
         Box::new(ArArchiveBuilder::new(sess, &DEFAULT_OBJECT_READER))
     }
-
-    fn create_dll_import_lib(
-        &self,
-        sess: &Session,
-        lib_name: &str,
-        import_name_and_ordinal_vector: Vec<(String, Option<u16>)>,
-        output_path: &Path,
-    ) {
-        if is_mingw_gnu_toolchain(&sess.target) {
-            // The binutils linker used on -windows-gnu targets cannot read the import
-            // libraries generated by LLVM: in our attempts, the linker produced an .EXE
-            // that loaded but crashed with an AV upon calling one of the imported
-            // functions. Therefore, use binutils to create the import library instead,
-            // by writing a .DEF file to the temp dir and calling binutils's dlltool.
-            create_mingw_dll_import_lib(
-                sess,
-                lib_name,
-                import_name_and_ordinal_vector,
-                output_path,
-            );
-        } else {
-            let mut file =
-                match fs::OpenOptions::new().write(true).create_new(true).open(&output_path) {
-                    Ok(file) => file,
-                    Err(error) => {
-                        sess.dcx().fatal(format!(
-                            "failed to create import library file `{path}`: {error}",
-                            path = output_path.display(),
-                        ));
-                    }
-                };
-
-            let machine = match sess.target.arch.borrow() {
-                "x86" => MachineTypes::I386,
-                "x86_64" => MachineTypes::AMD64,
-                "arm" => MachineTypes::ARMNT,
-                "aarch64" => MachineTypes::ARM64,
-                _ => {
-                    sess.dcx().fatal(format!(
-                        "unsupported target architecture `{arch}`",
-                        arch = sess.target.arch,
-                    ));
-                }
-            };
-
-            let exports = import_name_and_ordinal_vector
-                .iter()
-                .map(|(name, ordinal)| COFFShortExport {
-                    name: name.to_string(),
-                    ext_name: None,
-                    symbol_name: None,
-                    alias_target: None,
-                    ordinal: ordinal.unwrap_or(0),
-                    noname: ordinal.is_some(),
-                    data: false,
-                    private: false,
-                    constant: false,
-                })
-                .collect::<Vec<_>>();
-
-            if let Err(error) = ar_archive_writer::write_import_library(
-                &mut file,
-                lib_name,
-                &exports,
-                machine,
-                !sess.target.is_like_msvc,
-            ) {
-                sess.dcx().fatal(format!(
-                    "failed to create import library `{path}`: `{error}`",
-                    path = output_path.display(),
-                ));
-            }
-        }
-    }
 }
diff --git a/compiler/rustc_codegen_cranelift/src/lib.rs b/compiler/rustc_codegen_cranelift/src/lib.rs
index 21930fa2ddb49..f737af25b62ee 100644
--- a/compiler/rustc_codegen_cranelift/src/lib.rs
+++ b/compiler/rustc_codegen_cranelift/src/lib.rs
@@ -12,7 +12,6 @@
 #![warn(unused_lifetimes)]
 // tidy-alphabetical-end
 
-extern crate ar_archive_writer;
 extern crate jobserver;
 #[macro_use]
 extern crate rustc_middle;
diff --git a/compiler/rustc_codegen_llvm/messages.ftl b/compiler/rustc_codegen_llvm/messages.ftl
index 267da9325c386..df2198df14b6a 100644
--- a/compiler/rustc_codegen_llvm/messages.ftl
+++ b/compiler/rustc_codegen_llvm/messages.ftl
@@ -5,9 +5,6 @@ codegen_llvm_dynamic_linking_with_lto =
     .note = only 'staticlib', 'bin', and 'cdylib' outputs are supported with LTO
 
 
-codegen_llvm_error_creating_import_library =
-    Error creating import library for {$lib_name}: {$error}
-
 codegen_llvm_fixed_x18_invalid_arch = the `-Zfixed-x18` flag is not supported on the `{$arch}` architecture
 
 codegen_llvm_from_llvm_diag = {$message}
diff --git a/compiler/rustc_codegen_llvm/src/back/archive.rs b/compiler/rustc_codegen_llvm/src/back/archive.rs
index 2120fc1815cd8..c0ec4f86b4dbb 100644
--- a/compiler/rustc_codegen_llvm/src/back/archive.rs
+++ b/compiler/rustc_codegen_llvm/src/back/archive.rs
@@ -5,17 +5,13 @@ use std::path::{Path, PathBuf};
 use std::{io, mem, ptr, str};
 
 use rustc_codegen_ssa::back::archive::{
-    create_mingw_dll_import_lib, try_extract_macho_fat_archive, ArArchiveBuilder,
-    ArchiveBuildFailure, ArchiveBuilder, ArchiveBuilderBuilder, ObjectReader, UnknownArchiveKind,
-    DEFAULT_OBJECT_READER,
+    try_extract_macho_fat_archive, ArArchiveBuilder, ArchiveBuildFailure, ArchiveBuilder,
+    ArchiveBuilderBuilder, ObjectReader, UnknownArchiveKind, DEFAULT_OBJECT_READER,
 };
-use rustc_codegen_ssa::common;
 use rustc_session::Session;
-use tracing::trace;
 
-use crate::errors::ErrorCreatingImportLibrary;
 use crate::llvm::archive_ro::{ArchiveRO, Child};
-use crate::llvm::{self, ArchiveKind, LLVMMachineType, LLVMRustCOFFShortExport};
+use crate::llvm::{self, ArchiveKind};
 
 /// Helper for adding many files to an archive.
 #[must_use = "must call build() to finish building the archive"]
@@ -44,18 +40,6 @@ fn is_relevant_child(c: &Child<'_>) -> bool {
     }
 }
 
-/// Map machine type strings to values of LLVM's MachineTypes enum.
-fn llvm_machine_type(cpu: &str) -> LLVMMachineType {
-    match cpu {
-        "x86_64" => LLVMMachineType::AMD64,
-        "x86" => LLVMMachineType::I386,
-        "aarch64" => LLVMMachineType::ARM64,
-        "arm64ec" => LLVMMachineType::ARM64EC,
-        "arm" => LLVMMachineType::ARM,
-        _ => panic!("unsupported cpu type {cpu}"),
-    }
-}
-
 impl<'a> ArchiveBuilder for LlvmArchiveBuilder<'a> {
     fn add_archive(
         &mut self,
@@ -116,78 +100,6 @@ impl ArchiveBuilderBuilder for LlvmArchiveBuilderBuilder {
             Box::new(ArArchiveBuilder::new(sess, &LLVM_OBJECT_READER))
         }
     }
-
-    fn create_dll_import_lib(
-        &self,
-        sess: &Session,
-        lib_name: &str,
-        import_name_and_ordinal_vector: Vec<(String, Option<u16>)>,
-        output_path: &Path,
-    ) {
-        if common::is_mingw_gnu_toolchain(&sess.target) {
-            // The binutils linker used on -windows-gnu targets cannot read the import
-            // libraries generated by LLVM: in our attempts, the linker produced an .EXE
-            // that loaded but crashed with an AV upon calling one of the imported
-            // functions. Therefore, use binutils to create the import library instead,
-            // by writing a .DEF file to the temp dir and calling binutils's dlltool.
-            create_mingw_dll_import_lib(
-                sess,
-                lib_name,
-                import_name_and_ordinal_vector,
-                output_path,
-            );
-        } else {
-            // we've checked for \0 characters in the library name already
-            let dll_name_z = CString::new(lib_name).unwrap();
-
-            let output_path_z = rustc_fs_util::path_to_c_string(&output_path);
-
-            trace!("invoking LLVMRustWriteImportLibrary");
-            trace!("  dll_name {:#?}", dll_name_z);
-            trace!("  output_path {}", output_path.display());
-            trace!(
-                "  import names: {}",
-                import_name_and_ordinal_vector
-                    .iter()
-                    .map(|(name, _ordinal)| name.clone())
-                    .collect::<Vec<_>>()
-                    .join(", "),
-            );
-
-            // All import names are Rust identifiers and therefore cannot contain \0 characters.
-            // FIXME: when support for #[link_name] is implemented, ensure that the import names
-            // still don't contain any \0 characters. Also need to check that the names don't
-            // contain substrings like " @" or "NONAME" that are keywords or otherwise reserved
-            // in definition files.
-            let cstring_import_name_and_ordinal_vector: Vec<(CString, Option<u16>)> =
-                import_name_and_ordinal_vector
-                    .into_iter()
-                    .map(|(name, ordinal)| (CString::new(name).unwrap(), ordinal))
-                    .collect();
-
-            let ffi_exports: Vec<LLVMRustCOFFShortExport> = cstring_import_name_and_ordinal_vector
-                .iter()
-                .map(|(name_z, ordinal)| LLVMRustCOFFShortExport::new(name_z.as_ptr(), *ordinal))
-                .collect();
-            let result = unsafe {
-                crate::llvm::LLVMRustWriteImportLibrary(
-                    dll_name_z.as_ptr(),
-                    output_path_z.as_ptr(),
-                    ffi_exports.as_ptr(),
-                    ffi_exports.len(),
-                    llvm_machine_type(&sess.target.arch) as u16,
-                    !sess.target.is_like_msvc,
-                )
-            };
-
-            if result == crate::llvm::LLVMRustResult::Failure {
-                sess.dcx().emit_fatal(ErrorCreatingImportLibrary {
-                    lib_name,
-                    error: llvm::last_error().unwrap_or("unknown LLVM error".to_string()),
-                });
-            }
-        }
-    }
 }
 
 // The object crate doesn't know how to get symbols for LLVM bitcode and COFF bigobj files.
diff --git a/compiler/rustc_codegen_llvm/src/errors.rs b/compiler/rustc_codegen_llvm/src/errors.rs
index 7e53d32ce8cd3..e0ec9cdca5606 100644
--- a/compiler/rustc_codegen_llvm/src/errors.rs
+++ b/compiler/rustc_codegen_llvm/src/errors.rs
@@ -39,13 +39,6 @@ pub(crate) enum PossibleFeature<'a> {
     None,
 }
 
-#[derive(Diagnostic)]
-#[diag(codegen_llvm_error_creating_import_library)]
-pub(crate) struct ErrorCreatingImportLibrary<'a> {
-    pub lib_name: &'a str,
-    pub error: String,
-}
-
 #[derive(Diagnostic)]
 #[diag(codegen_llvm_symbol_already_defined)]
 pub(crate) struct SymbolAlreadyDefined<'a> {
diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml
index 6e1c323cbd063..0af34a1b9fa62 100644
--- a/compiler/rustc_codegen_ssa/Cargo.toml
+++ b/compiler/rustc_codegen_ssa/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 # tidy-alphabetical-start
-ar_archive_writer = "0.3.3"
+ar_archive_writer = "0.4.0"
 arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
 cc = "1.0.90"
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index 80f25d42a085e..8a6a2acd87d44 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -32,6 +32,9 @@ codegen_ssa_dlltool_fail_import_library =
 codegen_ssa_error_calling_dlltool =
     Error calling dlltool '{$dlltool_path}': {$error}
 
+codegen_ssa_error_creating_import_library =
+    Error creating import library for {$lib_name}: {$error}
+
 codegen_ssa_error_creating_remark_dir = failed to create remark directory: {$error}
 
 codegen_ssa_error_writing_def_file =
diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs
index 8eb44d1201640..38a440a707a23 100644
--- a/compiler/rustc_codegen_ssa/src/back/archive.rs
+++ b/compiler/rustc_codegen_ssa/src/back/archive.rs
@@ -5,7 +5,9 @@ use std::fs::{self, File};
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 
-use ar_archive_writer::{write_archive_to_stream, ArchiveKind, NewArchiveMember};
+use ar_archive_writer::{
+    write_archive_to_stream, ArchiveKind, COFFShortExport, MachineTypes, NewArchiveMember,
+};
 pub use ar_archive_writer::{ObjectReader, DEFAULT_OBJECT_READER};
 use object::read::archive::ArchiveFile;
 use object::read::macho::FatArch;
@@ -14,11 +16,15 @@ use rustc_data_structures::memmap::Mmap;
 use rustc_session::Session;
 use rustc_span::symbol::Symbol;
 use tempfile::Builder as TempFileBuilder;
+use tracing::trace;
 
 use super::metadata::search_for_section;
+use crate::common;
 // Re-exporting for rustc_codegen_llvm::back::archive
 pub use crate::errors::{ArchiveBuildFailure, ExtractBundledLibsError, UnknownArchiveKind};
-use crate::errors::{DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorWritingDEFFile};
+use crate::errors::{
+    DlltoolFailImportLibrary, ErrorCallingDllTool, ErrorCreatingImportLibrary, ErrorWritingDEFFile,
+};
 
 pub trait ArchiveBuilderBuilder {
     fn new_archive_builder<'a>(&self, sess: &'a Session) -> Box<dyn ArchiveBuilder + 'a>;
@@ -34,7 +40,81 @@ pub trait ArchiveBuilderBuilder {
         lib_name: &str,
         import_name_and_ordinal_vector: Vec<(String, Option<u16>)>,
         output_path: &Path,
-    );
+    ) {
+        if common::is_mingw_gnu_toolchain(&sess.target) {
+            // The binutils linker used on -windows-gnu targets cannot read the import
+            // libraries generated by LLVM: in our attempts, the linker produced an .EXE
+            // that loaded but crashed with an AV upon calling one of the imported
+            // functions. Therefore, use binutils to create the import library instead,
+            // by writing a .DEF file to the temp dir and calling binutils's dlltool.
+            create_mingw_dll_import_lib(
+                sess,
+                lib_name,
+                import_name_and_ordinal_vector,
+                output_path,
+            );
+        } else {
+            trace!("creating import library");
+            trace!("  dll_name {:#?}", lib_name);
+            trace!("  output_path {}", output_path.display());
+            trace!(
+                "  import names: {}",
+                import_name_and_ordinal_vector
+                    .iter()
+                    .map(|(name, _ordinal)| name.clone())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+
+            // All import names are Rust identifiers and therefore cannot contain \0 characters.
+            // FIXME: when support for #[link_name] is implemented, ensure that the import names
+            // still don't contain any \0 characters. Also need to check that the names don't
+            // contain substrings like " @" or "NONAME" that are keywords or otherwise reserved
+            // in definition files.
+
+            let mut file = match fs::File::create_new(&output_path) {
+                Ok(file) => file,
+                Err(error) => sess
+                    .dcx()
+                    .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() }),
+            };
+
+            let exports = import_name_and_ordinal_vector
+                .iter()
+                .map(|(name, ordinal)| COFFShortExport {
+                    name: name.to_string(),
+                    ext_name: None,
+                    symbol_name: None,
+                    alias_target: None,
+                    ordinal: ordinal.unwrap_or(0),
+                    noname: ordinal.is_some(),
+                    data: false,
+                    private: false,
+                    constant: false,
+                })
+                .collect::<Vec<_>>();
+            let machine = match &*sess.target.arch {
+                "x86_64" => MachineTypes::AMD64,
+                "x86" => MachineTypes::I386,
+                "aarch64" => MachineTypes::ARM64,
+                "arm64ec" => MachineTypes::ARM64EC,
+                "arm" => MachineTypes::ARMNT,
+                cpu => panic!("unsupported cpu type {cpu}"),
+            };
+
+            if let Err(error) = ar_archive_writer::write_import_library(
+                &mut file,
+                lib_name,
+                &exports,
+                machine,
+                !sess.target.is_like_msvc,
+                /*comdat=*/ false,
+            ) {
+                sess.dcx()
+                    .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() });
+            }
+        }
+    }
 
     fn extract_bundled_libs<'a>(
         &'a self,
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index 94bf0ab34e21b..573a8cf7cbe42 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -1060,3 +1060,10 @@ pub struct CompilerBuiltinsCannotCall {
     pub caller: String,
     pub callee: String,
 }
+
+#[derive(Diagnostic)]
+#[diag(codegen_ssa_error_creating_import_library)]
+pub(crate) struct ErrorCreatingImportLibrary<'a> {
+    pub lib_name: &'a str,
+    pub error: String,
+}

From 803cbaf5fb5021eafaa60578ed33d708370ba3c0 Mon Sep 17 00:00:00 2001
From: Rezwan ahmed sami <samiahmed0f0@gmail.com>
Date: Sun, 18 Aug 2024 01:11:18 +0600
Subject: [PATCH 380/685] Add f16 and f128 to
 tests/ui/consts/const-float-bits-conv.rs

---
 tests/ui/consts/const-float-bits-conv.rs | 65 +++++++++++++++++++++++-
 1 file changed, 64 insertions(+), 1 deletion(-)

diff --git a/tests/ui/consts/const-float-bits-conv.rs b/tests/ui/consts/const-float-bits-conv.rs
index 45e8ea570ed73..2c4df96562a9d 100644
--- a/tests/ui/consts/const-float-bits-conv.rs
+++ b/tests/ui/consts/const-float-bits-conv.rs
@@ -3,8 +3,9 @@
 
 #![feature(const_float_bits_conv)]
 #![feature(const_float_classify)]
+#![feature(f16)]
+#![feature(f128)]
 #![allow(unused_macro_rules)]
-
 // Don't promote
 const fn nop<T>(x: T) -> T { x }
 
@@ -28,6 +29,36 @@ fn has_broken_floats() -> bool {
     std::env::var("TARGET").is_ok_and(|v| v.contains("i586"))
 }
 
+fn f16(){
+    const_assert!((1f16).to_bits(), 0x3c00);
+    const_assert!(u16::from_be_bytes(1f16.to_be_bytes()), 0x3c00);
+    const_assert!((12.5f16).to_bits(), 0x4a40);
+    const_assert!(u16::from_le_bytes(12.5f16.to_le_bytes()), 0x4a40);
+    const_assert!((1337f16).to_bits(), 0x6539);
+    const_assert!(u16::from_ne_bytes(1337f16.to_ne_bytes()), 0x6539);
+    const_assert!((-14.25f16).to_bits(), 0xcb20);
+    const_assert!(f16::from_bits(0x3c00), 1.0);
+    const_assert!(f16::from_be_bytes(0x3c00u16.to_be_bytes()), 1.0);
+    const_assert!(f16::from_bits(0x4a40), 12.5);
+    const_assert!(f16::from_le_bytes(0x4a40u16.to_le_bytes()), 12.5);
+    const_assert!(f16::from_bits(0x5be0), 252.0);
+    const_assert!(f16::from_ne_bytes(0x5be0u16.to_ne_bytes()), 252.0);
+    const_assert!(f16::from_bits(0xcb20), -14.25);
+
+    // Check that NaNs roundtrip their bits regardless of signalingness
+    // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
+    // NOTE: These names assume `f{BITS}::NAN` is a quiet NAN and IEEE754-2008's NaN rules apply!
+    const QUIET_NAN: u16 = f16::NAN.to_bits() ^ 0x0155;
+    const SIGNALING_NAN: u16 = f16::NAN.to_bits() ^ 0x02AA;
+
+    const_assert!(f16::from_bits(QUIET_NAN).is_nan());
+    const_assert!(f16::from_bits(SIGNALING_NAN).is_nan());
+    const_assert!(f16::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
+    if !has_broken_floats() {
+        const_assert!(f16::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
+    }
+}
+
 fn f32() {
     const_assert!((1f32).to_bits(), 0x3f800000);
     const_assert!(u32::from_be_bytes(1f32.to_be_bytes()), 0x3f800000);
@@ -88,7 +119,39 @@ fn f64() {
     }
 }
 
+fn f128() {
+    const_assert!((1f128).to_bits(), 0x3fff0000000000000000000000000000);
+    const_assert!(u128::from_be_bytes(1f128.to_be_bytes()), 0x3fff0000000000000000000000000000);
+    const_assert!((12.5f128).to_bits(), 0x40029000000000000000000000000000);
+    const_assert!(u128::from_le_bytes(12.5f128.to_le_bytes()), 0x40029000000000000000000000000000);
+    const_assert!((1337f128).to_bits(), 0x40094e40000000000000000000000000);
+    const_assert!(u128::from_ne_bytes(1337f128.to_ne_bytes()), 0x40094e40000000000000000000000000);
+    const_assert!((-14.25f128).to_bits(), 0xc002c800000000000000000000000000);
+    const_assert!(f128::from_bits(0x3fff0000000000000000000000000000), 1.0);
+    const_assert!(f128::from_be_bytes(0x3fff0000000000000000000000000000u128.to_be_bytes()), 1.0);
+    const_assert!(f128::from_bits(0x40029000000000000000000000000000), 12.5);
+    const_assert!(f128::from_le_bytes(0x40029000000000000000000000000000u128.to_le_bytes()), 12.5);
+    const_assert!(f128::from_bits(0x40094e40000000000000000000000000), 1337.0);
+    assert_eq!(f128::from_ne_bytes(0x40094e40000000000000000000000000u128.to_ne_bytes()), 1337.0);
+    const_assert!(f128::from_bits(0xc002c800000000000000000000000000), -14.25);
+
+    // Check that NaNs roundtrip their bits regardless of signalingness
+    // 0xA is 0b1010; 0x5 is 0b0101 -- so these two together clobbers all the mantissa bits
+    // NOTE: These names assume `f{BITS}::NAN` is a quiet NAN and IEEE754-2008's NaN rules apply!
+    const QUIET_NAN: u128 = f128::NAN.to_bits() | 0x0000_AAAA_AAAA_AAAA_AAAA_AAAA_AAAA_AAAA;
+    const SIGNALING_NAN: u128 = f128::NAN.to_bits() ^ 0x0000_5555_5555_5555_5555_5555_5555_5555;
+
+    const_assert!(f128::from_bits(QUIET_NAN).is_nan());
+    const_assert!(f128::from_bits(SIGNALING_NAN).is_nan());
+    const_assert!(f128::from_bits(QUIET_NAN).to_bits(), QUIET_NAN);
+    if !has_broken_floats() {
+        const_assert!(f128::from_bits(SIGNALING_NAN).to_bits(), SIGNALING_NAN);
+    }
+}
+
 fn main() {
+    f16();
     f32();
     f64();
+    f128();
 }

From 7fd62320feddcb3fa85a3ab25bc4c0ac55ddac7c Mon Sep 17 00:00:00 2001
From: Luca Versari <veluca93@gmail.com>
Date: Sat, 17 Aug 2024 20:45:45 +0200
Subject: [PATCH 381/685] Fix order of normalization and recursion in const
 folding.

Fixes #126831.

Without this patch, type normalization is not always idempotent, which
leads to all sorts of bugs in places that assume that normalizing a
normalized type does nothing.
---
 .../src/traits/query/normalize.rs             |  8 +++---
 .../const-generics/const-ty-is-normalized.rs  | 25 +++++++++++++++++++
 2 files changed, 29 insertions(+), 4 deletions(-)
 create mode 100644 tests/ui/const-generics/const-ty-is-normalized.rs

diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
index 247b6e4823c4b..cb96db5f7a22e 100644
--- a/compiler/rustc_trait_selection/src/traits/query/normalize.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
@@ -333,14 +333,14 @@ impl<'cx, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'cx, 'tcx>
             return Ok(constant);
         }
 
-        let constant = constant.try_super_fold_with(self)?;
-        debug!(?constant, ?self.param_env);
-        Ok(crate::traits::with_replaced_escaping_bound_vars(
+        let constant = crate::traits::with_replaced_escaping_bound_vars(
             self.infcx,
             &mut self.universes,
             constant,
             |constant| constant.normalize(self.infcx.tcx, self.param_env),
-        ))
+        );
+        debug!(?constant, ?self.param_env);
+        constant.try_super_fold_with(self)
     }
 
     #[inline]
diff --git a/tests/ui/const-generics/const-ty-is-normalized.rs b/tests/ui/const-generics/const-ty-is-normalized.rs
new file mode 100644
index 0000000000000..784145f735ed3
--- /dev/null
+++ b/tests/ui/const-generics/const-ty-is-normalized.rs
@@ -0,0 +1,25 @@
+//@ compile-flags: -Cdebuginfo=2 --crate-type=lib
+//@ build-pass
+#![feature(adt_const_params)]
+
+const N_ISLANDS: usize = 4;
+
+pub type Matrix = [[usize; N_ISLANDS]; N_ISLANDS];
+
+const EMPTY_MATRIX: Matrix = [[0; N_ISLANDS]; N_ISLANDS];
+
+const fn to_matrix() -> Matrix {
+    EMPTY_MATRIX
+}
+
+const BRIDGE_MATRIX: [[usize; N_ISLANDS]; N_ISLANDS] = to_matrix();
+
+pub struct Walk<const CURRENT: usize, const REMAINING: Matrix> {
+    _p: (),
+}
+
+impl Walk<0, BRIDGE_MATRIX> {
+    pub const fn new() -> Self {
+        Self { _p: () }
+    }
+}

From f458886a405553294aca62defe7a90446f2a8a27 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Sat, 17 Aug 2024 17:34:52 -0700
Subject: [PATCH 382/685] Remove JohnTitor from review rotation

---
 triagebot.toml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/triagebot.toml b/triagebot.toml
index a98d5f6a7c215..161fe98fca94d 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -970,7 +970,6 @@ rustdoc = [
 docs = [
     "@ehuss",
     "@GuillaumeGomez",
-    "@JohnTitor",
 ]
 query-system = [
     "@cjgillot",

From 1687c55168f3837506afcd2240a8a0b6eadcc1eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?=
 <39484203+jieyouxu@users.noreply.github.com>
Date: Sat, 17 Aug 2024 17:06:26 +0800
Subject: [PATCH 383/685] bootstrap: fix clean's `remove_dir_all`
 implementation

... by using `std::fs::remove_dir_all`, which handles a bunch of edge
cases including read-only files and symlinks which are extremely tricky
on Windows.
---
 src/bootstrap/src/core/build_steps/clean.rs | 93 ++++-----------------
 1 file changed, 15 insertions(+), 78 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/clean.rs b/src/bootstrap/src/core/build_steps/clean.rs
index f608e5d715e49..bcbe490c36a0f 100644
--- a/src/bootstrap/src/core/build_steps/clean.rs
+++ b/src/bootstrap/src/core/build_steps/clean.rs
@@ -6,7 +6,6 @@
 //! directory unless the `--all` flag is present.
 
 use std::fs;
-use std::io::{self, ErrorKind};
 use std::path::Path;
 
 use crate::core::builder::{crate_description, Builder, RunConfig, ShouldRun, Step};
@@ -101,11 +100,11 @@ fn clean(build: &Build, all: bool, stage: Option<u32>) {
         return;
     }
 
-    rm_rf("tmp".as_ref());
+    remove_dir_recursive("tmp");
 
     // Clean the entire build directory
     if all {
-        rm_rf(&build.out);
+        remove_dir_recursive(&build.out);
         return;
     }
 
@@ -136,17 +135,17 @@ fn clean_specific_stage(build: &Build, stage: u32) {
             }
 
             let path = t!(entry.path().canonicalize());
-            rm_rf(&path);
+            remove_dir_recursive(&path);
         }
     }
 }
 
 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("bootstrap-shims-dump"));
-    rm_rf(&build.out.join("rustfmt.stamp"));
+    remove_dir_recursive(build.out.join("tmp"));
+    remove_dir_recursive(build.out.join("dist"));
+    remove_dir_recursive(build.out.join("bootstrap").join(".last-warned-change-id"));
+    remove_dir_recursive(build.out.join("bootstrap-shims-dump"));
+    remove_dir_recursive(build.out.join("rustfmt.stamp"));
 
     let mut hosts: Vec<_> = build.hosts.iter().map(|t| build.out.join(t)).collect();
     // After cross-compilation, artifacts of the host architecture (which may differ from build.host)
@@ -166,78 +165,16 @@ fn clean_default(build: &Build) {
                 continue;
             }
             let path = t!(entry.path().canonicalize());
-            rm_rf(&path);
+            remove_dir_recursive(&path);
         }
     }
 }
 
-fn rm_rf(path: &Path) {
-    match path.symlink_metadata() {
-        Err(e) => {
-            if e.kind() == ErrorKind::NotFound {
-                return;
-            }
-            panic!("failed to get metadata for file {}: {}", path.display(), e);
-        }
-        Ok(metadata) => {
-            if metadata.file_type().is_file() || metadata.file_type().is_symlink() {
-                do_op(path, "remove file", |p| match fs::remove_file(p) {
-                    #[cfg(windows)]
-                    Err(e)
-                        if e.kind() == std::io::ErrorKind::PermissionDenied
-                            && p.file_name().and_then(std::ffi::OsStr::to_str)
-                                == Some("bootstrap.exe") =>
-                    {
-                        eprintln!("WARNING: failed to delete '{}'.", p.display());
-                        Ok(())
-                    }
-                    r => r,
-                });
-
-                return;
-            }
-
-            for file in t!(fs::read_dir(path)) {
-                rm_rf(&t!(file).path());
-            }
-
-            do_op(path, "remove dir", |p| match fs::remove_dir(p) {
-                // Check for dir not empty on Windows
-                // FIXME: Once `ErrorKind::DirectoryNotEmpty` is stabilized,
-                // match on `e.kind()` instead.
-                #[cfg(windows)]
-                Err(e) if e.raw_os_error() == Some(145) => Ok(()),
-                r => r,
-            });
-        }
-    };
-}
-
-fn do_op<F>(path: &Path, desc: &str, mut f: F)
-where
-    F: FnMut(&Path) -> io::Result<()>,
-{
-    match f(path) {
-        Ok(()) => {}
-        // On windows we can't remove a readonly file, and git will often clone files as readonly.
-        // As a result, we have some special logic to remove readonly files on windows.
-        // This is also the reason that we can't use things like fs::remove_dir_all().
-        #[cfg(windows)]
-        Err(ref e) if e.kind() == ErrorKind::PermissionDenied => {
-            let m = t!(path.symlink_metadata());
-            let mut p = m.permissions();
-            p.set_readonly(false);
-            t!(fs::set_permissions(path, p));
-            f(path).unwrap_or_else(|e| {
-                // Delete symlinked directories on Windows
-                if m.file_type().is_symlink() && path.is_dir() && fs::remove_dir(path).is_ok() {
-                    return;
-                }
-                panic!("failed to {} {}: {}", desc, path.display(), e);
-            });
-        }
-        Err(e) => {
-            panic!("failed to {} {}: {}", desc, path.display(), e);
-        }
+/// Wrapper for [`std::fs::remove_dir_all`] that panics on failure and prints the `path` we failed
+/// on.
+fn remove_dir_recursive<P: AsRef<Path>>(path: P) {
+    let path = path.as_ref();
+    if let Err(e) = fs::remove_dir_all(path) {
+        panic!("failed to `remove_dir_all` at `{}`: {e}", path.display());
     }
 }

From c0e799db1a0acfd638a8a165eb703766b683ff37 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Sun, 18 Aug 2024 01:57:24 +0800
Subject: [PATCH 384/685] Set EINVAL for epoll_wait maxevent value 0

---
 src/tools/miri/src/shims/unix/linux/epoll.rs     |  3 ++-
 src/tools/miri/tests/pass-dep/libc/libc-epoll.rs | 15 +++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index 127817d5bbe3b..c69a2ac216e6d 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -409,11 +409,12 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         )?;
         let timeout = this.read_scalar(timeout)?.to_i32()?;
 
-        if epfd <= 0 {
+        if epfd <= 0 || maxevents <= 0 {
             let einval = this.eval_libc("EINVAL");
             this.set_last_error(einval)?;
             return Ok(Scalar::from_i32(-1));
         }
+
         // FIXME: Implement blocking support
         if timeout != 0 {
             throw_unsup_format!("epoll_wait: timeout value can only be 0");
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index 71f0e832afb11..eb742f2ccfb0a 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -19,6 +19,7 @@ fn main() {
     test_epoll_ctl_del();
     test_pointer();
     test_two_same_fd_in_same_epoll_instance();
+    test_epoll_wait_less_maxevent_zero();
 }
 
 // Using `as` cast since `EPOLLET` wraps around
@@ -528,3 +529,17 @@ fn test_no_notification_for_unregister_flag() {
     let expected_value = u64::try_from(fds[0]).unwrap();
     check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
+
+
+fn test_epoll_wait_less_maxevent_zero() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+    // It is ok to use uninitialised pointer here because it will error out before the
+    // pointer actually get accessed.
+    let array_ptr = MaybeUninit::<libc::epoll_event>::uninit().as_mut_ptr();
+    let res = unsafe { libc::epoll_wait(epfd, array_ptr, 0, 0) };
+    let e = std::io::Error::last_os_error();
+    assert_eq!(e.raw_os_error(), Some(libc::EINVAL));
+    assert_eq!(res, -1);
+}

From 9f39427228d09d7a06b9dd55a4f52b4b9ac15817 Mon Sep 17 00:00:00 2001
From: Rezwan ahmed sami <samiahmed0f0@gmail.com>
Date: Sun, 18 Aug 2024 11:12:40 +0600
Subject: [PATCH 385/685] Added #[cfg(target_arch = x86_64)] to f16 and f128

---
 tests/ui/consts/const-float-bits-conv.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/tests/ui/consts/const-float-bits-conv.rs b/tests/ui/consts/const-float-bits-conv.rs
index 2c4df96562a9d..3a526c54dc376 100644
--- a/tests/ui/consts/const-float-bits-conv.rs
+++ b/tests/ui/consts/const-float-bits-conv.rs
@@ -29,6 +29,7 @@ fn has_broken_floats() -> bool {
     std::env::var("TARGET").is_ok_and(|v| v.contains("i586"))
 }
 
+#[cfg(target_arch = "x86_64")]
 fn f16(){
     const_assert!((1f16).to_bits(), 0x3c00);
     const_assert!(u16::from_be_bytes(1f16.to_be_bytes()), 0x3c00);
@@ -119,6 +120,7 @@ fn f64() {
     }
 }
 
+#[cfg(target_arch = "x86_64")]
 fn f128() {
     const_assert!((1f128).to_bits(), 0x3fff0000000000000000000000000000);
     const_assert!(u128::from_be_bytes(1f128.to_be_bytes()), 0x3fff0000000000000000000000000000);
@@ -150,8 +152,11 @@ fn f128() {
 }
 
 fn main() {
-    f16();
+    #[cfg(target_arch = "x86_64")]
+    {
+        f16();
+        f128();
+    }
     f32();
     f64();
-    f128();
 }

From 8ae118dc0a9115c6a2783fd42a236d54fab15417 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Sun, 18 Aug 2024 13:36:56 +0800
Subject: [PATCH 386/685] Move the maxevents.try_into().unwrap() after value
 check

---
 src/tools/miri/src/shims/unix/linux/epoll.rs     | 12 +++++++-----
 src/tools/miri/tests/pass-dep/libc/libc-epoll.rs |  5 ++---
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index c69a2ac216e6d..9ee2ad9625772 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -403,18 +403,20 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         let epfd = this.read_scalar(epfd)?.to_i32()?;
         let maxevents = this.read_scalar(maxevents)?.to_i32()?;
-        let event = this.deref_pointer_as(
-            events_op,
-            this.libc_array_ty_layout("epoll_event", maxevents.try_into().unwrap()),
-        )?;
         let timeout = this.read_scalar(timeout)?.to_i32()?;
-
         if epfd <= 0 || maxevents <= 0 {
             let einval = this.eval_libc("EINVAL");
             this.set_last_error(einval)?;
             return Ok(Scalar::from_i32(-1));
         }
 
+        // This needs to come after the maxevents value check, or else maxevents.try_into().unwrap()
+        // will fail.
+        let event = this.deref_pointer_as(
+            events_op,
+            this.libc_array_ty_layout("epoll_event", maxevents.try_into().unwrap()),
+        )?;
+
         // FIXME: Implement blocking support
         if timeout != 0 {
             throw_unsup_format!("epoll_wait: timeout value can only be 0");
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index eb742f2ccfb0a..773204c49476d 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -19,7 +19,7 @@ fn main() {
     test_epoll_ctl_del();
     test_pointer();
     test_two_same_fd_in_same_epoll_instance();
-    test_epoll_wait_less_maxevent_zero();
+    test_epoll_wait_maxevent_zero();
 }
 
 // Using `as` cast since `EPOLLET` wraps around
@@ -530,8 +530,7 @@ fn test_no_notification_for_unregister_flag() {
     check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
 
-
-fn test_epoll_wait_less_maxevent_zero() {
+fn test_epoll_wait_maxevent_zero() {
     // Create an epoll instance.
     let epfd = unsafe { libc::epoll_create1(0) };
     assert_ne!(epfd, -1);

From c7832b8d05d50478836532688ac90eb1d1ad9f23 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sun, 18 Aug 2024 11:34:42 +0300
Subject: [PATCH 387/685] move `Build::update_submodule` to
 `Config::update_submodule`

During config parsing, some bootstrap logic (e.g., `download-ci-llvm`) checks certain sources
and acts based on their state. This means that if path is a git submodule, bootstrap needs to
update it before checking its state. Otherwise it may make incorrect assumptions by relying on
outdated sources. To enable submodule updates during config parsing, we need to move the `update_submodule`
function from the `Build` to `Config` instance, so we can access to it during the parsing process.

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/build_steps/llvm.rs |   2 +-
 src/bootstrap/src/core/config/config.rs    | 119 ++++++++++++++++++++-
 src/bootstrap/src/lib.rs                   | 117 +-------------------
 3 files changed, 122 insertions(+), 116 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
index c5a1ab788016a..e1eea31b3bbf3 100644
--- a/src/bootstrap/src/core/build_steps/llvm.rs
+++ b/src/bootstrap/src/core/build_steps/llvm.rs
@@ -110,7 +110,7 @@ pub fn prebuilt_llvm_config(builder: &Builder<'_>, target: TargetSelection) -> L
 
     // Initialize the llvm submodule if not initialized already.
     // If submodules are disabled, this does nothing.
-    builder.update_submodule("src/llvm-project");
+    builder.config.update_submodule("src/llvm-project");
 
     let root = "src/llvm-project/llvm";
     let out_dir = builder.llvm_out(target);
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index bdd9fd755aa26..ad67a1d4310fd 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -14,7 +14,7 @@ use std::sync::OnceLock;
 use std::{cmp, env, fs};
 
 use build_helper::exit;
-use build_helper::git::GitConfig;
+use build_helper::git::{output_result, GitConfig};
 use serde::{Deserialize, Deserializer};
 use serde_derive::Deserialize;
 
@@ -2509,6 +2509,123 @@ impl Config {
         }
     }
 
+    /// Given a path to the directory of a submodule, update it.
+    ///
+    /// `relative_path` should be relative to the root of the git repository, not an absolute path.
+    ///
+    /// This *does not* update the submodule if `config.toml` explicitly says
+    /// not to, or if we're not in a git repository (like a plain source
+    /// tarball). Typically [`Build::require_submodule`] should be
+    /// used instead to provide a nice error to the user if the submodule is
+    /// missing.
+    pub(crate) fn update_submodule(&self, relative_path: &str) {
+        if !self.submodules() {
+            return;
+        }
+
+        let absolute_path = self.src.join(relative_path);
+
+        // NOTE: The check for the empty directory is here because when running x.py the first time,
+        // the submodule won't be checked out. Check it out now so we can build it.
+        if !GitInfo::new(false, &absolute_path).is_managed_git_subrepository()
+            && !helpers::dir_is_empty(&absolute_path)
+        {
+            return;
+        }
+
+        // Submodule updating actually happens during in the dry run mode. We need to make sure that
+        // all the git commands below are actually executed, because some follow-up code
+        // in bootstrap might depend on the submodules being checked out. Furthermore, not all
+        // the command executions below work with an empty output (produced during dry run).
+        // Therefore, all commands below are marked with `run_always()`, so that they also run in
+        // dry run mode.
+        let submodule_git = || {
+            let mut cmd = helpers::git(Some(&absolute_path));
+            cmd.run_always();
+            cmd
+        };
+
+        // Determine commit checked out in submodule.
+        let checked_out_hash = output(submodule_git().args(["rev-parse", "HEAD"]).as_command_mut());
+        let checked_out_hash = checked_out_hash.trim_end();
+        // Determine commit that the submodule *should* have.
+        let recorded = output(
+            helpers::git(Some(&self.src))
+                .run_always()
+                .args(["ls-tree", "HEAD"])
+                .arg(relative_path)
+                .as_command_mut(),
+        );
+
+        let actual_hash = recorded
+            .split_whitespace()
+            .nth(2)
+            .unwrap_or_else(|| panic!("unexpected output `{}`", recorded));
+
+        if actual_hash == checked_out_hash {
+            // already checked out
+            return;
+        }
+
+        println!("Updating submodule {relative_path}");
+        self.check_run(
+            helpers::git(Some(&self.src))
+                .run_always()
+                .args(["submodule", "-q", "sync"])
+                .arg(relative_path),
+        );
+
+        // Try passing `--progress` to start, then run git again without if that fails.
+        let update = |progress: bool| {
+            // Git is buggy and will try to fetch submodules from the tracking branch for *this* repository,
+            // even though that has no relation to the upstream for the submodule.
+            let current_branch = output_result(
+                helpers::git(Some(&self.src))
+                    .allow_failure()
+                    .run_always()
+                    .args(["symbolic-ref", "--short", "HEAD"])
+                    .as_command_mut(),
+            )
+            .map(|b| b.trim().to_owned());
+
+            let mut git = helpers::git(Some(&self.src)).allow_failure();
+            git.run_always();
+            if let Ok(branch) = current_branch {
+                // If there is a tag named after the current branch, git will try to disambiguate by prepending `heads/` to the branch name.
+                // This syntax isn't accepted by `branch.{branch}`. Strip it.
+                let branch = branch.strip_prefix("heads/").unwrap_or(&branch);
+                git.arg("-c").arg(format!("branch.{branch}.remote=origin"));
+            }
+            git.args(["submodule", "update", "--init", "--recursive", "--depth=1"]);
+            if progress {
+                git.arg("--progress");
+            }
+            git.arg(relative_path);
+            git
+        };
+        if !self.check_run(&mut update(true)) {
+            self.check_run(&mut update(false));
+        }
+
+        // Save any local changes, but avoid running `git stash pop` if there are none (since it will exit with an error).
+        // diff-index reports the modifications through the exit status
+        let has_local_modifications = !self.check_run(submodule_git().allow_failure().args([
+            "diff-index",
+            "--quiet",
+            "HEAD",
+        ]));
+        if has_local_modifications {
+            self.check_run(submodule_git().args(["stash", "push"]));
+        }
+
+        self.check_run(submodule_git().args(["reset", "-q", "--hard"]));
+        self.check_run(submodule_git().args(["clean", "-qdfx"]));
+
+        if has_local_modifications {
+            self.check_run(submodule_git().args(["stash", "pop"]));
+        }
+    }
+
     #[cfg(feature = "bootstrap-self-test")]
     pub fn check_stage0_version(&self, _program_path: &Path, _component_name: &'static str) {}
 
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 784519a20a2d8..268392c5fb118 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -473,117 +473,6 @@ impl Build {
         build
     }
 
-    /// Given a path to the directory of a submodule, update it.
-    ///
-    /// `relative_path` should be relative to the root of the git repository, not an absolute path.
-    ///
-    /// This *does not* update the submodule if `config.toml` explicitly says
-    /// not to, or if we're not in a git repository (like a plain source
-    /// tarball). Typically [`Build::require_submodule`] should be
-    /// used instead to provide a nice error to the user if the submodule is
-    /// missing.
-    fn update_submodule(&self, relative_path: &str) {
-        if !self.config.submodules() {
-            return;
-        }
-
-        let absolute_path = self.config.src.join(relative_path);
-
-        // NOTE: The check for the empty directory is here because when running x.py the first time,
-        // the submodule won't be checked out. Check it out now so we can build it.
-        if !GitInfo::new(false, &absolute_path).is_managed_git_subrepository()
-            && !dir_is_empty(&absolute_path)
-        {
-            return;
-        }
-
-        // Submodule updating actually happens during in the dry run mode. We need to make sure that
-        // all the git commands below are actually executed, because some follow-up code
-        // in bootstrap might depend on the submodules being checked out. Furthermore, not all
-        // the command executions below work with an empty output (produced during dry run).
-        // Therefore, all commands below are marked with `run_always()`, so that they also run in
-        // dry run mode.
-        let submodule_git = || {
-            let mut cmd = helpers::git(Some(&absolute_path));
-            cmd.run_always();
-            cmd
-        };
-
-        // Determine commit checked out in submodule.
-        let checked_out_hash =
-            submodule_git().args(["rev-parse", "HEAD"]).run_capture_stdout(self).stdout();
-        let checked_out_hash = checked_out_hash.trim_end();
-        // Determine commit that the submodule *should* have.
-        let recorded = helpers::git(Some(&self.src))
-            .run_always()
-            .args(["ls-tree", "HEAD"])
-            .arg(relative_path)
-            .run_capture_stdout(self)
-            .stdout();
-        let actual_hash = recorded
-            .split_whitespace()
-            .nth(2)
-            .unwrap_or_else(|| panic!("unexpected output `{}`", recorded));
-
-        if actual_hash == checked_out_hash {
-            // already checked out
-            return;
-        }
-
-        println!("Updating submodule {relative_path}");
-        helpers::git(Some(&self.src))
-            .run_always()
-            .args(["submodule", "-q", "sync"])
-            .arg(relative_path)
-            .run(self);
-
-        // Try passing `--progress` to start, then run git again without if that fails.
-        let update = |progress: bool| {
-            // Git is buggy and will try to fetch submodules from the tracking branch for *this* repository,
-            // even though that has no relation to the upstream for the submodule.
-            let current_branch = helpers::git(Some(&self.src))
-                .allow_failure()
-                .run_always()
-                .args(["symbolic-ref", "--short", "HEAD"])
-                .run_capture_stdout(self)
-                .stdout_if_ok()
-                .map(|s| s.trim().to_owned());
-
-            let mut git = helpers::git(Some(&self.src)).allow_failure();
-            git.run_always();
-            if let Some(branch) = current_branch {
-                // If there is a tag named after the current branch, git will try to disambiguate by prepending `heads/` to the branch name.
-                // This syntax isn't accepted by `branch.{branch}`. Strip it.
-                let branch = branch.strip_prefix("heads/").unwrap_or(&branch);
-                git.arg("-c").arg(format!("branch.{branch}.remote=origin"));
-            }
-            git.args(["submodule", "update", "--init", "--recursive", "--depth=1"]);
-            if progress {
-                git.arg("--progress");
-            }
-            git.arg(relative_path);
-            git
-        };
-        if !update(true).run(self) {
-            update(false).run(self);
-        }
-
-        // Save any local changes, but avoid running `git stash pop` if there are none (since it will exit with an error).
-        // diff-index reports the modifications through the exit status
-        let has_local_modifications =
-            !submodule_git().allow_failure().args(["diff-index", "--quiet", "HEAD"]).run(self);
-        if has_local_modifications {
-            submodule_git().args(["stash", "push"]).run(self);
-        }
-
-        submodule_git().args(["reset", "-q", "--hard"]).run(self);
-        submodule_git().args(["clean", "-qdfx"]).run(self);
-
-        if has_local_modifications {
-            submodule_git().args(["stash", "pop"]).run(self);
-        }
-    }
-
     /// Updates a submodule, and exits with a failure if submodule management
     /// is disabled and the submodule does not exist.
     ///
@@ -598,7 +487,7 @@ impl Build {
         if cfg!(test) && !self.config.submodules() {
             return;
         }
-        self.update_submodule(submodule);
+        self.config.update_submodule(submodule);
         let absolute_path = self.config.src.join(submodule);
         if dir_is_empty(&absolute_path) {
             let maybe_enable = if !self.config.submodules()
@@ -646,7 +535,7 @@ impl Build {
             let path = Path::new(submodule);
             // Don't update the submodule unless it's already been cloned.
             if GitInfo::new(false, path).is_managed_git_subrepository() {
-                self.update_submodule(submodule);
+                self.config.update_submodule(submodule);
             }
         }
     }
@@ -659,7 +548,7 @@ impl Build {
         }
 
         if GitInfo::new(false, Path::new(submodule)).is_managed_git_subrepository() {
-            self.update_submodule(submodule);
+            self.config.update_submodule(submodule);
         }
     }
 

From 3d0f3b209622ebbc2e4e568fa88a9c8905fcb301 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sun, 18 Aug 2024 11:40:03 +0300
Subject: [PATCH 388/685] bypass `dry_run` if the command is `run_always`

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

diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index ae39afa1fa270..d014239d0c570 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -56,7 +56,7 @@ impl Config {
     /// Returns false if do not execute at all, otherwise returns its
     /// `status.success()`.
     pub(crate) fn check_run(&self, cmd: &mut BootstrapCommand) -> bool {
-        if self.dry_run() {
+        if self.dry_run() && !cmd.run_always {
             return true;
         }
         self.verbose(|| println!("running: {cmd:?}"));

From f918de8c4a268fb5632c56cafecff0e602010e67 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 18 Aug 2024 10:41:58 +0200
Subject: [PATCH 389/685] make sure we read all arguments before returning
 early

---
 src/tools/miri/src/shims/unix/linux/epoll.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index 9ee2ad9625772..3af7c188dfcd3 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -402,8 +402,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let this = self.eval_context_mut();
 
         let epfd = this.read_scalar(epfd)?.to_i32()?;
+        let events = this.read_immediate(events_op)?;
         let maxevents = this.read_scalar(maxevents)?.to_i32()?;
         let timeout = this.read_scalar(timeout)?.to_i32()?;
+
         if epfd <= 0 || maxevents <= 0 {
             let einval = this.eval_libc("EINVAL");
             this.set_last_error(einval)?;
@@ -412,8 +414,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
         // This needs to come after the maxevents value check, or else maxevents.try_into().unwrap()
         // will fail.
-        let event = this.deref_pointer_as(
-            events_op,
+        let events = this.deref_pointer_as(
+            &events,
             this.libc_array_ty_layout("epoll_event", maxevents.try_into().unwrap()),
         )?;
 
@@ -432,7 +434,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let ready_list = epoll_file_description.get_ready_list();
         let mut ready_list = ready_list.borrow_mut();
         let mut num_of_events: i32 = 0;
-        let mut array_iter = this.project_array_fields(&event)?;
+        let mut array_iter = this.project_array_fields(&events)?;
 
         while let Some((epoll_key, epoll_return)) = ready_list.pop_first() {
             // If the file description is fully close, the entry for corresponding FdID in the

From e614d7d51b4f5a8fe65d0fb7ea2e2b7950507aff Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 18 Aug 2024 10:49:56 +0200
Subject: [PATCH 390/685] epoll test_socketpair_read: explicitly check real and
 Miri behavior

---
 src/tools/miri/tests/pass-dep/libc/libc-epoll.rs | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index 71f0e832afb11..5bc6779bdfb13 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -478,11 +478,17 @@ fn test_socketpair_read() {
     assert_eq!(res, 3);
     assert_eq!(buf, "abc".as_bytes());
 
-    // Notification will be provided.
-    // But in real system, no notification will be provided here.
+    // Notification will be provided in Miri.
+    // But in real systems, no notification will be provided here, since Linux prefers to avoid
+    // wakeups that are likely to lead to only small amounts of data being read/written.
+    // We make the test work in both cases, thus documenting the difference in behavior.
     let expected_event = u32::try_from(libc::EPOLLOUT).unwrap();
     let expected_value = fds[1] as u64;
-    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+    if cfg!(miri) {
+        check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+    } else {
+        check_epoll_wait::<8>(epfd, &[]);
+    }
 
     // Read until the buffer is empty.
     let mut buf: [u8; 2] = [0; 2];

From 6702f158fd2d774496bb86de41a48097da92eee7 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Sat, 17 Aug 2024 13:52:25 +0800
Subject: [PATCH 391/685] epoll: iterate through output buffer then fetch an
 event from ready list

---
 src/tools/miri/src/shims/unix/linux/epoll.rs  | 47 +++++++++-----
 .../miri/tests/pass-dep/libc/libc-epoll.rs    | 64 +++++++++++++++++++
 2 files changed, 94 insertions(+), 17 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index 3af7c188dfcd3..f58a6d294b940 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -436,23 +436,18 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let mut num_of_events: i32 = 0;
         let mut array_iter = this.project_array_fields(&events)?;
 
-        while let Some((epoll_key, epoll_return)) = ready_list.pop_first() {
-            // If the file description is fully close, the entry for corresponding FdID in the
-            // global epoll event interest table would be empty.
-            if this.machine.epoll_interests.get_epoll_interest(epoll_key.0).is_some() {
-                // Return notification to the caller if the file description is not fully closed.
-                if let Some(des) = array_iter.next(this)? {
-                    this.write_int_fields_named(
-                        &[
-                            ("events", epoll_return.events.into()),
-                            ("u64", epoll_return.data.into()),
-                        ],
-                        &des.1,
-                    )?;
-                    num_of_events = num_of_events.checked_add(1).unwrap();
-                } else {
-                    break;
-                }
+        while let Some(des) = array_iter.next(this)? {
+            if let Some(epoll_event_instance) = ready_list_next(this, &mut ready_list) {
+                this.write_int_fields_named(
+                    &[
+                        ("events", epoll_event_instance.events.into()),
+                        ("u64", epoll_event_instance.data.into()),
+                    ],
+                    &des.1,
+                )?;
+                num_of_events = num_of_events.strict_add(1);
+            } else {
+                break;
             }
         }
         Ok(Scalar::from_i32(num_of_events))
@@ -495,3 +490,21 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         Ok(())
     }
 }
+
+/// This function takes in ready list and returns EpollEventInstance with file description
+/// that is not closed.
+fn ready_list_next(
+    ecx: &MiriInterpCx<'_>,
+    ready_list: &mut BTreeMap<(FdId, i32), EpollEventInstance>,
+) -> Option<EpollEventInstance> {
+    while let Some((epoll_key, epoll_event_instance)) = ready_list.pop_first() {
+        // This ensures that we only return events that we are interested. The FD might have been closed since
+        // the event was generated, in which case we are not interested anymore.
+        // When a file description is fully closed, it gets removed from `machine.epoll_interests`,
+        // so we skip events whose FD is not in that map anymore.
+        if ecx.machine.epoll_interests.get_epoll_interest(epoll_key.0).is_some() {
+            return Some(epoll_event_instance);
+        }
+    }
+    return None;
+}
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index 773204c49476d..5eb74f9d00184 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -20,6 +20,8 @@ fn main() {
     test_pointer();
     test_two_same_fd_in_same_epoll_instance();
     test_epoll_wait_maxevent_zero();
+    test_epoll_lost_events();
+    test_ready_list_fetching_logic();
 }
 
 // Using `as` cast since `EPOLLET` wraps around
@@ -542,3 +544,65 @@ fn test_epoll_wait_maxevent_zero() {
     assert_eq!(e.raw_os_error(), Some(libc::EINVAL));
     assert_eq!(res, -1);
 }
+
+// This is a test for https://github.com/rust-lang/miri/issues/3812,
+// epoll can lose events if they don't fit in the output buffer.
+fn test_epoll_lost_events() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Register both fd to the same epoll instance.
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fds[0] as u64 };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[0], &mut ev) };
+    assert_eq!(res, 0);
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fds[1] as u64 };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
+    assert_eq!(res, 0);
+
+    //Two notification should be received. But we only provide buffer for one event.
+    let expected_event0 = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value0 = fds[0] as u64;
+    check_epoll_wait::<1>(epfd, &[(expected_event0, expected_value0)]);
+
+    // Previous event should be returned for the second epoll_wait.
+    let expected_event1 = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value1 = fds[1] as u64;
+    check_epoll_wait::<1>(epfd, &[(expected_event1, expected_value1)]);
+}
+
+// This is testing if closing an fd that is already in ready list will cause an empty entry in
+// returned notification.
+// Related discussion in https://github.com/rust-lang/miri/pull/3818#discussion_r1720679440.
+fn test_ready_list_fetching_logic() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create two eventfd instances.
+    let flags = libc::EFD_NONBLOCK | libc::EFD_CLOEXEC;
+    let fd0 = unsafe { libc::eventfd(0, flags) };
+    let fd1 = unsafe { libc::eventfd(0, flags) };
+
+    // Register both fd to the same epoll instance. At this point, both of them are on the ready list.
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fd0 as u64 };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd0, &mut ev) };
+    assert_eq!(res, 0);
+    let mut ev = libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: fd1 as u64 };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fd1, &mut ev) };
+    assert_eq!(res, 0);
+
+    // Close fd0 so the first entry in the ready list will be empty.
+    let res = unsafe { libc::close(fd0) };
+    assert_eq!(res, 0);
+
+    // Notification for fd1 should be returned.
+    let expected_event1 = u32::try_from(libc::EPOLLOUT).unwrap();
+    let expected_value1 = fd1 as u64;
+    check_epoll_wait::<1>(epfd, &[(expected_event1, expected_value1)]);
+}

From ce7a70ade8c73cf8622fb4eb051ccb3599ba75c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?=
 <jieyouxu@outlook.com>
Date: Sun, 18 Aug 2024 09:13:44 +0000
Subject: [PATCH 392/685] tests: disable `dump-ice-to-disk` for i686-mingw

To avoid blocking full CI.
---
 tests/run-make/dump-ice-to-disk/rmake.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/run-make/dump-ice-to-disk/rmake.rs b/tests/run-make/dump-ice-to-disk/rmake.rs
index 08767246b90d0..15f35eb2d3d88 100644
--- a/tests/run-make/dump-ice-to-disk/rmake.rs
+++ b/tests/run-make/dump-ice-to-disk/rmake.rs
@@ -23,6 +23,9 @@
 //! - An attempt is made to re-enable this test on `i686-mingw` (by removing `ignore-windows`). If
 //!   this test is still flakey, please restore the `ignore-windows` directive.
 
+//@ ignore-windows
+//FIXME(#128911): still flakey on i686-mingw.
+
 use std::cell::OnceCell;
 use std::path::{Path, PathBuf};
 

From 483120d6cee9607f0a95dda469e800161d4e3441 Mon Sep 17 00:00:00 2001
From: tiif <pekyuan@gmail.com>
Date: Sat, 17 Aug 2024 16:03:59 +0800
Subject: [PATCH 393/685] Add EPOLLER support

---
 src/tools/miri/src/shims/unix/linux/epoll.rs  | 23 +++++++++--
 .../miri/src/shims/unix/unnamed_socket.rs     | 28 ++++++++++++--
 .../miri/tests/pass-dep/libc/libc-epoll.rs    | 38 +++++++++++++++++++
 3 files changed, 83 insertions(+), 6 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/linux/epoll.rs b/src/tools/miri/src/shims/unix/linux/epoll.rs
index f58a6d294b940..fb1e0afdf9ed7 100644
--- a/src/tools/miri/src/shims/unix/linux/epoll.rs
+++ b/src/tools/miri/src/shims/unix/linux/epoll.rs
@@ -76,11 +76,19 @@ pub struct EpollReadyEvents {
     /// epollrdhup also gets set when only the write half is closed, which is possible
     /// via `shutdown(_, SHUT_WR)`.
     pub epollhup: bool,
+    /// Error condition happened on the associated file descriptor.
+    pub epollerr: bool,
 }
 
 impl EpollReadyEvents {
     pub fn new() -> Self {
-        EpollReadyEvents { epollin: false, epollout: false, epollrdhup: false, epollhup: false }
+        EpollReadyEvents {
+            epollin: false,
+            epollout: false,
+            epollrdhup: false,
+            epollhup: false,
+            epollerr: false,
+        }
     }
 
     pub fn get_event_bitmask<'tcx>(&self, ecx: &MiriInterpCx<'tcx>) -> u32 {
@@ -88,6 +96,7 @@ impl EpollReadyEvents {
         let epollout = ecx.eval_libc_u32("EPOLLOUT");
         let epollrdhup = ecx.eval_libc_u32("EPOLLRDHUP");
         let epollhup = ecx.eval_libc_u32("EPOLLHUP");
+        let epollerr = ecx.eval_libc_u32("EPOLLERR");
 
         let mut bitmask = 0;
         if self.epollin {
@@ -102,6 +111,9 @@ impl EpollReadyEvents {
         if self.epollhup {
             bitmask |= epollhup;
         }
+        if self.epollerr {
+            bitmask |= epollerr;
+        }
         bitmask
     }
 }
@@ -229,6 +241,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let epollrdhup = this.eval_libc_u32("EPOLLRDHUP");
         let epollet = this.eval_libc_u32("EPOLLET");
         let epollhup = this.eval_libc_u32("EPOLLHUP");
+        let epollerr = this.eval_libc_u32("EPOLLERR");
 
         // Fail on unsupported operations.
         if op & epoll_ctl_add != epoll_ctl_add
@@ -261,10 +274,11 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
             // Unset the flag we support to discover if any unsupported flags are used.
             let mut flags = events;
-            // epoll_wait(2) will always wait for epollhup; it is not
+            // epoll_wait(2) will always wait for epollhup and epollerr; it is not
             // necessary to set it in events when calling epoll_ctl().
-            // So we will always set this event type.
+            // So we will always set these two event types.
             events |= epollhup;
+            events |= epollerr;
 
             if events & epollet != epollet {
                 // We only support edge-triggered notification for now.
@@ -284,6 +298,9 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             if flags & epollhup == epollhup {
                 flags &= !epollhup;
             }
+            if flags & epollerr == epollerr {
+                flags &= !epollerr;
+            }
             if flags != 0 {
                 throw_unsup_format!(
                     "epoll_ctl: encountered unknown unsupported flags {:#x}",
diff --git a/src/tools/miri/src/shims/unix/unnamed_socket.rs b/src/tools/miri/src/shims/unix/unnamed_socket.rs
index 5f4640a2d840c..745f27398d0a8 100644
--- a/src/tools/miri/src/shims/unix/unnamed_socket.rs
+++ b/src/tools/miri/src/shims/unix/unnamed_socket.rs
@@ -2,7 +2,7 @@
 //! are entirely implemented inside Miri.
 //! We also use the same infrastructure to implement unnamed pipes.
 
-use std::cell::{OnceCell, RefCell};
+use std::cell::{Cell, OnceCell, RefCell};
 use std::collections::VecDeque;
 use std::io;
 use std::io::{Error, ErrorKind, Read};
@@ -27,6 +27,10 @@ struct AnonSocket {
     /// writing to. This is a weak reference because the other side may be closed before us; all
     /// future writes will then trigger EPIPE.
     peer_fd: OnceCell<WeakFileDescriptionRef>,
+    /// Indicates whether the peer has lost data when the file description is closed.
+    /// This flag is set to `true` if the peer's `readbuf` is non-empty at the time
+    /// of closure.
+    peer_lost_data: Cell<bool>,
     is_nonblock: bool,
 }
 
@@ -91,6 +95,10 @@ impl FileDescription for AnonSocket {
             // for read and write.
             epoll_ready_events.epollin = true;
             epoll_ready_events.epollout = true;
+            // If there is data lost in peer_fd, set EPOLLERR.
+            if self.peer_lost_data.get() {
+                epoll_ready_events.epollerr = true;
+            }
         }
         Ok(epoll_ready_events)
     }
@@ -101,6 +109,13 @@ impl FileDescription for AnonSocket {
         ecx: &mut MiriInterpCx<'tcx>,
     ) -> InterpResult<'tcx, io::Result<()>> {
         if let Some(peer_fd) = self.peer_fd().upgrade() {
+            // If the current readbuf is non-empty when the file description is closed,
+            // notify the peer that data lost has happened in current file description.
+            if let Some(readbuf) = &self.readbuf {
+                if !readbuf.borrow().buf.is_empty() {
+                    peer_fd.downcast::<AnonSocket>().unwrap().peer_lost_data.set(true);
+                }
+            }
             // Notify peer fd that close has happened, since that can unblock reads and writes.
             ecx.check_and_update_readiness(&peer_fd)?;
         }
@@ -290,11 +305,13 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let fd0 = fds.new_ref(AnonSocket {
             readbuf: Some(RefCell::new(Buffer::new())),
             peer_fd: OnceCell::new(),
+            peer_lost_data: Cell::new(false),
             is_nonblock: is_sock_nonblock,
         });
         let fd1 = fds.new_ref(AnonSocket {
             readbuf: Some(RefCell::new(Buffer::new())),
             peer_fd: OnceCell::new(),
+            peer_lost_data: Cell::new(false),
             is_nonblock: is_sock_nonblock,
         });
 
@@ -340,10 +357,15 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         let fd0 = fds.new_ref(AnonSocket {
             readbuf: Some(RefCell::new(Buffer::new())),
             peer_fd: OnceCell::new(),
+            peer_lost_data: Cell::new(false),
+            is_nonblock: false,
+        });
+        let fd1 = fds.new_ref(AnonSocket {
+            readbuf: None,
+            peer_fd: OnceCell::new(),
+            peer_lost_data: Cell::new(false),
             is_nonblock: false,
         });
-        let fd1 =
-            fds.new_ref(AnonSocket { readbuf: None, peer_fd: OnceCell::new(), is_nonblock: false });
 
         // Make the file descriptions point to each other.
         fd0.downcast::<AnonSocket>().unwrap().peer_fd.set(fd1.downgrade()).unwrap();
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index 763263b463097..e28cafd3c285b 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -20,6 +20,7 @@ fn main() {
     test_pointer();
     test_two_same_fd_in_same_epoll_instance();
     test_epoll_wait_maxevent_zero();
+    test_socketpair_epollerr();
     test_epoll_lost_events();
     test_ready_list_fetching_logic();
 }
@@ -551,6 +552,43 @@ fn test_epoll_wait_maxevent_zero() {
     assert_eq!(res, -1);
 }
 
+fn test_socketpair_epollerr() {
+    // Create an epoll instance.
+    let epfd = unsafe { libc::epoll_create1(0) };
+    assert_ne!(epfd, -1);
+
+    // Create a socketpair instance.
+    let mut fds = [-1, -1];
+    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
+    assert_eq!(res, 0);
+
+    // Write to fd[0]
+    let data = "abcde".as_bytes().as_ptr();
+    let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
+    assert_eq!(res, 5);
+
+    // Close fds[1].
+    // EPOLLERR will be triggered if we close peer fd that still has data in its read buffer.
+    let res = unsafe { libc::close(fds[1]) };
+    assert_eq!(res, 0);
+
+    // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET|EPOLLRDHUP
+    let mut ev = libc::epoll_event {
+        events: (libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLET | libc::EPOLLRDHUP) as _,
+        u64: u64::try_from(fds[1]).unwrap(),
+    };
+    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[0], &mut ev) };
+    assert_ne!(res, -1);
+
+    // Check result from epoll_wait.
+    let expected_event = u32::try_from(
+        libc::EPOLLIN | libc::EPOLLOUT | libc::EPOLLHUP | libc::EPOLLRDHUP | libc::EPOLLERR,
+    )
+    .unwrap();
+    let expected_value = u64::try_from(fds[1]).unwrap();
+    check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
+}
+
 // This is a test for https://github.com/rust-lang/miri/issues/3812,
 // epoll can lose events if they don't fit in the output buffer.
 fn test_epoll_lost_events() {

From 1faccbaadc53c167fcb16bdd8498dc05aabef126 Mon Sep 17 00:00:00 2001
From: ivmarkov <ivan.markov@gmail.com>
Date: Sun, 18 Aug 2024 11:29:50 +0000
Subject: [PATCH 394/685] Fix for issue #129212 for the ESP-IDF

---
 library/std/src/sys/pal/unix/thread.rs | 30 ++++++++++++++++++++------
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/library/std/src/sys/pal/unix/thread.rs b/library/std/src/sys/pal/unix/thread.rs
index 0fa610eebb4ef..c9dcc5ad97a50 100644
--- a/library/std/src/sys/pal/unix/thread.rs
+++ b/library/std/src/sys/pal/unix/thread.rs
@@ -267,14 +267,32 @@ impl Thread {
 
     #[cfg(target_os = "espidf")]
     pub fn sleep(dur: Duration) {
-        let mut micros = dur.as_micros();
-        unsafe {
-            while micros > 0 {
-                let st = if micros > u32::MAX as u128 { u32::MAX } else { micros as u32 };
+        // ESP-IDF does not have `nanosleep`, so we use `usleep` instead.
+        // As per the documentation of `usleep`, it is expected to support
+        // sleep times as big as at least up to 1 second.
+        //
+        // ESP-IDF does support almost up to `u32::MAX`, but due to a potential integer overflow in its
+        // `usleep` implementation
+        // (https://github.com/espressif/esp-idf/blob/d7ca8b94c852052e3bc33292287ef4dd62c9eeb1/components/newlib/time.c#L210),
+        // we limit the sleep time to the maximum one that would not cause the underlying `usleep` implementation to overflow
+        // (`portTICK_PERIOD_MS` can be anything between 1 to 1000, and is 10 by default).
+        const MAX_MICROS: u32 = u32::MAX - 1_000_000 - 1;
+
+        // Add any nanoseconds smaller than a microsecond as an extra microsecond
+        // so as to comply with the `std::thread::sleep` contract which mandates
+        // implementations to sleep for _at least_ the provided `dur`.
+        // We can't overflow `micros` as it is a `u128`, while `Duration` is a pair of
+        // (`u64` secs, `u32` nanos), where the nanos are strictly smaller than 1 second
+        // (i.e. < 1_000_000_000)
+        let mut micros = dur.as_micros() + if dur.subsec_nanos() % 1_000 > 0 { 1 } else { 0 };
+
+        while micros > 0 {
+            let st = if micros > MAX_MICROS as u128 { MAX_MICROS } else { micros as u32 };
+            unsafe {
                 libc::usleep(st);
-
-                micros -= st as u128;
             }
+
+            micros -= st as u128;
         }
     }
 

From 0708b289b72fc3328c0244be6c1b267bba18fabd Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 18 Aug 2024 13:36:11 +0200
Subject: [PATCH 395/685] fix build with bootstrap compiler

---
 src/tools/miri/src/eval.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/tools/miri/src/eval.rs b/src/tools/miri/src/eval.rs
index 0850a8f24d96c..bb623c66892a0 100644
--- a/src/tools/miri/src/eval.rs
+++ b/src/tools/miri/src/eval.rs
@@ -458,7 +458,14 @@ pub fn eval_entry<'tcx>(
         panic::resume_unwind(panic_payload)
     });
     // `Ok` can never happen.
+    #[cfg(not(bootstrap))]
     let Err(res) = res;
+    #[cfg(bootstrap)]
+    let res = match res {
+        Err(res) => res,
+        // `Ok` can never happen
+        Ok(never) => match never {},
+    };
 
     // Machine cleanup. Only do this if all threads have terminated; threads that are still running
     // might cause Stacked Borrows errors (https://github.com/rust-lang/miri/issues/2396).

From a2033428c4ca9883a2b7cbbd1f167d481b0d240c Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 18 Aug 2024 14:13:45 +0200
Subject: [PATCH 396/685] Do not emit `TOO_LONG_FIRST_DOC_PARAGRAPH` lint if
 item is generated from proc-macro and simplify code to emit lint

---
 .../src/doc/too_long_first_doc_paragraph.rs   | 39 +++++++++----------
 1 file changed, 18 insertions(+), 21 deletions(-)

diff --git a/clippy_lints/src/doc/too_long_first_doc_paragraph.rs b/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
index a47cba64b28e5..7bb3bb12f2ca9 100644
--- a/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
+++ b/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
@@ -3,7 +3,8 @@ use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::LateContext;
 
-use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::is_from_proc_macro;
 use clippy_utils::source::snippet_opt;
 
 use super::TOO_LONG_FIRST_DOC_PARAGRAPH;
@@ -63,32 +64,28 @@ pub(super) fn check(
     let &[first_span, .., last_span] = spans.as_slice() else {
         return;
     };
+    if is_from_proc_macro(cx, item) {
+        return;
+    }
 
-    if should_suggest_empty_doc
-        && let Some(second_span) = spans.get(1)
-        && let new_span = first_span.with_hi(second_span.lo()).with_lo(first_span.hi())
-        && let Some(snippet) = snippet_opt(cx, new_span)
-    {
-        span_lint_and_then(
-            cx,
-            TOO_LONG_FIRST_DOC_PARAGRAPH,
-            first_span.with_hi(last_span.lo()),
-            "first doc comment paragraph is too long",
-            |diag| {
+    span_lint_and_then(
+        cx,
+        TOO_LONG_FIRST_DOC_PARAGRAPH,
+        first_span.with_hi(last_span.lo()),
+        "first doc comment paragraph is too long",
+        |diag| {
+            if should_suggest_empty_doc
+                && let Some(second_span) = spans.get(1)
+                && let new_span = first_span.with_hi(second_span.lo()).with_lo(first_span.hi())
+                && let Some(snippet) = snippet_opt(cx, new_span)
+            {
                 diag.span_suggestion(
                     new_span,
                     "add an empty line",
                     format!("{snippet}///\n"),
                     Applicability::MachineApplicable,
                 );
-            },
-        );
-        return;
-    }
-    span_lint(
-        cx,
-        TOO_LONG_FIRST_DOC_PARAGRAPH,
-        first_span.with_hi(last_span.lo()),
-        "first doc comment paragraph is too long",
+            }
+        },
     );
 }

From 1ca2708e77ac735adc3824501667694b4f9c1303 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sun, 18 Aug 2024 11:42:18 +0300
Subject: [PATCH 397/685] sync llvm submodule during config parse

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/config/config.rs | 28 ++++++++++++++-----------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index ad67a1d4310fd..65d9c24b6c56f 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -2730,19 +2730,23 @@ impl Config {
         asserts: bool,
     ) -> bool {
         let if_unchanged = || {
-            // Git is needed to track modifications here, but tarball source is not available.
-            // If not modified here or built through tarball source, we maintain consistency
-            // with '"if available"'.
-            if !self.rust_info.is_from_tarball()
-                && self
-                    .last_modified_commit(&["src/llvm-project"], "download-ci-llvm", true)
-                    .is_none()
-            {
-                // there are some untracked changes in the given paths.
-                false
-            } else {
-                llvm::is_ci_llvm_available(self, asserts)
+            if self.rust_info.is_from_tarball() {
+                // Git is needed for running "if-unchanged" logic.
+                println!(
+                    "WARNING: 'if-unchanged' has no effect on tarball sources; ignoring `download-ci-llvm`."
+                );
+                return false;
             }
+
+            self.update_submodule("src/llvm-project");
+
+            // Check for untracked changes in `src/llvm-project`.
+            let has_changes = self
+                .last_modified_commit(&["src/llvm-project"], "download-ci-llvm", true)
+                .is_none();
+
+            // Return false if there are untracked changes, otherwise check if CI LLVM is available.
+            if has_changes { false } else { llvm::is_ci_llvm_available(self, asserts) }
         };
 
         match download_ci_llvm {

From b0023f5a417374aad980422b3f437f133676d4ef Mon Sep 17 00:00:00 2001
From: Evan Jones <ej@evanjones.ca>
Date: Sun, 18 Aug 2024 10:43:36 -0400
Subject: [PATCH 398/685] code review improvements

---
 library/std/src/env.rs | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/library/std/src/env.rs b/library/std/src/env.rs
index 215b7b03f04c3..bbe191181c5a8 100644
--- a/library/std/src/env.rs
+++ b/library/std/src/env.rs
@@ -198,16 +198,12 @@ impl fmt::Debug for VarsOs {
 ///
 /// # Errors
 ///
-/// This function returns [`VarError::NotPresent`] if the environment variable
-/// isn't set.
+/// Returns [`VarError::NotPresent`] if:
+/// - The variable is not set.
+/// - The variable's name contains an equal sign or NUL (`'='` or `'\0'`).
 ///
-/// This function may return [`VarError::NotPresent`] if the
-/// environment variable's name contains the equal sign character (`=`) or the
-/// NUL character.
-///
-/// This function will return [`VarError::NotUnicode`] if the environment
-/// variable's value is not valid Unicode. If this is not desired, consider
-/// using [`var_os`].
+/// Returns [`VarError::NotUnicode`] if the variable's value is not valid
+/// Unicode. If this is not desired, consider using [`var_os`].
 ///
 /// # Examples
 ///

From 43146616710b6ea7017aed22a978f942d6eb7ca3 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sat, 17 Aug 2024 17:31:13 -0400
Subject: [PATCH 399/685] Delete gdbg commands

---
 tests/debuginfo/associated-types.rs           |  2 --
 .../debuginfo/basic-types-globals-metadata.rs | 15 --------
 tests/debuginfo/basic-types-globals.rs        | 16 ---------
 tests/debuginfo/basic-types-metadata.rs       | 11 ------
 tests/debuginfo/basic-types-mut-globals.rs    | 32 -----------------
 tests/debuginfo/basic-types.rs                |  2 --
 tests/debuginfo/borrowed-basic.rs             |  2 --
 tests/debuginfo/borrowed-c-style-enum.rs      |  3 --
 tests/debuginfo/borrowed-struct.rs            |  3 --
 tests/debuginfo/borrowed-tuple.rs             |  3 --
 tests/debuginfo/box.rs                        |  1 -
 tests/debuginfo/boxed-struct.rs               |  2 --
 .../by-value-non-immediate-argument.rs        |  5 ---
 .../by-value-self-argument-in-trait-impl.rs   |  2 --
 tests/debuginfo/c-style-enum-in-composite.rs  |  7 ----
 tests/debuginfo/c-style-enum.rs               | 29 ---------------
 tests/debuginfo/cross-crate-spans.rs          |  2 --
 tests/debuginfo/destructured-fn-argument.rs   |  8 -----
 .../destructured-for-loop-variable.rs         |  2 --
 tests/debuginfo/destructured-local.rs         |  8 -----
 tests/debuginfo/evec-in-struct.rs             |  5 ---
 .../debuginfo/function-arg-initialization.rs  |  2 --
 .../debuginfo/gdb-pretty-struct-and-enums.rs  |  5 ---
 tests/debuginfo/generic-function.rs           |  1 -
 .../generic-method-on-generic-struct.rs       |  5 ---
 tests/debuginfo/generic-struct.rs             |  4 ---
 .../lexical-scopes-in-block-expression.rs     |  9 -----
 tests/debuginfo/limited-debuginfo.rs          |  4 ---
 tests/debuginfo/method-on-enum.rs             |  5 ---
 tests/debuginfo/method-on-generic-struct.rs   |  5 ---
 tests/debuginfo/method-on-struct.rs           |  5 ---
 tests/debuginfo/method-on-trait.rs            |  5 ---
 tests/debuginfo/method-on-tuple-struct.rs     |  5 ---
 tests/debuginfo/option-like-enum.rs           |  8 -----
 .../packed-struct-with-destructor.rs          |  8 -----
 tests/debuginfo/packed-struct.rs              |  4 ---
 tests/debuginfo/pretty-slices.rs              |  2 --
 tests/debuginfo/pretty-std.rs                 |  1 -
 tests/debuginfo/reference-debuginfo.rs        |  2 --
 tests/debuginfo/self-in-default-method.rs     |  5 ---
 .../self-in-generic-default-method.rs         |  5 ---
 tests/debuginfo/simd.rs                       | 18 ----------
 tests/debuginfo/simple-struct.rs              | 30 ----------------
 tests/debuginfo/simple-tuple.rs               | 36 -------------------
 tests/debuginfo/struct-in-enum.rs             |  3 --
 tests/debuginfo/struct-in-struct.rs           |  3 --
 tests/debuginfo/struct-with-destructor.rs     |  4 ---
 tests/debuginfo/tuple-in-struct.rs            | 10 ------
 tests/debuginfo/tuple-in-tuple.rs             |  7 ----
 tests/debuginfo/tuple-struct.rs               |  6 ----
 tests/debuginfo/union-smoke.rs                |  2 --
 tests/debuginfo/unsized.rs                    |  6 ----
 .../var-captured-in-nested-closure.rs         |  4 ---
 .../var-captured-in-sendable-closure.rs       |  1 -
 .../var-captured-in-stack-closure.rs          |  4 ---
 tests/debuginfo/vec-slices.rs                 | 12 -------
 tests/debuginfo/vec.rs                        |  2 --
 57 files changed, 398 deletions(-)

diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs
index d1d4e320b05d4..8dd9853efe720 100644
--- a/tests/debuginfo/associated-types.rs
+++ b/tests/debuginfo/associated-types.rs
@@ -8,7 +8,6 @@
 // gdb-command:run
 
 // gdb-command:print arg
-// gdbg-check:$1 = {b = -1, b1 = 0}
 // gdbr-check:$1 = associated_types::Struct<i32> {b: -1, b1: 0}
 // gdb-command:continue
 
@@ -23,7 +22,6 @@
 // gdb-command:continue
 
 // gdb-command:print arg
-// gdbg-check:$5 = {__0 = 4, __1 = 5}
 // gdbr-check:$5 = (4, 5)
 // gdb-command:continue
 
diff --git a/tests/debuginfo/basic-types-globals-metadata.rs b/tests/debuginfo/basic-types-globals-metadata.rs
index 13678c31e765b..5276d6f4a5dce 100644
--- a/tests/debuginfo/basic-types-globals-metadata.rs
+++ b/tests/debuginfo/basic-types-globals-metadata.rs
@@ -2,49 +2,34 @@
 
 //@ compile-flags:-g
 // gdb-command:run
-// gdbg-command:whatis 'basic_types_globals_metadata::B'
 // gdbr-command:whatis basic_types_globals_metadata::B
 // gdb-check:type = bool
-// gdbg-command:whatis 'basic_types_globals_metadata::I'
 // gdbr-command:whatis basic_types_globals_metadata::I
 // gdb-check:type = isize
-// gdbg-command:whatis 'basic_types_globals_metadata::C'
 // gdbr-command:whatis basic_types_globals_metadata::C
 // gdb-check:type = char
-// gdbg-command:whatis 'basic_types_globals_metadata::I8'
 // gdbr-command:whatis basic_types_globals_metadata::I8
 // gdb-check:type = i8
-// gdbg-command:whatis 'basic_types_globals_metadata::I16'
 // gdbr-command:whatis basic_types_globals_metadata::I16
 // gdb-check:type = i16
-// gdbg-command:whatis 'basic_types_globals_metadata::I32'
 // gdbr-command:whatis basic_types_globals_metadata::I32
 // gdb-check:type = i32
-// gdbg-command:whatis 'basic_types_globals_metadata::I64'
 // gdbr-command:whatis basic_types_globals_metadata::I64
 // gdb-check:type = i64
-// gdbg-command:whatis 'basic_types_globals_metadata::U'
 // gdbr-command:whatis basic_types_globals_metadata::U
 // gdb-check:type = usize
-// gdbg-command:whatis 'basic_types_globals_metadata::U8'
 // gdbr-command:whatis basic_types_globals_metadata::U8
 // gdb-check:type = u8
-// gdbg-command:whatis 'basic_types_globals_metadata::U16'
 // gdbr-command:whatis basic_types_globals_metadata::U16
 // gdb-check:type = u16
-// gdbg-command:whatis 'basic_types_globals_metadata::U32'
 // gdbr-command:whatis basic_types_globals_metadata::U32
 // gdb-check:type = u32
-// gdbg-command:whatis 'basic_types_globals_metadata::U64'
 // gdbr-command:whatis basic_types_globals_metadata::U64
 // gdb-check:type = u64
-// gdbg-command:whatis 'basic_types_globals_metadata::F16'
 // gdbr-command:whatis basic_types_globals_metadata::F16
 // gdb-check:type = f16
-// gdbg-command:whatis 'basic_types_globals_metadata::F32'
 // gdbr-command:whatis basic_types_globals_metadata::F32
 // gdb-check:type = f32
-// gdbg-command:whatis 'basic_types_globals_metadata::F64'
 // gdbr-command:whatis basic_types_globals_metadata::F64
 // gdb-check:type = f64
 // gdb-command:continue
diff --git a/tests/debuginfo/basic-types-globals.rs b/tests/debuginfo/basic-types-globals.rs
index 0425d14fa5a34..7f86dce417794 100644
--- a/tests/debuginfo/basic-types-globals.rs
+++ b/tests/debuginfo/basic-types-globals.rs
@@ -12,50 +12,34 @@
 //@ [lto] no-prefer-dynamic
 
 // gdb-command:run
-// gdbg-command:print 'basic_types_globals::B'
 // gdbr-command:print B
 // gdb-check:$1 = false
-// gdbg-command:print 'basic_types_globals::I'
 // gdbr-command:print I
 // gdb-check:$2 = -1
-// gdbg-command:print 'basic_types_globals::C'
 // gdbr-command:print/d C
-// gdbg-check:$3 = 97
 // gdbr-check:$3 = 97
-// gdbg-command:print/d 'basic_types_globals::I8'
 // gdbr-command:print I8
 // gdb-check:$4 = 68
-// gdbg-command:print 'basic_types_globals::I16'
 // gdbr-command:print I16
 // gdb-check:$5 = -16
-// gdbg-command:print 'basic_types_globals::I32'
 // gdbr-command:print I32
 // gdb-check:$6 = -32
-// gdbg-command:print 'basic_types_globals::I64'
 // gdbr-command:print I64
 // gdb-check:$7 = -64
-// gdbg-command:print 'basic_types_globals::U'
 // gdbr-command:print U
 // gdb-check:$8 = 1
-// gdbg-command:print/d 'basic_types_globals::U8'
 // gdbr-command:print U8
 // gdb-check:$9 = 100
-// gdbg-command:print 'basic_types_globals::U16'
 // gdbr-command:print U16
 // gdb-check:$10 = 16
-// gdbg-command:print 'basic_types_globals::U32'
 // gdbr-command:print U32
 // gdb-check:$11 = 32
-// gdbg-command:print 'basic_types_globals::U64'
 // gdbr-command:print U64
 // gdb-check:$12 = 64
-// gdbg-command:print 'basic_types_globals::F16'
 // gdbr-command:print F16
 // gdb-check:$13 = 1.5
-// gdbg-command:print 'basic_types_globals::F32'
 // gdbr-command:print F32
 // gdb-check:$14 = 2.5
-// gdbg-command:print 'basic_types_globals::F64'
 // gdbr-command:print F64
 // gdb-check:$15 = 3.5
 // gdb-command:continue
diff --git a/tests/debuginfo/basic-types-metadata.rs b/tests/debuginfo/basic-types-metadata.rs
index 3aebf2577b6b3..a2662068fa4c3 100644
--- a/tests/debuginfo/basic-types-metadata.rs
+++ b/tests/debuginfo/basic-types-metadata.rs
@@ -37,25 +37,14 @@
 // gdb-command:whatis fnptr
 // gdb-check:type = *mut fn ()
 // gdb-command:info functions _yyy
-// gdbg-check:[...]![...]_yyy([...]);
 // gdbr-check:static fn basic_types_metadata::_yyy();
 // gdb-command:ptype closure_0
 // gdbr-check: type = struct basic_types_metadata::main::{closure_env#0}
-// gdbg-check: type = struct closure {
-// gdbg-check:     <no data fields>
-// gdbg-check: }
 // gdb-command:ptype closure_1
-// gdbg-check: type = struct closure {
-// gdbg-check:     bool *__0;
-// gdbg-check: }
 // gdbr-check: type = struct basic_types_metadata::main::{closure_env#1} {
 // gdbr-check:     *mut bool,
 // gdbr-check: }
 // gdb-command:ptype closure_2
-// gdbg-check: type = struct closure {
-// gdbg-check:     bool *__0;
-// gdbg-check:     isize *__1;
-// gdbg-check: }
 // gdbr-check: type = struct basic_types_metadata::main::{closure_env#2} {
 // gdbr-check:     *mut bool,
 // gdbr-check:     *mut isize,
diff --git a/tests/debuginfo/basic-types-mut-globals.rs b/tests/debuginfo/basic-types-mut-globals.rs
index c676fd737714d..fab2dc8507b5c 100644
--- a/tests/debuginfo/basic-types-mut-globals.rs
+++ b/tests/debuginfo/basic-types-mut-globals.rs
@@ -11,99 +11,67 @@
 // gdb-command:run
 
 // Check initializers
-// gdbg-command:print 'basic_types_mut_globals::B'
 // gdbr-command:print B
 // gdb-check:$1 = false
-// gdbg-command:print 'basic_types_mut_globals::I'
 // gdbr-command:print I
 // gdb-check:$2 = -1
-// gdbg-command:print/d 'basic_types_mut_globals::C'
 // gdbr-command:print C
-// gdbg-check:$3 = 97
 // gdbr-check:$3 = 97 'a'
-// gdbg-command:print/d 'basic_types_mut_globals::I8'
 // gdbr-command:print I8
 // gdb-check:$4 = 68
-// gdbg-command:print 'basic_types_mut_globals::I16'
 // gdbr-command:print I16
 // gdb-check:$5 = -16
-// gdbg-command:print 'basic_types_mut_globals::I32'
 // gdbr-command:print I32
 // gdb-check:$6 = -32
-// gdbg-command:print 'basic_types_mut_globals::I64'
 // gdbr-command:print I64
 // gdb-check:$7 = -64
-// gdbg-command:print 'basic_types_mut_globals::U'
 // gdbr-command:print U
 // gdb-check:$8 = 1
-// gdbg-command:print/d 'basic_types_mut_globals::U8'
 // gdbr-command:print U8
 // gdb-check:$9 = 100
-// gdbg-command:print 'basic_types_mut_globals::U16'
 // gdbr-command:print U16
 // gdb-check:$10 = 16
-// gdbg-command:print 'basic_types_mut_globals::U32'
 // gdbr-command:print U32
 // gdb-check:$11 = 32
-// gdbg-command:print 'basic_types_mut_globals::U64'
 // gdbr-command:print U64
 // gdb-check:$12 = 64
-// gdbg-command:print 'basic_types_mut_globals::F16'
 // gdbr-command:print F16
 // gdb-check:$13 = 1.5
-// gdbg-command:print 'basic_types_mut_globals::F32'
 // gdbr-command:print F32
 // gdb-check:$14 = 2.5
-// gdbg-command:print 'basic_types_mut_globals::F64'
 // gdbr-command:print F64
 // gdb-check:$15 = 3.5
 // gdb-command:continue
 
 // Check new values
-// gdbg-command:print 'basic_types_mut_globals'::B
 // gdbr-command:print B
 // gdb-check:$16 = true
-// gdbg-command:print 'basic_types_mut_globals'::I
 // gdbr-command:print I
 // gdb-check:$17 = 2
-// gdbg-command:print/d 'basic_types_mut_globals'::C
 // gdbr-command:print C
-// gdbg-check:$18 = 102
 // gdbr-check:$18 = 102 'f'
-// gdbg-command:print/d 'basic_types_mut_globals'::I8
 // gdbr-command:print/d I8
 // gdb-check:$19 = 78
-// gdbg-command:print 'basic_types_mut_globals'::I16
 // gdbr-command:print I16
 // gdb-check:$20 = -26
-// gdbg-command:print 'basic_types_mut_globals'::I32
 // gdbr-command:print I32
 // gdb-check:$21 = -12
-// gdbg-command:print 'basic_types_mut_globals'::I64
 // gdbr-command:print I64
 // gdb-check:$22 = -54
-// gdbg-command:print 'basic_types_mut_globals'::U
 // gdbr-command:print U
 // gdb-check:$23 = 5
-// gdbg-command:print/d 'basic_types_mut_globals'::U8
 // gdbr-command:print/d U8
 // gdb-check:$24 = 20
-// gdbg-command:print 'basic_types_mut_globals'::U16
 // gdbr-command:print U16
 // gdb-check:$25 = 32
-// gdbg-command:print 'basic_types_mut_globals'::U32
 // gdbr-command:print U32
 // gdb-check:$26 = 16
-// gdbg-command:print 'basic_types_mut_globals'::U64
 // gdbr-command:print U64
 // gdb-check:$27 = 128
-// gdbg-command:print 'basic_types_mut_globals'::F16
 // gdbr-command:print F16
 // gdb-check:$28 = 2.25
-// gdbg-command:print 'basic_types_mut_globals'::F32
 // gdbr-command:print F32
 // gdb-check:$29 = 5.75
-// gdbg-command:print 'basic_types_mut_globals'::F64
 // gdbr-command:print F64
 // gdb-check:$30 = 9.25
 
diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs
index d836525240ae2..215599e6f0efd 100644
--- a/tests/debuginfo/basic-types.rs
+++ b/tests/debuginfo/basic-types.rs
@@ -16,7 +16,6 @@
 // gdb-command:print i
 // gdb-check:$2 = -1
 // gdb-command:print c
-// gdbg-check:$3 = 97
 // gdbr-check:$3 = 97 'a'
 // gdb-command:print/d i8
 // gdb-check:$4 = 68
@@ -43,7 +42,6 @@
 // gdb-command:print f64
 // gdb-check:$15 = 3.5
 // gdb-command:print s
-// gdbg-check:$16 = {data_ptr = [...] "Hello, World!", length = 13}
 // gdbr-check:$16 = "Hello, World!"
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs
index e3cf74dab1e75..68fcc31699196 100644
--- a/tests/debuginfo/borrowed-basic.rs
+++ b/tests/debuginfo/borrowed-basic.rs
@@ -14,7 +14,6 @@
 // gdb-check:$3 = 97
 
 // gdb-command:print *i8_ref
-// gdbg-check:$4 = 68 'D'
 // gdbr-check:$4 = 68
 
 // gdb-command:print *i16_ref
@@ -30,7 +29,6 @@
 // gdb-check:$8 = 1
 
 // gdb-command:print *u8_ref
-// gdbg-check:$9 = 100 'd'
 // gdbr-check:$9 = 100
 
 // gdb-command:print *u16_ref
diff --git a/tests/debuginfo/borrowed-c-style-enum.rs b/tests/debuginfo/borrowed-c-style-enum.rs
index 1a582e8a6d9a5..7ca19217a7947 100644
--- a/tests/debuginfo/borrowed-c-style-enum.rs
+++ b/tests/debuginfo/borrowed-c-style-enum.rs
@@ -6,15 +6,12 @@
 // gdb-command:run
 
 // gdb-command:print *the_a_ref
-// gdbg-check:$1 = TheA
 // gdbr-check:$1 = borrowed_c_style_enum::ABC::TheA
 
 // gdb-command:print *the_b_ref
-// gdbg-check:$2 = TheB
 // gdbr-check:$2 = borrowed_c_style_enum::ABC::TheB
 
 // gdb-command:print *the_c_ref
-// gdbg-check:$3 = TheC
 // gdbr-check:$3 = borrowed_c_style_enum::ABC::TheC
 
 
diff --git a/tests/debuginfo/borrowed-struct.rs b/tests/debuginfo/borrowed-struct.rs
index d108a29592bc6..84e63d9cf634e 100644
--- a/tests/debuginfo/borrowed-struct.rs
+++ b/tests/debuginfo/borrowed-struct.rs
@@ -6,7 +6,6 @@
 // gdb-command:run
 
 // gdb-command:print *stack_val_ref
-// gdbg-check:$1 = {x = 10, y = 23.5}
 // gdbr-check:$1 = borrowed_struct::SomeStruct {x: 10, y: 23.5}
 
 // gdb-command:print *stack_val_interior_ref_1
@@ -16,11 +15,9 @@
 // gdb-check:$3 = 23.5
 
 // gdb-command:print *ref_to_unnamed
-// gdbg-check:$4 = {x = 11, y = 24.5}
 // gdbr-check:$4 = borrowed_struct::SomeStruct {x: 11, y: 24.5}
 
 // gdb-command:print *unique_val_ref
-// gdbg-check:$5 = {x = 13, y = 26.5}
 // gdbr-check:$5 = borrowed_struct::SomeStruct {x: 13, y: 26.5}
 
 // gdb-command:print *unique_val_interior_ref_1
diff --git a/tests/debuginfo/borrowed-tuple.rs b/tests/debuginfo/borrowed-tuple.rs
index 4c5643deb9d0a..c7253410f95b2 100644
--- a/tests/debuginfo/borrowed-tuple.rs
+++ b/tests/debuginfo/borrowed-tuple.rs
@@ -7,15 +7,12 @@
 // gdb-command:run
 
 // gdb-command:print *stack_val_ref
-// gdbg-check:$1 = {__0 = -14, __1 = -19}
 // gdbr-check:$1 = (-14, -19)
 
 // gdb-command:print *ref_to_unnamed
-// gdbg-check:$2 = {__0 = -15, __1 = -20}
 // gdbr-check:$2 = (-15, -20)
 
 // gdb-command:print *unique_val_ref
-// gdbg-check:$3 = {__0 = -17, __1 = -22}
 // gdbr-check:$3 = (-17, -22)
 
 
diff --git a/tests/debuginfo/box.rs b/tests/debuginfo/box.rs
index 46019bcb1a764..f27e7cbafbf22 100644
--- a/tests/debuginfo/box.rs
+++ b/tests/debuginfo/box.rs
@@ -9,7 +9,6 @@
 // gdb-command:print *a
 // gdb-check:$1 = 1
 // gdb-command:print *b
-// gdbg-check:$2 = {__0 = 2, __1 = 3.5}
 // gdbr-check:$2 = (2, 3.5)
 
 
diff --git a/tests/debuginfo/boxed-struct.rs b/tests/debuginfo/boxed-struct.rs
index 1ee639690eab9..078af68c84dfd 100644
--- a/tests/debuginfo/boxed-struct.rs
+++ b/tests/debuginfo/boxed-struct.rs
@@ -7,11 +7,9 @@
 // gdb-command:run
 
 // gdb-command:print *boxed_with_padding
-// gdbg-check:$1 = {x = 99, y = 999, z = 9999, w = 99999}
 // gdbr-check:$1 = boxed_struct::StructWithSomePadding {x: 99, y: 999, z: 9999, w: 99999}
 
 // gdb-command:print *boxed_with_dtor
-// gdbg-check:$2 = {x = 77, y = 777, z = 7777, w = 77777}
 // gdbr-check:$2 = boxed_struct::StructWithDestructor {x: 77, y: 777, z: 7777, w: 77777}
 
 
diff --git a/tests/debuginfo/by-value-non-immediate-argument.rs b/tests/debuginfo/by-value-non-immediate-argument.rs
index 68717b7953374..623c939ee143e 100644
--- a/tests/debuginfo/by-value-non-immediate-argument.rs
+++ b/tests/debuginfo/by-value-non-immediate-argument.rs
@@ -7,12 +7,10 @@
 // gdb-command:run
 
 // gdb-command:print s
-// gdbg-check:$1 = {a = 1, b = 2.5}
 // gdbr-check:$1 = by_value_non_immediate_argument::Struct {a: 1, b: 2.5}
 // gdb-command:continue
 
 // gdb-command:print x
-// gdbg-check:$2 = {a = 3, b = 4.5}
 // gdbr-check:$2 = by_value_non_immediate_argument::Struct {a: 3, b: 4.5}
 // gdb-command:print y
 // gdb-check:$3 = 5
@@ -21,17 +19,14 @@
 // gdb-command:continue
 
 // gdb-command:print a
-// gdbg-check:$5 = {__0 = 7, __1 = 8, __2 = 9.5, __3 = 10.5}
 // gdbr-check:$5 = (7, 8, 9.5, 10.5)
 // gdb-command:continue
 
 // gdb-command:print a
-// gdbg-check:$6 = {__0 = 11.5, __1 = 12.5, __2 = 13, __3 = 14}
 // gdbr-check:$6 = by_value_non_immediate_argument::Newtype (11.5, 12.5, 13, 14)
 // gdb-command:continue
 
 // gdb-command:print x
-// gdbg-check:$7 = {{RUST$ENUM$DISR = Case1, x = 0, y = 8970181431921507452}, {RUST$ENUM$DISR = Case1, [...]}}
 // gdbr-check:$7 = by_value_non_immediate_argument::Enum::Case1{x: 0, y: 8970181431921507452}
 // gdb-command:continue
 
diff --git a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
index 5276ec827333d..91a8792a69f90 100644
--- a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
+++ b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
@@ -11,12 +11,10 @@
 // gdb-command:continue
 
 // gdb-command:print self
-// gdbg-check:$2 = {x = 2222, y = 3333}
 // gdbr-check:$2 = by_value_self_argument_in_trait_impl::Struct {x: 2222, y: 3333}
 // gdb-command:continue
 
 // gdb-command:print self
-// gdbg-check:$3 = {__0 = 4444.5, __1 = 5555, __2 = 6666, __3 = 7777.5}
 // gdbr-check:$3 = (4444.5, 5555, 6666, 7777.5)
 // gdb-command:continue
 
diff --git a/tests/debuginfo/c-style-enum-in-composite.rs b/tests/debuginfo/c-style-enum-in-composite.rs
index ec11d5f465558..112631e874ebe 100644
--- a/tests/debuginfo/c-style-enum-in-composite.rs
+++ b/tests/debuginfo/c-style-enum-in-composite.rs
@@ -7,31 +7,24 @@
 // gdb-command:run
 
 // gdb-command:print tuple_interior_padding
-// gdbg-check:$1 = {__0 = 0, __1 = OneHundred}
 // gdbr-check:$1 = (0, c_style_enum_in_composite::AnEnum::OneHundred)
 
 // gdb-command:print tuple_padding_at_end
-// gdbg-check:$2 = {__0 = {__0 = 1, __1 = OneThousand}, __1 = 2}
 // gdbr-check:$2 = ((1, c_style_enum_in_composite::AnEnum::OneThousand), 2)
 
 // gdb-command:print tuple_different_enums
-// gdbg-check:$3 = {__0 = OneThousand, __1 = MountainView, __2 = OneMillion, __3 = Vienna}
 // gdbr-check:$3 = (c_style_enum_in_composite::AnEnum::OneThousand, c_style_enum_in_composite::AnotherEnum::MountainView, c_style_enum_in_composite::AnEnum::OneMillion, c_style_enum_in_composite::AnotherEnum::Vienna)
 
 // gdb-command:print padded_struct
-// gdbg-check:$4 = {a = 3, b = OneMillion, c = 4, d = Toronto, e = 5}
 // gdbr-check:$4 = c_style_enum_in_composite::PaddedStruct {a: 3, b: c_style_enum_in_composite::AnEnum::OneMillion, c: 4, d: c_style_enum_in_composite::AnotherEnum::Toronto, e: 5}
 
 // gdb-command:print packed_struct
-// gdbg-check:$5 = {a = 6, b = OneHundred, c = 7, d = Vienna, e = 8}
 // gdbr-check:$5 = c_style_enum_in_composite::PackedStruct {a: 6, b: c_style_enum_in_composite::AnEnum::OneHundred, c: 7, d: c_style_enum_in_composite::AnotherEnum::Vienna, e: 8}
 
 // gdb-command:print non_padded_struct
-// gdbg-check:$6 = {a = OneMillion, b = MountainView, c = OneThousand, d = Toronto}
 // gdbr-check:$6 = c_style_enum_in_composite::NonPaddedStruct {a: c_style_enum_in_composite::AnEnum::OneMillion, b: c_style_enum_in_composite::AnotherEnum::MountainView, c: c_style_enum_in_composite::AnEnum::OneThousand, d: c_style_enum_in_composite::AnotherEnum::Toronto}
 
 // gdb-command:print struct_with_drop
-// gdbg-check:$7 = {__0 = {a = OneHundred, b = Vienna}, __1 = 9}
 // gdbr-check:$7 = (c_style_enum_in_composite::StructWithDrop {a: c_style_enum_in_composite::AnEnum::OneHundred, b: c_style_enum_in_composite::AnotherEnum::Vienna}, 9)
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs
index 2ab5d5ccf2cbe..6f14f41f06003 100644
--- a/tests/debuginfo/c-style-enum.rs
+++ b/tests/debuginfo/c-style-enum.rs
@@ -5,89 +5,60 @@
 
 // === GDB TESTS ===================================================================================
 
-// gdbg-command:print 'c_style_enum::SINGLE_VARIANT'
 // gdbr-command:print c_style_enum::SINGLE_VARIANT
-// gdbg-check:$1 = TheOnlyVariant
 // gdbr-check:$1 = c_style_enum::SingleVariant::TheOnlyVariant
 
-// gdbg-command:print 'c_style_enum::AUTO_ONE'
 // gdbr-command:print c_style_enum::AUTO_ONE
-// gdbg-check:$2 = One
 // gdbr-check:$2 = c_style_enum::AutoDiscriminant::One
 
-// gdbg-command:print 'c_style_enum::AUTO_TWO'
 // gdbr-command:print c_style_enum::AUTO_TWO
-// gdbg-check:$3 = One
 // gdbr-check:$3 = c_style_enum::AutoDiscriminant::One
 
-// gdbg-command:print 'c_style_enum::AUTO_THREE'
 // gdbr-command:print c_style_enum::AUTO_THREE
-// gdbg-check:$4 = One
 // gdbr-check:$4 = c_style_enum::AutoDiscriminant::One
 
-// gdbg-command:print 'c_style_enum::MANUAL_ONE'
 // gdbr-command:print c_style_enum::MANUAL_ONE
-// gdbg-check:$5 = OneHundred
 // gdbr-check:$5 = c_style_enum::ManualDiscriminant::OneHundred
 
-// gdbg-command:print 'c_style_enum::MANUAL_TWO'
 // gdbr-command:print c_style_enum::MANUAL_TWO
-// gdbg-check:$6 = OneHundred
 // gdbr-check:$6 = c_style_enum::ManualDiscriminant::OneHundred
 
-// gdbg-command:print 'c_style_enum::MANUAL_THREE'
 // gdbr-command:print c_style_enum::MANUAL_THREE
-// gdbg-check:$7 = OneHundred
 // gdbr-check:$7 = c_style_enum::ManualDiscriminant::OneHundred
 
 // gdb-command:run
 
 // gdb-command:print auto_one
-// gdbg-check:$8 = One
 // gdbr-check:$8 = c_style_enum::AutoDiscriminant::One
 
 // gdb-command:print auto_two
-// gdbg-check:$9 = Two
 // gdbr-check:$9 = c_style_enum::AutoDiscriminant::Two
 
 // gdb-command:print auto_three
-// gdbg-check:$10 = Three
 // gdbr-check:$10 = c_style_enum::AutoDiscriminant::Three
 
 // gdb-command:print manual_one_hundred
-// gdbg-check:$11 = OneHundred
 // gdbr-check:$11 = c_style_enum::ManualDiscriminant::OneHundred
 
 // gdb-command:print manual_one_thousand
-// gdbg-check:$12 = OneThousand
 // gdbr-check:$12 = c_style_enum::ManualDiscriminant::OneThousand
 
 // gdb-command:print manual_one_million
-// gdbg-check:$13 = OneMillion
 // gdbr-check:$13 = c_style_enum::ManualDiscriminant::OneMillion
 
 // gdb-command:print single_variant
-// gdbg-check:$14 = TheOnlyVariant
 // gdbr-check:$14 = c_style_enum::SingleVariant::TheOnlyVariant
 
-// gdbg-command:print 'c_style_enum::AUTO_TWO'
 // gdbr-command:print AUTO_TWO
-// gdbg-check:$15 = Two
 // gdbr-check:$15 = c_style_enum::AutoDiscriminant::Two
 
-// gdbg-command:print 'c_style_enum::AUTO_THREE'
 // gdbr-command:print AUTO_THREE
-// gdbg-check:$16 = Three
 // gdbr-check:$16 = c_style_enum::AutoDiscriminant::Three
 
-// gdbg-command:print 'c_style_enum::MANUAL_TWO'
 // gdbr-command:print MANUAL_TWO
-// gdbg-check:$17 = OneThousand
 // gdbr-check:$17 = c_style_enum::ManualDiscriminant::OneThousand
 
-// gdbg-command:print 'c_style_enum::MANUAL_THREE'
 // gdbr-command:print MANUAL_THREE
-// gdbg-check:$18 = OneMillion
 // gdbr-check:$18 = c_style_enum::ManualDiscriminant::OneMillion
 
 
diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs
index a93c8f46930e5..57e1e63bb8fb0 100644
--- a/tests/debuginfo/cross-crate-spans.rs
+++ b/tests/debuginfo/cross-crate-spans.rs
@@ -15,7 +15,6 @@ extern crate cross_crate_spans;
 // gdb-command:run
 
 // gdb-command:print result
-// gdbg-check:$1 = {__0 = 17, __1 = 17}
 // gdbr-check:$1 = (17, 17)
 // gdb-command:print a_variable
 // gdb-check:$2 = 123456789
@@ -24,7 +23,6 @@ extern crate cross_crate_spans;
 // gdb-command:continue
 
 // gdb-command:print result
-// gdbg-check:$4 = {__0 = 1212, __1 = 1212}
 // gdbr-check:$4 = (1212, 1212)
 // gdb-command:print a_variable
 // gdb-check:$5 = 123456789
diff --git a/tests/debuginfo/destructured-fn-argument.rs b/tests/debuginfo/destructured-fn-argument.rs
index 74e18a594d789..2ebf49ca881ef 100644
--- a/tests/debuginfo/destructured-fn-argument.rs
+++ b/tests/debuginfo/destructured-fn-argument.rs
@@ -23,14 +23,12 @@
 // gdb-command:print a
 // gdb-check:$6 = 5
 // gdb-command:print b
-// gdbg-check:$7 = {__0 = 6, __1 = 7}
 // gdbr-check:$7 = (6, 7)
 // gdb-command:continue
 
 // gdb-command:print h
 // gdb-check:$8 = 8
 // gdb-command:print i
-// gdbg-check:$9 = {a = 9, b = 10}
 // gdbr-check:$9 = destructured_fn_argument::Struct {a: 9, b: 10}
 // gdb-command:print j
 // gdb-check:$10 = 11
@@ -57,7 +55,6 @@
 // gdb-command:print q
 // gdb-check:$17 = 20
 // gdb-command:print r
-// gdbg-check:$18 = {a = 21, b = 22}
 // gdbr-check:$18 = destructured_fn_argument::Struct {a: 21, b: 22}
 // gdb-command:continue
 
@@ -88,12 +85,10 @@
 // gdb-command:continue
 
 // gdb-command:print aa
-// gdbg-check:$30 = {__0 = 34, __1 = 35}
 // gdbr-check:$30 = (34, 35)
 // gdb-command:continue
 
 // gdb-command:print bb
-// gdbg-check:$31 = {__0 = 36, __1 = 37}
 // gdbr-check:$31 = (36, 37)
 // gdb-command:continue
 
@@ -102,19 +97,16 @@
 // gdb-command:continue
 
 // gdb-command:print dd
-// gdbg-check:$33 = {__0 = 40, __1 = 41, __2 = 42}
 // gdbr-check:$33 = (40, 41, 42)
 // gdb-command:continue
 
 // gdb-command:print *ee
-// gdbg-check:$34 = {__0 = 43, __1 = 44, __2 = 45}
 // gdbr-check:$34 = (43, 44, 45)
 // gdb-command:continue
 
 // gdb-command:print *ff
 // gdb-check:$35 = 46
 // gdb-command:print gg
-// gdbg-check:$36 = {__0 = 47, __1 = 48}
 // gdbr-check:$36 = (47, 48)
 // gdb-command:continue
 
diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs
index a8c7cc1489f62..f6b10f9989029 100644
--- a/tests/debuginfo/destructured-for-loop-variable.rs
+++ b/tests/debuginfo/destructured-for-loop-variable.rs
@@ -63,12 +63,10 @@
 // gdb-command:continue
 
 // gdb-command:print simple_struct_ident
-// gdbg-check:$23 = {x = 3537, y = 35437.5, z = true}
 // gdbr-check:$23 = destructured_for_loop_variable::Struct {x: 3537, y: 35437.5, z: true}
 // gdb-command:continue
 
 // gdb-command:print simple_tuple_ident
-// gdbg-check:$24 = {__0 = 34903493, __1 = 232323}
 // gdbr-check:$24 = (34903493, 232323)
 // gdb-command:continue
 
diff --git a/tests/debuginfo/destructured-local.rs b/tests/debuginfo/destructured-local.rs
index 8d62fe5db0311..d65b352e695f3 100644
--- a/tests/debuginfo/destructured-local.rs
+++ b/tests/debuginfo/destructured-local.rs
@@ -21,13 +21,11 @@
 // gdb-command:print f
 // gdb-check:$6 = 5
 // gdb-command:print g
-// gdbg-check:$7 = {__0 = 6, __1 = 7}
 // gdbr-check:$7 = (6, 7)
 
 // gdb-command:print h
 // gdb-check:$8 = 8
 // gdb-command:print i
-// gdbg-check:$9 = {a = 9, b = 10}
 // gdbr-check:$9 = destructured_local::Struct {a: 9, b: 10}
 // gdb-command:print j
 // gdb-check:$10 = 11
@@ -50,7 +48,6 @@
 // gdb-command:print q
 // gdb-check:$17 = 20
 // gdb-command:print r
-// gdbg-check:$18 = {a = 21, b = 22}
 // gdbr-check:$18 = destructured_local::Struct {a: 21, b: 22}
 
 // gdb-command:print s
@@ -78,29 +75,24 @@
 // gdb-check:$29 = 33
 
 // gdb-command:print aa
-// gdbg-check:$30 = {__0 = 34, __1 = 35}
 // gdbr-check:$30 = (34, 35)
 
 // gdb-command:print bb
-// gdbg-check:$31 = {__0 = 36, __1 = 37}
 // gdbr-check:$31 = (36, 37)
 
 // gdb-command:print cc
 // gdb-check:$32 = 38
 
 // gdb-command:print dd
-// gdbg-check:$33 = {__0 = 40, __1 = 41, __2 = 42}
 // gdbr-check:$33 = (40, 41, 42)
 
 // gdb-command:print *ee
-// gdbg-check:$34 = {__0 = 43, __1 = 44, __2 = 45}
 // gdbr-check:$34 = (43, 44, 45)
 
 // gdb-command:print *ff
 // gdb-check:$35 = 46
 
 // gdb-command:print gg
-// gdbg-check:$36 = {__0 = 47, __1 = 48}
 // gdbr-check:$36 = (47, 48)
 
 // gdb-command:print *hh
diff --git a/tests/debuginfo/evec-in-struct.rs b/tests/debuginfo/evec-in-struct.rs
index 2283e96c0ad6b..7e0dea0680bcb 100644
--- a/tests/debuginfo/evec-in-struct.rs
+++ b/tests/debuginfo/evec-in-struct.rs
@@ -7,22 +7,17 @@
 // gdb-command:run
 
 // gdb-command:print no_padding1
-// gdbg-check:$1 = {x = {0, 1, 2}, y = -3, z = {4.5, 5.5}}
 // gdbr-check:$1 = evec_in_struct::NoPadding1 {x: [0, 1, 2], y: -3, z: [4.5, 5.5]}
 // gdb-command:print no_padding2
-// gdbg-check:$2 = {x = {6, 7, 8}, y = {{9, 10}, {11, 12}}}
 // gdbr-check:$2 = evec_in_struct::NoPadding2 {x: [6, 7, 8], y: [[9, 10], [11, 12]]}
 
 // gdb-command:print struct_internal_padding
-// gdbg-check:$3 = {x = {13, 14}, y = {15, 16}}
 // gdbr-check:$3 = evec_in_struct::StructInternalPadding {x: [13, 14], y: [15, 16]}
 
 // gdb-command:print single_vec
-// gdbg-check:$4 = {x = {17, 18, 19, 20, 21}}
 // gdbr-check:$4 = evec_in_struct::SingleVec {x: [17, 18, 19, 20, 21]}
 
 // gdb-command:print struct_padded_at_end
-// gdbg-check:$5 = {x = {22, 23}, y = {24, 25}}
 // gdbr-check:$5 = evec_in_struct::StructPaddedAtEnd {x: [22, 23], y: [24, 25]}
 
 
diff --git a/tests/debuginfo/function-arg-initialization.rs b/tests/debuginfo/function-arg-initialization.rs
index c641a35c9a58c..ae54d56623c60 100644
--- a/tests/debuginfo/function-arg-initialization.rs
+++ b/tests/debuginfo/function-arg-initialization.rs
@@ -24,10 +24,8 @@
 
 // NON IMMEDIATE ARGS
 // gdb-command:print a
-// gdbg-check:$4 = {a = 3, b = 4, c = 5, d = 6, e = 7, f = 8, g = 9, h = 10}
 // gdbt-check:$4 = function_arg_initialization::BigStruct {a: 3, b: 4, c: 5, d: 6, e: 7, f: 8, g: 9, h: 10}
 // gdb-command:print b
-// gdbg-check:$5 = {a = 11, b = 12, c = 13, d = 14, e = 15, f = 16, g = 17, h = 18}
 // gdbt-check:$5 = function_arg_initialization::BigStruct {a: 11, b: 12, c: 13, d: 14, e: 15, f: 16, g: 17, h: 18}
 // gdb-command:continue
 
diff --git a/tests/debuginfo/gdb-pretty-struct-and-enums.rs b/tests/debuginfo/gdb-pretty-struct-and-enums.rs
index 235295e887c22..5b6977fdd5bcd 100644
--- a/tests/debuginfo/gdb-pretty-struct-and-enums.rs
+++ b/tests/debuginfo/gdb-pretty-struct-and-enums.rs
@@ -7,23 +7,18 @@
 // gdb-command: run
 
 // gdb-command: print regular_struct
-// gdbg-check:$1 = {the_first_field = 101, the_second_field = 102.5, the_third_field = false}
 // gdbr-check:$1 = gdb_pretty_struct_and_enums::RegularStruct {the_first_field: 101, the_second_field: 102.5, the_third_field: false}
 
 // gdb-command: print empty_struct
-// gdbg-check:$2 = EmptyStruct
 // gdbr-check:$2 = gdb_pretty_struct_and_enums::EmptyStruct
 
 // gdb-command: print c_style_enum1
-// gdbg-check:$3 = CStyleEnumVar1
 // gdbr-check:$3 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar1
 
 // gdb-command: print c_style_enum2
-// gdbg-check:$4 = CStyleEnumVar2
 // gdbr-check:$4 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar2
 
 // gdb-command: print c_style_enum3
-// gdbg-check:$5 = CStyleEnumVar3
 // gdbr-check:$5 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar3
 
 #![allow(dead_code, unused_variables)]
diff --git a/tests/debuginfo/generic-function.rs b/tests/debuginfo/generic-function.rs
index e131ebfa306ec..7378a5960f302 100644
--- a/tests/debuginfo/generic-function.rs
+++ b/tests/debuginfo/generic-function.rs
@@ -21,7 +21,6 @@
 // gdb-command:print *t0
 // gdb-check:$5 = 5
 // gdb-command:print *t1
-// gdbg-check:$6 = {a = 6, b = 7.5}
 // gdbr-check:$6 = generic_function::Struct {a: 6, b: 7.5}
 // gdb-command:continue
 
diff --git a/tests/debuginfo/generic-method-on-generic-struct.rs b/tests/debuginfo/generic-method-on-generic-struct.rs
index 0f70674041037..0b7bee53dabac 100644
--- a/tests/debuginfo/generic-method-on-generic-struct.rs
+++ b/tests/debuginfo/generic-method-on-generic-struct.rs
@@ -10,7 +10,6 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbg-check:$1 = {x = {__0 = 8888, __1 = -8888}}
 // gdbr-check:$1 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
@@ -20,7 +19,6 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbg-check:$4 = {x = {__0 = 8888, __1 = -8888}}
 // gdbr-check:$4 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
@@ -30,7 +28,6 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbg-check:$7 = {x = 1234.5}
 // gdbr-check:$7 = generic_method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
@@ -40,7 +37,6 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbg-check:$10 = {x = 1234.5}
 // gdbr-check:$10 = generic_method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
@@ -50,7 +46,6 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbg-check:$13 = {x = 1234.5}
 // gdbr-check:$13 = generic_method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs
index 8c74aa42d2ca6..7a0caf280a4ba 100644
--- a/tests/debuginfo/generic-struct.rs
+++ b/tests/debuginfo/generic-struct.rs
@@ -9,16 +9,12 @@
 // gdb-command:run
 
 // gdb-command:print int_int
-// gdbg-check:$1 = {key = 0, value = 1}
 // gdbr-check:$1 = generic_struct::AGenericStruct<i32, i32> {key: 0, value: 1}
 // gdb-command:print int_float
-// gdbg-check:$2 = {key = 2, value = 3.5}
 // gdbr-check:$2 = generic_struct::AGenericStruct<i32, f64> {key: 2, value: 3.5}
 // gdb-command:print float_int
-// gdbg-check:$3 = {key = 4.5, value = 5}
 // gdbr-check:$3 = generic_struct::AGenericStruct<f64, i32> {key: 4.5, value: 5}
 // gdb-command:print float_int_float
-// gdbg-check:$4 = {key = 6.5, value = {key = 7, value = 8.5}}
 // gdbr-check:$4 = generic_struct::AGenericStruct<f64, generic_struct::AGenericStruct<i32, f64>> {key: 6.5, value: generic_struct::AGenericStruct<i32, f64> {key: 7, value: 8.5}}
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs
index bd5a607586dc5..62a9ec0d19d19 100644
--- a/tests/debuginfo/lexical-scopes-in-block-expression.rs
+++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs
@@ -6,7 +6,6 @@
 
 // gdb-command:run
 
-// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT'
 // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$1 = 0
 
@@ -19,7 +18,6 @@
 
 // gdb-command:print val
 // gdb-check:$4 = 11
-// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT'
 // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$5 = 1
 // gdb-command:print ten
@@ -41,7 +39,6 @@
 
 // gdb-command:print val
 // gdb-check:$11 = 12
-// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT'
 // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$12 = 2
 // gdb-command:print ten
@@ -63,7 +60,6 @@
 
 // gdb-command:print val
 // gdb-check:$18 = 13
-// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT'
 // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$19 = 3
 // gdb-command:print ten
@@ -85,7 +81,6 @@
 
 // gdb-command:print val
 // gdb-check:$25 = 14
-// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT'
 // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$26 = 4
 // gdb-command:print ten
@@ -107,7 +102,6 @@
 
 // gdb-command:print val
 // gdb-check:$32 = 15
-// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT'
 // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$33 = 5
 // gdb-command:print ten
@@ -129,7 +123,6 @@
 
 // gdb-command:print val
 // gdb-check:$39 = 16
-// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT'
 // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$40 = 6
 // gdb-command:print ten
@@ -152,7 +145,6 @@
 
 // gdb-command:print val
 // gdb-check:$46 = 17
-// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT'
 // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$47 = 7
 // gdb-command:print ten
@@ -174,7 +166,6 @@
 
 // gdb-command:print val
 // gdb-check:$53 = 18
-// gdbg-command:print 'lexical_scopes_in_block_expression::MUT_INT'
 // gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$54 = 8
 // gdb-command:print ten
diff --git a/tests/debuginfo/limited-debuginfo.rs b/tests/debuginfo/limited-debuginfo.rs
index 2e49acd240170..e82e8e26aca72 100644
--- a/tests/debuginfo/limited-debuginfo.rs
+++ b/tests/debuginfo/limited-debuginfo.rs
@@ -4,13 +4,9 @@
 
 // Make sure functions have proper names
 // gdb-command:info functions
-// gdbg-check:[...]void[...]main([...]);
 // gdbr-check:fn limited_debuginfo::main();
-// gdbg-check:[...]void[...]some_function([...]);
 // gdbr-check:fn limited_debuginfo::some_function();
-// gdbg-check:[...]void[...]some_other_function([...]);
 // gdbr-check:fn limited_debuginfo::some_other_function();
-// gdbg-check:[...]void[...]zzz([...]);
 // gdbr-check:fn limited_debuginfo::zzz();
 
 // gdb-command:run
diff --git a/tests/debuginfo/method-on-enum.rs b/tests/debuginfo/method-on-enum.rs
index 7bee54451aa91..1d447686b0009 100644
--- a/tests/debuginfo/method-on-enum.rs
+++ b/tests/debuginfo/method-on-enum.rs
@@ -9,7 +9,6 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbg-check:$1 = {{RUST$ENUM$DISR = Variant2, [...]}, {RUST$ENUM$DISR = Variant2, __0 = 117901063}}
 // gdbr-check:$1 = method_on_enum::Enum::Variant2(117901063)
 // gdb-command:print arg1
 // gdb-check:$2 = -1
@@ -19,7 +18,6 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbg-check:$4 = {{RUST$ENUM$DISR = Variant2, [...]}, {RUST$ENUM$DISR = Variant2, __0 = 117901063}}
 // gdbr-check:$4 = method_on_enum::Enum::Variant2(117901063)
 // gdb-command:print arg1
 // gdb-check:$5 = -3
@@ -29,7 +27,6 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbg-check:$7 = {{RUST$ENUM$DISR = Variant1, x = 1799, y = 1799}, {RUST$ENUM$DISR = Variant1, [...]}}
 // gdbr-check:$7 = method_on_enum::Enum::Variant1{x: 1799, y: 1799}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
@@ -39,7 +36,6 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbg-check:$10 = {{RUST$ENUM$DISR = Variant1, x = 1799, y = 1799}, {RUST$ENUM$DISR = Variant1, [...]}}
 // gdbr-check:$10 = method_on_enum::Enum::Variant1{x: 1799, y: 1799}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
@@ -49,7 +45,6 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbg-check:$13 = {{RUST$ENUM$DISR = Variant1, x = 1799, y = 1799}, {RUST$ENUM$DISR = Variant1, [...]}}
 // gdbr-check:$13 = method_on_enum::Enum::Variant1{x: 1799, y: 1799}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs
index 64ef0e6bb0c3b..d8f5508090d55 100644
--- a/tests/debuginfo/method-on-generic-struct.rs
+++ b/tests/debuginfo/method-on-generic-struct.rs
@@ -10,7 +10,6 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbg-check:$1 = {x = {__0 = 8888, __1 = -8888}}
 // gdbr-check:$1 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
@@ -20,7 +19,6 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbg-check:$4 = {x = {__0 = 8888, __1 = -8888}}
 // gdbr-check:$4 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
@@ -30,7 +28,6 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbg-check:$7 = {x = 1234.5}
 // gdbr-check:$7 = method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
@@ -40,7 +37,6 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbg-check:$10 = {x = 1234.5}
 // gdbr-check:$10 = method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
@@ -50,7 +46,6 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbg-check:$13 = {x = 1234.5}
 // gdbr-check:$13 = method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
diff --git a/tests/debuginfo/method-on-struct.rs b/tests/debuginfo/method-on-struct.rs
index a4129af542906..c2632dafc3947 100644
--- a/tests/debuginfo/method-on-struct.rs
+++ b/tests/debuginfo/method-on-struct.rs
@@ -8,7 +8,6 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbg-check:$1 = {x = 100}
 // gdbr-check:$1 = method_on_struct::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
@@ -18,7 +17,6 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbg-check:$4 = {x = 100}
 // gdbr-check:$4 = method_on_struct::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
@@ -28,7 +26,6 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbg-check:$7 = {x = 200}
 // gdbr-check:$7 = method_on_struct::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
@@ -38,7 +35,6 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbg-check:$10 = {x = 200}
 // gdbr-check:$10 = method_on_struct::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
@@ -48,7 +44,6 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbg-check:$13 = {x = 200}
 // gdbr-check:$13 = method_on_struct::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
diff --git a/tests/debuginfo/method-on-trait.rs b/tests/debuginfo/method-on-trait.rs
index 0934c267ab136..9172c6976a1a6 100644
--- a/tests/debuginfo/method-on-trait.rs
+++ b/tests/debuginfo/method-on-trait.rs
@@ -8,7 +8,6 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbg-check:$1 = {x = 100}
 // gdbr-check:$1 = method_on_trait::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
@@ -18,7 +17,6 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbg-check:$4 = {x = 100}
 // gdbr-check:$4 = method_on_trait::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
@@ -28,7 +26,6 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbg-check:$7 = {x = 200}
 // gdbr-check:$7 = method_on_trait::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
@@ -38,7 +35,6 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbg-check:$10 = {x = 200}
 // gdbr-check:$10 = method_on_trait::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
@@ -48,7 +44,6 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbg-check:$13 = {x = 200}
 // gdbr-check:$13 = method_on_trait::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
diff --git a/tests/debuginfo/method-on-tuple-struct.rs b/tests/debuginfo/method-on-tuple-struct.rs
index 9cf9c6d7fbae9..71a11093f7d38 100644
--- a/tests/debuginfo/method-on-tuple-struct.rs
+++ b/tests/debuginfo/method-on-tuple-struct.rs
@@ -8,7 +8,6 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbg-check:$1 = {__0 = 100, __1 = -100.5}
 // gdbr-check:$1 = method_on_tuple_struct::TupleStruct (100, -100.5)
 // gdb-command:print arg1
 // gdb-check:$2 = -1
@@ -18,7 +17,6 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbg-check:$4 = {__0 = 100, __1 = -100.5}
 // gdbr-check:$4 = method_on_tuple_struct::TupleStruct (100, -100.5)
 // gdb-command:print arg1
 // gdb-check:$5 = -3
@@ -28,7 +26,6 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbg-check:$7 = {__0 = 200, __1 = -200.5}
 // gdbr-check:$7 = method_on_tuple_struct::TupleStruct (200, -200.5)
 // gdb-command:print arg1
 // gdb-check:$8 = -5
@@ -38,7 +35,6 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbg-check:$10 = {__0 = 200, __1 = -200.5}
 // gdbr-check:$10 = method_on_tuple_struct::TupleStruct (200, -200.5)
 // gdb-command:print arg1
 // gdb-check:$11 = -7
@@ -48,7 +44,6 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbg-check:$13 = {__0 = 200, __1 = -200.5}
 // gdbr-check:$13 = method_on_tuple_struct::TupleStruct (200, -200.5)
 // gdb-command:print arg1
 // gdb-check:$14 = -9
diff --git a/tests/debuginfo/option-like-enum.rs b/tests/debuginfo/option-like-enum.rs
index da556d613d088..159d8e976c7c4 100644
--- a/tests/debuginfo/option-like-enum.rs
+++ b/tests/debuginfo/option-like-enum.rs
@@ -8,35 +8,27 @@
 // gdb-command:run
 
 // gdb-command:print some
-// gdbg-check:$1 = {RUST$ENCODED$ENUM$0$None = {__0 = 0x12345678}}
 // gdbr-check:$1 = core::option::Option<&u32>::Some(0x12345678)
 
 // gdb-command:print none
-// gdbg-check:$2 = {RUST$ENCODED$ENUM$0$None = {__0 = 0x0}}
 // gdbr-check:$2 = core::option::Option<&u32>::None
 
 // gdb-command:print full
-// gdbg-check:$3 = {RUST$ENCODED$ENUM$1$Empty = {__0 = 454545, __1 = 0x87654321, __2 = 9988}}
 // gdbr-check:$3 = option_like_enum::MoreFields::Full(454545, 0x87654321, 9988)
 
-// gdbg-command:print empty_gdb->discr
 // gdbr-command:print empty_gdb.discr
 // gdb-check:$4 = (*mut isize) 0x1
 
 // gdb-command:print droid
-// gdbg-check:$5 = {RUST$ENCODED$ENUM$2$Void = {id = 675675, range = 10000001, internals = 0x43218765}}
 // gdbr-check:$5 = option_like_enum::NamedFields::Droid{id: 675675, range: 10000001, internals: 0x43218765}
 
-// gdbg-command:print void_droid_gdb->internals
 // gdbr-command:print void_droid_gdb.internals
 // gdb-check:$6 = (*mut isize) 0x1
 
 // gdb-command:print nested_non_zero_yep
-// gdbg-check:$7 = {RUST$ENCODED$ENUM$1$2$Nope = {__0 = 10.5, __1 = {a = 10, b = 20, c = [...]}}}
 // gdbr-check:$7 = option_like_enum::NestedNonZero::Yep(10.5, option_like_enum::NestedNonZeroField {a: 10, b: 20, c: 0x[...]})
 
 // gdb-command:print nested_non_zero_nope
-// gdbg-check:$8 = {RUST$ENCODED$ENUM$1$2$Nope = {__0 = [...], __1 = {a = [...], b = [...], c = 0x0}}}
 // gdbr-check:$8 = option_like_enum::NestedNonZero::Nope
 
 // gdb-command:continue
diff --git a/tests/debuginfo/packed-struct-with-destructor.rs b/tests/debuginfo/packed-struct-with-destructor.rs
index f9bac84437629..afd0d570b0b33 100644
--- a/tests/debuginfo/packed-struct-with-destructor.rs
+++ b/tests/debuginfo/packed-struct-with-destructor.rs
@@ -7,36 +7,28 @@
 // gdb-command:run
 
 // gdb-command:print packed
-// gdbg-check:$1 = {x = 123, y = 234, z = 345}
 // gdbr-check:$1 = packed_struct_with_destructor::Packed {x: 123, y: 234, z: 345}
 
 // gdb-command:print packedInPacked
-// gdbg-check:$2 = {a = 1111, b = {x = 2222, y = 3333, z = 4444}, c = 5555, d = {x = 6666, y = 7777, z = 8888}}
 // gdbr-check:$2 = packed_struct_with_destructor::PackedInPacked {a: 1111, b: packed_struct_with_destructor::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct_with_destructor::Packed {x: 6666, y: 7777, z: 8888}}
 
 // gdb-command:print packedInUnpacked
-// gdbg-check:$3 = {a = -1111, b = {x = -2222, y = -3333, z = -4444}, c = -5555, d = {x = -6666, y = -7777, z = -8888}}
 // gdbr-check:$3 = packed_struct_with_destructor::PackedInUnpacked {a: -1111, b: packed_struct_with_destructor::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct_with_destructor::Packed {x: -6666, y: -7777, z: -8888}}
 
 // gdb-command:print unpackedInPacked
-// gdbg-check:$4 = {a = 987, b = {x = 876, y = 765, z = 654}, c = {x = 543, y = 432, z = 321}, d = 210}
 // gdbr-check:$4 = packed_struct_with_destructor::UnpackedInPacked {a: 987, b: packed_struct_with_destructor::Unpacked {x: 876, y: 765, z: 654}, c: packed_struct_with_destructor::Unpacked {x: 543, y: 432, z: 321}, d: 210}
 
 
 // gdb-command:print packedInPackedWithDrop
-// gdbg-check:$5 = {a = 11, b = {x = 22, y = 33, z = 44}, c = 55, d = {x = 66, y = 77, z = 88}}
 // gdbr-check:$5 = packed_struct_with_destructor::PackedInPackedWithDrop {a: 11, b: packed_struct_with_destructor::Packed {x: 22, y: 33, z: 44}, c: 55, d: packed_struct_with_destructor::Packed {x: 66, y: 77, z: 88}}
 
 // gdb-command:print packedInUnpackedWithDrop
-// gdbg-check:$6 = {a = -11, b = {x = -22, y = -33, z = -44}, c = -55, d = {x = -66, y = -77, z = -88}}
 // gdbr-check:$6 = packed_struct_with_destructor::PackedInUnpackedWithDrop {a: -11, b: packed_struct_with_destructor::Packed {x: -22, y: -33, z: -44}, c: -55, d: packed_struct_with_destructor::Packed {x: -66, y: -77, z: -88}}
 
 // gdb-command:print unpackedInPackedWithDrop
-// gdbg-check:$7 = {a = 98, b = {x = 87, y = 76, z = 65}, c = {x = 54, y = 43, z = 32}, d = 21}
 // gdbr-check:$7 = packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 98, b: packed_struct_with_destructor::Unpacked {x: 87, y: 76, z: 65}, c: packed_struct_with_destructor::Unpacked {x: 54, y: 43, z: 32}, d: 21}
 
 // gdb-command:print deeplyNested
-// gdbg-check:$8 = {a = {a = 1, b = {x = 2, y = 3, z = 4}, c = 5, d = {x = 6, y = 7, z = 8}}, b = {a = 9, b = {x = 10, y = 11, z = 12}, c = {x = 13, y = 14, z = 15}, d = 16}, c = {a = 17, b = {x = 18, y = 19, z = 20}, c = 21, d = {x = 22, y = 23, z = 24}}, d = {a = 25, b = {x = 26, y = 27, z = 28}, c = 29, d = {x = 30, y = 31, z = 32}}, e = {a = 33, b = {x = 34, y = 35, z = 36}, c = {x = 37, y = 38, z = 39}, d = 40}, f = {a = 41, b = {x = 42, y = 43, z = 44}, c = 45, d = {x = 46, y = 47, z = 48}}}
 // gdbr-check:$8 = packed_struct_with_destructor::DeeplyNested {a: packed_struct_with_destructor::PackedInPacked {a: 1, b: packed_struct_with_destructor::Packed {x: 2, y: 3, z: 4}, c: 5, d: packed_struct_with_destructor::Packed {x: 6, y: 7, z: 8}}, b: packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 9, b: packed_struct_with_destructor::Unpacked {x: 10, y: 11, z: 12}, c: packed_struct_with_destructor::Unpacked {x: 13, y: 14, z: 15}, d: 16}, c: packed_struct_with_destructor::PackedInUnpacked {a: 17, b: packed_struct_with_destructor::Packed {x: 18, y: 19, z: 20}, c: 21, d: packed_struct_with_destructor::Packed {x: 22, y: 23, z: 24}}, d: packed_struct_with_destructor::PackedInUnpackedWithDrop {a: 25, b: packed_struct_with_destructor::Packed {x: 26, y: 27, z: 28}, c: 29, d: packed_struct_with_destructor::Packed {x: 30, y: 31, z: 32}}, e: packed_struct_with_destructor::UnpackedInPacked {a: 33, b: packed_struct_with_destructor::Unpacked {x: 34, y: 35, z: 36}, c: packed_struct_with_destructor::Unpacked {x: 37, y: 38, z: 39}, d: 40}, f: packed_struct_with_destructor::PackedInPackedWithDrop {a: 41, b: packed_struct_with_destructor::Packed {x: 42, y: 43, z: 44}, c: 45, d: packed_struct_with_destructor::Packed {x: 46, y: 47, z: 48}}}
 
 
diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs
index ea9aa22ba5501..6ef4995bc16d2 100644
--- a/tests/debuginfo/packed-struct.rs
+++ b/tests/debuginfo/packed-struct.rs
@@ -8,19 +8,15 @@
 // gdb-command:run
 
 // gdb-command:print packed
-// gdbg-check:$1 = {x = 123, y = 234, z = 345}
 // gdbr-check:$1 = packed_struct::Packed {x: 123, y: 234, z: 345}
 
 // gdb-command:print packedInPacked
-// gdbg-check:$2 = {a = 1111, b = {x = 2222, y = 3333, z = 4444}, c = 5555, d = {x = 6666, y = 7777, z = 8888}}
 // gdbr-check:$2 = packed_struct::PackedInPacked {a: 1111, b: packed_struct::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct::Packed {x: 6666, y: 7777, z: 8888}}
 
 // gdb-command:print packedInUnpacked
-// gdbg-check:$3 = {a = -1111, b = {x = -2222, y = -3333, z = -4444}, c = -5555, d = {x = -6666, y = -7777, z = -8888}}
 // gdbr-check:$3 = packed_struct::PackedInUnpacked {a: -1111, b: packed_struct::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct::Packed {x: -6666, y: -7777, z: -8888}}
 
 // gdb-command:print unpackedInPacked
-// gdbg-check:$4 = {a = 987, b = {x = 876, y = 765, z = 654, w = 543}, c = {x = 432, y = 321, z = 210, w = 109}, d = -98}
 // gdbr-check:$4 = packed_struct::UnpackedInPacked {a: 987, b: packed_struct::Unpacked {x: 876, y: 765, z: 654, w: 543}, c: packed_struct::Unpacked {x: 432, y: 321, z: 210, w: 109}, d: -98}
 
 // gdb-command:print sizeof(packed)
diff --git a/tests/debuginfo/pretty-slices.rs b/tests/debuginfo/pretty-slices.rs
index 44335f5c83b3f..90cad4e6639e4 100644
--- a/tests/debuginfo/pretty-slices.rs
+++ b/tests/debuginfo/pretty-slices.rs
@@ -5,11 +5,9 @@
 // gdb-command: run
 
 // gdb-command: print slice
-// gdbg-check: $1 = struct &[i32](size=3) = {0, 1, 2}
 // gdbr-check: $1 = &[i32](size=3) = {0, 1, 2}
 
 // gdb-command: print mut_slice
-// gdbg-check: $2 = struct &mut [i32](size=4) = {2, 3, 5, 7}
 // gdbr-check: $2 = &mut [i32](size=4) = {2, 3, 5, 7}
 
 // gdb-command: print str_slice
diff --git a/tests/debuginfo/pretty-std.rs b/tests/debuginfo/pretty-std.rs
index 933be9772343c..c42bdc5ee3fc1 100644
--- a/tests/debuginfo/pretty-std.rs
+++ b/tests/debuginfo/pretty-std.rs
@@ -26,7 +26,6 @@
 // gdb-check:$5 = core::option::Option<i16>::Some(8)
 
 // gdb-command: print none
-// gdbg-check:$6 = None
 // gdbr-check:$6 = core::option::Option<i64>::None
 
 // gdb-command: print os_string
diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs
index e2fb964ace521..d59cf61420f23 100644
--- a/tests/debuginfo/reference-debuginfo.rs
+++ b/tests/debuginfo/reference-debuginfo.rs
@@ -18,7 +18,6 @@
 // gdb-check:$3 = 97
 
 // gdb-command:print *i8_ref
-// gdbg-check:$4 = 68 'D'
 // gdbr-check:$4 = 68
 
 // gdb-command:print *i16_ref
@@ -34,7 +33,6 @@
 // gdb-check:$8 = 1
 
 // gdb-command:print *u8_ref
-// gdbg-check:$9 = 100 'd'
 // gdbr-check:$9 = 100
 
 // gdb-command:print *u16_ref
diff --git a/tests/debuginfo/self-in-default-method.rs b/tests/debuginfo/self-in-default-method.rs
index 374951475fc07..89e1a8fab2b9e 100644
--- a/tests/debuginfo/self-in-default-method.rs
+++ b/tests/debuginfo/self-in-default-method.rs
@@ -8,7 +8,6 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbg-check:$1 = {x = 100}
 // gdbr-check:$1 = self_in_default_method::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
@@ -18,7 +17,6 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbg-check:$4 = {x = 100}
 // gdbr-check:$4 = self_in_default_method::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
@@ -28,7 +26,6 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbg-check:$7 = {x = 200}
 // gdbr-check:$7 = self_in_default_method::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
@@ -38,7 +35,6 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbg-check:$10 = {x = 200}
 // gdbr-check:$10 = self_in_default_method::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
@@ -48,7 +44,6 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbg-check:$13 = {x = 200}
 // gdbr-check:$13 = self_in_default_method::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
diff --git a/tests/debuginfo/self-in-generic-default-method.rs b/tests/debuginfo/self-in-generic-default-method.rs
index 4759ca3ecdc0a..b4908486cdf88 100644
--- a/tests/debuginfo/self-in-generic-default-method.rs
+++ b/tests/debuginfo/self-in-generic-default-method.rs
@@ -8,7 +8,6 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbg-check:$1 = {x = 987}
 // gdbr-check:$1 = self_in_generic_default_method::Struct {x: 987}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
@@ -18,7 +17,6 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbg-check:$4 = {x = 987}
 // gdbr-check:$4 = self_in_generic_default_method::Struct {x: 987}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
@@ -28,7 +26,6 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbg-check:$7 = {x = 879}
 // gdbr-check:$7 = self_in_generic_default_method::Struct {x: 879}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
@@ -38,7 +35,6 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbg-check:$10 = {x = 879}
 // gdbr-check:$10 = self_in_generic_default_method::Struct {x: 879}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
@@ -48,7 +44,6 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbg-check:$13 = {x = 879}
 // gdbr-check:$13 = self_in_generic_default_method::Struct {x: 879}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
diff --git a/tests/debuginfo/simd.rs b/tests/debuginfo/simd.rs
index a5dd2e61a8ded..44a3efee39133 100644
--- a/tests/debuginfo/simd.rs
+++ b/tests/debuginfo/simd.rs
@@ -9,45 +9,27 @@
 //@ compile-flags:-g
 // gdb-command:run
 
-// gdbg-command:print/d vi8x16
 // gdbr-command:print vi8x16
-// gdbg-check:$1 = {__0 = 0, __1 = 1, __2 = 2, __3 = 3, __4 = 4, __5 = 5, __6 = 6, __7 = 7, __8 = 8, __9 = 9, __10 = 10, __11 = 11, __12 = 12, __13 = 13, __14 = 14, __15 = 15}
 // gdbr-check:$1 = simd::i8x16 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
-// gdbg-command:print/d vi16x8
 // gdbr-command:print vi16x8
-// gdbg-check:$2 = {__0 = 16, __1 = 17, __2 = 18, __3 = 19, __4 = 20, __5 = 21, __6 = 22, __7 = 23}
 // gdbr-check:$2 = simd::i16x8 (16, 17, 18, 19, 20, 21, 22, 23)
-// gdbg-command:print/d vi32x4
 // gdbr-command:print vi32x4
-// gdbg-check:$3 = {__0 = 24, __1 = 25, __2 = 26, __3 = 27}
 // gdbr-check:$3 = simd::i32x4 (24, 25, 26, 27)
-// gdbg-command:print/d vi64x2
 // gdbr-command:print vi64x2
-// gdbg-check:$4 = {__0 = 28, __1 = 29}
 // gdbr-check:$4 = simd::i64x2 (28, 29)
 
-// gdbg-command:print/d vu8x16
 // gdbr-command:print vu8x16
-// gdbg-check:$5 = {__0 = 30, __1 = 31, __2 = 32, __3 = 33, __4 = 34, __5 = 35, __6 = 36, __7 = 37, __8 = 38, __9 = 39, __10 = 40, __11 = 41, __12 = 42, __13 = 43, __14 = 44, __15 = 45}
 // gdbr-check:$5 = simd::u8x16 (30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45)
-// gdbg-command:print/d vu16x8
 // gdbr-command:print vu16x8
-// gdbg-check:$6 = {__0 = 46, __1 = 47, __2 = 48, __3 = 49, __4 = 50, __5 = 51, __6 = 52, __7 = 53}
 // gdbr-check:$6 = simd::u16x8 (46, 47, 48, 49, 50, 51, 52, 53)
-// gdbg-command:print/d vu32x4
 // gdbr-command:print vu32x4
-// gdbg-check:$7 = {__0 = 54, __1 = 55, __2 = 56, __3 = 57}
 // gdbr-check:$7 = simd::u32x4 (54, 55, 56, 57)
-// gdbg-command:print/d vu64x2
 // gdbr-command:print vu64x2
-// gdbg-check:$8 = {__0 = 58, __1 = 59}
 // gdbr-check:$8 = simd::u64x2 (58, 59)
 
 // gdb-command:print vf32x4
-// gdbg-check:$9 = {__0 = 60.5, __1 = 61.5, __2 = 62.5, __3 = 63.5}
 // gdbr-check:$9 = simd::f32x4 (60.5, 61.5, 62.5, 63.5)
 // gdb-command:print vf64x2
-// gdbg-check:$10 = {__0 = 64.5, __1 = 65.5}
 // gdbr-check:$10 = simd::f64x2 (64.5, 65.5)
 
 // gdb-command:continue
diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs
index aaa654aeb7a67..54d543d90a4c1 100644
--- a/tests/debuginfo/simple-struct.rs
+++ b/tests/debuginfo/simple-struct.rs
@@ -4,90 +4,60 @@
 
 // === GDB TESTS ===================================================================================
 
-// gdbg-command:print 'simple_struct::NO_PADDING_16'
 // gdbr-command:print simple_struct::NO_PADDING_16
-// gdbg-check:$1 = {x = 1000, y = -1001}
 // gdbr-check:$1 = simple_struct::NoPadding16 {x: 1000, y: -1001}
 
-// gdbg-command:print 'simple_struct::NO_PADDING_32'
 // gdbr-command:print simple_struct::NO_PADDING_32
-// gdbg-check:$2 = {x = 1, y = 2, z = 3}
 // gdbr-check:$2 = simple_struct::NoPadding32 {x: 1, y: 2, z: 3}
 
-// gdbg-command:print 'simple_struct::NO_PADDING_64'
 // gdbr-command:print simple_struct::NO_PADDING_64
-// gdbg-check:$3 = {x = 4, y = 5, z = 6}
 // gdbr-check:$3 = simple_struct::NoPadding64 {x: 4, y: 5, z: 6}
 
-// gdbg-command:print 'simple_struct::NO_PADDING_163264'
 // gdbr-command:print simple_struct::NO_PADDING_163264
-// gdbg-check:$4 = {a = 7, b = 8, c = 9, d = 10}
 // gdbr-check:$4 = simple_struct::NoPadding163264 {a: 7, b: 8, c: 9, d: 10}
 
-// gdbg-command:print 'simple_struct::INTERNAL_PADDING'
 // gdbr-command:print simple_struct::INTERNAL_PADDING
-// gdbg-check:$5 = {x = 11, y = 12}
 // gdbr-check:$5 = simple_struct::InternalPadding {x: 11, y: 12}
 
-// gdbg-command:print 'simple_struct::PADDING_AT_END'
 // gdbr-command:print simple_struct::PADDING_AT_END
-// gdbg-check:$6 = {x = 13, y = 14}
 // gdbr-check:$6 = simple_struct::PaddingAtEnd {x: 13, y: 14}
 
 // gdb-command:run
 
 // gdb-command:print no_padding16
-// gdbg-check:$7 = {x = 10000, y = -10001}
 // gdbr-check:$7 = simple_struct::NoPadding16 {x: 10000, y: -10001}
 
 // gdb-command:print no_padding32
-// gdbg-check:$8 = {x = -10002, y = -10003.5, z = 10004}
 // gdbr-check:$8 = simple_struct::NoPadding32 {x: -10002, y: -10003.5, z: 10004}
 
 // gdb-command:print no_padding64
-// gdbg-check:$9 = {x = -10005.5, y = 10006, z = 10007}
 // gdbr-check:$9 = simple_struct::NoPadding64 {x: -10005.5, y: 10006, z: 10007}
 
 // gdb-command:print no_padding163264
-// gdbg-check:$10 = {a = -10008, b = 10009, c = 10010, d = 10011}
 // gdbr-check:$10 = simple_struct::NoPadding163264 {a: -10008, b: 10009, c: 10010, d: 10011}
 
 // gdb-command:print internal_padding
-// gdbg-check:$11 = {x = 10012, y = -10013}
 // gdbr-check:$11 = simple_struct::InternalPadding {x: 10012, y: -10013}
 
 // gdb-command:print padding_at_end
-// gdbg-check:$12 = {x = -10014, y = 10015}
 // gdbr-check:$12 = simple_struct::PaddingAtEnd {x: -10014, y: 10015}
 
-// gdbg-command:print 'simple_struct::NO_PADDING_16'
 // gdbr-command:print simple_struct::NO_PADDING_16
-// gdbg-check:$13 = {x = 100, y = -101}
 // gdbr-check:$13 = simple_struct::NoPadding16 {x: 100, y: -101}
 
-// gdbg-command:print 'simple_struct::NO_PADDING_32'
 // gdbr-command:print simple_struct::NO_PADDING_32
-// gdbg-check:$14 = {x = -15, y = -16, z = 17}
 // gdbr-check:$14 = simple_struct::NoPadding32 {x: -15, y: -16, z: 17}
 
-// gdbg-command:print 'simple_struct::NO_PADDING_64'
 // gdbr-command:print simple_struct::NO_PADDING_64
-// gdbg-check:$15 = {x = -18, y = 19, z = 20}
 // gdbr-check:$15 = simple_struct::NoPadding64 {x: -18, y: 19, z: 20}
 
-// gdbg-command:print 'simple_struct::NO_PADDING_163264'
 // gdbr-command:print simple_struct::NO_PADDING_163264
-// gdbg-check:$16 = {a = -21, b = 22, c = 23, d = 24}
 // gdbr-check:$16 = simple_struct::NoPadding163264 {a: -21, b: 22, c: 23, d: 24}
 
-// gdbg-command:print 'simple_struct::INTERNAL_PADDING'
 // gdbr-command:print simple_struct::INTERNAL_PADDING
-// gdbg-check:$17 = {x = 25, y = -26}
 // gdbr-check:$17 = simple_struct::InternalPadding {x: 25, y: -26}
 
-// gdbg-command:print 'simple_struct::PADDING_AT_END'
 // gdbr-command:print simple_struct::PADDING_AT_END
-// gdbg-check:$18 = {x = -27, y = 28}
 // gdbr-check:$18 = simple_struct::PaddingAtEnd {x: -27, y: 28}
 
 // gdb-command:continue
diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs
index 9d809a11cac52..e19fb59cdc5ce 100644
--- a/tests/debuginfo/simple-tuple.rs
+++ b/tests/debuginfo/simple-tuple.rs
@@ -4,93 +4,57 @@
 
 // === GDB TESTS ===================================================================================
 
-// gdbg-command:print/d 'simple_tuple::NO_PADDING_8'
 // gdbr-command:print simple_tuple::NO_PADDING_8
-// gdbg-check:$1 = {__0 = -50, __1 = 50}
 // gdbr-check:$1 = (-50, 50)
-// gdbg-command:print 'simple_tuple::NO_PADDING_16'
 // gdbr-command:print simple_tuple::NO_PADDING_16
-// gdbg-check:$2 = {__0 = -1, __1 = 2, __2 = 3}
 // gdbr-check:$2 = (-1, 2, 3)
-// gdbg-command:print 'simple_tuple::NO_PADDING_32'
 // gdbr-command:print simple_tuple::NO_PADDING_32
-// gdbg-check:$3 = {__0 = 4, __1 = 5, __2 = 6}
 // gdbr-check:$3 = (4, 5, 6)
-// gdbg-command:print 'simple_tuple::NO_PADDING_64'
 // gdbr-command:print simple_tuple::NO_PADDING_64
-// gdbg-check:$4 = {__0 = 7, __1 = 8, __2 = 9}
 // gdbr-check:$4 = (7, 8, 9)
 
-// gdbg-command:print 'simple_tuple::INTERNAL_PADDING_1'
 // gdbr-command:print simple_tuple::INTERNAL_PADDING_1
-// gdbg-check:$5 = {__0 = 10, __1 = 11}
 // gdbr-check:$5 = (10, 11)
-// gdbg-command:print 'simple_tuple::INTERNAL_PADDING_2'
 // gdbr-command:print simple_tuple::INTERNAL_PADDING_2
-// gdbg-check:$6 = {__0 = 12, __1 = 13, __2 = 14, __3 = 15}
 // gdbr-check:$6 = (12, 13, 14, 15)
 
-// gdbg-command:print 'simple_tuple::PADDING_AT_END'
 // gdbr-command:print simple_tuple::PADDING_AT_END
-// gdbg-check:$7 = {__0 = 16, __1 = 17}
 // gdbr-check:$7 = (16, 17)
 
 // gdb-command:run
 
-// gdbg-command:print/d noPadding8
 // gdbr-command:print noPadding8
-// gdbg-check:$8 = {__0 = -100, __1 = 100}
 // gdbr-check:$8 = (-100, 100)
 // gdb-command:print noPadding16
-// gdbg-check:$9 = {__0 = 0, __1 = 1, __2 = 2}
 // gdbr-check:$9 = (0, 1, 2)
 // gdb-command:print noPadding32
-// gdbg-check:$10 = {__0 = 3, __1 = 4.5, __2 = 5}
 // gdbr-check:$10 = (3, 4.5, 5)
 // gdb-command:print noPadding64
-// gdbg-check:$11 = {__0 = 6, __1 = 7.5, __2 = 8}
 // gdbr-check:$11 = (6, 7.5, 8)
 
 // gdb-command:print internalPadding1
-// gdbg-check:$12 = {__0 = 9, __1 = 10}
 // gdbr-check:$12 = (9, 10)
 // gdb-command:print internalPadding2
-// gdbg-check:$13 = {__0 = 11, __1 = 12, __2 = 13, __3 = 14}
 // gdbr-check:$13 = (11, 12, 13, 14)
 
 // gdb-command:print paddingAtEnd
-// gdbg-check:$14 = {__0 = 15, __1 = 16}
 // gdbr-check:$14 = (15, 16)
 
-// gdbg-command:print/d 'simple_tuple::NO_PADDING_8'
 // gdbr-command:print simple_tuple::NO_PADDING_8
-// gdbg-check:$15 = {__0 = -127, __1 = 127}
 // gdbr-check:$15 = (-127, 127)
-// gdbg-command:print 'simple_tuple::NO_PADDING_16'
 // gdbr-command:print simple_tuple::NO_PADDING_16
-// gdbg-check:$16 = {__0 = -10, __1 = 10, __2 = 9}
 // gdbr-check:$16 = (-10, 10, 9)
-// gdbg-command:print 'simple_tuple::NO_PADDING_32'
 // gdbr-command:print simple_tuple::NO_PADDING_32
-// gdbg-check:$17 = {__0 = 14, __1 = 15, __2 = 16}
 // gdbr-check:$17 = (14, 15, 16)
-// gdbg-command:print 'simple_tuple::NO_PADDING_64'
 // gdbr-command:print simple_tuple::NO_PADDING_64
-// gdbg-check:$18 = {__0 = 17, __1 = 18, __2 = 19}
 // gdbr-check:$18 = (17, 18, 19)
 
-// gdbg-command:print 'simple_tuple::INTERNAL_PADDING_1'
 // gdbr-command:print simple_tuple::INTERNAL_PADDING_1
-// gdbg-check:$19 = {__0 = 110, __1 = 111}
 // gdbr-check:$19 = (110, 111)
-// gdbg-command:print 'simple_tuple::INTERNAL_PADDING_2'
 // gdbr-command:print simple_tuple::INTERNAL_PADDING_2
-// gdbg-check:$20 = {__0 = 112, __1 = 113, __2 = 114, __3 = 115}
 // gdbr-check:$20 = (112, 113, 114, 115)
 
-// gdbg-command:print 'simple_tuple::PADDING_AT_END'
 // gdbr-command:print simple_tuple::PADDING_AT_END
-// gdbg-check:$21 = {__0 = 116, __1 = 117}
 // gdbr-check:$21 = (116, 117)
 
 
diff --git a/tests/debuginfo/struct-in-enum.rs b/tests/debuginfo/struct-in-enum.rs
index e4b647a4ac16b..9e97741444e86 100644
--- a/tests/debuginfo/struct-in-enum.rs
+++ b/tests/debuginfo/struct-in-enum.rs
@@ -9,15 +9,12 @@
 // gdb-command:run
 
 // gdb-command:print case1
-// gdbg-check:$1 = {{RUST$ENUM$DISR = Case1, __0 = 0, __1 = {x = 2088533116, y = 2088533116, z = 31868}}, {RUST$ENUM$DISR = Case1, [...]}}
 // gdbr-check:$1 = struct_in_enum::Regular::Case1(0, struct_in_enum::Struct {x: 2088533116, y: 2088533116, z: 31868})
 
 // gdb-command:print case2
-// gdbg-check:$2 = {{RUST$ENUM$DISR = Case2, [...]}, {RUST$ENUM$DISR = Case2, __0 = 0, __1 = 1229782938247303441, __2 = 4369}}
 // gdbr-check:$2 = struct_in_enum::Regular::Case2(0, 1229782938247303441, 4369)
 
 // gdb-command:print univariant
-// gdbg-check:$3 = {{__0 = {x = 123, y = 456, z = 789}}}
 // gdbr-check:$3 = struct_in_enum::Univariant::TheOnlyCase(struct_in_enum::Struct {x: 123, y: 456, z: 789})
 
 
diff --git a/tests/debuginfo/struct-in-struct.rs b/tests/debuginfo/struct-in-struct.rs
index 7ca0e3a5ef63c..0025f571aa78d 100644
--- a/tests/debuginfo/struct-in-struct.rs
+++ b/tests/debuginfo/struct-in-struct.rs
@@ -7,15 +7,12 @@
 // gdb-command:run
 
 // gdb-command:print three_simple_structs
-// gdbg-check:$1 = {x = {x = 1}, y = {x = 2}, z = {x = 3}}
 // gdbr-check:$1 = struct_in_struct::ThreeSimpleStructs {x: struct_in_struct::Simple {x: 1}, y: struct_in_struct::Simple {x: 2}, z: struct_in_struct::Simple {x: 3}}
 
 // gdb-command:print internal_padding_parent
-// gdbg-check:$2 = {x = {x = 4, y = 5}, y = {x = 6, y = 7}, z = {x = 8, y = 9}}
 // gdbr-check:$2 = struct_in_struct::InternalPaddingParent {x: struct_in_struct::InternalPadding {x: 4, y: 5}, y: struct_in_struct::InternalPadding {x: 6, y: 7}, z: struct_in_struct::InternalPadding {x: 8, y: 9}}
 
 // gdb-command:print padding_at_end_parent
-// gdbg-check:$3 = {x = {x = 10, y = 11}, y = {x = 12, y = 13}, z = {x = 14, y = 15}}
 // gdbr-check:$3 = struct_in_struct::PaddingAtEndParent {x: struct_in_struct::PaddingAtEnd {x: 10, y: 11}, y: struct_in_struct::PaddingAtEnd {x: 12, y: 13}, z: struct_in_struct::PaddingAtEnd {x: 14, y: 15}}
 
 
diff --git a/tests/debuginfo/struct-with-destructor.rs b/tests/debuginfo/struct-with-destructor.rs
index 12e2ac4225c06..8d854369d686e 100644
--- a/tests/debuginfo/struct-with-destructor.rs
+++ b/tests/debuginfo/struct-with-destructor.rs
@@ -6,19 +6,15 @@
 
 // gdb-command:run
 // gdb-command:print simple
-// gdbg-check:$1 = {x = 10, y = 20}
 // gdbr-check:$1 = struct_with_destructor::WithDestructor {x: 10, y: 20}
 
 // gdb-command:print noDestructor
-// gdbg-check:$2 = {a = {x = 10, y = 20}, guard = -1}
 // gdbr-check:$2 = struct_with_destructor::NoDestructorGuarded {a: struct_with_destructor::NoDestructor {x: 10, y: 20}, guard: -1}
 
 // gdb-command:print withDestructor
-// gdbg-check:$3 = {a = {x = 10, y = 20}, guard = -1}
 // gdbr-check:$3 = struct_with_destructor::WithDestructorGuarded {a: struct_with_destructor::WithDestructor {x: 10, y: 20}, guard: -1}
 
 // gdb-command:print nested
-// gdbg-check:$4 = {a = {a = {x = 7890, y = 9870}}}
 // gdbr-check:$4 = struct_with_destructor::NestedOuter {a: struct_with_destructor::NestedInner {a: struct_with_destructor::WithDestructor {x: 7890, y: 9870}}}
 
 
diff --git a/tests/debuginfo/tuple-in-struct.rs b/tests/debuginfo/tuple-in-struct.rs
index e36d924e9259e..11175c73f55b5 100644
--- a/tests/debuginfo/tuple-in-struct.rs
+++ b/tests/debuginfo/tuple-in-struct.rs
@@ -5,38 +5,28 @@
 // gdb-command:run
 
 // gdb-command:print no_padding1
-// gdbg-check:$1 = {x = {__0 = 0, __1 = 1}, y = 2, z = {__0 = 3, __1 = 4, __2 = 5}}
 // gdbr-check:$1 = tuple_in_struct::NoPadding1 {x: (0, 1), y: 2, z: (3, 4, 5)}
 // gdb-command:print no_padding2
-// gdbg-check:$2 = {x = {__0 = 6, __1 = 7}, y = {__0 = {__0 = 8, __1 = 9}, __1 = 10}}
 // gdbr-check:$2 = tuple_in_struct::NoPadding2 {x: (6, 7), y: ((8, 9), 10)}
 
 // gdb-command:print tuple_internal_padding
-// gdbg-check:$3 = {x = {__0 = 11, __1 = 12}, y = {__0 = 13, __1 = 14}}
 // gdbr-check:$3 = tuple_in_struct::TupleInternalPadding {x: (11, 12), y: (13, 14)}
 // gdb-command:print struct_internal_padding
-// gdbg-check:$4 = {x = {__0 = 15, __1 = 16}, y = {__0 = 17, __1 = 18}}
 // gdbr-check:$4 = tuple_in_struct::StructInternalPadding {x: (15, 16), y: (17, 18)}
 // gdb-command:print both_internally_padded
-// gdbg-check:$5 = {x = {__0 = 19, __1 = 20, __2 = 21}, y = {__0 = 22, __1 = 23}}
 // gdbr-check:$5 = tuple_in_struct::BothInternallyPadded {x: (19, 20, 21), y: (22, 23)}
 
 // gdb-command:print single_tuple
-// gdbg-check:$6 = {x = {__0 = 24, __1 = 25, __2 = 26}}
 // gdbr-check:$6 = tuple_in_struct::SingleTuple {x: (24, 25, 26)}
 
 // gdb-command:print tuple_padded_at_end
-// gdbg-check:$7 = {x = {__0 = 27, __1 = 28}, y = {__0 = 29, __1 = 30}}
 // gdbr-check:$7 = tuple_in_struct::TuplePaddedAtEnd {x: (27, 28), y: (29, 30)}
 // gdb-command:print struct_padded_at_end
-// gdbg-check:$8 = {x = {__0 = 31, __1 = 32}, y = {__0 = 33, __1 = 34}}
 // gdbr-check:$8 = tuple_in_struct::StructPaddedAtEnd {x: (31, 32), y: (33, 34)}
 // gdb-command:print both_padded_at_end
-// gdbg-check:$9 = {x = {__0 = 35, __1 = 36, __2 = 37}, y = {__0 = 38, __1 = 39}}
 // gdbr-check:$9 = tuple_in_struct::BothPaddedAtEnd {x: (35, 36, 37), y: (38, 39)}
 
 // gdb-command:print mixed_padding
-// gdbg-check:$10 = {x = {__0 = {__0 = 40, __1 = 41, __2 = 42}, __1 = {__0 = 43, __1 = 44}}, y = {__0 = 45, __1 = 46, __2 = 47, __3 = 48}}
 // gdbr-check:$10 = tuple_in_struct::MixedPadding {x: ((40, 41, 42), (43, 44)), y: (45, 46, 47, 48)}
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/tuple-in-tuple.rs b/tests/debuginfo/tuple-in-tuple.rs
index 8ed0e1f9c13b7..98bded68b14ef 100644
--- a/tests/debuginfo/tuple-in-tuple.rs
+++ b/tests/debuginfo/tuple-in-tuple.rs
@@ -7,27 +7,20 @@
 // gdb-command:run
 
 // gdb-command:print no_padding1
-// gdbg-check:$1 = {__0 = {__0 = 0, __1 = 1}, __1 = 2, __2 = 3}
 // gdbr-check:$1 = ((0, 1), 2, 3)
 // gdb-command:print no_padding2
-// gdbg-check:$2 = {__0 = 4, __1 = {__0 = 5, __1 = 6}, __2 = 7}
 // gdbr-check:$2 = (4, (5, 6), 7)
 // gdb-command:print no_padding3
-// gdbg-check:$3 = {__0 = 8, __1 = 9, __2 = {__0 = 10, __1 = 11}}
 // gdbr-check:$3 = (8, 9, (10, 11))
 
 // gdb-command:print internal_padding1
-// gdbg-check:$4 = {__0 = 12, __1 = {__0 = 13, __1 = 14}}
 // gdbr-check:$4 = (12, (13, 14))
 // gdb-command:print internal_padding2
-// gdbg-check:$5 = {__0 = 15, __1 = {__0 = 16, __1 = 17}}
 // gdbr-check:$5 = (15, (16, 17))
 
 // gdb-command:print padding_at_end1
-// gdbg-check:$6 = {__0 = 18, __1 = {__0 = 19, __1 = 20}}
 // gdbr-check:$6 = (18, (19, 20))
 // gdb-command:print padding_at_end2
-// gdbg-check:$7 = {__0 = {__0 = 21, __1 = 22}, __1 = 23}
 // gdbr-check:$7 = ((21, 22), 23)
 
 
diff --git a/tests/debuginfo/tuple-struct.rs b/tests/debuginfo/tuple-struct.rs
index 88b1ae19e2959..a3e88c0f92660 100644
--- a/tests/debuginfo/tuple-struct.rs
+++ b/tests/debuginfo/tuple-struct.rs
@@ -7,27 +7,21 @@
 // gdb-command:run
 
 // gdb-command:print no_padding16
-// gdbg-check:$1 = {__0 = 10000, __1 = -10001}
 // gdbr-check:$1 = tuple_struct::NoPadding16 (10000, -10001)
 
 // gdb-command:print no_padding32
-// gdbg-check:$2 = {__0 = -10002, __1 = -10003.5, __2 = 10004}
 // gdbr-check:$2 = tuple_struct::NoPadding32 (-10002, -10003.5, 10004)
 
 // gdb-command:print no_padding64
-// gdbg-check:$3 = {__0 = -10005.5, __1 = 10006, __2 = 10007}
 // gdbr-check:$3 = tuple_struct::NoPadding64 (-10005.5, 10006, 10007)
 
 // gdb-command:print no_padding163264
-// gdbg-check:$4 = {__0 = -10008, __1 = 10009, __2 = 10010, __3 = 10011}
 // gdbr-check:$4 = tuple_struct::NoPadding163264 (-10008, 10009, 10010, 10011)
 
 // gdb-command:print internal_padding
-// gdbg-check:$5 = {__0 = 10012, __1 = -10013}
 // gdbr-check:$5 = tuple_struct::InternalPadding (10012, -10013)
 
 // gdb-command:print padding_at_end
-// gdbg-check:$6 = {__0 = -10014, __1 = 10015}
 // gdbr-check:$6 = tuple_struct::PaddingAtEnd (-10014, 10015)
 
 
diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs
index d786ba612714a..cd2c9a1397300 100644
--- a/tests/debuginfo/union-smoke.rs
+++ b/tests/debuginfo/union-smoke.rs
@@ -8,10 +8,8 @@
 
 // gdb-command:run
 // gdb-command:print u
-// gdbg-check:$1 = {a = {__0 = 2 '\002', __1 = 2 '\002'}, b = 514}
 // gdbr-check:$1 = union_smoke::U {a: (2, 2), b: 514}
 // gdb-command:print union_smoke::SU
-// gdbg-check:$2 = {a = {__0 = 1 '\001', __1 = 1 '\001'}, b = 257}
 // gdbr-check:$2 = union_smoke::U {a: (1, 1), b: 257}
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/unsized.rs b/tests/debuginfo/unsized.rs
index 982ab003a2a16..ee6fe22c6b8d1 100644
--- a/tests/debuginfo/unsized.rs
+++ b/tests/debuginfo/unsized.rs
@@ -7,27 +7,21 @@
 // gdb-command:run
 
 // gdb-command:print a
-// gdbg-check:$1 = {data_ptr = [...], length = 4}
 // gdbr-check:$1 = &unsized::Foo<[u8]> {data_ptr: [...], length: 4}
 
 // gdb-command:print b
-// gdbg-check:$2 = {data_ptr = [...], length = 4}
 // gdbr-check:$2 = &unsized::Foo<unsized::Foo<[u8]>> {data_ptr: [...], length: 4}
 
 // gdb-command:print c
-// gdbg-check:$3 = {pointer = [...], vtable = [...]}
 // gdbr-check:$3 = &unsized::Foo<dyn core::fmt::Debug> {pointer: [...], vtable: [...]}
 
 // gdb-command:print _box
-// gdbg-check:$4 = {pointer = [...], vtable = [...]}
 // gdbr-check:$4 = alloc::boxed::Box<unsized::Foo<dyn core::fmt::Debug>, alloc::alloc::Global> {pointer: [...], vtable: [...]}
 
 // gdb-command:print tuple_slice
-// gdbg-check:$5 = {data_ptr = [...], length = 2}
 // gdbr-check:$5 = &(i32, i32, [i32]) {data_ptr: [...], length: 2}
 
 // gdb-command:print tuple_dyn
-// gdbg-check:$6 = {pointer = [...], vtable = [...]}
 // gdbr-check:$6 = &(i32, i32, dyn core::fmt::Debug) {pointer: [...], vtable: [...]}
 
 // === CDB TESTS ===================================================================================
diff --git a/tests/debuginfo/var-captured-in-nested-closure.rs b/tests/debuginfo/var-captured-in-nested-closure.rs
index 7772ec0033782..e2974f418ae98 100644
--- a/tests/debuginfo/var-captured-in-nested-closure.rs
+++ b/tests/debuginfo/var-captured-in-nested-closure.rs
@@ -11,10 +11,8 @@
 // gdb-command:print constant
 // gdb-check:$2 = 2
 // gdb-command:print a_struct
-// gdbg-check:$3 = {a = -3, b = 4.5, c = 5}
 // gdbr-check:$3 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *struct_ref
-// gdbg-check:$4 = {a = -3, b = 4.5, c = 5}
 // gdbr-check:$4 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *owned
 // gdb-check:$5 = 6
@@ -27,10 +25,8 @@
 // gdb-command:print constant
 // gdb-check:$8 = 2
 // gdb-command:print a_struct
-// gdbg-check:$9 = {a = -3, b = 4.5, c = 5}
 // gdbr-check:$9 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *struct_ref
-// gdbg-check:$10 = {a = -3, b = 4.5, c = 5}
 // gdbr-check:$10 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *owned
 // gdb-check:$11 = 6
diff --git a/tests/debuginfo/var-captured-in-sendable-closure.rs b/tests/debuginfo/var-captured-in-sendable-closure.rs
index 782a7d1137381..1029ab6b788b7 100644
--- a/tests/debuginfo/var-captured-in-sendable-closure.rs
+++ b/tests/debuginfo/var-captured-in-sendable-closure.rs
@@ -9,7 +9,6 @@
 // gdb-command:print constant
 // gdb-check:$1 = 1
 // gdb-command:print a_struct
-// gdbg-check:$2 = {a = -2, b = 3.5, c = 4}
 // gdbr-check:$2 = var_captured_in_sendable_closure::Struct {a: -2, b: 3.5, c: 4}
 // gdb-command:print *owned
 // gdb-check:$3 = 5
diff --git a/tests/debuginfo/var-captured-in-stack-closure.rs b/tests/debuginfo/var-captured-in-stack-closure.rs
index c9a93cd7b7f9a..baa784e5c4591 100644
--- a/tests/debuginfo/var-captured-in-stack-closure.rs
+++ b/tests/debuginfo/var-captured-in-stack-closure.rs
@@ -11,10 +11,8 @@
 // gdb-command:print constant
 // gdb-check:$2 = 2
 // gdb-command:print a_struct
-// gdbg-check:$3 = {a = -3, b = 4.5, c = 5}
 // gdbr-check:$3 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *struct_ref
-// gdbg-check:$4 = {a = -3, b = 4.5, c = 5}
 // gdbr-check:$4 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *owned
 // gdb-check:$5 = 6
@@ -26,10 +24,8 @@
 // gdb-command:print constant
 // gdb-check:$7 = 2
 // gdb-command:print a_struct
-// gdbg-check:$8 = {a = -3, b = 4.5, c = 5}
 // gdbr-check:$8 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *struct_ref
-// gdbg-check:$9 = {a = -3, b = 4.5, c = 5}
 // gdbr-check:$9 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *owned
 // gdb-check:$10 = 6
diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs
index a8235dba40c0a..9d7e3eef8045f 100644
--- a/tests/debuginfo/vec-slices.rs
+++ b/tests/debuginfo/vec-slices.rs
@@ -12,48 +12,36 @@
 
 // gdb-command:print singleton.length
 // gdb-check:$2 = 1
-// gdbg-command:print *((i64[1]*)(singleton.data_ptr))
 // gdbr-command:print *(singleton.data_ptr as *const [i64; 1])
-// gdbg-check:$3 = {1}
 // gdbr-check:$3 = [1]
 
 // gdb-command:print multiple.length
 // gdb-check:$4 = 4
-// gdbg-command:print *((i64[4]*)(multiple.data_ptr))
 // gdbr-command:print *(multiple.data_ptr as *const [i64; 4])
-// gdbg-check:$5 = {2, 3, 4, 5}
 // gdbr-check:$5 = [2, 3, 4, 5]
 
 // gdb-command:print slice_of_slice.length
 // gdb-check:$6 = 2
-// gdbg-command:print *((i64[2]*)(slice_of_slice.data_ptr))
 // gdbr-command:print *(slice_of_slice.data_ptr as *const [i64; 2])
-// gdbg-check:$7 = {3, 4}
 // gdbr-check:$7 = [3, 4]
 
 // gdb-command:print padded_tuple.length
 // gdb-check:$8 = 2
 // gdb-command:print padded_tuple.data_ptr[0]
-// gdbg-check:$9 = {__0 = 6, __1 = 7}
 // gdbr-check:$9 = (6, 7)
 // gdb-command:print padded_tuple.data_ptr[1]
-// gdbg-check:$10 = {__0 = 8, __1 = 9}
 // gdbr-check:$10 = (8, 9)
 
 // gdb-command:print padded_struct.length
 // gdb-check:$11 = 2
 // gdb-command:print padded_struct.data_ptr[0]
-// gdbg-check:$12 = {x = 10, y = 11, z = 12}
 // gdbr-check:$12 = vec_slices::AStruct {x: 10, y: 11, z: 12}
 // gdb-command:print padded_struct.data_ptr[1]
-// gdbg-check:$13 = {x = 13, y = 14, z = 15}
 // gdbr-check:$13 = vec_slices::AStruct {x: 13, y: 14, z: 15}
 
 // gdb-command:print mut_slice.length
 // gdb-check:$14 = 5
-// gdbg-command:print *((i64[5]*)(mut_slice.data_ptr))
 // gdbr-command:print *(mut_slice.data_ptr as *const [i64; 5])
-// gdbg-check:$15 = {1, 2, 3, 4, 5}
 // gdbr-check:$15 = [1, 2, 3, 4, 5]
 
 // Some lines below are marked with [ignored] because old GDB versions seem to have trouble
diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs
index 20cfd785ca7f0..bc1f995ce0e1b 100644
--- a/tests/debuginfo/vec.rs
+++ b/tests/debuginfo/vec.rs
@@ -6,10 +6,8 @@
 
 // gdb-command:run
 // gdb-command:print a
-// gdbg-check:$1 = {1, 2, 3}
 // gdbr-check:$1 = [1, 2, 3]
 // gdb-command:print vec::VECT
-// gdbg-check:$2 = {4, 5, 6}
 // gdbr-check:$2 = [4, 5, 6]
 
 

From fa0e8585d4c3484c344e84ed3e639a8fd63616b8 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sat, 17 Aug 2024 17:31:49 -0400
Subject: [PATCH 400/685] Replace gdbr with gdbg

---
 tests/debuginfo/associated-types.rs           |  4 +-
 .../debuginfo/basic-types-globals-metadata.rs | 30 +++----
 tests/debuginfo/basic-types-globals.rs        | 32 ++++----
 tests/debuginfo/basic-types-metadata.rs       | 18 ++--
 tests/debuginfo/basic-types-mut-globals.rs    | 64 +++++++--------
 tests/debuginfo/basic-types.rs                |  4 +-
 tests/debuginfo/borrowed-basic.rs             |  4 +-
 tests/debuginfo/borrowed-c-style-enum.rs      |  6 +-
 tests/debuginfo/borrowed-enum.rs              |  6 +-
 tests/debuginfo/borrowed-struct.rs            |  6 +-
 tests/debuginfo/borrowed-tuple.rs             |  6 +-
 tests/debuginfo/box.rs                        |  2 +-
 tests/debuginfo/boxed-struct.rs               |  4 +-
 .../by-value-non-immediate-argument.rs        | 10 +--
 .../by-value-self-argument-in-trait-impl.rs   |  4 +-
 tests/debuginfo/c-style-enum-in-composite.rs  | 14 ++--
 tests/debuginfo/c-style-enum.rs               | 58 ++++++-------
 tests/debuginfo/captured-fields-1.rs          | 12 +--
 tests/debuginfo/captured-fields-2.rs          |  4 +-
 tests/debuginfo/cross-crate-spans.rs          |  4 +-
 tests/debuginfo/destructured-fn-argument.rs   | 16 ++--
 .../destructured-for-loop-variable.rs         |  4 +-
 tests/debuginfo/destructured-local.rs         | 16 ++--
 tests/debuginfo/enum-thinlto.rs               |  2 +-
 tests/debuginfo/evec-in-struct.rs             | 10 +--
 .../debuginfo/gdb-pretty-struct-and-enums.rs  | 10 +--
 .../generic-enum-with-different-disr-sizes.rs | 16 ++--
 tests/debuginfo/generic-function.rs           |  2 +-
 .../generic-method-on-generic-struct.rs       | 10 +--
 tests/debuginfo/generic-struct-style-enum.rs  |  8 +-
 tests/debuginfo/generic-struct.rs             |  8 +-
 tests/debuginfo/generic-tuple-style-enum.rs   |  8 +-
 .../lexical-scopes-in-block-expression.rs     | 18 ++--
 tests/debuginfo/limited-debuginfo.rs          |  8 +-
 tests/debuginfo/method-on-enum.rs             | 10 +--
 tests/debuginfo/method-on-generic-struct.rs   | 10 +--
 tests/debuginfo/method-on-struct.rs           | 10 +--
 tests/debuginfo/method-on-trait.rs            | 10 +--
 tests/debuginfo/method-on-tuple-struct.rs     | 10 +--
 tests/debuginfo/option-like-enum.rs           | 16 ++--
 .../packed-struct-with-destructor.rs          | 16 ++--
 tests/debuginfo/packed-struct.rs              |  8 +-
 tests/debuginfo/pretty-slices.rs              |  4 +-
 tests/debuginfo/pretty-std.rs                 |  2 +-
 tests/debuginfo/recursive-struct.rs           | 28 +++----
 tests/debuginfo/reference-debuginfo.rs        |  4 +-
 tests/debuginfo/self-in-default-method.rs     | 10 +--
 .../self-in-generic-default-method.rs         | 10 +--
 tests/debuginfo/simd.rs                       | 36 ++++----
 tests/debuginfo/simple-struct.rs              | 60 +++++++-------
 tests/debuginfo/simple-tuple.rs               | 82 +++++++++----------
 tests/debuginfo/strings-and-strs.rs           | 10 +--
 tests/debuginfo/struct-in-enum.rs             |  6 +-
 tests/debuginfo/struct-in-struct.rs           |  6 +-
 tests/debuginfo/struct-style-enum.rs          |  8 +-
 tests/debuginfo/struct-with-destructor.rs     |  8 +-
 tests/debuginfo/tuple-in-struct.rs            | 20 ++---
 tests/debuginfo/tuple-in-tuple.rs             | 14 ++--
 tests/debuginfo/tuple-struct.rs               | 12 +--
 tests/debuginfo/tuple-style-enum.rs           |  8 +-
 tests/debuginfo/union-smoke.rs                |  4 +-
 tests/debuginfo/unique-enum.rs                |  6 +-
 tests/debuginfo/unsized.rs                    | 12 +--
 .../var-captured-in-nested-closure.rs         |  8 +-
 .../var-captured-in-sendable-closure.rs       |  2 +-
 .../var-captured-in-stack-closure.rs          |  8 +-
 tests/debuginfo/vec-slices.rs                 | 32 ++++----
 tests/debuginfo/vec.rs                        |  4 +-
 68 files changed, 461 insertions(+), 461 deletions(-)

diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs
index 8dd9853efe720..bc7a62082b763 100644
--- a/tests/debuginfo/associated-types.rs
+++ b/tests/debuginfo/associated-types.rs
@@ -8,7 +8,7 @@
 // gdb-command:run
 
 // gdb-command:print arg
-// gdbr-check:$1 = associated_types::Struct<i32> {b: -1, b1: 0}
+// gdb-check:$1 = associated_types::Struct<i32> {b: -1, b1: 0}
 // gdb-command:continue
 
 // gdb-command:print inferred
@@ -22,7 +22,7 @@
 // gdb-command:continue
 
 // gdb-command:print arg
-// gdbr-check:$5 = (4, 5)
+// gdb-check:$5 = (4, 5)
 // gdb-command:continue
 
 // gdb-command:print a
diff --git a/tests/debuginfo/basic-types-globals-metadata.rs b/tests/debuginfo/basic-types-globals-metadata.rs
index 5276d6f4a5dce..8819db86cedec 100644
--- a/tests/debuginfo/basic-types-globals-metadata.rs
+++ b/tests/debuginfo/basic-types-globals-metadata.rs
@@ -2,35 +2,35 @@
 
 //@ compile-flags:-g
 // gdb-command:run
-// gdbr-command:whatis basic_types_globals_metadata::B
+// gdb-command:whatis basic_types_globals_metadata::B
 // gdb-check:type = bool
-// gdbr-command:whatis basic_types_globals_metadata::I
+// gdb-command:whatis basic_types_globals_metadata::I
 // gdb-check:type = isize
-// gdbr-command:whatis basic_types_globals_metadata::C
+// gdb-command:whatis basic_types_globals_metadata::C
 // gdb-check:type = char
-// gdbr-command:whatis basic_types_globals_metadata::I8
+// gdb-command:whatis basic_types_globals_metadata::I8
 // gdb-check:type = i8
-// gdbr-command:whatis basic_types_globals_metadata::I16
+// gdb-command:whatis basic_types_globals_metadata::I16
 // gdb-check:type = i16
-// gdbr-command:whatis basic_types_globals_metadata::I32
+// gdb-command:whatis basic_types_globals_metadata::I32
 // gdb-check:type = i32
-// gdbr-command:whatis basic_types_globals_metadata::I64
+// gdb-command:whatis basic_types_globals_metadata::I64
 // gdb-check:type = i64
-// gdbr-command:whatis basic_types_globals_metadata::U
+// gdb-command:whatis basic_types_globals_metadata::U
 // gdb-check:type = usize
-// gdbr-command:whatis basic_types_globals_metadata::U8
+// gdb-command:whatis basic_types_globals_metadata::U8
 // gdb-check:type = u8
-// gdbr-command:whatis basic_types_globals_metadata::U16
+// gdb-command:whatis basic_types_globals_metadata::U16
 // gdb-check:type = u16
-// gdbr-command:whatis basic_types_globals_metadata::U32
+// gdb-command:whatis basic_types_globals_metadata::U32
 // gdb-check:type = u32
-// gdbr-command:whatis basic_types_globals_metadata::U64
+// gdb-command:whatis basic_types_globals_metadata::U64
 // gdb-check:type = u64
-// gdbr-command:whatis basic_types_globals_metadata::F16
+// gdb-command:whatis basic_types_globals_metadata::F16
 // gdb-check:type = f16
-// gdbr-command:whatis basic_types_globals_metadata::F32
+// gdb-command:whatis basic_types_globals_metadata::F32
 // gdb-check:type = f32
-// gdbr-command:whatis basic_types_globals_metadata::F64
+// gdb-command:whatis basic_types_globals_metadata::F64
 // gdb-check:type = f64
 // gdb-command:continue
 
diff --git a/tests/debuginfo/basic-types-globals.rs b/tests/debuginfo/basic-types-globals.rs
index 7f86dce417794..515d70e193530 100644
--- a/tests/debuginfo/basic-types-globals.rs
+++ b/tests/debuginfo/basic-types-globals.rs
@@ -12,35 +12,35 @@
 //@ [lto] no-prefer-dynamic
 
 // gdb-command:run
-// gdbr-command:print B
+// gdb-command:print B
 // gdb-check:$1 = false
-// gdbr-command:print I
+// gdb-command:print I
 // gdb-check:$2 = -1
-// gdbr-command:print/d C
-// gdbr-check:$3 = 97
-// gdbr-command:print I8
+// gdb-command:print/d C
+// gdb-check:$3 = 97
+// gdb-command:print I8
 // gdb-check:$4 = 68
-// gdbr-command:print I16
+// gdb-command:print I16
 // gdb-check:$5 = -16
-// gdbr-command:print I32
+// gdb-command:print I32
 // gdb-check:$6 = -32
-// gdbr-command:print I64
+// gdb-command:print I64
 // gdb-check:$7 = -64
-// gdbr-command:print U
+// gdb-command:print U
 // gdb-check:$8 = 1
-// gdbr-command:print U8
+// gdb-command:print U8
 // gdb-check:$9 = 100
-// gdbr-command:print U16
+// gdb-command:print U16
 // gdb-check:$10 = 16
-// gdbr-command:print U32
+// gdb-command:print U32
 // gdb-check:$11 = 32
-// gdbr-command:print U64
+// gdb-command:print U64
 // gdb-check:$12 = 64
-// gdbr-command:print F16
+// gdb-command:print F16
 // gdb-check:$13 = 1.5
-// gdbr-command:print F32
+// gdb-command:print F32
 // gdb-check:$14 = 2.5
-// gdbr-command:print F64
+// gdb-command:print F64
 // gdb-check:$15 = 3.5
 // gdb-command:continue
 
diff --git a/tests/debuginfo/basic-types-metadata.rs b/tests/debuginfo/basic-types-metadata.rs
index a2662068fa4c3..9bfbdc8670115 100644
--- a/tests/debuginfo/basic-types-metadata.rs
+++ b/tests/debuginfo/basic-types-metadata.rs
@@ -37,18 +37,18 @@
 // gdb-command:whatis fnptr
 // gdb-check:type = *mut fn ()
 // gdb-command:info functions _yyy
-// gdbr-check:static fn basic_types_metadata::_yyy();
+// gdb-check:static fn basic_types_metadata::_yyy();
 // gdb-command:ptype closure_0
-// gdbr-check: type = struct basic_types_metadata::main::{closure_env#0}
+// gdb-check: type = struct basic_types_metadata::main::{closure_env#0}
 // gdb-command:ptype closure_1
-// gdbr-check: type = struct basic_types_metadata::main::{closure_env#1} {
-// gdbr-check:     *mut bool,
-// gdbr-check: }
+// gdb-check: type = struct basic_types_metadata::main::{closure_env#1} {
+// gdb-check:     *mut bool,
+// gdb-check: }
 // gdb-command:ptype closure_2
-// gdbr-check: type = struct basic_types_metadata::main::{closure_env#2} {
-// gdbr-check:     *mut bool,
-// gdbr-check:     *mut isize,
-// gdbr-check: }
+// gdb-check: type = struct basic_types_metadata::main::{closure_env#2} {
+// gdb-check:     *mut bool,
+// gdb-check:     *mut isize,
+// gdb-check: }
 
 //
 // gdb-command:continue
diff --git a/tests/debuginfo/basic-types-mut-globals.rs b/tests/debuginfo/basic-types-mut-globals.rs
index fab2dc8507b5c..af0963177f54d 100644
--- a/tests/debuginfo/basic-types-mut-globals.rs
+++ b/tests/debuginfo/basic-types-mut-globals.rs
@@ -11,68 +11,68 @@
 // gdb-command:run
 
 // Check initializers
-// gdbr-command:print B
+// gdb-command:print B
 // gdb-check:$1 = false
-// gdbr-command:print I
+// gdb-command:print I
 // gdb-check:$2 = -1
-// gdbr-command:print C
-// gdbr-check:$3 = 97 'a'
-// gdbr-command:print I8
+// gdb-command:print C
+// gdb-check:$3 = 97 'a'
+// gdb-command:print I8
 // gdb-check:$4 = 68
-// gdbr-command:print I16
+// gdb-command:print I16
 // gdb-check:$5 = -16
-// gdbr-command:print I32
+// gdb-command:print I32
 // gdb-check:$6 = -32
-// gdbr-command:print I64
+// gdb-command:print I64
 // gdb-check:$7 = -64
-// gdbr-command:print U
+// gdb-command:print U
 // gdb-check:$8 = 1
-// gdbr-command:print U8
+// gdb-command:print U8
 // gdb-check:$9 = 100
-// gdbr-command:print U16
+// gdb-command:print U16
 // gdb-check:$10 = 16
-// gdbr-command:print U32
+// gdb-command:print U32
 // gdb-check:$11 = 32
-// gdbr-command:print U64
+// gdb-command:print U64
 // gdb-check:$12 = 64
-// gdbr-command:print F16
+// gdb-command:print F16
 // gdb-check:$13 = 1.5
-// gdbr-command:print F32
+// gdb-command:print F32
 // gdb-check:$14 = 2.5
-// gdbr-command:print F64
+// gdb-command:print F64
 // gdb-check:$15 = 3.5
 // gdb-command:continue
 
 // Check new values
-// gdbr-command:print B
+// gdb-command:print B
 // gdb-check:$16 = true
-// gdbr-command:print I
+// gdb-command:print I
 // gdb-check:$17 = 2
-// gdbr-command:print C
-// gdbr-check:$18 = 102 'f'
-// gdbr-command:print/d I8
+// gdb-command:print C
+// gdb-check:$18 = 102 'f'
+// gdb-command:print/d I8
 // gdb-check:$19 = 78
-// gdbr-command:print I16
+// gdb-command:print I16
 // gdb-check:$20 = -26
-// gdbr-command:print I32
+// gdb-command:print I32
 // gdb-check:$21 = -12
-// gdbr-command:print I64
+// gdb-command:print I64
 // gdb-check:$22 = -54
-// gdbr-command:print U
+// gdb-command:print U
 // gdb-check:$23 = 5
-// gdbr-command:print/d U8
+// gdb-command:print/d U8
 // gdb-check:$24 = 20
-// gdbr-command:print U16
+// gdb-command:print U16
 // gdb-check:$25 = 32
-// gdbr-command:print U32
+// gdb-command:print U32
 // gdb-check:$26 = 16
-// gdbr-command:print U64
+// gdb-command:print U64
 // gdb-check:$27 = 128
-// gdbr-command:print F16
+// gdb-command:print F16
 // gdb-check:$28 = 2.25
-// gdbr-command:print F32
+// gdb-command:print F32
 // gdb-check:$29 = 5.75
-// gdbr-command:print F64
+// gdb-command:print F64
 // gdb-check:$30 = 9.25
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs
index 215599e6f0efd..e78c2746fec88 100644
--- a/tests/debuginfo/basic-types.rs
+++ b/tests/debuginfo/basic-types.rs
@@ -16,7 +16,7 @@
 // gdb-command:print i
 // gdb-check:$2 = -1
 // gdb-command:print c
-// gdbr-check:$3 = 97 'a'
+// gdb-check:$3 = 97 'a'
 // gdb-command:print/d i8
 // gdb-check:$4 = 68
 // gdb-command:print i16
@@ -42,7 +42,7 @@
 // gdb-command:print f64
 // gdb-check:$15 = 3.5
 // gdb-command:print s
-// gdbr-check:$16 = "Hello, World!"
+// gdb-check:$16 = "Hello, World!"
 
 // === LLDB TESTS ==================================================================================
 
diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs
index 68fcc31699196..397097cc19b0c 100644
--- a/tests/debuginfo/borrowed-basic.rs
+++ b/tests/debuginfo/borrowed-basic.rs
@@ -14,7 +14,7 @@
 // gdb-check:$3 = 97
 
 // gdb-command:print *i8_ref
-// gdbr-check:$4 = 68
+// gdb-check:$4 = 68
 
 // gdb-command:print *i16_ref
 // gdb-check:$5 = -16
@@ -29,7 +29,7 @@
 // gdb-check:$8 = 1
 
 // gdb-command:print *u8_ref
-// gdbr-check:$9 = 100
+// gdb-check:$9 = 100
 
 // gdb-command:print *u16_ref
 // gdb-check:$10 = 16
diff --git a/tests/debuginfo/borrowed-c-style-enum.rs b/tests/debuginfo/borrowed-c-style-enum.rs
index 7ca19217a7947..95554211522a1 100644
--- a/tests/debuginfo/borrowed-c-style-enum.rs
+++ b/tests/debuginfo/borrowed-c-style-enum.rs
@@ -6,13 +6,13 @@
 // gdb-command:run
 
 // gdb-command:print *the_a_ref
-// gdbr-check:$1 = borrowed_c_style_enum::ABC::TheA
+// gdb-check:$1 = borrowed_c_style_enum::ABC::TheA
 
 // gdb-command:print *the_b_ref
-// gdbr-check:$2 = borrowed_c_style_enum::ABC::TheB
+// gdb-check:$2 = borrowed_c_style_enum::ABC::TheB
 
 // gdb-command:print *the_c_ref
-// gdbr-check:$3 = borrowed_c_style_enum::ABC::TheC
+// gdb-check:$3 = borrowed_c_style_enum::ABC::TheC
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/borrowed-enum.rs b/tests/debuginfo/borrowed-enum.rs
index fc2ab62a21c49..444adac8b0aa3 100644
--- a/tests/debuginfo/borrowed-enum.rs
+++ b/tests/debuginfo/borrowed-enum.rs
@@ -9,13 +9,13 @@
 // gdb-command:run
 
 // gdb-command:print *the_a_ref
-// gdbr-check:$1 = borrowed_enum::ABC::TheA{x: 0, y: 8970181431921507452}
+// gdb-check:$1 = borrowed_enum::ABC::TheA{x: 0, y: 8970181431921507452}
 
 // gdb-command:print *the_b_ref
-// gdbr-check:$2 = borrowed_enum::ABC::TheB(0, 286331153, 286331153)
+// gdb-check:$2 = borrowed_enum::ABC::TheB(0, 286331153, 286331153)
 
 // gdb-command:print *univariant_ref
-// gdbr-check:$3 = borrowed_enum::Univariant::TheOnlyCase(4820353753753434)
+// gdb-check:$3 = borrowed_enum::Univariant::TheOnlyCase(4820353753753434)
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/borrowed-struct.rs b/tests/debuginfo/borrowed-struct.rs
index 84e63d9cf634e..f74a6b5796f5b 100644
--- a/tests/debuginfo/borrowed-struct.rs
+++ b/tests/debuginfo/borrowed-struct.rs
@@ -6,7 +6,7 @@
 // gdb-command:run
 
 // gdb-command:print *stack_val_ref
-// gdbr-check:$1 = borrowed_struct::SomeStruct {x: 10, y: 23.5}
+// gdb-check:$1 = borrowed_struct::SomeStruct {x: 10, y: 23.5}
 
 // gdb-command:print *stack_val_interior_ref_1
 // gdb-check:$2 = 10
@@ -15,10 +15,10 @@
 // gdb-check:$3 = 23.5
 
 // gdb-command:print *ref_to_unnamed
-// gdbr-check:$4 = borrowed_struct::SomeStruct {x: 11, y: 24.5}
+// gdb-check:$4 = borrowed_struct::SomeStruct {x: 11, y: 24.5}
 
 // gdb-command:print *unique_val_ref
-// gdbr-check:$5 = borrowed_struct::SomeStruct {x: 13, y: 26.5}
+// gdb-check:$5 = borrowed_struct::SomeStruct {x: 13, y: 26.5}
 
 // gdb-command:print *unique_val_interior_ref_1
 // gdb-check:$6 = 13
diff --git a/tests/debuginfo/borrowed-tuple.rs b/tests/debuginfo/borrowed-tuple.rs
index c7253410f95b2..8f11f545ca79d 100644
--- a/tests/debuginfo/borrowed-tuple.rs
+++ b/tests/debuginfo/borrowed-tuple.rs
@@ -7,13 +7,13 @@
 // gdb-command:run
 
 // gdb-command:print *stack_val_ref
-// gdbr-check:$1 = (-14, -19)
+// gdb-check:$1 = (-14, -19)
 
 // gdb-command:print *ref_to_unnamed
-// gdbr-check:$2 = (-15, -20)
+// gdb-check:$2 = (-15, -20)
 
 // gdb-command:print *unique_val_ref
-// gdbr-check:$3 = (-17, -22)
+// gdb-check:$3 = (-17, -22)
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/box.rs b/tests/debuginfo/box.rs
index f27e7cbafbf22..bc6928ada3a53 100644
--- a/tests/debuginfo/box.rs
+++ b/tests/debuginfo/box.rs
@@ -9,7 +9,7 @@
 // gdb-command:print *a
 // gdb-check:$1 = 1
 // gdb-command:print *b
-// gdbr-check:$2 = (2, 3.5)
+// gdb-check:$2 = (2, 3.5)
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/boxed-struct.rs b/tests/debuginfo/boxed-struct.rs
index 078af68c84dfd..d31b912ab8c61 100644
--- a/tests/debuginfo/boxed-struct.rs
+++ b/tests/debuginfo/boxed-struct.rs
@@ -7,10 +7,10 @@
 // gdb-command:run
 
 // gdb-command:print *boxed_with_padding
-// gdbr-check:$1 = boxed_struct::StructWithSomePadding {x: 99, y: 999, z: 9999, w: 99999}
+// gdb-check:$1 = boxed_struct::StructWithSomePadding {x: 99, y: 999, z: 9999, w: 99999}
 
 // gdb-command:print *boxed_with_dtor
-// gdbr-check:$2 = boxed_struct::StructWithDestructor {x: 77, y: 777, z: 7777, w: 77777}
+// gdb-check:$2 = boxed_struct::StructWithDestructor {x: 77, y: 777, z: 7777, w: 77777}
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/by-value-non-immediate-argument.rs b/tests/debuginfo/by-value-non-immediate-argument.rs
index 623c939ee143e..f0a39a45195a1 100644
--- a/tests/debuginfo/by-value-non-immediate-argument.rs
+++ b/tests/debuginfo/by-value-non-immediate-argument.rs
@@ -7,11 +7,11 @@
 // gdb-command:run
 
 // gdb-command:print s
-// gdbr-check:$1 = by_value_non_immediate_argument::Struct {a: 1, b: 2.5}
+// gdb-check:$1 = by_value_non_immediate_argument::Struct {a: 1, b: 2.5}
 // gdb-command:continue
 
 // gdb-command:print x
-// gdbr-check:$2 = by_value_non_immediate_argument::Struct {a: 3, b: 4.5}
+// gdb-check:$2 = by_value_non_immediate_argument::Struct {a: 3, b: 4.5}
 // gdb-command:print y
 // gdb-check:$3 = 5
 // gdb-command:print z
@@ -19,15 +19,15 @@
 // gdb-command:continue
 
 // gdb-command:print a
-// gdbr-check:$5 = (7, 8, 9.5, 10.5)
+// gdb-check:$5 = (7, 8, 9.5, 10.5)
 // gdb-command:continue
 
 // gdb-command:print a
-// gdbr-check:$6 = by_value_non_immediate_argument::Newtype (11.5, 12.5, 13, 14)
+// gdb-check:$6 = by_value_non_immediate_argument::Newtype (11.5, 12.5, 13, 14)
 // gdb-command:continue
 
 // gdb-command:print x
-// gdbr-check:$7 = by_value_non_immediate_argument::Enum::Case1{x: 0, y: 8970181431921507452}
+// gdb-check:$7 = by_value_non_immediate_argument::Enum::Case1{x: 0, y: 8970181431921507452}
 // gdb-command:continue
 
 
diff --git a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
index 91a8792a69f90..985f84881c729 100644
--- a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
+++ b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
@@ -11,11 +11,11 @@
 // gdb-command:continue
 
 // gdb-command:print self
-// gdbr-check:$2 = by_value_self_argument_in_trait_impl::Struct {x: 2222, y: 3333}
+// gdb-check:$2 = by_value_self_argument_in_trait_impl::Struct {x: 2222, y: 3333}
 // gdb-command:continue
 
 // gdb-command:print self
-// gdbr-check:$3 = (4444.5, 5555, 6666, 7777.5)
+// gdb-check:$3 = (4444.5, 5555, 6666, 7777.5)
 // gdb-command:continue
 
 
diff --git a/tests/debuginfo/c-style-enum-in-composite.rs b/tests/debuginfo/c-style-enum-in-composite.rs
index 112631e874ebe..bd025c2ae8c13 100644
--- a/tests/debuginfo/c-style-enum-in-composite.rs
+++ b/tests/debuginfo/c-style-enum-in-composite.rs
@@ -7,25 +7,25 @@
 // gdb-command:run
 
 // gdb-command:print tuple_interior_padding
-// gdbr-check:$1 = (0, c_style_enum_in_composite::AnEnum::OneHundred)
+// gdb-check:$1 = (0, c_style_enum_in_composite::AnEnum::OneHundred)
 
 // gdb-command:print tuple_padding_at_end
-// gdbr-check:$2 = ((1, c_style_enum_in_composite::AnEnum::OneThousand), 2)
+// gdb-check:$2 = ((1, c_style_enum_in_composite::AnEnum::OneThousand), 2)
 
 // gdb-command:print tuple_different_enums
-// gdbr-check:$3 = (c_style_enum_in_composite::AnEnum::OneThousand, c_style_enum_in_composite::AnotherEnum::MountainView, c_style_enum_in_composite::AnEnum::OneMillion, c_style_enum_in_composite::AnotherEnum::Vienna)
+// gdb-check:$3 = (c_style_enum_in_composite::AnEnum::OneThousand, c_style_enum_in_composite::AnotherEnum::MountainView, c_style_enum_in_composite::AnEnum::OneMillion, c_style_enum_in_composite::AnotherEnum::Vienna)
 
 // gdb-command:print padded_struct
-// gdbr-check:$4 = c_style_enum_in_composite::PaddedStruct {a: 3, b: c_style_enum_in_composite::AnEnum::OneMillion, c: 4, d: c_style_enum_in_composite::AnotherEnum::Toronto, e: 5}
+// gdb-check:$4 = c_style_enum_in_composite::PaddedStruct {a: 3, b: c_style_enum_in_composite::AnEnum::OneMillion, c: 4, d: c_style_enum_in_composite::AnotherEnum::Toronto, e: 5}
 
 // gdb-command:print packed_struct
-// gdbr-check:$5 = c_style_enum_in_composite::PackedStruct {a: 6, b: c_style_enum_in_composite::AnEnum::OneHundred, c: 7, d: c_style_enum_in_composite::AnotherEnum::Vienna, e: 8}
+// gdb-check:$5 = c_style_enum_in_composite::PackedStruct {a: 6, b: c_style_enum_in_composite::AnEnum::OneHundred, c: 7, d: c_style_enum_in_composite::AnotherEnum::Vienna, e: 8}
 
 // gdb-command:print non_padded_struct
-// gdbr-check:$6 = c_style_enum_in_composite::NonPaddedStruct {a: c_style_enum_in_composite::AnEnum::OneMillion, b: c_style_enum_in_composite::AnotherEnum::MountainView, c: c_style_enum_in_composite::AnEnum::OneThousand, d: c_style_enum_in_composite::AnotherEnum::Toronto}
+// gdb-check:$6 = c_style_enum_in_composite::NonPaddedStruct {a: c_style_enum_in_composite::AnEnum::OneMillion, b: c_style_enum_in_composite::AnotherEnum::MountainView, c: c_style_enum_in_composite::AnEnum::OneThousand, d: c_style_enum_in_composite::AnotherEnum::Toronto}
 
 // gdb-command:print struct_with_drop
-// gdbr-check:$7 = (c_style_enum_in_composite::StructWithDrop {a: c_style_enum_in_composite::AnEnum::OneHundred, b: c_style_enum_in_composite::AnotherEnum::Vienna}, 9)
+// gdb-check:$7 = (c_style_enum_in_composite::StructWithDrop {a: c_style_enum_in_composite::AnEnum::OneHundred, b: c_style_enum_in_composite::AnotherEnum::Vienna}, 9)
 
 // === LLDB TESTS ==================================================================================
 
diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs
index 6f14f41f06003..d39576bd3878b 100644
--- a/tests/debuginfo/c-style-enum.rs
+++ b/tests/debuginfo/c-style-enum.rs
@@ -5,61 +5,61 @@
 
 // === GDB TESTS ===================================================================================
 
-// gdbr-command:print c_style_enum::SINGLE_VARIANT
-// gdbr-check:$1 = c_style_enum::SingleVariant::TheOnlyVariant
+// gdb-command:print c_style_enum::SINGLE_VARIANT
+// gdb-check:$1 = c_style_enum::SingleVariant::TheOnlyVariant
 
-// gdbr-command:print c_style_enum::AUTO_ONE
-// gdbr-check:$2 = c_style_enum::AutoDiscriminant::One
+// gdb-command:print c_style_enum::AUTO_ONE
+// gdb-check:$2 = c_style_enum::AutoDiscriminant::One
 
-// gdbr-command:print c_style_enum::AUTO_TWO
-// gdbr-check:$3 = c_style_enum::AutoDiscriminant::One
+// gdb-command:print c_style_enum::AUTO_TWO
+// gdb-check:$3 = c_style_enum::AutoDiscriminant::One
 
-// gdbr-command:print c_style_enum::AUTO_THREE
-// gdbr-check:$4 = c_style_enum::AutoDiscriminant::One
+// gdb-command:print c_style_enum::AUTO_THREE
+// gdb-check:$4 = c_style_enum::AutoDiscriminant::One
 
-// gdbr-command:print c_style_enum::MANUAL_ONE
-// gdbr-check:$5 = c_style_enum::ManualDiscriminant::OneHundred
+// gdb-command:print c_style_enum::MANUAL_ONE
+// gdb-check:$5 = c_style_enum::ManualDiscriminant::OneHundred
 
-// gdbr-command:print c_style_enum::MANUAL_TWO
-// gdbr-check:$6 = c_style_enum::ManualDiscriminant::OneHundred
+// gdb-command:print c_style_enum::MANUAL_TWO
+// gdb-check:$6 = c_style_enum::ManualDiscriminant::OneHundred
 
-// gdbr-command:print c_style_enum::MANUAL_THREE
-// gdbr-check:$7 = c_style_enum::ManualDiscriminant::OneHundred
+// gdb-command:print c_style_enum::MANUAL_THREE
+// gdb-check:$7 = c_style_enum::ManualDiscriminant::OneHundred
 
 // gdb-command:run
 
 // gdb-command:print auto_one
-// gdbr-check:$8 = c_style_enum::AutoDiscriminant::One
+// gdb-check:$8 = c_style_enum::AutoDiscriminant::One
 
 // gdb-command:print auto_two
-// gdbr-check:$9 = c_style_enum::AutoDiscriminant::Two
+// gdb-check:$9 = c_style_enum::AutoDiscriminant::Two
 
 // gdb-command:print auto_three
-// gdbr-check:$10 = c_style_enum::AutoDiscriminant::Three
+// gdb-check:$10 = c_style_enum::AutoDiscriminant::Three
 
 // gdb-command:print manual_one_hundred
-// gdbr-check:$11 = c_style_enum::ManualDiscriminant::OneHundred
+// gdb-check:$11 = c_style_enum::ManualDiscriminant::OneHundred
 
 // gdb-command:print manual_one_thousand
-// gdbr-check:$12 = c_style_enum::ManualDiscriminant::OneThousand
+// gdb-check:$12 = c_style_enum::ManualDiscriminant::OneThousand
 
 // gdb-command:print manual_one_million
-// gdbr-check:$13 = c_style_enum::ManualDiscriminant::OneMillion
+// gdb-check:$13 = c_style_enum::ManualDiscriminant::OneMillion
 
 // gdb-command:print single_variant
-// gdbr-check:$14 = c_style_enum::SingleVariant::TheOnlyVariant
+// gdb-check:$14 = c_style_enum::SingleVariant::TheOnlyVariant
 
-// gdbr-command:print AUTO_TWO
-// gdbr-check:$15 = c_style_enum::AutoDiscriminant::Two
+// gdb-command:print AUTO_TWO
+// gdb-check:$15 = c_style_enum::AutoDiscriminant::Two
 
-// gdbr-command:print AUTO_THREE
-// gdbr-check:$16 = c_style_enum::AutoDiscriminant::Three
+// gdb-command:print AUTO_THREE
+// gdb-check:$16 = c_style_enum::AutoDiscriminant::Three
 
-// gdbr-command:print MANUAL_TWO
-// gdbr-check:$17 = c_style_enum::ManualDiscriminant::OneThousand
+// gdb-command:print MANUAL_TWO
+// gdb-check:$17 = c_style_enum::ManualDiscriminant::OneThousand
 
-// gdbr-command:print MANUAL_THREE
-// gdbr-check:$18 = c_style_enum::ManualDiscriminant::OneMillion
+// gdb-command:print MANUAL_THREE
+// gdb-check:$18 = c_style_enum::ManualDiscriminant::OneMillion
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/captured-fields-1.rs b/tests/debuginfo/captured-fields-1.rs
index d96f2590570bc..217a1f27b6783 100644
--- a/tests/debuginfo/captured-fields-1.rs
+++ b/tests/debuginfo/captured-fields-1.rs
@@ -4,22 +4,22 @@
 
 // gdb-command:run
 // gdb-command:print test
-// gdbr-check:$1 = captured_fields_1::main::{closure_env#0} {_ref__my_ref__my_field1: 0x[...]}
+// gdb-check:$1 = captured_fields_1::main::{closure_env#0} {_ref__my_ref__my_field1: 0x[...]}
 // gdb-command:continue
 // gdb-command:print test
-// gdbr-check:$2 = captured_fields_1::main::{closure_env#1} {_ref__my_ref__my_field2: 0x[...]}
+// gdb-check:$2 = captured_fields_1::main::{closure_env#1} {_ref__my_ref__my_field2: 0x[...]}
 // gdb-command:continue
 // gdb-command:print test
-// gdbr-check:$3 = captured_fields_1::main::{closure_env#2} {_ref__my_ref: 0x[...]}
+// gdb-check:$3 = captured_fields_1::main::{closure_env#2} {_ref__my_ref: 0x[...]}
 // gdb-command:continue
 // gdb-command:print test
-// gdbr-check:$4 = captured_fields_1::main::{closure_env#3} {my_ref: 0x[...]}
+// gdb-check:$4 = captured_fields_1::main::{closure_env#3} {my_ref: 0x[...]}
 // gdb-command:continue
 // gdb-command:print test
-// gdbr-check:$5 = captured_fields_1::main::{closure_env#4} {my_var__my_field2: 22}
+// gdb-check:$5 = captured_fields_1::main::{closure_env#4} {my_var__my_field2: 22}
 // gdb-command:continue
 // gdb-command:print test
-// gdbr-check:$6 = captured_fields_1::main::{closure_env#5} {my_var: captured_fields_1::MyStruct {my_field1: 11, my_field2: 22}}
+// gdb-check:$6 = captured_fields_1::main::{closure_env#5} {my_var: captured_fields_1::MyStruct {my_field1: 11, my_field2: 22}}
 // gdb-command:continue
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/captured-fields-2.rs b/tests/debuginfo/captured-fields-2.rs
index 446c5c70fefb3..940f07ecacbb2 100644
--- a/tests/debuginfo/captured-fields-2.rs
+++ b/tests/debuginfo/captured-fields-2.rs
@@ -4,10 +4,10 @@
 
 // gdb-command:run
 // gdb-command:print my_ref__my_field1
-// gdbr-check:$1 = 11
+// gdb-check:$1 = 11
 // gdb-command:continue
 // gdb-command:print my_var__my_field2
-// gdbr-check:$2 = 22
+// gdb-check:$2 = 22
 // gdb-command:continue
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs
index 57e1e63bb8fb0..7344901ec31c0 100644
--- a/tests/debuginfo/cross-crate-spans.rs
+++ b/tests/debuginfo/cross-crate-spans.rs
@@ -15,7 +15,7 @@ extern crate cross_crate_spans;
 // gdb-command:run
 
 // gdb-command:print result
-// gdbr-check:$1 = (17, 17)
+// gdb-check:$1 = (17, 17)
 // gdb-command:print a_variable
 // gdb-check:$2 = 123456789
 // gdb-command:print another_variable
@@ -23,7 +23,7 @@ extern crate cross_crate_spans;
 // gdb-command:continue
 
 // gdb-command:print result
-// gdbr-check:$4 = (1212, 1212)
+// gdb-check:$4 = (1212, 1212)
 // gdb-command:print a_variable
 // gdb-check:$5 = 123456789
 // gdb-command:print another_variable
diff --git a/tests/debuginfo/destructured-fn-argument.rs b/tests/debuginfo/destructured-fn-argument.rs
index 2ebf49ca881ef..783cafb43b35a 100644
--- a/tests/debuginfo/destructured-fn-argument.rs
+++ b/tests/debuginfo/destructured-fn-argument.rs
@@ -23,13 +23,13 @@
 // gdb-command:print a
 // gdb-check:$6 = 5
 // gdb-command:print b
-// gdbr-check:$7 = (6, 7)
+// gdb-check:$7 = (6, 7)
 // gdb-command:continue
 
 // gdb-command:print h
 // gdb-check:$8 = 8
 // gdb-command:print i
-// gdbr-check:$9 = destructured_fn_argument::Struct {a: 9, b: 10}
+// gdb-check:$9 = destructured_fn_argument::Struct {a: 9, b: 10}
 // gdb-command:print j
 // gdb-check:$10 = 11
 // gdb-command:continue
@@ -55,7 +55,7 @@
 // gdb-command:print q
 // gdb-check:$17 = 20
 // gdb-command:print r
-// gdbr-check:$18 = destructured_fn_argument::Struct {a: 21, b: 22}
+// gdb-check:$18 = destructured_fn_argument::Struct {a: 21, b: 22}
 // gdb-command:continue
 
 // gdb-command:print s
@@ -85,11 +85,11 @@
 // gdb-command:continue
 
 // gdb-command:print aa
-// gdbr-check:$30 = (34, 35)
+// gdb-check:$30 = (34, 35)
 // gdb-command:continue
 
 // gdb-command:print bb
-// gdbr-check:$31 = (36, 37)
+// gdb-check:$31 = (36, 37)
 // gdb-command:continue
 
 // gdb-command:print cc
@@ -97,17 +97,17 @@
 // gdb-command:continue
 
 // gdb-command:print dd
-// gdbr-check:$33 = (40, 41, 42)
+// gdb-check:$33 = (40, 41, 42)
 // gdb-command:continue
 
 // gdb-command:print *ee
-// gdbr-check:$34 = (43, 44, 45)
+// gdb-check:$34 = (43, 44, 45)
 // gdb-command:continue
 
 // gdb-command:print *ff
 // gdb-check:$35 = 46
 // gdb-command:print gg
-// gdbr-check:$36 = (47, 48)
+// gdb-check:$36 = (47, 48)
 // gdb-command:continue
 
 // gdb-command:print *hh
diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs
index f6b10f9989029..7636a8d0ad526 100644
--- a/tests/debuginfo/destructured-for-loop-variable.rs
+++ b/tests/debuginfo/destructured-for-loop-variable.rs
@@ -63,11 +63,11 @@
 // gdb-command:continue
 
 // gdb-command:print simple_struct_ident
-// gdbr-check:$23 = destructured_for_loop_variable::Struct {x: 3537, y: 35437.5, z: true}
+// gdb-check:$23 = destructured_for_loop_variable::Struct {x: 3537, y: 35437.5, z: true}
 // gdb-command:continue
 
 // gdb-command:print simple_tuple_ident
-// gdbr-check:$24 = (34903493, 232323)
+// gdb-check:$24 = (34903493, 232323)
 // gdb-command:continue
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/destructured-local.rs b/tests/debuginfo/destructured-local.rs
index d65b352e695f3..06f1355dcfe64 100644
--- a/tests/debuginfo/destructured-local.rs
+++ b/tests/debuginfo/destructured-local.rs
@@ -21,12 +21,12 @@
 // gdb-command:print f
 // gdb-check:$6 = 5
 // gdb-command:print g
-// gdbr-check:$7 = (6, 7)
+// gdb-check:$7 = (6, 7)
 
 // gdb-command:print h
 // gdb-check:$8 = 8
 // gdb-command:print i
-// gdbr-check:$9 = destructured_local::Struct {a: 9, b: 10}
+// gdb-check:$9 = destructured_local::Struct {a: 9, b: 10}
 // gdb-command:print j
 // gdb-check:$10 = 11
 
@@ -48,7 +48,7 @@
 // gdb-command:print q
 // gdb-check:$17 = 20
 // gdb-command:print r
-// gdbr-check:$18 = destructured_local::Struct {a: 21, b: 22}
+// gdb-check:$18 = destructured_local::Struct {a: 21, b: 22}
 
 // gdb-command:print s
 // gdb-check:$19 = 24
@@ -75,25 +75,25 @@
 // gdb-check:$29 = 33
 
 // gdb-command:print aa
-// gdbr-check:$30 = (34, 35)
+// gdb-check:$30 = (34, 35)
 
 // gdb-command:print bb
-// gdbr-check:$31 = (36, 37)
+// gdb-check:$31 = (36, 37)
 
 // gdb-command:print cc
 // gdb-check:$32 = 38
 
 // gdb-command:print dd
-// gdbr-check:$33 = (40, 41, 42)
+// gdb-check:$33 = (40, 41, 42)
 
 // gdb-command:print *ee
-// gdbr-check:$34 = (43, 44, 45)
+// gdb-check:$34 = (43, 44, 45)
 
 // gdb-command:print *ff
 // gdb-check:$35 = 46
 
 // gdb-command:print gg
-// gdbr-check:$36 = (47, 48)
+// gdb-check:$36 = (47, 48)
 
 // gdb-command:print *hh
 // gdb-check:$37 = 50
diff --git a/tests/debuginfo/enum-thinlto.rs b/tests/debuginfo/enum-thinlto.rs
index 42a0d1e28f8e5..ff39c09e2a5d0 100644
--- a/tests/debuginfo/enum-thinlto.rs
+++ b/tests/debuginfo/enum-thinlto.rs
@@ -8,7 +8,7 @@
 // gdb-command:run
 
 // gdb-command:print *abc
-// gdbr-check:$1 = enum_thinlto::ABC::TheA{x: 0, y: 8970181431921507452}
+// gdb-check:$1 = enum_thinlto::ABC::TheA{x: 0, y: 8970181431921507452}
 
 // === LLDB TESTS ==================================================================================
 
diff --git a/tests/debuginfo/evec-in-struct.rs b/tests/debuginfo/evec-in-struct.rs
index 7e0dea0680bcb..9552dba17f6fc 100644
--- a/tests/debuginfo/evec-in-struct.rs
+++ b/tests/debuginfo/evec-in-struct.rs
@@ -7,18 +7,18 @@
 // gdb-command:run
 
 // gdb-command:print no_padding1
-// gdbr-check:$1 = evec_in_struct::NoPadding1 {x: [0, 1, 2], y: -3, z: [4.5, 5.5]}
+// gdb-check:$1 = evec_in_struct::NoPadding1 {x: [0, 1, 2], y: -3, z: [4.5, 5.5]}
 // gdb-command:print no_padding2
-// gdbr-check:$2 = evec_in_struct::NoPadding2 {x: [6, 7, 8], y: [[9, 10], [11, 12]]}
+// gdb-check:$2 = evec_in_struct::NoPadding2 {x: [6, 7, 8], y: [[9, 10], [11, 12]]}
 
 // gdb-command:print struct_internal_padding
-// gdbr-check:$3 = evec_in_struct::StructInternalPadding {x: [13, 14], y: [15, 16]}
+// gdb-check:$3 = evec_in_struct::StructInternalPadding {x: [13, 14], y: [15, 16]}
 
 // gdb-command:print single_vec
-// gdbr-check:$4 = evec_in_struct::SingleVec {x: [17, 18, 19, 20, 21]}
+// gdb-check:$4 = evec_in_struct::SingleVec {x: [17, 18, 19, 20, 21]}
 
 // gdb-command:print struct_padded_at_end
-// gdbr-check:$5 = evec_in_struct::StructPaddedAtEnd {x: [22, 23], y: [24, 25]}
+// gdb-check:$5 = evec_in_struct::StructPaddedAtEnd {x: [22, 23], y: [24, 25]}
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/gdb-pretty-struct-and-enums.rs b/tests/debuginfo/gdb-pretty-struct-and-enums.rs
index 5b6977fdd5bcd..15f0fe8e261f5 100644
--- a/tests/debuginfo/gdb-pretty-struct-and-enums.rs
+++ b/tests/debuginfo/gdb-pretty-struct-and-enums.rs
@@ -7,19 +7,19 @@
 // gdb-command: run
 
 // gdb-command: print regular_struct
-// gdbr-check:$1 = gdb_pretty_struct_and_enums::RegularStruct {the_first_field: 101, the_second_field: 102.5, the_third_field: false}
+// gdb-check:$1 = gdb_pretty_struct_and_enums::RegularStruct {the_first_field: 101, the_second_field: 102.5, the_third_field: false}
 
 // gdb-command: print empty_struct
-// gdbr-check:$2 = gdb_pretty_struct_and_enums::EmptyStruct
+// gdb-check:$2 = gdb_pretty_struct_and_enums::EmptyStruct
 
 // gdb-command: print c_style_enum1
-// gdbr-check:$3 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar1
+// gdb-check:$3 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar1
 
 // gdb-command: print c_style_enum2
-// gdbr-check:$4 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar2
+// gdb-check:$4 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar2
 
 // gdb-command: print c_style_enum3
-// gdbr-check:$5 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar3
+// gdb-check:$5 = gdb_pretty_struct_and_enums::CStyleEnum::CStyleEnumVar3
 
 #![allow(dead_code, unused_variables)]
 
diff --git a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs
index 7b23221213a58..03118a11aadd6 100644
--- a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs
+++ b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs
@@ -10,29 +10,29 @@
 // gdb-command:run
 
 // gdb-command:print eight_bytes1
-// gdbr-check:$1 = generic_enum_with_different_disr_sizes::Enum<f64>::Variant1(100)
+// gdb-check:$1 = generic_enum_with_different_disr_sizes::Enum<f64>::Variant1(100)
 
 // gdb-command:print four_bytes1
-// gdbr-check:$2 = generic_enum_with_different_disr_sizes::Enum<i32>::Variant1(101)
+// gdb-check:$2 = generic_enum_with_different_disr_sizes::Enum<i32>::Variant1(101)
 
 // gdb-command:print two_bytes1
-// gdbr-check:$3 = generic_enum_with_different_disr_sizes::Enum<i16>::Variant1(102)
+// gdb-check:$3 = generic_enum_with_different_disr_sizes::Enum<i16>::Variant1(102)
 
 // gdb-command:print one_byte1
-// gdbr-check:$4 = generic_enum_with_different_disr_sizes::Enum<u8>::Variant1(65)
+// gdb-check:$4 = generic_enum_with_different_disr_sizes::Enum<u8>::Variant1(65)
 
 
 // gdb-command:print eight_bytes2
-// gdbr-check:$5 = generic_enum_with_different_disr_sizes::Enum<f64>::Variant2(100)
+// gdb-check:$5 = generic_enum_with_different_disr_sizes::Enum<f64>::Variant2(100)
 
 // gdb-command:print four_bytes2
-// gdbr-check:$6 = generic_enum_with_different_disr_sizes::Enum<i32>::Variant2(101)
+// gdb-check:$6 = generic_enum_with_different_disr_sizes::Enum<i32>::Variant2(101)
 
 // gdb-command:print two_bytes2
-// gdbr-check:$7 = generic_enum_with_different_disr_sizes::Enum<i16>::Variant2(102)
+// gdb-check:$7 = generic_enum_with_different_disr_sizes::Enum<i16>::Variant2(102)
 
 // gdb-command:print one_byte2
-// gdbr-check:$8 = generic_enum_with_different_disr_sizes::Enum<u8>::Variant2(65)
+// gdb-check:$8 = generic_enum_with_different_disr_sizes::Enum<u8>::Variant2(65)
 
 // gdb-command:continue
 
diff --git a/tests/debuginfo/generic-function.rs b/tests/debuginfo/generic-function.rs
index 7378a5960f302..fce1a3f3ec523 100644
--- a/tests/debuginfo/generic-function.rs
+++ b/tests/debuginfo/generic-function.rs
@@ -21,7 +21,7 @@
 // gdb-command:print *t0
 // gdb-check:$5 = 5
 // gdb-command:print *t1
-// gdbr-check:$6 = generic_function::Struct {a: 6, b: 7.5}
+// gdb-check:$6 = generic_function::Struct {a: 6, b: 7.5}
 // gdb-command:continue
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/generic-method-on-generic-struct.rs b/tests/debuginfo/generic-method-on-generic-struct.rs
index 0b7bee53dabac..0f72e2b092be7 100644
--- a/tests/debuginfo/generic-method-on-generic-struct.rs
+++ b/tests/debuginfo/generic-method-on-generic-struct.rs
@@ -10,7 +10,7 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbr-check:$1 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
+// gdb-check:$1 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
 // gdb-command:print arg2
@@ -19,7 +19,7 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbr-check:$4 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
+// gdb-check:$4 = generic_method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
 // gdb-command:print arg2
@@ -28,7 +28,7 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbr-check:$7 = generic_method_on_generic_struct::Struct<f64> {x: 1234.5}
+// gdb-check:$7 = generic_method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
 // gdb-command:print arg2
@@ -37,7 +37,7 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbr-check:$10 = generic_method_on_generic_struct::Struct<f64> {x: 1234.5}
+// gdb-check:$10 = generic_method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
 // gdb-command:print arg2
@@ -46,7 +46,7 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbr-check:$13 = generic_method_on_generic_struct::Struct<f64> {x: 1234.5}
+// gdb-check:$13 = generic_method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
 // gdb-command:print arg2
diff --git a/tests/debuginfo/generic-struct-style-enum.rs b/tests/debuginfo/generic-struct-style-enum.rs
index 7d929b91064c5..7be1922d26710 100644
--- a/tests/debuginfo/generic-struct-style-enum.rs
+++ b/tests/debuginfo/generic-struct-style-enum.rs
@@ -9,16 +9,16 @@
 // gdb-command:run
 
 // gdb-command:print case1
-// gdbr-check:$1 = generic_struct_style_enum::Regular<u16, u32, i64>::Case1{a: 0, b: 31868, c: 31868, d: 31868, e: 31868}
+// gdb-check:$1 = generic_struct_style_enum::Regular<u16, u32, i64>::Case1{a: 0, b: 31868, c: 31868, d: 31868, e: 31868}
 
 // gdb-command:print case2
-// gdbr-check:$2 = generic_struct_style_enum::Regular<i16, u32, i64>::Case2{a: 0, b: 286331153, c: 286331153}
+// gdb-check:$2 = generic_struct_style_enum::Regular<i16, u32, i64>::Case2{a: 0, b: 286331153, c: 286331153}
 
 // gdb-command:print case3
-// gdbr-check:$3 = generic_struct_style_enum::Regular<u16, i32, u64>::Case3{a: 0, b: 6438275382588823897}
+// gdb-check:$3 = generic_struct_style_enum::Regular<u16, i32, u64>::Case3{a: 0, b: 6438275382588823897}
 
 // gdb-command:print univariant
-// gdbr-check:$4 = generic_struct_style_enum::Univariant<i32>::TheOnlyCase{a: -1}
+// gdb-check:$4 = generic_struct_style_enum::Univariant<i32>::TheOnlyCase{a: -1}
 
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs
index 7a0caf280a4ba..df01d33a0dc59 100644
--- a/tests/debuginfo/generic-struct.rs
+++ b/tests/debuginfo/generic-struct.rs
@@ -9,13 +9,13 @@
 // gdb-command:run
 
 // gdb-command:print int_int
-// gdbr-check:$1 = generic_struct::AGenericStruct<i32, i32> {key: 0, value: 1}
+// gdb-check:$1 = generic_struct::AGenericStruct<i32, i32> {key: 0, value: 1}
 // gdb-command:print int_float
-// gdbr-check:$2 = generic_struct::AGenericStruct<i32, f64> {key: 2, value: 3.5}
+// gdb-check:$2 = generic_struct::AGenericStruct<i32, f64> {key: 2, value: 3.5}
 // gdb-command:print float_int
-// gdbr-check:$3 = generic_struct::AGenericStruct<f64, i32> {key: 4.5, value: 5}
+// gdb-check:$3 = generic_struct::AGenericStruct<f64, i32> {key: 4.5, value: 5}
 // gdb-command:print float_int_float
-// gdbr-check:$4 = generic_struct::AGenericStruct<f64, generic_struct::AGenericStruct<i32, f64>> {key: 6.5, value: generic_struct::AGenericStruct<i32, f64> {key: 7, value: 8.5}}
+// gdb-check:$4 = generic_struct::AGenericStruct<f64, generic_struct::AGenericStruct<i32, f64>> {key: 6.5, value: generic_struct::AGenericStruct<i32, f64> {key: 7, value: 8.5}}
 
 // === LLDB TESTS ==================================================================================
 
diff --git a/tests/debuginfo/generic-tuple-style-enum.rs b/tests/debuginfo/generic-tuple-style-enum.rs
index af90c6ce30ea6..feb62a1f5d1f6 100644
--- a/tests/debuginfo/generic-tuple-style-enum.rs
+++ b/tests/debuginfo/generic-tuple-style-enum.rs
@@ -10,16 +10,16 @@
 // gdb-command:run
 
 // gdb-command:print case1
-// gdbr-check:$1 = generic_tuple_style_enum::Regular<u16, u32, u64>::Case1(0, 31868, 31868, 31868, 31868)
+// gdb-check:$1 = generic_tuple_style_enum::Regular<u16, u32, u64>::Case1(0, 31868, 31868, 31868, 31868)
 
 // gdb-command:print case2
-// gdbr-check:$2 = generic_tuple_style_enum::Regular<i16, i32, i64>::Case2(0, 286331153, 286331153)
+// gdb-check:$2 = generic_tuple_style_enum::Regular<i16, i32, i64>::Case2(0, 286331153, 286331153)
 
 // gdb-command:print case3
-// gdbr-check:$3 = generic_tuple_style_enum::Regular<i16, i32, i64>::Case3(0, 6438275382588823897)
+// gdb-check:$3 = generic_tuple_style_enum::Regular<i16, i32, i64>::Case3(0, 6438275382588823897)
 
 // gdb-command:print univariant
-// gdbr-check:$4 = generic_tuple_style_enum::Univariant<i64>::TheOnlyCase(-1)
+// gdb-check:$4 = generic_tuple_style_enum::Univariant<i64>::TheOnlyCase(-1)
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs
index 62a9ec0d19d19..46af09f093439 100644
--- a/tests/debuginfo/lexical-scopes-in-block-expression.rs
+++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs
@@ -6,7 +6,7 @@
 
 // gdb-command:run
 
-// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
+// gdb-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$1 = 0
 
 // STRUCT EXPRESSION
@@ -18,7 +18,7 @@
 
 // gdb-command:print val
 // gdb-check:$4 = 11
-// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
+// gdb-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$5 = 1
 // gdb-command:print ten
 // gdb-check:$6 = 10
@@ -39,7 +39,7 @@
 
 // gdb-command:print val
 // gdb-check:$11 = 12
-// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
+// gdb-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$12 = 2
 // gdb-command:print ten
 // gdb-check:$13 = 10
@@ -60,7 +60,7 @@
 
 // gdb-command:print val
 // gdb-check:$18 = 13
-// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
+// gdb-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$19 = 3
 // gdb-command:print ten
 // gdb-check:$20 = 10
@@ -81,7 +81,7 @@
 
 // gdb-command:print val
 // gdb-check:$25 = 14
-// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
+// gdb-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$26 = 4
 // gdb-command:print ten
 // gdb-check:$27 = 10
@@ -102,7 +102,7 @@
 
 // gdb-command:print val
 // gdb-check:$32 = 15
-// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
+// gdb-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$33 = 5
 // gdb-command:print ten
 // gdb-check:$34 = 10
@@ -123,7 +123,7 @@
 
 // gdb-command:print val
 // gdb-check:$39 = 16
-// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
+// gdb-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$40 = 6
 // gdb-command:print ten
 // gdb-check:$41 = 10
@@ -145,7 +145,7 @@
 
 // gdb-command:print val
 // gdb-check:$46 = 17
-// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
+// gdb-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$47 = 7
 // gdb-command:print ten
 // gdb-check:$48 = 10
@@ -166,7 +166,7 @@
 
 // gdb-command:print val
 // gdb-check:$53 = 18
-// gdbr-command:print lexical_scopes_in_block_expression::MUT_INT
+// gdb-command:print lexical_scopes_in_block_expression::MUT_INT
 // gdb-check:$54 = 8
 // gdb-command:print ten
 // gdb-check:$55 = 10
diff --git a/tests/debuginfo/limited-debuginfo.rs b/tests/debuginfo/limited-debuginfo.rs
index e82e8e26aca72..fb453d8078ce9 100644
--- a/tests/debuginfo/limited-debuginfo.rs
+++ b/tests/debuginfo/limited-debuginfo.rs
@@ -4,10 +4,10 @@
 
 // Make sure functions have proper names
 // gdb-command:info functions
-// gdbr-check:fn limited_debuginfo::main();
-// gdbr-check:fn limited_debuginfo::some_function();
-// gdbr-check:fn limited_debuginfo::some_other_function();
-// gdbr-check:fn limited_debuginfo::zzz();
+// gdb-check:fn limited_debuginfo::main();
+// gdb-check:fn limited_debuginfo::some_function();
+// gdb-check:fn limited_debuginfo::some_other_function();
+// gdb-check:fn limited_debuginfo::zzz();
 
 // gdb-command:run
 
diff --git a/tests/debuginfo/method-on-enum.rs b/tests/debuginfo/method-on-enum.rs
index 1d447686b0009..a570144450d70 100644
--- a/tests/debuginfo/method-on-enum.rs
+++ b/tests/debuginfo/method-on-enum.rs
@@ -9,7 +9,7 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbr-check:$1 = method_on_enum::Enum::Variant2(117901063)
+// gdb-check:$1 = method_on_enum::Enum::Variant2(117901063)
 // gdb-command:print arg1
 // gdb-check:$2 = -1
 // gdb-command:print arg2
@@ -18,7 +18,7 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbr-check:$4 = method_on_enum::Enum::Variant2(117901063)
+// gdb-check:$4 = method_on_enum::Enum::Variant2(117901063)
 // gdb-command:print arg1
 // gdb-check:$5 = -3
 // gdb-command:print arg2
@@ -27,7 +27,7 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbr-check:$7 = method_on_enum::Enum::Variant1{x: 1799, y: 1799}
+// gdb-check:$7 = method_on_enum::Enum::Variant1{x: 1799, y: 1799}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
 // gdb-command:print arg2
@@ -36,7 +36,7 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbr-check:$10 = method_on_enum::Enum::Variant1{x: 1799, y: 1799}
+// gdb-check:$10 = method_on_enum::Enum::Variant1{x: 1799, y: 1799}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
 // gdb-command:print arg2
@@ -45,7 +45,7 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbr-check:$13 = method_on_enum::Enum::Variant1{x: 1799, y: 1799}
+// gdb-check:$13 = method_on_enum::Enum::Variant1{x: 1799, y: 1799}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
 // gdb-command:print arg2
diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs
index d8f5508090d55..c20c1cec9db70 100644
--- a/tests/debuginfo/method-on-generic-struct.rs
+++ b/tests/debuginfo/method-on-generic-struct.rs
@@ -10,7 +10,7 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbr-check:$1 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
+// gdb-check:$1 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
 // gdb-command:print arg2
@@ -19,7 +19,7 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbr-check:$4 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
+// gdb-check:$4 = method_on_generic_struct::Struct<(u32, i32)> {x: (8888, -8888)}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
 // gdb-command:print arg2
@@ -28,7 +28,7 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbr-check:$7 = method_on_generic_struct::Struct<f64> {x: 1234.5}
+// gdb-check:$7 = method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
 // gdb-command:print arg2
@@ -37,7 +37,7 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbr-check:$10 = method_on_generic_struct::Struct<f64> {x: 1234.5}
+// gdb-check:$10 = method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
 // gdb-command:print arg2
@@ -46,7 +46,7 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbr-check:$13 = method_on_generic_struct::Struct<f64> {x: 1234.5}
+// gdb-check:$13 = method_on_generic_struct::Struct<f64> {x: 1234.5}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
 // gdb-command:print arg2
diff --git a/tests/debuginfo/method-on-struct.rs b/tests/debuginfo/method-on-struct.rs
index c2632dafc3947..eef1b1043b81d 100644
--- a/tests/debuginfo/method-on-struct.rs
+++ b/tests/debuginfo/method-on-struct.rs
@@ -8,7 +8,7 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbr-check:$1 = method_on_struct::Struct {x: 100}
+// gdb-check:$1 = method_on_struct::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
 // gdb-command:print arg2
@@ -17,7 +17,7 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbr-check:$4 = method_on_struct::Struct {x: 100}
+// gdb-check:$4 = method_on_struct::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
 // gdb-command:print arg2
@@ -26,7 +26,7 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbr-check:$7 = method_on_struct::Struct {x: 200}
+// gdb-check:$7 = method_on_struct::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
 // gdb-command:print arg2
@@ -35,7 +35,7 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbr-check:$10 = method_on_struct::Struct {x: 200}
+// gdb-check:$10 = method_on_struct::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
 // gdb-command:print arg2
@@ -44,7 +44,7 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbr-check:$13 = method_on_struct::Struct {x: 200}
+// gdb-check:$13 = method_on_struct::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
 // gdb-command:print arg2
diff --git a/tests/debuginfo/method-on-trait.rs b/tests/debuginfo/method-on-trait.rs
index 9172c6976a1a6..ff4f6c5e131ee 100644
--- a/tests/debuginfo/method-on-trait.rs
+++ b/tests/debuginfo/method-on-trait.rs
@@ -8,7 +8,7 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbr-check:$1 = method_on_trait::Struct {x: 100}
+// gdb-check:$1 = method_on_trait::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
 // gdb-command:print arg2
@@ -17,7 +17,7 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbr-check:$4 = method_on_trait::Struct {x: 100}
+// gdb-check:$4 = method_on_trait::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
 // gdb-command:print arg2
@@ -26,7 +26,7 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbr-check:$7 = method_on_trait::Struct {x: 200}
+// gdb-check:$7 = method_on_trait::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
 // gdb-command:print arg2
@@ -35,7 +35,7 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbr-check:$10 = method_on_trait::Struct {x: 200}
+// gdb-check:$10 = method_on_trait::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
 // gdb-command:print arg2
@@ -44,7 +44,7 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbr-check:$13 = method_on_trait::Struct {x: 200}
+// gdb-check:$13 = method_on_trait::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
 // gdb-command:print arg2
diff --git a/tests/debuginfo/method-on-tuple-struct.rs b/tests/debuginfo/method-on-tuple-struct.rs
index 71a11093f7d38..cb8014cace5d7 100644
--- a/tests/debuginfo/method-on-tuple-struct.rs
+++ b/tests/debuginfo/method-on-tuple-struct.rs
@@ -8,7 +8,7 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbr-check:$1 = method_on_tuple_struct::TupleStruct (100, -100.5)
+// gdb-check:$1 = method_on_tuple_struct::TupleStruct (100, -100.5)
 // gdb-command:print arg1
 // gdb-check:$2 = -1
 // gdb-command:print arg2
@@ -17,7 +17,7 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbr-check:$4 = method_on_tuple_struct::TupleStruct (100, -100.5)
+// gdb-check:$4 = method_on_tuple_struct::TupleStruct (100, -100.5)
 // gdb-command:print arg1
 // gdb-check:$5 = -3
 // gdb-command:print arg2
@@ -26,7 +26,7 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbr-check:$7 = method_on_tuple_struct::TupleStruct (200, -200.5)
+// gdb-check:$7 = method_on_tuple_struct::TupleStruct (200, -200.5)
 // gdb-command:print arg1
 // gdb-check:$8 = -5
 // gdb-command:print arg2
@@ -35,7 +35,7 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbr-check:$10 = method_on_tuple_struct::TupleStruct (200, -200.5)
+// gdb-check:$10 = method_on_tuple_struct::TupleStruct (200, -200.5)
 // gdb-command:print arg1
 // gdb-check:$11 = -7
 // gdb-command:print arg2
@@ -44,7 +44,7 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbr-check:$13 = method_on_tuple_struct::TupleStruct (200, -200.5)
+// gdb-check:$13 = method_on_tuple_struct::TupleStruct (200, -200.5)
 // gdb-command:print arg1
 // gdb-check:$14 = -9
 // gdb-command:print arg2
diff --git a/tests/debuginfo/option-like-enum.rs b/tests/debuginfo/option-like-enum.rs
index 159d8e976c7c4..d370796efa9d2 100644
--- a/tests/debuginfo/option-like-enum.rs
+++ b/tests/debuginfo/option-like-enum.rs
@@ -8,28 +8,28 @@
 // gdb-command:run
 
 // gdb-command:print some
-// gdbr-check:$1 = core::option::Option<&u32>::Some(0x12345678)
+// gdb-check:$1 = core::option::Option<&u32>::Some(0x12345678)
 
 // gdb-command:print none
-// gdbr-check:$2 = core::option::Option<&u32>::None
+// gdb-check:$2 = core::option::Option<&u32>::None
 
 // gdb-command:print full
-// gdbr-check:$3 = option_like_enum::MoreFields::Full(454545, 0x87654321, 9988)
+// gdb-check:$3 = option_like_enum::MoreFields::Full(454545, 0x87654321, 9988)
 
-// gdbr-command:print empty_gdb.discr
+// gdb-command:print empty_gdb.discr
 // gdb-check:$4 = (*mut isize) 0x1
 
 // gdb-command:print droid
-// gdbr-check:$5 = option_like_enum::NamedFields::Droid{id: 675675, range: 10000001, internals: 0x43218765}
+// gdb-check:$5 = option_like_enum::NamedFields::Droid{id: 675675, range: 10000001, internals: 0x43218765}
 
-// gdbr-command:print void_droid_gdb.internals
+// gdb-command:print void_droid_gdb.internals
 // gdb-check:$6 = (*mut isize) 0x1
 
 // gdb-command:print nested_non_zero_yep
-// gdbr-check:$7 = option_like_enum::NestedNonZero::Yep(10.5, option_like_enum::NestedNonZeroField {a: 10, b: 20, c: 0x[...]})
+// gdb-check:$7 = option_like_enum::NestedNonZero::Yep(10.5, option_like_enum::NestedNonZeroField {a: 10, b: 20, c: 0x[...]})
 
 // gdb-command:print nested_non_zero_nope
-// gdbr-check:$8 = option_like_enum::NestedNonZero::Nope
+// gdb-check:$8 = option_like_enum::NestedNonZero::Nope
 
 // gdb-command:continue
 
diff --git a/tests/debuginfo/packed-struct-with-destructor.rs b/tests/debuginfo/packed-struct-with-destructor.rs
index afd0d570b0b33..e3138b1185fac 100644
--- a/tests/debuginfo/packed-struct-with-destructor.rs
+++ b/tests/debuginfo/packed-struct-with-destructor.rs
@@ -7,29 +7,29 @@
 // gdb-command:run
 
 // gdb-command:print packed
-// gdbr-check:$1 = packed_struct_with_destructor::Packed {x: 123, y: 234, z: 345}
+// gdb-check:$1 = packed_struct_with_destructor::Packed {x: 123, y: 234, z: 345}
 
 // gdb-command:print packedInPacked
-// gdbr-check:$2 = packed_struct_with_destructor::PackedInPacked {a: 1111, b: packed_struct_with_destructor::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct_with_destructor::Packed {x: 6666, y: 7777, z: 8888}}
+// gdb-check:$2 = packed_struct_with_destructor::PackedInPacked {a: 1111, b: packed_struct_with_destructor::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct_with_destructor::Packed {x: 6666, y: 7777, z: 8888}}
 
 // gdb-command:print packedInUnpacked
-// gdbr-check:$3 = packed_struct_with_destructor::PackedInUnpacked {a: -1111, b: packed_struct_with_destructor::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct_with_destructor::Packed {x: -6666, y: -7777, z: -8888}}
+// gdb-check:$3 = packed_struct_with_destructor::PackedInUnpacked {a: -1111, b: packed_struct_with_destructor::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct_with_destructor::Packed {x: -6666, y: -7777, z: -8888}}
 
 // gdb-command:print unpackedInPacked
-// gdbr-check:$4 = packed_struct_with_destructor::UnpackedInPacked {a: 987, b: packed_struct_with_destructor::Unpacked {x: 876, y: 765, z: 654}, c: packed_struct_with_destructor::Unpacked {x: 543, y: 432, z: 321}, d: 210}
+// gdb-check:$4 = packed_struct_with_destructor::UnpackedInPacked {a: 987, b: packed_struct_with_destructor::Unpacked {x: 876, y: 765, z: 654}, c: packed_struct_with_destructor::Unpacked {x: 543, y: 432, z: 321}, d: 210}
 
 
 // gdb-command:print packedInPackedWithDrop
-// gdbr-check:$5 = packed_struct_with_destructor::PackedInPackedWithDrop {a: 11, b: packed_struct_with_destructor::Packed {x: 22, y: 33, z: 44}, c: 55, d: packed_struct_with_destructor::Packed {x: 66, y: 77, z: 88}}
+// gdb-check:$5 = packed_struct_with_destructor::PackedInPackedWithDrop {a: 11, b: packed_struct_with_destructor::Packed {x: 22, y: 33, z: 44}, c: 55, d: packed_struct_with_destructor::Packed {x: 66, y: 77, z: 88}}
 
 // gdb-command:print packedInUnpackedWithDrop
-// gdbr-check:$6 = packed_struct_with_destructor::PackedInUnpackedWithDrop {a: -11, b: packed_struct_with_destructor::Packed {x: -22, y: -33, z: -44}, c: -55, d: packed_struct_with_destructor::Packed {x: -66, y: -77, z: -88}}
+// gdb-check:$6 = packed_struct_with_destructor::PackedInUnpackedWithDrop {a: -11, b: packed_struct_with_destructor::Packed {x: -22, y: -33, z: -44}, c: -55, d: packed_struct_with_destructor::Packed {x: -66, y: -77, z: -88}}
 
 // gdb-command:print unpackedInPackedWithDrop
-// gdbr-check:$7 = packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 98, b: packed_struct_with_destructor::Unpacked {x: 87, y: 76, z: 65}, c: packed_struct_with_destructor::Unpacked {x: 54, y: 43, z: 32}, d: 21}
+// gdb-check:$7 = packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 98, b: packed_struct_with_destructor::Unpacked {x: 87, y: 76, z: 65}, c: packed_struct_with_destructor::Unpacked {x: 54, y: 43, z: 32}, d: 21}
 
 // gdb-command:print deeplyNested
-// gdbr-check:$8 = packed_struct_with_destructor::DeeplyNested {a: packed_struct_with_destructor::PackedInPacked {a: 1, b: packed_struct_with_destructor::Packed {x: 2, y: 3, z: 4}, c: 5, d: packed_struct_with_destructor::Packed {x: 6, y: 7, z: 8}}, b: packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 9, b: packed_struct_with_destructor::Unpacked {x: 10, y: 11, z: 12}, c: packed_struct_with_destructor::Unpacked {x: 13, y: 14, z: 15}, d: 16}, c: packed_struct_with_destructor::PackedInUnpacked {a: 17, b: packed_struct_with_destructor::Packed {x: 18, y: 19, z: 20}, c: 21, d: packed_struct_with_destructor::Packed {x: 22, y: 23, z: 24}}, d: packed_struct_with_destructor::PackedInUnpackedWithDrop {a: 25, b: packed_struct_with_destructor::Packed {x: 26, y: 27, z: 28}, c: 29, d: packed_struct_with_destructor::Packed {x: 30, y: 31, z: 32}}, e: packed_struct_with_destructor::UnpackedInPacked {a: 33, b: packed_struct_with_destructor::Unpacked {x: 34, y: 35, z: 36}, c: packed_struct_with_destructor::Unpacked {x: 37, y: 38, z: 39}, d: 40}, f: packed_struct_with_destructor::PackedInPackedWithDrop {a: 41, b: packed_struct_with_destructor::Packed {x: 42, y: 43, z: 44}, c: 45, d: packed_struct_with_destructor::Packed {x: 46, y: 47, z: 48}}}
+// gdb-check:$8 = packed_struct_with_destructor::DeeplyNested {a: packed_struct_with_destructor::PackedInPacked {a: 1, b: packed_struct_with_destructor::Packed {x: 2, y: 3, z: 4}, c: 5, d: packed_struct_with_destructor::Packed {x: 6, y: 7, z: 8}}, b: packed_struct_with_destructor::UnpackedInPackedWithDrop {a: 9, b: packed_struct_with_destructor::Unpacked {x: 10, y: 11, z: 12}, c: packed_struct_with_destructor::Unpacked {x: 13, y: 14, z: 15}, d: 16}, c: packed_struct_with_destructor::PackedInUnpacked {a: 17, b: packed_struct_with_destructor::Packed {x: 18, y: 19, z: 20}, c: 21, d: packed_struct_with_destructor::Packed {x: 22, y: 23, z: 24}}, d: packed_struct_with_destructor::PackedInUnpackedWithDrop {a: 25, b: packed_struct_with_destructor::Packed {x: 26, y: 27, z: 28}, c: 29, d: packed_struct_with_destructor::Packed {x: 30, y: 31, z: 32}}, e: packed_struct_with_destructor::UnpackedInPacked {a: 33, b: packed_struct_with_destructor::Unpacked {x: 34, y: 35, z: 36}, c: packed_struct_with_destructor::Unpacked {x: 37, y: 38, z: 39}, d: 40}, f: packed_struct_with_destructor::PackedInPackedWithDrop {a: 41, b: packed_struct_with_destructor::Packed {x: 42, y: 43, z: 44}, c: 45, d: packed_struct_with_destructor::Packed {x: 46, y: 47, z: 48}}}
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs
index 6ef4995bc16d2..cfff4c27d7057 100644
--- a/tests/debuginfo/packed-struct.rs
+++ b/tests/debuginfo/packed-struct.rs
@@ -8,16 +8,16 @@
 // gdb-command:run
 
 // gdb-command:print packed
-// gdbr-check:$1 = packed_struct::Packed {x: 123, y: 234, z: 345}
+// gdb-check:$1 = packed_struct::Packed {x: 123, y: 234, z: 345}
 
 // gdb-command:print packedInPacked
-// gdbr-check:$2 = packed_struct::PackedInPacked {a: 1111, b: packed_struct::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct::Packed {x: 6666, y: 7777, z: 8888}}
+// gdb-check:$2 = packed_struct::PackedInPacked {a: 1111, b: packed_struct::Packed {x: 2222, y: 3333, z: 4444}, c: 5555, d: packed_struct::Packed {x: 6666, y: 7777, z: 8888}}
 
 // gdb-command:print packedInUnpacked
-// gdbr-check:$3 = packed_struct::PackedInUnpacked {a: -1111, b: packed_struct::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct::Packed {x: -6666, y: -7777, z: -8888}}
+// gdb-check:$3 = packed_struct::PackedInUnpacked {a: -1111, b: packed_struct::Packed {x: -2222, y: -3333, z: -4444}, c: -5555, d: packed_struct::Packed {x: -6666, y: -7777, z: -8888}}
 
 // gdb-command:print unpackedInPacked
-// gdbr-check:$4 = packed_struct::UnpackedInPacked {a: 987, b: packed_struct::Unpacked {x: 876, y: 765, z: 654, w: 543}, c: packed_struct::Unpacked {x: 432, y: 321, z: 210, w: 109}, d: -98}
+// gdb-check:$4 = packed_struct::UnpackedInPacked {a: 987, b: packed_struct::Unpacked {x: 876, y: 765, z: 654, w: 543}, c: packed_struct::Unpacked {x: 432, y: 321, z: 210, w: 109}, d: -98}
 
 // gdb-command:print sizeof(packed)
 // gdb-check:$5 = 14
diff --git a/tests/debuginfo/pretty-slices.rs b/tests/debuginfo/pretty-slices.rs
index 90cad4e6639e4..f1aad836434ed 100644
--- a/tests/debuginfo/pretty-slices.rs
+++ b/tests/debuginfo/pretty-slices.rs
@@ -5,10 +5,10 @@
 // gdb-command: run
 
 // gdb-command: print slice
-// gdbr-check: $1 = &[i32](size=3) = {0, 1, 2}
+// gdb-check: $1 = &[i32](size=3) = {0, 1, 2}
 
 // gdb-command: print mut_slice
-// gdbr-check: $2 = &mut [i32](size=4) = {2, 3, 5, 7}
+// gdb-check: $2 = &mut [i32](size=4) = {2, 3, 5, 7}
 
 // gdb-command: print str_slice
 // gdb-check: $3 = "string slice"
diff --git a/tests/debuginfo/pretty-std.rs b/tests/debuginfo/pretty-std.rs
index c42bdc5ee3fc1..e33d0b237be0a 100644
--- a/tests/debuginfo/pretty-std.rs
+++ b/tests/debuginfo/pretty-std.rs
@@ -26,7 +26,7 @@
 // gdb-check:$5 = core::option::Option<i16>::Some(8)
 
 // gdb-command: print none
-// gdbr-check:$6 = core::option::Option<i64>::None
+// gdb-check:$6 = core::option::Option<i64>::None
 
 // gdb-command: print os_string
 // gdb-check:$7 = "IAMA OS string 😃"
diff --git a/tests/debuginfo/recursive-struct.rs b/tests/debuginfo/recursive-struct.rs
index 1d039527d1abe..d6f5b9f2868d8 100644
--- a/tests/debuginfo/recursive-struct.rs
+++ b/tests/debuginfo/recursive-struct.rs
@@ -9,53 +9,53 @@
 
 // gdb-command:print stack_unique.value
 // gdb-check:$1 = 0
-// gdbr-command:print stack_unique.next.val.value
+// gdb-command:print stack_unique.next.val.value
 // gdb-check:$2 = 1
 
-// gdbr-command:print unique_unique.value
+// gdb-command:print unique_unique.value
 // gdb-check:$3 = 2
-// gdbr-command:print unique_unique.next.val.value
+// gdb-command:print unique_unique.next.val.value
 // gdb-check:$4 = 3
 
 // gdb-command:print vec_unique[0].value
 // gdb-check:$5 = 6.5
-// gdbr-command:print vec_unique[0].next.val.value
+// gdb-command:print vec_unique[0].next.val.value
 // gdb-check:$6 = 7.5
 
-// gdbr-command:print borrowed_unique.value
+// gdb-command:print borrowed_unique.value
 // gdb-check:$7 = 8.5
-// gdbr-command:print borrowed_unique.next.val.value
+// gdb-command:print borrowed_unique.next.val.value
 // gdb-check:$8 = 9.5
 
 // LONG CYCLE
 // gdb-command:print long_cycle1.value
 // gdb-check:$9 = 20
-// gdbr-command:print long_cycle1.next.value
+// gdb-command:print long_cycle1.next.value
 // gdb-check:$10 = 21
-// gdbr-command:print long_cycle1.next.next.value
+// gdb-command:print long_cycle1.next.next.value
 // gdb-check:$11 = 22
-// gdbr-command:print long_cycle1.next.next.next.value
+// gdb-command:print long_cycle1.next.next.next.value
 // gdb-check:$12 = 23
 
 // gdb-command:print long_cycle2.value
 // gdb-check:$13 = 24
-// gdbr-command:print long_cycle2.next.value
+// gdb-command:print long_cycle2.next.value
 // gdb-check:$14 = 25
-// gdbr-command:print long_cycle2.next.next.value
+// gdb-command:print long_cycle2.next.next.value
 // gdb-check:$15 = 26
 
 // gdb-command:print long_cycle3.value
 // gdb-check:$16 = 27
-// gdbr-command:print long_cycle3.next.value
+// gdb-command:print long_cycle3.next.value
 // gdb-check:$17 = 28
 
 // gdb-command:print long_cycle4.value
 // gdb-check:$18 = 29.5
 
-// gdbr-command:print long_cycle_w_anon_types.value
+// gdb-command:print long_cycle_w_anon_types.value
 // gdb-check:$19 = 30
 
-// gdbr-command:print long_cycle_w_anon_types.next.val.value
+// gdb-command:print long_cycle_w_anon_types.next.val.value
 // gdb-check:$20 = 31
 
 // gdb-command:continue
diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs
index d59cf61420f23..c21a2f01f2f9c 100644
--- a/tests/debuginfo/reference-debuginfo.rs
+++ b/tests/debuginfo/reference-debuginfo.rs
@@ -18,7 +18,7 @@
 // gdb-check:$3 = 97
 
 // gdb-command:print *i8_ref
-// gdbr-check:$4 = 68
+// gdb-check:$4 = 68
 
 // gdb-command:print *i16_ref
 // gdb-check:$5 = -16
@@ -33,7 +33,7 @@
 // gdb-check:$8 = 1
 
 // gdb-command:print *u8_ref
-// gdbr-check:$9 = 100
+// gdb-check:$9 = 100
 
 // gdb-command:print *u16_ref
 // gdb-check:$10 = 16
diff --git a/tests/debuginfo/self-in-default-method.rs b/tests/debuginfo/self-in-default-method.rs
index 89e1a8fab2b9e..e5a53bb618db6 100644
--- a/tests/debuginfo/self-in-default-method.rs
+++ b/tests/debuginfo/self-in-default-method.rs
@@ -8,7 +8,7 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbr-check:$1 = self_in_default_method::Struct {x: 100}
+// gdb-check:$1 = self_in_default_method::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
 // gdb-command:print arg2
@@ -17,7 +17,7 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbr-check:$4 = self_in_default_method::Struct {x: 100}
+// gdb-check:$4 = self_in_default_method::Struct {x: 100}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
 // gdb-command:print arg2
@@ -26,7 +26,7 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbr-check:$7 = self_in_default_method::Struct {x: 200}
+// gdb-check:$7 = self_in_default_method::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
 // gdb-command:print arg2
@@ -35,7 +35,7 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbr-check:$10 = self_in_default_method::Struct {x: 200}
+// gdb-check:$10 = self_in_default_method::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
 // gdb-command:print arg2
@@ -44,7 +44,7 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbr-check:$13 = self_in_default_method::Struct {x: 200}
+// gdb-check:$13 = self_in_default_method::Struct {x: 200}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
 // gdb-command:print arg2
diff --git a/tests/debuginfo/self-in-generic-default-method.rs b/tests/debuginfo/self-in-generic-default-method.rs
index b4908486cdf88..8c6abad837712 100644
--- a/tests/debuginfo/self-in-generic-default-method.rs
+++ b/tests/debuginfo/self-in-generic-default-method.rs
@@ -8,7 +8,7 @@
 
 // STACK BY REF
 // gdb-command:print *self
-// gdbr-check:$1 = self_in_generic_default_method::Struct {x: 987}
+// gdb-check:$1 = self_in_generic_default_method::Struct {x: 987}
 // gdb-command:print arg1
 // gdb-check:$2 = -1
 // gdb-command:print arg2
@@ -17,7 +17,7 @@
 
 // STACK BY VAL
 // gdb-command:print self
-// gdbr-check:$4 = self_in_generic_default_method::Struct {x: 987}
+// gdb-check:$4 = self_in_generic_default_method::Struct {x: 987}
 // gdb-command:print arg1
 // gdb-check:$5 = -3
 // gdb-command:print arg2
@@ -26,7 +26,7 @@
 
 // OWNED BY REF
 // gdb-command:print *self
-// gdbr-check:$7 = self_in_generic_default_method::Struct {x: 879}
+// gdb-check:$7 = self_in_generic_default_method::Struct {x: 879}
 // gdb-command:print arg1
 // gdb-check:$8 = -5
 // gdb-command:print arg2
@@ -35,7 +35,7 @@
 
 // OWNED BY VAL
 // gdb-command:print self
-// gdbr-check:$10 = self_in_generic_default_method::Struct {x: 879}
+// gdb-check:$10 = self_in_generic_default_method::Struct {x: 879}
 // gdb-command:print arg1
 // gdb-check:$11 = -7
 // gdb-command:print arg2
@@ -44,7 +44,7 @@
 
 // OWNED MOVED
 // gdb-command:print *self
-// gdbr-check:$13 = self_in_generic_default_method::Struct {x: 879}
+// gdb-check:$13 = self_in_generic_default_method::Struct {x: 879}
 // gdb-command:print arg1
 // gdb-check:$14 = -9
 // gdb-command:print arg2
diff --git a/tests/debuginfo/simd.rs b/tests/debuginfo/simd.rs
index 44a3efee39133..e4fe262235bae 100644
--- a/tests/debuginfo/simd.rs
+++ b/tests/debuginfo/simd.rs
@@ -9,28 +9,28 @@
 //@ compile-flags:-g
 // gdb-command:run
 
-// gdbr-command:print vi8x16
-// gdbr-check:$1 = simd::i8x16 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
-// gdbr-command:print vi16x8
-// gdbr-check:$2 = simd::i16x8 (16, 17, 18, 19, 20, 21, 22, 23)
-// gdbr-command:print vi32x4
-// gdbr-check:$3 = simd::i32x4 (24, 25, 26, 27)
-// gdbr-command:print vi64x2
-// gdbr-check:$4 = simd::i64x2 (28, 29)
+// gdb-command:print vi8x16
+// gdb-check:$1 = simd::i8x16 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+// gdb-command:print vi16x8
+// gdb-check:$2 = simd::i16x8 (16, 17, 18, 19, 20, 21, 22, 23)
+// gdb-command:print vi32x4
+// gdb-check:$3 = simd::i32x4 (24, 25, 26, 27)
+// gdb-command:print vi64x2
+// gdb-check:$4 = simd::i64x2 (28, 29)
 
-// gdbr-command:print vu8x16
-// gdbr-check:$5 = simd::u8x16 (30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45)
-// gdbr-command:print vu16x8
-// gdbr-check:$6 = simd::u16x8 (46, 47, 48, 49, 50, 51, 52, 53)
-// gdbr-command:print vu32x4
-// gdbr-check:$7 = simd::u32x4 (54, 55, 56, 57)
-// gdbr-command:print vu64x2
-// gdbr-check:$8 = simd::u64x2 (58, 59)
+// gdb-command:print vu8x16
+// gdb-check:$5 = simd::u8x16 (30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45)
+// gdb-command:print vu16x8
+// gdb-check:$6 = simd::u16x8 (46, 47, 48, 49, 50, 51, 52, 53)
+// gdb-command:print vu32x4
+// gdb-check:$7 = simd::u32x4 (54, 55, 56, 57)
+// gdb-command:print vu64x2
+// gdb-check:$8 = simd::u64x2 (58, 59)
 
 // gdb-command:print vf32x4
-// gdbr-check:$9 = simd::f32x4 (60.5, 61.5, 62.5, 63.5)
+// gdb-check:$9 = simd::f32x4 (60.5, 61.5, 62.5, 63.5)
 // gdb-command:print vf64x2
-// gdbr-check:$10 = simd::f64x2 (64.5, 65.5)
+// gdb-check:$10 = simd::f64x2 (64.5, 65.5)
 
 // gdb-command:continue
 
diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs
index 54d543d90a4c1..77bfb8a0676b1 100644
--- a/tests/debuginfo/simple-struct.rs
+++ b/tests/debuginfo/simple-struct.rs
@@ -4,61 +4,61 @@
 
 // === GDB TESTS ===================================================================================
 
-// gdbr-command:print simple_struct::NO_PADDING_16
-// gdbr-check:$1 = simple_struct::NoPadding16 {x: 1000, y: -1001}
+// gdb-command:print simple_struct::NO_PADDING_16
+// gdb-check:$1 = simple_struct::NoPadding16 {x: 1000, y: -1001}
 
-// gdbr-command:print simple_struct::NO_PADDING_32
-// gdbr-check:$2 = simple_struct::NoPadding32 {x: 1, y: 2, z: 3}
+// gdb-command:print simple_struct::NO_PADDING_32
+// gdb-check:$2 = simple_struct::NoPadding32 {x: 1, y: 2, z: 3}
 
-// gdbr-command:print simple_struct::NO_PADDING_64
-// gdbr-check:$3 = simple_struct::NoPadding64 {x: 4, y: 5, z: 6}
+// gdb-command:print simple_struct::NO_PADDING_64
+// gdb-check:$3 = simple_struct::NoPadding64 {x: 4, y: 5, z: 6}
 
-// gdbr-command:print simple_struct::NO_PADDING_163264
-// gdbr-check:$4 = simple_struct::NoPadding163264 {a: 7, b: 8, c: 9, d: 10}
+// gdb-command:print simple_struct::NO_PADDING_163264
+// gdb-check:$4 = simple_struct::NoPadding163264 {a: 7, b: 8, c: 9, d: 10}
 
-// gdbr-command:print simple_struct::INTERNAL_PADDING
-// gdbr-check:$5 = simple_struct::InternalPadding {x: 11, y: 12}
+// gdb-command:print simple_struct::INTERNAL_PADDING
+// gdb-check:$5 = simple_struct::InternalPadding {x: 11, y: 12}
 
-// gdbr-command:print simple_struct::PADDING_AT_END
-// gdbr-check:$6 = simple_struct::PaddingAtEnd {x: 13, y: 14}
+// gdb-command:print simple_struct::PADDING_AT_END
+// gdb-check:$6 = simple_struct::PaddingAtEnd {x: 13, y: 14}
 
 // gdb-command:run
 
 // gdb-command:print no_padding16
-// gdbr-check:$7 = simple_struct::NoPadding16 {x: 10000, y: -10001}
+// gdb-check:$7 = simple_struct::NoPadding16 {x: 10000, y: -10001}
 
 // gdb-command:print no_padding32
-// gdbr-check:$8 = simple_struct::NoPadding32 {x: -10002, y: -10003.5, z: 10004}
+// gdb-check:$8 = simple_struct::NoPadding32 {x: -10002, y: -10003.5, z: 10004}
 
 // gdb-command:print no_padding64
-// gdbr-check:$9 = simple_struct::NoPadding64 {x: -10005.5, y: 10006, z: 10007}
+// gdb-check:$9 = simple_struct::NoPadding64 {x: -10005.5, y: 10006, z: 10007}
 
 // gdb-command:print no_padding163264
-// gdbr-check:$10 = simple_struct::NoPadding163264 {a: -10008, b: 10009, c: 10010, d: 10011}
+// gdb-check:$10 = simple_struct::NoPadding163264 {a: -10008, b: 10009, c: 10010, d: 10011}
 
 // gdb-command:print internal_padding
-// gdbr-check:$11 = simple_struct::InternalPadding {x: 10012, y: -10013}
+// gdb-check:$11 = simple_struct::InternalPadding {x: 10012, y: -10013}
 
 // gdb-command:print padding_at_end
-// gdbr-check:$12 = simple_struct::PaddingAtEnd {x: -10014, y: 10015}
+// gdb-check:$12 = simple_struct::PaddingAtEnd {x: -10014, y: 10015}
 
-// gdbr-command:print simple_struct::NO_PADDING_16
-// gdbr-check:$13 = simple_struct::NoPadding16 {x: 100, y: -101}
+// gdb-command:print simple_struct::NO_PADDING_16
+// gdb-check:$13 = simple_struct::NoPadding16 {x: 100, y: -101}
 
-// gdbr-command:print simple_struct::NO_PADDING_32
-// gdbr-check:$14 = simple_struct::NoPadding32 {x: -15, y: -16, z: 17}
+// gdb-command:print simple_struct::NO_PADDING_32
+// gdb-check:$14 = simple_struct::NoPadding32 {x: -15, y: -16, z: 17}
 
-// gdbr-command:print simple_struct::NO_PADDING_64
-// gdbr-check:$15 = simple_struct::NoPadding64 {x: -18, y: 19, z: 20}
+// gdb-command:print simple_struct::NO_PADDING_64
+// gdb-check:$15 = simple_struct::NoPadding64 {x: -18, y: 19, z: 20}
 
-// gdbr-command:print simple_struct::NO_PADDING_163264
-// gdbr-check:$16 = simple_struct::NoPadding163264 {a: -21, b: 22, c: 23, d: 24}
+// gdb-command:print simple_struct::NO_PADDING_163264
+// gdb-check:$16 = simple_struct::NoPadding163264 {a: -21, b: 22, c: 23, d: 24}
 
-// gdbr-command:print simple_struct::INTERNAL_PADDING
-// gdbr-check:$17 = simple_struct::InternalPadding {x: 25, y: -26}
+// gdb-command:print simple_struct::INTERNAL_PADDING
+// gdb-check:$17 = simple_struct::InternalPadding {x: 25, y: -26}
 
-// gdbr-command:print simple_struct::PADDING_AT_END
-// gdbr-check:$18 = simple_struct::PaddingAtEnd {x: -27, y: 28}
+// gdb-command:print simple_struct::PADDING_AT_END
+// gdb-check:$18 = simple_struct::PaddingAtEnd {x: -27, y: 28}
 
 // gdb-command:continue
 
diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs
index e19fb59cdc5ce..eb1d5ab3c3d3a 100644
--- a/tests/debuginfo/simple-tuple.rs
+++ b/tests/debuginfo/simple-tuple.rs
@@ -4,58 +4,58 @@
 
 // === GDB TESTS ===================================================================================
 
-// gdbr-command:print simple_tuple::NO_PADDING_8
-// gdbr-check:$1 = (-50, 50)
-// gdbr-command:print simple_tuple::NO_PADDING_16
-// gdbr-check:$2 = (-1, 2, 3)
-// gdbr-command:print simple_tuple::NO_PADDING_32
-// gdbr-check:$3 = (4, 5, 6)
-// gdbr-command:print simple_tuple::NO_PADDING_64
-// gdbr-check:$4 = (7, 8, 9)
-
-// gdbr-command:print simple_tuple::INTERNAL_PADDING_1
-// gdbr-check:$5 = (10, 11)
-// gdbr-command:print simple_tuple::INTERNAL_PADDING_2
-// gdbr-check:$6 = (12, 13, 14, 15)
-
-// gdbr-command:print simple_tuple::PADDING_AT_END
-// gdbr-check:$7 = (16, 17)
+// gdb-command:print simple_tuple::NO_PADDING_8
+// gdb-check:$1 = (-50, 50)
+// gdb-command:print simple_tuple::NO_PADDING_16
+// gdb-check:$2 = (-1, 2, 3)
+// gdb-command:print simple_tuple::NO_PADDING_32
+// gdb-check:$3 = (4, 5, 6)
+// gdb-command:print simple_tuple::NO_PADDING_64
+// gdb-check:$4 = (7, 8, 9)
+
+// gdb-command:print simple_tuple::INTERNAL_PADDING_1
+// gdb-check:$5 = (10, 11)
+// gdb-command:print simple_tuple::INTERNAL_PADDING_2
+// gdb-check:$6 = (12, 13, 14, 15)
+
+// gdb-command:print simple_tuple::PADDING_AT_END
+// gdb-check:$7 = (16, 17)
 
 // gdb-command:run
 
-// gdbr-command:print noPadding8
-// gdbr-check:$8 = (-100, 100)
+// gdb-command:print noPadding8
+// gdb-check:$8 = (-100, 100)
 // gdb-command:print noPadding16
-// gdbr-check:$9 = (0, 1, 2)
+// gdb-check:$9 = (0, 1, 2)
 // gdb-command:print noPadding32
-// gdbr-check:$10 = (3, 4.5, 5)
+// gdb-check:$10 = (3, 4.5, 5)
 // gdb-command:print noPadding64
-// gdbr-check:$11 = (6, 7.5, 8)
+// gdb-check:$11 = (6, 7.5, 8)
 
 // gdb-command:print internalPadding1
-// gdbr-check:$12 = (9, 10)
+// gdb-check:$12 = (9, 10)
 // gdb-command:print internalPadding2
-// gdbr-check:$13 = (11, 12, 13, 14)
+// gdb-check:$13 = (11, 12, 13, 14)
 
 // gdb-command:print paddingAtEnd
-// gdbr-check:$14 = (15, 16)
-
-// gdbr-command:print simple_tuple::NO_PADDING_8
-// gdbr-check:$15 = (-127, 127)
-// gdbr-command:print simple_tuple::NO_PADDING_16
-// gdbr-check:$16 = (-10, 10, 9)
-// gdbr-command:print simple_tuple::NO_PADDING_32
-// gdbr-check:$17 = (14, 15, 16)
-// gdbr-command:print simple_tuple::NO_PADDING_64
-// gdbr-check:$18 = (17, 18, 19)
-
-// gdbr-command:print simple_tuple::INTERNAL_PADDING_1
-// gdbr-check:$19 = (110, 111)
-// gdbr-command:print simple_tuple::INTERNAL_PADDING_2
-// gdbr-check:$20 = (112, 113, 114, 115)
-
-// gdbr-command:print simple_tuple::PADDING_AT_END
-// gdbr-check:$21 = (116, 117)
+// gdb-check:$14 = (15, 16)
+
+// gdb-command:print simple_tuple::NO_PADDING_8
+// gdb-check:$15 = (-127, 127)
+// gdb-command:print simple_tuple::NO_PADDING_16
+// gdb-check:$16 = (-10, 10, 9)
+// gdb-command:print simple_tuple::NO_PADDING_32
+// gdb-check:$17 = (14, 15, 16)
+// gdb-command:print simple_tuple::NO_PADDING_64
+// gdb-check:$18 = (17, 18, 19)
+
+// gdb-command:print simple_tuple::INTERNAL_PADDING_1
+// gdb-check:$19 = (110, 111)
+// gdb-command:print simple_tuple::INTERNAL_PADDING_2
+// gdb-check:$20 = (112, 113, 114, 115)
+
+// gdb-command:print simple_tuple::PADDING_AT_END
+// gdb-check:$21 = (116, 117)
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/strings-and-strs.rs b/tests/debuginfo/strings-and-strs.rs
index 2d29ac12bd8a0..c109b40230097 100644
--- a/tests/debuginfo/strings-and-strs.rs
+++ b/tests/debuginfo/strings-and-strs.rs
@@ -7,19 +7,19 @@
 // gdb-command:run
 
 // gdb-command:print plain_string
-// gdbr-check:$1 = alloc::string::String {vec: alloc::vec::Vec<u8, alloc::alloc::Global> {buf: alloc::raw_vec::RawVec<u8, alloc::alloc::Global> {inner: alloc::raw_vec::RawVecInner<alloc::alloc::Global> {ptr: core::ptr::unique::Unique<u8> {pointer: core::ptr::non_null::NonNull<u8> {pointer: 0x[...]}, _marker: core::marker::PhantomData<u8>}, cap: alloc::raw_vec::Cap (5), alloc: alloc::alloc::Global}, _marker: core::marker::PhantomData<u8>}, len: 5}}
+// gdb-check:$1 = alloc::string::String {vec: alloc::vec::Vec<u8, alloc::alloc::Global> {buf: alloc::raw_vec::RawVec<u8, alloc::alloc::Global> {inner: alloc::raw_vec::RawVecInner<alloc::alloc::Global> {ptr: core::ptr::unique::Unique<u8> {pointer: core::ptr::non_null::NonNull<u8> {pointer: 0x[...]}, _marker: core::marker::PhantomData<u8>}, cap: alloc::raw_vec::Cap (5), alloc: alloc::alloc::Global}, _marker: core::marker::PhantomData<u8>}, len: 5}}
 
 // gdb-command:print plain_str
-// gdbr-check:$2 = "Hello"
+// gdb-check:$2 = "Hello"
 
 // gdb-command:print str_in_struct
-// gdbr-check:$3 = strings_and_strs::Foo {inner: "Hello"}
+// gdb-check:$3 = strings_and_strs::Foo {inner: "Hello"}
 
 // gdb-command:print str_in_tuple
-// gdbr-check:$4 = ("Hello", "World")
+// gdb-check:$4 = ("Hello", "World")
 
 // gdb-command:print str_in_rc
-// gdbr-check:$5 = alloc::rc::Rc<&str, alloc::alloc::Global> {ptr: core::ptr::non_null::NonNull<alloc::rc::RcBox<&str>> {pointer: 0x[...]}, phantom: core::marker::PhantomData<alloc::rc::RcBox<&str>>, alloc: alloc::alloc::Global}
+// gdb-check:$5 = alloc::rc::Rc<&str, alloc::alloc::Global> {ptr: core::ptr::non_null::NonNull<alloc::rc::RcBox<&str>> {pointer: 0x[...]}, phantom: core::marker::PhantomData<alloc::rc::RcBox<&str>>, alloc: alloc::alloc::Global}
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/struct-in-enum.rs b/tests/debuginfo/struct-in-enum.rs
index 9e97741444e86..8d7ad93e0a214 100644
--- a/tests/debuginfo/struct-in-enum.rs
+++ b/tests/debuginfo/struct-in-enum.rs
@@ -9,13 +9,13 @@
 // gdb-command:run
 
 // gdb-command:print case1
-// gdbr-check:$1 = struct_in_enum::Regular::Case1(0, struct_in_enum::Struct {x: 2088533116, y: 2088533116, z: 31868})
+// gdb-check:$1 = struct_in_enum::Regular::Case1(0, struct_in_enum::Struct {x: 2088533116, y: 2088533116, z: 31868})
 
 // gdb-command:print case2
-// gdbr-check:$2 = struct_in_enum::Regular::Case2(0, 1229782938247303441, 4369)
+// gdb-check:$2 = struct_in_enum::Regular::Case2(0, 1229782938247303441, 4369)
 
 // gdb-command:print univariant
-// gdbr-check:$3 = struct_in_enum::Univariant::TheOnlyCase(struct_in_enum::Struct {x: 123, y: 456, z: 789})
+// gdb-check:$3 = struct_in_enum::Univariant::TheOnlyCase(struct_in_enum::Struct {x: 123, y: 456, z: 789})
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/struct-in-struct.rs b/tests/debuginfo/struct-in-struct.rs
index 0025f571aa78d..75141e28e4988 100644
--- a/tests/debuginfo/struct-in-struct.rs
+++ b/tests/debuginfo/struct-in-struct.rs
@@ -7,13 +7,13 @@
 // gdb-command:run
 
 // gdb-command:print three_simple_structs
-// gdbr-check:$1 = struct_in_struct::ThreeSimpleStructs {x: struct_in_struct::Simple {x: 1}, y: struct_in_struct::Simple {x: 2}, z: struct_in_struct::Simple {x: 3}}
+// gdb-check:$1 = struct_in_struct::ThreeSimpleStructs {x: struct_in_struct::Simple {x: 1}, y: struct_in_struct::Simple {x: 2}, z: struct_in_struct::Simple {x: 3}}
 
 // gdb-command:print internal_padding_parent
-// gdbr-check:$2 = struct_in_struct::InternalPaddingParent {x: struct_in_struct::InternalPadding {x: 4, y: 5}, y: struct_in_struct::InternalPadding {x: 6, y: 7}, z: struct_in_struct::InternalPadding {x: 8, y: 9}}
+// gdb-check:$2 = struct_in_struct::InternalPaddingParent {x: struct_in_struct::InternalPadding {x: 4, y: 5}, y: struct_in_struct::InternalPadding {x: 6, y: 7}, z: struct_in_struct::InternalPadding {x: 8, y: 9}}
 
 // gdb-command:print padding_at_end_parent
-// gdbr-check:$3 = struct_in_struct::PaddingAtEndParent {x: struct_in_struct::PaddingAtEnd {x: 10, y: 11}, y: struct_in_struct::PaddingAtEnd {x: 12, y: 13}, z: struct_in_struct::PaddingAtEnd {x: 14, y: 15}}
+// gdb-check:$3 = struct_in_struct::PaddingAtEndParent {x: struct_in_struct::PaddingAtEnd {x: 10, y: 11}, y: struct_in_struct::PaddingAtEnd {x: 12, y: 13}, z: struct_in_struct::PaddingAtEnd {x: 14, y: 15}}
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/struct-style-enum.rs b/tests/debuginfo/struct-style-enum.rs
index 42368017cae69..7c5846ea350f5 100644
--- a/tests/debuginfo/struct-style-enum.rs
+++ b/tests/debuginfo/struct-style-enum.rs
@@ -9,16 +9,16 @@
 // gdb-command:run
 
 // gdb-command:print case1
-// gdbr-check:$1 = struct_style_enum::Regular::Case1{a: 0, b: 31868, c: 31868, d: 31868, e: 31868}
+// gdb-check:$1 = struct_style_enum::Regular::Case1{a: 0, b: 31868, c: 31868, d: 31868, e: 31868}
 
 // gdb-command:print case2
-// gdbr-check:$2 = struct_style_enum::Regular::Case2{a: 0, b: 286331153, c: 286331153}
+// gdb-check:$2 = struct_style_enum::Regular::Case2{a: 0, b: 286331153, c: 286331153}
 
 // gdb-command:print case3
-// gdbr-check:$3 = struct_style_enum::Regular::Case3{a: 0, b: 6438275382588823897}
+// gdb-check:$3 = struct_style_enum::Regular::Case3{a: 0, b: 6438275382588823897}
 
 // gdb-command:print univariant
-// gdbr-check:$4 = struct_style_enum::Univariant::TheOnlyCase{a: -1}
+// gdb-check:$4 = struct_style_enum::Univariant::TheOnlyCase{a: -1}
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/struct-with-destructor.rs b/tests/debuginfo/struct-with-destructor.rs
index 8d854369d686e..17dc6edd36574 100644
--- a/tests/debuginfo/struct-with-destructor.rs
+++ b/tests/debuginfo/struct-with-destructor.rs
@@ -6,16 +6,16 @@
 
 // gdb-command:run
 // gdb-command:print simple
-// gdbr-check:$1 = struct_with_destructor::WithDestructor {x: 10, y: 20}
+// gdb-check:$1 = struct_with_destructor::WithDestructor {x: 10, y: 20}
 
 // gdb-command:print noDestructor
-// gdbr-check:$2 = struct_with_destructor::NoDestructorGuarded {a: struct_with_destructor::NoDestructor {x: 10, y: 20}, guard: -1}
+// gdb-check:$2 = struct_with_destructor::NoDestructorGuarded {a: struct_with_destructor::NoDestructor {x: 10, y: 20}, guard: -1}
 
 // gdb-command:print withDestructor
-// gdbr-check:$3 = struct_with_destructor::WithDestructorGuarded {a: struct_with_destructor::WithDestructor {x: 10, y: 20}, guard: -1}
+// gdb-check:$3 = struct_with_destructor::WithDestructorGuarded {a: struct_with_destructor::WithDestructor {x: 10, y: 20}, guard: -1}
 
 // gdb-command:print nested
-// gdbr-check:$4 = struct_with_destructor::NestedOuter {a: struct_with_destructor::NestedInner {a: struct_with_destructor::WithDestructor {x: 7890, y: 9870}}}
+// gdb-check:$4 = struct_with_destructor::NestedOuter {a: struct_with_destructor::NestedInner {a: struct_with_destructor::WithDestructor {x: 7890, y: 9870}}}
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/tuple-in-struct.rs b/tests/debuginfo/tuple-in-struct.rs
index 11175c73f55b5..afda586c1544c 100644
--- a/tests/debuginfo/tuple-in-struct.rs
+++ b/tests/debuginfo/tuple-in-struct.rs
@@ -5,29 +5,29 @@
 // gdb-command:run
 
 // gdb-command:print no_padding1
-// gdbr-check:$1 = tuple_in_struct::NoPadding1 {x: (0, 1), y: 2, z: (3, 4, 5)}
+// gdb-check:$1 = tuple_in_struct::NoPadding1 {x: (0, 1), y: 2, z: (3, 4, 5)}
 // gdb-command:print no_padding2
-// gdbr-check:$2 = tuple_in_struct::NoPadding2 {x: (6, 7), y: ((8, 9), 10)}
+// gdb-check:$2 = tuple_in_struct::NoPadding2 {x: (6, 7), y: ((8, 9), 10)}
 
 // gdb-command:print tuple_internal_padding
-// gdbr-check:$3 = tuple_in_struct::TupleInternalPadding {x: (11, 12), y: (13, 14)}
+// gdb-check:$3 = tuple_in_struct::TupleInternalPadding {x: (11, 12), y: (13, 14)}
 // gdb-command:print struct_internal_padding
-// gdbr-check:$4 = tuple_in_struct::StructInternalPadding {x: (15, 16), y: (17, 18)}
+// gdb-check:$4 = tuple_in_struct::StructInternalPadding {x: (15, 16), y: (17, 18)}
 // gdb-command:print both_internally_padded
-// gdbr-check:$5 = tuple_in_struct::BothInternallyPadded {x: (19, 20, 21), y: (22, 23)}
+// gdb-check:$5 = tuple_in_struct::BothInternallyPadded {x: (19, 20, 21), y: (22, 23)}
 
 // gdb-command:print single_tuple
-// gdbr-check:$6 = tuple_in_struct::SingleTuple {x: (24, 25, 26)}
+// gdb-check:$6 = tuple_in_struct::SingleTuple {x: (24, 25, 26)}
 
 // gdb-command:print tuple_padded_at_end
-// gdbr-check:$7 = tuple_in_struct::TuplePaddedAtEnd {x: (27, 28), y: (29, 30)}
+// gdb-check:$7 = tuple_in_struct::TuplePaddedAtEnd {x: (27, 28), y: (29, 30)}
 // gdb-command:print struct_padded_at_end
-// gdbr-check:$8 = tuple_in_struct::StructPaddedAtEnd {x: (31, 32), y: (33, 34)}
+// gdb-check:$8 = tuple_in_struct::StructPaddedAtEnd {x: (31, 32), y: (33, 34)}
 // gdb-command:print both_padded_at_end
-// gdbr-check:$9 = tuple_in_struct::BothPaddedAtEnd {x: (35, 36, 37), y: (38, 39)}
+// gdb-check:$9 = tuple_in_struct::BothPaddedAtEnd {x: (35, 36, 37), y: (38, 39)}
 
 // gdb-command:print mixed_padding
-// gdbr-check:$10 = tuple_in_struct::MixedPadding {x: ((40, 41, 42), (43, 44)), y: (45, 46, 47, 48)}
+// gdb-check:$10 = tuple_in_struct::MixedPadding {x: ((40, 41, 42), (43, 44)), y: (45, 46, 47, 48)}
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/tuple-in-tuple.rs b/tests/debuginfo/tuple-in-tuple.rs
index 98bded68b14ef..24147e6ce0e45 100644
--- a/tests/debuginfo/tuple-in-tuple.rs
+++ b/tests/debuginfo/tuple-in-tuple.rs
@@ -7,21 +7,21 @@
 // gdb-command:run
 
 // gdb-command:print no_padding1
-// gdbr-check:$1 = ((0, 1), 2, 3)
+// gdb-check:$1 = ((0, 1), 2, 3)
 // gdb-command:print no_padding2
-// gdbr-check:$2 = (4, (5, 6), 7)
+// gdb-check:$2 = (4, (5, 6), 7)
 // gdb-command:print no_padding3
-// gdbr-check:$3 = (8, 9, (10, 11))
+// gdb-check:$3 = (8, 9, (10, 11))
 
 // gdb-command:print internal_padding1
-// gdbr-check:$4 = (12, (13, 14))
+// gdb-check:$4 = (12, (13, 14))
 // gdb-command:print internal_padding2
-// gdbr-check:$5 = (15, (16, 17))
+// gdb-check:$5 = (15, (16, 17))
 
 // gdb-command:print padding_at_end1
-// gdbr-check:$6 = (18, (19, 20))
+// gdb-check:$6 = (18, (19, 20))
 // gdb-command:print padding_at_end2
-// gdbr-check:$7 = ((21, 22), 23)
+// gdb-check:$7 = ((21, 22), 23)
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/tuple-struct.rs b/tests/debuginfo/tuple-struct.rs
index a3e88c0f92660..8c546be07c37d 100644
--- a/tests/debuginfo/tuple-struct.rs
+++ b/tests/debuginfo/tuple-struct.rs
@@ -7,22 +7,22 @@
 // gdb-command:run
 
 // gdb-command:print no_padding16
-// gdbr-check:$1 = tuple_struct::NoPadding16 (10000, -10001)
+// gdb-check:$1 = tuple_struct::NoPadding16 (10000, -10001)
 
 // gdb-command:print no_padding32
-// gdbr-check:$2 = tuple_struct::NoPadding32 (-10002, -10003.5, 10004)
+// gdb-check:$2 = tuple_struct::NoPadding32 (-10002, -10003.5, 10004)
 
 // gdb-command:print no_padding64
-// gdbr-check:$3 = tuple_struct::NoPadding64 (-10005.5, 10006, 10007)
+// gdb-check:$3 = tuple_struct::NoPadding64 (-10005.5, 10006, 10007)
 
 // gdb-command:print no_padding163264
-// gdbr-check:$4 = tuple_struct::NoPadding163264 (-10008, 10009, 10010, 10011)
+// gdb-check:$4 = tuple_struct::NoPadding163264 (-10008, 10009, 10010, 10011)
 
 // gdb-command:print internal_padding
-// gdbr-check:$5 = tuple_struct::InternalPadding (10012, -10013)
+// gdb-check:$5 = tuple_struct::InternalPadding (10012, -10013)
 
 // gdb-command:print padding_at_end
-// gdbr-check:$6 = tuple_struct::PaddingAtEnd (-10014, 10015)
+// gdb-check:$6 = tuple_struct::PaddingAtEnd (-10014, 10015)
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/tuple-style-enum.rs b/tests/debuginfo/tuple-style-enum.rs
index 3de4ecb128494..f231f3e059874 100644
--- a/tests/debuginfo/tuple-style-enum.rs
+++ b/tests/debuginfo/tuple-style-enum.rs
@@ -10,16 +10,16 @@
 // gdb-command:run
 
 // gdb-command:print case1
-// gdbr-check:$1 = tuple_style_enum::Regular::Case1(0, 31868, 31868, 31868, 31868)
+// gdb-check:$1 = tuple_style_enum::Regular::Case1(0, 31868, 31868, 31868, 31868)
 
 // gdb-command:print case2
-// gdbr-check:$2 = tuple_style_enum::Regular::Case2(0, 286331153, 286331153)
+// gdb-check:$2 = tuple_style_enum::Regular::Case2(0, 286331153, 286331153)
 
 // gdb-command:print case3
-// gdbr-check:$3 = tuple_style_enum::Regular::Case3(0, 6438275382588823897)
+// gdb-check:$3 = tuple_style_enum::Regular::Case3(0, 6438275382588823897)
 
 // gdb-command:print univariant
-// gdbr-check:$4 = tuple_style_enum::Univariant::TheOnlyCase(-1)
+// gdb-check:$4 = tuple_style_enum::Univariant::TheOnlyCase(-1)
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs
index cd2c9a1397300..f14437b1c3fbe 100644
--- a/tests/debuginfo/union-smoke.rs
+++ b/tests/debuginfo/union-smoke.rs
@@ -8,9 +8,9 @@
 
 // gdb-command:run
 // gdb-command:print u
-// gdbr-check:$1 = union_smoke::U {a: (2, 2), b: 514}
+// gdb-check:$1 = union_smoke::U {a: (2, 2), b: 514}
 // gdb-command:print union_smoke::SU
-// gdbr-check:$2 = union_smoke::U {a: (1, 1), b: 257}
+// gdb-check:$2 = union_smoke::U {a: (1, 1), b: 257}
 
 // === LLDB TESTS ==================================================================================
 
diff --git a/tests/debuginfo/unique-enum.rs b/tests/debuginfo/unique-enum.rs
index 514c7c50812c6..fcfbe856123e7 100644
--- a/tests/debuginfo/unique-enum.rs
+++ b/tests/debuginfo/unique-enum.rs
@@ -9,13 +9,13 @@
 // gdb-command:run
 
 // gdb-command:print *the_a
-// gdbr-check:$1 = unique_enum::ABC::TheA{x: 0, y: 8970181431921507452}
+// gdb-check:$1 = unique_enum::ABC::TheA{x: 0, y: 8970181431921507452}
 
 // gdb-command:print *the_b
-// gdbr-check:$2 = unique_enum::ABC::TheB(0, 286331153, 286331153)
+// gdb-check:$2 = unique_enum::ABC::TheB(0, 286331153, 286331153)
 
 // gdb-command:print *univariant
-// gdbr-check:$3 = unique_enum::Univariant::TheOnlyCase(123234)
+// gdb-check:$3 = unique_enum::Univariant::TheOnlyCase(123234)
 
 
 // === LLDB TESTS ==================================================================================
diff --git a/tests/debuginfo/unsized.rs b/tests/debuginfo/unsized.rs
index ee6fe22c6b8d1..acfe511be7c04 100644
--- a/tests/debuginfo/unsized.rs
+++ b/tests/debuginfo/unsized.rs
@@ -7,22 +7,22 @@
 // gdb-command:run
 
 // gdb-command:print a
-// gdbr-check:$1 = &unsized::Foo<[u8]> {data_ptr: [...], length: 4}
+// gdb-check:$1 = &unsized::Foo<[u8]> {data_ptr: [...], length: 4}
 
 // gdb-command:print b
-// gdbr-check:$2 = &unsized::Foo<unsized::Foo<[u8]>> {data_ptr: [...], length: 4}
+// gdb-check:$2 = &unsized::Foo<unsized::Foo<[u8]>> {data_ptr: [...], length: 4}
 
 // gdb-command:print c
-// gdbr-check:$3 = &unsized::Foo<dyn core::fmt::Debug> {pointer: [...], vtable: [...]}
+// gdb-check:$3 = &unsized::Foo<dyn core::fmt::Debug> {pointer: [...], vtable: [...]}
 
 // gdb-command:print _box
-// gdbr-check:$4 = alloc::boxed::Box<unsized::Foo<dyn core::fmt::Debug>, alloc::alloc::Global> {pointer: [...], vtable: [...]}
+// gdb-check:$4 = alloc::boxed::Box<unsized::Foo<dyn core::fmt::Debug>, alloc::alloc::Global> {pointer: [...], vtable: [...]}
 
 // gdb-command:print tuple_slice
-// gdbr-check:$5 = &(i32, i32, [i32]) {data_ptr: [...], length: 2}
+// gdb-check:$5 = &(i32, i32, [i32]) {data_ptr: [...], length: 2}
 
 // gdb-command:print tuple_dyn
-// gdbr-check:$6 = &(i32, i32, dyn core::fmt::Debug) {pointer: [...], vtable: [...]}
+// gdb-check:$6 = &(i32, i32, dyn core::fmt::Debug) {pointer: [...], vtable: [...]}
 
 // === CDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/var-captured-in-nested-closure.rs b/tests/debuginfo/var-captured-in-nested-closure.rs
index e2974f418ae98..5183245ad5dc1 100644
--- a/tests/debuginfo/var-captured-in-nested-closure.rs
+++ b/tests/debuginfo/var-captured-in-nested-closure.rs
@@ -11,9 +11,9 @@
 // gdb-command:print constant
 // gdb-check:$2 = 2
 // gdb-command:print a_struct
-// gdbr-check:$3 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
+// gdb-check:$3 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *struct_ref
-// gdbr-check:$4 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
+// gdb-check:$4 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *owned
 // gdb-check:$5 = 6
 // gdb-command:print closure_local
@@ -25,9 +25,9 @@
 // gdb-command:print constant
 // gdb-check:$8 = 2
 // gdb-command:print a_struct
-// gdbr-check:$9 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
+// gdb-check:$9 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *struct_ref
-// gdbr-check:$10 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
+// gdb-check:$10 = var_captured_in_nested_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *owned
 // gdb-check:$11 = 6
 // gdb-command:print closure_local
diff --git a/tests/debuginfo/var-captured-in-sendable-closure.rs b/tests/debuginfo/var-captured-in-sendable-closure.rs
index 1029ab6b788b7..094639ebf20c2 100644
--- a/tests/debuginfo/var-captured-in-sendable-closure.rs
+++ b/tests/debuginfo/var-captured-in-sendable-closure.rs
@@ -9,7 +9,7 @@
 // gdb-command:print constant
 // gdb-check:$1 = 1
 // gdb-command:print a_struct
-// gdbr-check:$2 = var_captured_in_sendable_closure::Struct {a: -2, b: 3.5, c: 4}
+// gdb-check:$2 = var_captured_in_sendable_closure::Struct {a: -2, b: 3.5, c: 4}
 // gdb-command:print *owned
 // gdb-check:$3 = 5
 // gdb-command:continue
diff --git a/tests/debuginfo/var-captured-in-stack-closure.rs b/tests/debuginfo/var-captured-in-stack-closure.rs
index baa784e5c4591..ca10cdcb518e5 100644
--- a/tests/debuginfo/var-captured-in-stack-closure.rs
+++ b/tests/debuginfo/var-captured-in-stack-closure.rs
@@ -11,9 +11,9 @@
 // gdb-command:print constant
 // gdb-check:$2 = 2
 // gdb-command:print a_struct
-// gdbr-check:$3 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
+// gdb-check:$3 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *struct_ref
-// gdbr-check:$4 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
+// gdb-check:$4 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *owned
 // gdb-check:$5 = 6
 
@@ -24,9 +24,9 @@
 // gdb-command:print constant
 // gdb-check:$7 = 2
 // gdb-command:print a_struct
-// gdbr-check:$8 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
+// gdb-check:$8 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *struct_ref
-// gdbr-check:$9 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
+// gdb-check:$9 = var_captured_in_stack_closure::Struct {a: -3, b: 4.5, c: 5}
 // gdb-command:print *owned
 // gdb-check:$10 = 6
 
diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs
index 9d7e3eef8045f..13342abf5d0e3 100644
--- a/tests/debuginfo/vec-slices.rs
+++ b/tests/debuginfo/vec-slices.rs
@@ -12,49 +12,49 @@
 
 // gdb-command:print singleton.length
 // gdb-check:$2 = 1
-// gdbr-command:print *(singleton.data_ptr as *const [i64; 1])
-// gdbr-check:$3 = [1]
+// gdb-command:print *(singleton.data_ptr as *const [i64; 1])
+// gdb-check:$3 = [1]
 
 // gdb-command:print multiple.length
 // gdb-check:$4 = 4
-// gdbr-command:print *(multiple.data_ptr as *const [i64; 4])
-// gdbr-check:$5 = [2, 3, 4, 5]
+// gdb-command:print *(multiple.data_ptr as *const [i64; 4])
+// gdb-check:$5 = [2, 3, 4, 5]
 
 // gdb-command:print slice_of_slice.length
 // gdb-check:$6 = 2
-// gdbr-command:print *(slice_of_slice.data_ptr as *const [i64; 2])
-// gdbr-check:$7 = [3, 4]
+// gdb-command:print *(slice_of_slice.data_ptr as *const [i64; 2])
+// gdb-check:$7 = [3, 4]
 
 // gdb-command:print padded_tuple.length
 // gdb-check:$8 = 2
 // gdb-command:print padded_tuple.data_ptr[0]
-// gdbr-check:$9 = (6, 7)
+// gdb-check:$9 = (6, 7)
 // gdb-command:print padded_tuple.data_ptr[1]
-// gdbr-check:$10 = (8, 9)
+// gdb-check:$10 = (8, 9)
 
 // gdb-command:print padded_struct.length
 // gdb-check:$11 = 2
 // gdb-command:print padded_struct.data_ptr[0]
-// gdbr-check:$12 = vec_slices::AStruct {x: 10, y: 11, z: 12}
+// gdb-check:$12 = vec_slices::AStruct {x: 10, y: 11, z: 12}
 // gdb-command:print padded_struct.data_ptr[1]
-// gdbr-check:$13 = vec_slices::AStruct {x: 13, y: 14, z: 15}
+// gdb-check:$13 = vec_slices::AStruct {x: 13, y: 14, z: 15}
 
 // gdb-command:print mut_slice.length
 // gdb-check:$14 = 5
-// gdbr-command:print *(mut_slice.data_ptr as *const [i64; 5])
-// gdbr-check:$15 = [1, 2, 3, 4, 5]
+// gdb-command:print *(mut_slice.data_ptr as *const [i64; 5])
+// gdb-check:$15 = [1, 2, 3, 4, 5]
 
 // Some lines below are marked with [ignored] because old GDB versions seem to have trouble
 // accessing globals.
 
 // [ignored] gdbg-command:print 'vec_slices::MUT_VECT_SLICE'.length
-// gdbr-command:print MUT_VECT_SLICE.length
+// gdb-command:print MUT_VECT_SLICE.length
 // [ignored] gdbg-check:$16 = 2
-// gdbr-check:$16 = 2
+// gdb-check:$16 = 2
 // [ignored] gdbg-command:print *((i64[2]*)('vec_slices::MUT_VECT_SLICE'.data_ptr))
-// gdbr-command:print *(MUT_VECT_SLICE.data_ptr as *const [i64; 2])
+// gdb-command:print *(MUT_VECT_SLICE.data_ptr as *const [i64; 2])
 // [ignored] gdbg-check:$17 = {64, 65}
-// gdbr-check:$17 = [64, 65]
+// gdb-check:$17 = [64, 65]
 
 // === LLDB TESTS ==================================================================================
 
diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs
index bc1f995ce0e1b..7b9054639a8d9 100644
--- a/tests/debuginfo/vec.rs
+++ b/tests/debuginfo/vec.rs
@@ -6,9 +6,9 @@
 
 // gdb-command:run
 // gdb-command:print a
-// gdbr-check:$1 = [1, 2, 3]
+// gdb-check:$1 = [1, 2, 3]
 // gdb-command:print vec::VECT
-// gdbr-check:$2 = [4, 5, 6]
+// gdb-check:$2 = [4, 5, 6]
 
 
 // === LLDB TESTS ==================================================================================

From 95ae9b8c841947adcd0a530f9fb94c70cc325f7e Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sat, 17 Aug 2024 17:34:11 -0400
Subject: [PATCH 401/685] Fix up a special case

---
 tests/debuginfo/vec-slices.rs | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs
index 13342abf5d0e3..18ff6c743228e 100644
--- a/tests/debuginfo/vec-slices.rs
+++ b/tests/debuginfo/vec-slices.rs
@@ -44,16 +44,9 @@
 // gdb-command:print *(mut_slice.data_ptr as *const [i64; 5])
 // gdb-check:$15 = [1, 2, 3, 4, 5]
 
-// Some lines below are marked with [ignored] because old GDB versions seem to have trouble
-// accessing globals.
-
-// [ignored] gdbg-command:print 'vec_slices::MUT_VECT_SLICE'.length
 // gdb-command:print MUT_VECT_SLICE.length
-// [ignored] gdbg-check:$16 = 2
 // gdb-check:$16 = 2
-// [ignored] gdbg-command:print *((i64[2]*)('vec_slices::MUT_VECT_SLICE'.data_ptr))
 // gdb-command:print *(MUT_VECT_SLICE.data_ptr as *const [i64; 2])
-// [ignored] gdbg-check:$17 = {64, 65}
 // gdb-check:$17 = [64, 65]
 
 // === LLDB TESTS ==================================================================================

From e1a82c96341747e486c72139748d3bc3d538f669 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sat, 17 Aug 2024 17:37:09 -0400
Subject: [PATCH 402/685] Delete compiletest support for gdbg

---
 src/tools/compiletest/src/runtest.rs | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 59fce44d1c725..394f24e6f359b 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -856,17 +856,7 @@ impl<'test> TestCx<'test> {
     }
 
     fn run_debuginfo_gdb_test_no_opt(&self) {
-        let prefixes = if self.config.gdb_native_rust {
-            // GDB with Rust
-            static PREFIXES: &[&str] = &["gdb", "gdbr"];
-            println!("NOTE: compiletest thinks it is using GDB with native rust support");
-            PREFIXES
-        } else {
-            // Generic GDB
-            static PREFIXES: &[&str] = &["gdb", "gdbg"];
-            println!("NOTE: compiletest thinks it is using GDB without native rust support");
-            PREFIXES
-        };
+        let prefixes = &["gdb"];
 
         let dbg_cmds = DebuggerCommands::parse_from(
             &self.testpaths.file,

From 4e6fc6fa052d3278a5bf11ba805d292f5a5ecb4a Mon Sep 17 00:00:00 2001
From: sobolevn <mail@sobolevn.me>
Date: Sun, 18 Aug 2024 19:40:56 +0300
Subject: [PATCH 403/685] Improve `collapsible_match` error message syntax

---
 clippy_lints/src/matches/collapsible_match.rs | 2 +-
 tests/ui/collapsible_match.stderr             | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/matches/collapsible_match.rs b/clippy_lints/src/matches/collapsible_match.rs
index 90cfdecc19936..b666e77c09ecb 100644
--- a/clippy_lints/src/matches/collapsible_match.rs
+++ b/clippy_lints/src/matches/collapsible_match.rs
@@ -96,7 +96,7 @@ fn check_arm<'tcx>(
         // collapsing patterns need an explicit field name in struct pattern matching
         // ex: Struct {x: Some(1)}
         let replace_msg = if is_innermost_parent_pat_struct {
-            format!(", prefixed by {}:", snippet(cx, binding_span, "their field name"))
+            format!(", prefixed by `{}`:", snippet(cx, binding_span, "their field name"))
         } else {
             String::new()
         };
diff --git a/tests/ui/collapsible_match.stderr b/tests/ui/collapsible_match.stderr
index 01944baee79af..1da78b56239c7 100644
--- a/tests/ui/collapsible_match.stderr
+++ b/tests/ui/collapsible_match.stderr
@@ -223,7 +223,7 @@ help: the outer pattern can be modified to include the inner pattern
 LL |     if let Issue9647::A { a, .. } = x {
    |                           ^ replace this binding
 LL |         if let Some(u) = a {
-   |                ^^^^^^^ with this pattern, prefixed by a:
+   |                ^^^^^^^ with this pattern, prefixed by `a`:
 
 error: this `if let` can be collapsed into the outer `if let`
   --> tests/ui/collapsible_match.rs:292:9

From dc4766536b892e91d8d499e9da7facc3006bf922 Mon Sep 17 00:00:00 2001
From: Samuel Moelius <35515885+smoelius@users.noreply.github.com>
Date: Sun, 18 Aug 2024 13:14:09 -0400
Subject: [PATCH 404/685] Typo

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

diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 6599e70346117..6c7125b75dbad 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1395,7 +1395,7 @@ pub struct LetExpr<'hir> {
     pub pat: &'hir Pat<'hir>,
     pub ty: Option<&'hir Ty<'hir>>,
     pub init: &'hir Expr<'hir>,
-    /// `Recovered::Yes` when this let expressions is not in a syntanctically valid location.
+    /// `Recovered::Yes` when this let expressions is not in a syntactically valid location.
     /// Used to prevent building MIR in such situations.
     pub recovered: ast::Recovered,
 }

From 3a9bf4551374893fdc522572ee569028186e22cc Mon Sep 17 00:00:00 2001
From: Goldstein <root@goldstein.rs>
Date: Sun, 18 Aug 2024 17:11:47 +0300
Subject: [PATCH 405/685] Check that `#[may_dangle]` is properly applied

It's only valid when applied to a type or lifetime parameter
in `Drop` trait implementation.
---
 compiler/rustc_passes/messages.ftl      |  3 ++
 compiler/rustc_passes/src/check_attr.rs | 23 ++++++++++-
 compiler/rustc_passes/src/errors.rs     |  7 ++++
 tests/ui/attributes/may_dangle.rs       | 53 +++++++++++++++++++++++++
 tests/ui/attributes/may_dangle.stderr   | 50 +++++++++++++++++++++++
 5 files changed, 135 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/attributes/may_dangle.rs
 create mode 100644 tests/ui/attributes/may_dangle.stderr

diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 1ea4ca375f156..7d4f351560b00 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -444,6 +444,9 @@ passes_macro_export_on_decl_macro =
 passes_macro_use =
     `#[{$name}]` only has an effect on `extern crate` and modules
 
+passes_may_dangle =
+    `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl
+
 passes_maybe_string_interpolation = you might have meant to use string interpolation in this string literal
 passes_missing_const_err =
     attributes `#[rustc_const_unstable]` and `#[rustc_const_stable]` require the function or method to be `const`
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index a47add929ebaa..60c8c1e7a0017 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -189,6 +189,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target),
                 [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target),
                 [sym::must_use, ..] => self.check_must_use(hir_id, attr, target),
+                [sym::may_dangle, ..] => self.check_may_dangle(hir_id, attr),
                 [sym::rustc_pass_by_value, ..] => self.check_pass_by_value(attr, span, target),
                 [sym::rustc_allow_incoherent_impl, ..] => {
                     self.check_allow_incoherent_impl(attr, span, target)
@@ -255,7 +256,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | sym::cfg_attr
                     // need to be fixed
                     | sym::cfi_encoding // FIXME(cfi_encoding)
-                    | sym::may_dangle // FIXME(dropck_eyepatch)
                     | sym::pointee // FIXME(derive_smart_pointer)
                     | sym::omit_gdb_pretty_printer_section // FIXME(omit_gdb_pretty_printer_section)
                     | sym::used // handled elsewhere to restrict to static items
@@ -1373,6 +1373,27 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
+    /// Checks if `#[may_dangle]` is applied to a lifetime or type generic parameter in `Drop` impl.
+    fn check_may_dangle(&self, hir_id: HirId, attr: &Attribute) {
+        if let hir::Node::GenericParam(param) = self.tcx.hir_node(hir_id)
+            && matches!(
+                param.kind,
+                hir::GenericParamKind::Lifetime { .. } | hir::GenericParamKind::Type { .. }
+            )
+            && matches!(param.source, hir::GenericParamSource::Generics)
+            && let parent_hir_id = self.tcx.parent_hir_id(hir_id)
+            && let hir::Node::Item(item) = self.tcx.hir_node(parent_hir_id)
+            && let hir::ItemKind::Impl(impl_) = item.kind
+            && let Some(trait_) = impl_.of_trait
+            && let Some(def_id) = trait_.trait_def_id()
+            && self.tcx.is_lang_item(def_id, hir::LangItem::Drop)
+        {
+            return;
+        }
+
+        self.dcx().emit_err(errors::InvalidMayDangle { attr_span: attr.span });
+    }
+
     /// Checks if `#[cold]` is applied to a non-function.
     fn check_cold(&self, hir_id: HirId, attr: &Attribute, span: Span, target: Target) {
         match target {
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 3a043e0e3c196..ee7d097e5d387 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -737,6 +737,13 @@ pub struct NonExportedMacroInvalidAttrs {
     pub attr_span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_may_dangle)]
+pub struct InvalidMayDangle {
+    #[primary_span]
+    pub attr_span: Span,
+}
+
 #[derive(LintDiagnostic)]
 #[diag(passes_unused_duplicate)]
 pub struct UnusedDuplicate {
diff --git a/tests/ui/attributes/may_dangle.rs b/tests/ui/attributes/may_dangle.rs
new file mode 100644
index 0000000000000..209ba0e88ad18
--- /dev/null
+++ b/tests/ui/attributes/may_dangle.rs
@@ -0,0 +1,53 @@
+#![feature(dropck_eyepatch)]
+
+struct Implee1<'a, T, const N: usize>(&'a T);
+struct Implee2<'a, T, const N: usize>(&'a T);
+struct Implee3<'a, T, const N: usize>(&'a T);
+trait NotDrop {}
+
+unsafe impl<#[may_dangle] 'a, T, const N: usize> NotDrop for Implee1<'a, T, N> {}
+//~^ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl
+
+unsafe impl<'a, #[may_dangle] T, const N: usize> NotDrop for Implee2<'a, T, N> {}
+//~^ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl
+
+unsafe impl<'a, T, #[may_dangle] const N: usize> Drop for Implee1<'a, T, N> {
+    //~^ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl
+    fn drop(&mut self) {}
+}
+
+// Ok, lifetime param in a `Drop` impl.
+unsafe impl<#[may_dangle] 'a, T, const N: usize> Drop for Implee2<'a, T, N> {
+    fn drop(&mut self) {}
+}
+
+// Ok, type param in a `Drop` impl.
+unsafe impl<'a, #[may_dangle] T, const N: usize> Drop for Implee3<'a, T, N> {
+    fn drop(&mut self) {}
+}
+
+// Check that this check is not textual.
+mod fake {
+    trait Drop {
+        fn drop(&mut self);
+    }
+    struct Implee<T>(T);
+
+    unsafe impl<#[may_dangle] T> Drop for Implee<T> {
+        //~^ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl
+        fn drop(&mut self) {}
+    }
+}
+
+#[may_dangle] //~ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl
+struct Dangling;
+
+#[may_dangle] //~ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl
+impl NotDrop for () {
+}
+
+#[may_dangle] //~ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl
+fn main() {
+    #[may_dangle] //~ ERROR must be applied to a lifetime or type generic parameter in `Drop` impl
+    let () = ();
+}
diff --git a/tests/ui/attributes/may_dangle.stderr b/tests/ui/attributes/may_dangle.stderr
new file mode 100644
index 0000000000000..dc24f847f712f
--- /dev/null
+++ b/tests/ui/attributes/may_dangle.stderr
@@ -0,0 +1,50 @@
+error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl
+  --> $DIR/may_dangle.rs:8:13
+   |
+LL | unsafe impl<#[may_dangle] 'a, T, const N: usize> NotDrop for Implee1<'a, T, N> {}
+   |             ^^^^^^^^^^^^^
+
+error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl
+  --> $DIR/may_dangle.rs:11:17
+   |
+LL | unsafe impl<'a, #[may_dangle] T, const N: usize> NotDrop for Implee2<'a, T, N> {}
+   |                 ^^^^^^^^^^^^^
+
+error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl
+  --> $DIR/may_dangle.rs:14:20
+   |
+LL | unsafe impl<'a, T, #[may_dangle] const N: usize> Drop for Implee1<'a, T, N> {
+   |                    ^^^^^^^^^^^^^
+
+error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl
+  --> $DIR/may_dangle.rs:42:1
+   |
+LL | #[may_dangle]
+   | ^^^^^^^^^^^^^
+
+error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl
+  --> $DIR/may_dangle.rs:45:1
+   |
+LL | #[may_dangle]
+   | ^^^^^^^^^^^^^
+
+error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl
+  --> $DIR/may_dangle.rs:49:1
+   |
+LL | #[may_dangle]
+   | ^^^^^^^^^^^^^
+
+error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl
+  --> $DIR/may_dangle.rs:51:5
+   |
+LL |     #[may_dangle]
+   |     ^^^^^^^^^^^^^
+
+error: `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl
+  --> $DIR/may_dangle.rs:36:17
+   |
+LL |     unsafe impl<#[may_dangle] T> Drop for Implee<T> {
+   |                 ^^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
+

From df6cb954bb50fa8567f7198c02db90edda3cd3e4 Mon Sep 17 00:00:00 2001
From: Goldstein <root@goldstein.rs>
Date: Sun, 18 Aug 2024 17:15:29 +0300
Subject: [PATCH 406/685] Fix wording of misapplied `must_not_suspend` error

---
 compiler/rustc_passes/messages.ftl                | 4 ++--
 compiler/rustc_passes/src/check_attr.rs           | 2 +-
 tests/ui/lint/must_not_suspend/other_items.stderr | 4 ++--
 tests/ui/lint/must_not_suspend/return.stderr      | 4 ++--
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 7d4f351560b00..dfc726efeb998 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -478,8 +478,8 @@ passes_multiple_start_functions =
     .previous = previous `#[start]` function here
 
 passes_must_not_suspend =
-    `must_not_suspend` attribute should be applied to a struct, enum, or trait
-    .label = is not a struct, enum, or trait
+    `must_not_suspend` attribute should be applied to a struct, enum, union, or trait
+    .label = is not a struct, enum, union, or trait
 
 passes_must_use_async =
     `must_use` attribute on `async` functions applies to the anonymous `Future` returned by the function, not the value within
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 60c8c1e7a0017..e3c2999142f3b 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1363,7 +1363,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    /// Checks if `#[must_not_suspend]` is applied to a function.
+    /// Checks if `#[must_not_suspend]` is applied to a struct, enum, union, or trait.
     fn check_must_not_suspend(&self, attr: &Attribute, span: Span, target: Target) {
         match target {
             Target::Struct | Target::Enum | Target::Union | Target::Trait => {}
diff --git a/tests/ui/lint/must_not_suspend/other_items.stderr b/tests/ui/lint/must_not_suspend/other_items.stderr
index e6c36b7895109..dff5210b7e47f 100644
--- a/tests/ui/lint/must_not_suspend/other_items.stderr
+++ b/tests/ui/lint/must_not_suspend/other_items.stderr
@@ -1,10 +1,10 @@
-error: `must_not_suspend` attribute should be applied to a struct, enum, or trait
+error: `must_not_suspend` attribute should be applied to a struct, enum, union, or trait
   --> $DIR/other_items.rs:5:1
    |
 LL | #[must_not_suspend]
    | ^^^^^^^^^^^^^^^^^^^
 LL | mod inner {}
-   | ------------ is not a struct, enum, or trait
+   | ------------ is not a struct, enum, union, or trait
 
 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 5a73064c78776..440f816568622 100644
--- a/tests/ui/lint/must_not_suspend/return.stderr
+++ b/tests/ui/lint/must_not_suspend/return.stderr
@@ -1,4 +1,4 @@
-error: `must_not_suspend` attribute should be applied to a struct, enum, or trait
+error: `must_not_suspend` attribute should be applied to a struct, enum, union, or trait
   --> $DIR/return.rs:5:1
    |
 LL |   #[must_not_suspend]
@@ -6,7 +6,7 @@ LL |   #[must_not_suspend]
 LL | / fn foo() -> i32 {
 LL | |     0
 LL | | }
-   | |_- is not a struct, enum, or trait
+   | |_- is not a struct, enum, union, or trait
 
 error: aborting due to 1 previous error
 

From 79503dd742253cdca54f10aec9052ff477ccaf38 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 13 Jul 2024 13:53:56 +0200
Subject: [PATCH 407/685] stabilize raw_ref_op

---
 compiler/rustc_ast_passes/src/feature_gate.rs |  1 -
 .../example/mini_core_hello_world.rs          |  3 +-
 .../example/mini_core_hello_world.rs          |  2 +-
 .../src/error_codes/E0745.md                  |  2 -
 compiler/rustc_feature/src/accepted.rs        |  2 +
 compiler/rustc_feature/src/unstable.rs        |  2 -
 compiler/rustc_parse/src/parser/expr.rs       |  5 +-
 .../dangling_pointer_to_raw_pointer.rs        |  1 -
 .../return_pointer_aliasing_read.rs           |  1 -
 .../return_pointer_aliasing_write.rs          |  1 -
 ...return_pointer_aliasing_write_tail_call.rs |  1 -
 .../return_pointer_on_unwind.rs               |  1 -
 .../function_calls/return_place_on_heap.rs    |  1 -
 tests/mir-opt/const_prop/indirect_mutation.rs |  1 -
 tests/mir-opt/copy-prop/reborrow.rs           |  2 -
 .../gvn.fn_pointers.GVN.panic-abort.diff      | 18 ++---
 .../gvn.fn_pointers.GVN.panic-unwind.diff     | 18 ++---
 tests/mir-opt/gvn.rs                          |  1 -
 tests/mir-opt/instsimplify/ref_of_deref.rs    |  1 -
 tests/mir-opt/reference_prop.rs               |  1 -
 tests/pretty/raw-address-of.rs                |  1 -
 .../borrow-raw-address-of-borrowed.rs         |  2 -
 .../borrow-raw-address-of-borrowed.stderr     |  6 +-
 ...rrow-raw-address-of-deref-mutability-ok.rs |  2 -
 .../borrow-raw-address-of-deref-mutability.rs |  2 -
 ...row-raw-address-of-deref-mutability.stderr |  4 +-
 .../borrow-raw-address-of-mutability-ok.rs    |  2 -
 .../borrow-raw-address-of-mutability.rs       |  2 -
 .../borrow-raw-address-of-mutability.stderr   | 10 +--
 .../consts/const-address-of-interior-mut.rs   |  2 -
 .../const-address-of-interior-mut.stderr      |  8 +--
 tests/ui/consts/const-address-of-mut.rs       |  2 -
 tests/ui/consts/const-address-of-mut.stderr   |  6 +-
 tests/ui/consts/const-address-of.rs           |  2 -
 .../const-mut-refs/const_mut_address_of.rs    |  1 -
 .../consts/const-mut-refs/mut_ref_in_final.rs |  1 -
 .../const-mut-refs/mut_ref_in_final.stderr    | 20 +++---
 .../mut_ref_in_final_dynamic_check.rs         |  1 -
 .../mut_ref_in_final_dynamic_check.stderr     | 10 +--
 tests/ui/consts/min_const_fn/address_of.rs    |  2 -
 .../ui/consts/min_const_fn/address_of.stderr  |  4 +-
 .../consts/min_const_fn/address_of_const.rs   |  2 -
 .../consts/qualif-indirect-mutation-fail.rs   |  1 -
 .../qualif-indirect-mutation-fail.stderr      | 22 +++----
 tests/ui/lint/lint-unnecessary-parens.fixed   |  1 -
 tests/ui/lint/lint-unnecessary-parens.rs      |  1 -
 tests/ui/lint/lint-unnecessary-parens.stderr  | 66 +++++++++----------
 .../lint/unused/lint-unused-mut-variables.rs  |  2 +-
 tests/ui/macros/stringify.rs                  |  1 -
 tests/ui/mir/mir_raw_fat_ptr.rs               |  1 -
 tests/ui/mir/mir_raw_fat_ptr.stderr           |  2 +-
 .../packed-struct-address-of-element.rs       |  1 -
 tests/ui/raw-ref-op/feature-raw-ref-op.rs     | 21 ------
 tests/ui/raw-ref-op/feature-raw-ref-op.stderr | 63 ------------------
 tests/ui/raw-ref-op/raw-ref-op.rs             |  2 -
 tests/ui/raw-ref-op/raw-ref-temp-deref.rs     |  2 +-
 tests/ui/raw-ref-op/raw-ref-temp.rs           |  2 +-
 tests/ui/raw-ref-op/unusual_locations.rs      |  2 -
 tests/ui/sanitizer/thread.rs                  |  1 -
 tests/ui/static/raw-ref-extern-static.rs      |  1 -
 tests/ui/static/raw-ref-static-mut.rs         |  1 -
 tests/ui/unpretty/expanded-exhaustive.rs      |  1 -
 tests/ui/unpretty/expanded-exhaustive.stdout  |  1 -
 63 files changed, 106 insertions(+), 246 deletions(-)
 delete mode 100644 tests/ui/raw-ref-op/feature-raw-ref-op.rs
 delete mode 100644 tests/ui/raw-ref-op/feature-raw-ref-op.stderr

diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index 214a37bca03e2..5ab99fbac866f 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -539,7 +539,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
         }
     }
     gate_all!(gen_blocks, "gen blocks are experimental");
-    gate_all!(raw_ref_op, "raw address of syntax is experimental");
     gate_all!(const_trait_impl, "const trait impls are experimental");
     gate_all!(
         half_open_range_patterns_in_slices,
diff --git a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
index e603ac566f4ec..ccbd5a78485d7 100644
--- a/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
+++ b/compiler/rustc_codegen_cranelift/example/mini_core_hello_world.rs
@@ -6,8 +6,7 @@
     extern_types,
     naked_functions,
     thread_local,
-    repr_simd,
-    raw_ref_op
+    repr_simd
 )]
 #![no_core]
 #![allow(dead_code, non_camel_case_types, internal_features)]
diff --git a/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs b/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs
index 9f096e9022012..dcfa34cb729d8 100644
--- a/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs
+++ b/compiler/rustc_codegen_gcc/example/mini_core_hello_world.rs
@@ -2,7 +2,7 @@
 
 #![feature(
     no_core, unboxed_closures, start, lang_items, never_type, linkage,
-    extern_types, thread_local, raw_ref_op
+    extern_types, thread_local
 )]
 #![no_core]
 #![allow(dead_code, internal_features, non_camel_case_types)]
diff --git a/compiler/rustc_error_codes/src/error_codes/E0745.md b/compiler/rustc_error_codes/src/error_codes/E0745.md
index 23ee7af30f418..32b28f3de949f 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0745.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0745.md
@@ -3,7 +3,6 @@ The address of temporary value was taken.
 Erroneous code example:
 
 ```compile_fail,E0745
-# #![feature(raw_ref_op)]
 fn temp_address() {
     let ptr = &raw const 2; // error!
 }
@@ -15,7 +14,6 @@ In this example, `2` is destroyed right after the assignment, which means that
 To avoid this error, first bind the temporary to a named local variable:
 
 ```
-# #![feature(raw_ref_op)]
 fn temp_address() {
     let val = 2;
     let ptr = &raw const val; // ok!
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 3d5ecbaae32a2..7838abca9b890 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -321,6 +321,8 @@ declare_features! (
     (accepted, raw_dylib, "1.71.0", Some(58713)),
     /// Allows keywords to be escaped for use as identifiers.
     (accepted, raw_identifiers, "1.30.0", Some(48589)),
+    /// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions.
+    (accepted, raw_ref_op, "CURRENT_RUSTC_VERSION", Some(64490)),
     /// Allows relaxing the coherence rules such that
     /// `impl<T> ForeignTrait<LocalType> for ForeignType<T>` is permitted.
     (accepted, re_rebalance_coherence, "1.41.0", Some(55437)),
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 459df9ea1b859..14e353f13ca49 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -565,8 +565,6 @@ declare_features! (
     (unstable, precise_capturing, "1.79.0", Some(123432)),
     /// Allows macro attributes on expressions, statements and non-inline modules.
     (unstable, proc_macro_hygiene, "1.30.0", Some(54727)),
-    /// Allows `&raw const $place_expr` and `&raw mut $place_expr` expressions.
-    (unstable, raw_ref_op, "1.41.0", Some(64490)),
     /// Makes `&` and `&mut` patterns eat only one layer of references in Rust 2024.
     (incomplete, ref_pat_eat_one_layer_2024, "1.79.0", Some(123076)),
     /// Makes `&` and `&mut` patterns eat only one layer of references in Rust 2024—structural variant
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index e0917ba43e41c..422206ebbce07 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -851,7 +851,7 @@ impl<'a> Parser<'a> {
         self.expect_and()?;
         let has_lifetime = self.token.is_lifetime() && self.look_ahead(1, |t| t != &token::Colon);
         let lifetime = has_lifetime.then(|| self.expect_lifetime()); // For recovery, see below.
-        let (borrow_kind, mutbl) = self.parse_borrow_modifiers(lo);
+        let (borrow_kind, mutbl) = self.parse_borrow_modifiers();
         let attrs = self.parse_outer_attributes()?;
         let expr = if self.token.is_range_separator() {
             self.parse_expr_prefix_range(attrs)
@@ -871,13 +871,12 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse `mut?` or `raw [ const | mut ]`.
-    fn parse_borrow_modifiers(&mut self, lo: Span) -> (ast::BorrowKind, ast::Mutability) {
+    fn parse_borrow_modifiers(&mut self) -> (ast::BorrowKind, ast::Mutability) {
         if self.check_keyword(kw::Raw) && self.look_ahead(1, Token::is_mutability) {
             // `raw [ const | mut ]`.
             let found_raw = self.eat_keyword(kw::Raw);
             assert!(found_raw);
             let mutability = self.parse_const_or_mut().unwrap();
-            self.psess.gated_spans.gate(sym::raw_ref_op, lo.to(self.prev_token.span));
             (ast::BorrowKind::Raw, mutability)
         } else {
             // `mut?`
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs
index 023bce1616b89..3e20b8da6223b 100644
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs
+++ b/src/tools/miri/tests/fail/dangling_pointers/dangling_pointer_to_raw_pointer.rs
@@ -1,4 +1,3 @@
-#![feature(raw_ref_op)]
 #![feature(strict_provenance)]
 use std::ptr;
 
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.rs
index c8e0782eff2ff..a6e0134bd173f 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.rs
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_read.rs
@@ -1,7 +1,6 @@
 //@revisions: stack tree none
 //@[tree]compile-flags: -Zmiri-tree-borrows
 //@[none]compile-flags: -Zmiri-disable-stacked-borrows
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics)]
 #![feature(custom_mir)]
 
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs
index 8de0b12b8b040..6155e925c4b99 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write.rs
@@ -1,7 +1,6 @@
 // This does need an aliasing model and protectors.
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics)]
 #![feature(custom_mir)]
 
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs
index facc323bbc518..37ee7ae1b0dc0 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_aliasing_write_tail_call.rs
@@ -1,7 +1,6 @@
 // This does need an aliasing model and protectors.
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics)]
 #![feature(custom_mir)]
 #![feature(explicit_tail_calls)]
diff --git a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.rs b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.rs
index 244acd8f2be5e..698a893f897fe 100644
--- a/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.rs
+++ b/src/tools/miri/tests/fail/function_calls/return_pointer_on_unwind.rs
@@ -1,6 +1,5 @@
 // Doesn't need an aliasing model.
 //@compile-flags: -Zmiri-disable-stacked-borrows
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics)]
 #![feature(custom_mir)]
 
diff --git a/src/tools/miri/tests/pass/function_calls/return_place_on_heap.rs b/src/tools/miri/tests/pass/function_calls/return_place_on_heap.rs
index a5cbe2a0d1d9e..04a55d7007ce7 100644
--- a/src/tools/miri/tests/pass/function_calls/return_place_on_heap.rs
+++ b/src/tools/miri/tests/pass/function_calls/return_place_on_heap.rs
@@ -1,4 +1,3 @@
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics)]
 #![feature(custom_mir)]
 
diff --git a/tests/mir-opt/const_prop/indirect_mutation.rs b/tests/mir-opt/const_prop/indirect_mutation.rs
index 32ff8f142b1e7..f001b631acb5f 100644
--- a/tests/mir-opt/const_prop/indirect_mutation.rs
+++ b/tests/mir-opt/const_prop/indirect_mutation.rs
@@ -1,6 +1,5 @@
 //@ test-mir-pass: GVN
 // Check that we do not propagate past an indirect mutation.
-#![feature(raw_ref_op)]
 
 // EMIT_MIR indirect_mutation.foo.GVN.diff
 fn foo() {
diff --git a/tests/mir-opt/copy-prop/reborrow.rs b/tests/mir-opt/copy-prop/reborrow.rs
index 2f1720556cdee..51a1f92cde2fc 100644
--- a/tests/mir-opt/copy-prop/reborrow.rs
+++ b/tests/mir-opt/copy-prop/reborrow.rs
@@ -3,8 +3,6 @@
 // Check that CopyProp considers reborrows as not mutating the pointer.
 //@ test-mir-pass: CopyProp
 
-#![feature(raw_ref_op)]
-
 #[inline(never)]
 fn opaque(_: impl Sized) {}
 
diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff
index b5c0cee784688..0c49e706c9ecf 100644
--- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff
@@ -8,10 +8,10 @@
       let mut _3: fn(u8) -> u8;
       let _5: ();
       let mut _6: fn(u8) -> u8;
-      let mut _9: {closure@$DIR/gvn.rs:615:19: 615:21};
+      let mut _9: {closure@$DIR/gvn.rs:614:19: 614:21};
       let _10: ();
       let mut _11: fn();
-      let mut _13: {closure@$DIR/gvn.rs:615:19: 615:21};
+      let mut _13: {closure@$DIR/gvn.rs:614:19: 614:21};
       let _14: ();
       let mut _15: fn();
       scope 1 {
@@ -19,7 +19,7 @@
           let _4: fn(u8) -> u8;
           scope 2 {
               debug g => _4;
-              let _7: {closure@$DIR/gvn.rs:615:19: 615:21};
+              let _7: {closure@$DIR/gvn.rs:614:19: 614:21};
               scope 3 {
                   debug closure => _7;
                   let _8: fn();
@@ -62,16 +62,16 @@
           StorageDead(_6);
           StorageDead(_5);
 -         StorageLive(_7);
--         _7 = {closure@$DIR/gvn.rs:615:19: 615:21};
+-         _7 = {closure@$DIR/gvn.rs:614:19: 614:21};
 -         StorageLive(_8);
 +         nop;
-+         _7 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
++         _7 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21};
 +         nop;
           StorageLive(_9);
 -         _9 = _7;
 -         _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe)));
-+         _9 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
-+         _8 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
++         _9 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21};
++         _8 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
           StorageDead(_9);
           StorageLive(_10);
           StorageLive(_11);
@@ -88,8 +88,8 @@
           StorageLive(_13);
 -         _13 = _7;
 -         _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe)));
-+         _13 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
-+         _12 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
++         _13 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21};
++         _12 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
           StorageDead(_13);
           StorageLive(_14);
           StorageLive(_15);
diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff
index 7bc6573c13d4d..e5f865b74b9f4 100644
--- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff
@@ -8,10 +8,10 @@
       let mut _3: fn(u8) -> u8;
       let _5: ();
       let mut _6: fn(u8) -> u8;
-      let mut _9: {closure@$DIR/gvn.rs:615:19: 615:21};
+      let mut _9: {closure@$DIR/gvn.rs:614:19: 614:21};
       let _10: ();
       let mut _11: fn();
-      let mut _13: {closure@$DIR/gvn.rs:615:19: 615:21};
+      let mut _13: {closure@$DIR/gvn.rs:614:19: 614:21};
       let _14: ();
       let mut _15: fn();
       scope 1 {
@@ -19,7 +19,7 @@
           let _4: fn(u8) -> u8;
           scope 2 {
               debug g => _4;
-              let _7: {closure@$DIR/gvn.rs:615:19: 615:21};
+              let _7: {closure@$DIR/gvn.rs:614:19: 614:21};
               scope 3 {
                   debug closure => _7;
                   let _8: fn();
@@ -62,16 +62,16 @@
           StorageDead(_6);
           StorageDead(_5);
 -         StorageLive(_7);
--         _7 = {closure@$DIR/gvn.rs:615:19: 615:21};
+-         _7 = {closure@$DIR/gvn.rs:614:19: 614:21};
 -         StorageLive(_8);
 +         nop;
-+         _7 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
++         _7 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21};
 +         nop;
           StorageLive(_9);
 -         _9 = _7;
 -         _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe)));
-+         _9 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
-+         _8 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
++         _9 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21};
++         _8 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
           StorageDead(_9);
           StorageLive(_10);
           StorageLive(_11);
@@ -88,8 +88,8 @@
           StorageLive(_13);
 -         _13 = _7;
 -         _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe)));
-+         _13 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
-+         _12 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
++         _13 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21};
++         _12 = const ZeroSized: {closure@$DIR/gvn.rs:614:19: 614:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
           StorageDead(_13);
           StorageLive(_14);
           StorageLive(_15);
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
index 430f979fec716..4bbef9920ff10 100644
--- a/tests/mir-opt/gvn.rs
+++ b/tests/mir-opt/gvn.rs
@@ -3,7 +3,6 @@
 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
 //@ only-64bit
 
-#![feature(raw_ref_op)]
 #![feature(rustc_attrs)]
 #![feature(custom_mir)]
 #![feature(core_intrinsics)]
diff --git a/tests/mir-opt/instsimplify/ref_of_deref.rs b/tests/mir-opt/instsimplify/ref_of_deref.rs
index dc0f5f8198bc7..72481f5579ac3 100644
--- a/tests/mir-opt/instsimplify/ref_of_deref.rs
+++ b/tests/mir-opt/instsimplify/ref_of_deref.rs
@@ -1,6 +1,5 @@
 //@ test-mir-pass: InstSimplify-after-simplifycfg
 #![crate_type = "lib"]
-#![feature(raw_ref_op)]
 
 // For each of these, only 2 of the 6 should simplify,
 // as the others have the wrong types.
diff --git a/tests/mir-opt/reference_prop.rs b/tests/mir-opt/reference_prop.rs
index 58d8b524ad642..7c5c02ee7ef6e 100644
--- a/tests/mir-opt/reference_prop.rs
+++ b/tests/mir-opt/reference_prop.rs
@@ -2,7 +2,6 @@
 //@ test-mir-pass: ReferencePropagation
 //@ needs-unwind
 
-#![feature(raw_ref_op)]
 #![feature(core_intrinsics, custom_mir)]
 
 #[inline(never)]
diff --git a/tests/pretty/raw-address-of.rs b/tests/pretty/raw-address-of.rs
index 6e97ab99407fc..c00a16e238a66 100644
--- a/tests/pretty/raw-address-of.rs
+++ b/tests/pretty/raw-address-of.rs
@@ -1,5 +1,4 @@
 //@ pp-exact
-#![feature(raw_ref_op)]
 
 const C_PTR: () = { let a = 1; &raw const a; };
 static S_PTR: () = { let b = false; &raw const b; };
diff --git a/tests/ui/borrowck/borrow-raw-address-of-borrowed.rs b/tests/ui/borrowck/borrow-raw-address-of-borrowed.rs
index f25fd7f66b3cc..3ed42d072891a 100644
--- a/tests/ui/borrowck/borrow-raw-address-of-borrowed.rs
+++ b/tests/ui/borrowck/borrow-raw-address-of-borrowed.rs
@@ -1,5 +1,3 @@
-#![feature(raw_ref_op)]
-
 fn address_of_shared() {
     let mut x = 0;
     let y = &x;
diff --git a/tests/ui/borrowck/borrow-raw-address-of-borrowed.stderr b/tests/ui/borrowck/borrow-raw-address-of-borrowed.stderr
index 6f7b7e08070bf..1a38f8c780e75 100644
--- a/tests/ui/borrowck/borrow-raw-address-of-borrowed.stderr
+++ b/tests/ui/borrowck/borrow-raw-address-of-borrowed.stderr
@@ -1,5 +1,5 @@
 error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
-  --> $DIR/borrow-raw-address-of-borrowed.rs:7:13
+  --> $DIR/borrow-raw-address-of-borrowed.rs:5:13
    |
 LL |     let y = &x;
    |             -- immutable borrow occurs here
@@ -11,7 +11,7 @@ LL |     drop(y);
    |          - immutable borrow later used here
 
 error[E0502]: cannot borrow `x` as immutable because it is also borrowed as mutable
-  --> $DIR/borrow-raw-address-of-borrowed.rs:16:13
+  --> $DIR/borrow-raw-address-of-borrowed.rs:14:13
    |
 LL |     let y = &mut x;
    |             ------ mutable borrow occurs here
@@ -23,7 +23,7 @@ LL |     drop(y);
    |          - mutable borrow later used here
 
 error[E0499]: cannot borrow `x` as mutable more than once at a time
-  --> $DIR/borrow-raw-address-of-borrowed.rs:17:13
+  --> $DIR/borrow-raw-address-of-borrowed.rs:15:13
    |
 LL |     let y = &mut x;
    |             ------ first mutable borrow occurs here
diff --git a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability-ok.rs b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability-ok.rs
index 0dfced34c7e2e..234097952274b 100644
--- a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability-ok.rs
+++ b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability-ok.rs
@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(raw_ref_op)]
-
 fn raw_reborrow() {
     let x = &0;
     let y = &mut 0;
diff --git a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.rs b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.rs
index 712873528b5f1..5b3936ef5a3f1 100644
--- a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.rs
+++ b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.rs
@@ -1,7 +1,5 @@
 // Check that `&raw mut` cannot be used to turn a `&T` into a `*mut T`.
 
-#![feature(raw_ref_op)]
-
 fn raw_reborrow() {
     let x = &0;
 
diff --git a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.stderr b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.stderr
index cfc86ff0dc121..ac0241cf9a76b 100644
--- a/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.stderr
+++ b/tests/ui/borrowck/borrow-raw-address-of-deref-mutability.stderr
@@ -1,5 +1,5 @@
 error[E0596]: cannot borrow `*x` as mutable, as it is behind a `&` reference
-  --> $DIR/borrow-raw-address-of-deref-mutability.rs:8:13
+  --> $DIR/borrow-raw-address-of-deref-mutability.rs:6:13
    |
 LL |     let q = &raw mut *x;
    |             ^^^^^^^^^^^ `x` is a `&` reference, so the data it refers to cannot be borrowed as mutable
@@ -10,7 +10,7 @@ LL |     let x = &mut 0;
    |              +++
 
 error[E0596]: cannot borrow `*x` as mutable, as it is behind a `*const` pointer
-  --> $DIR/borrow-raw-address-of-deref-mutability.rs:14:13
+  --> $DIR/borrow-raw-address-of-deref-mutability.rs:12:13
    |
 LL |     let q = &raw mut *x;
    |             ^^^^^^^^^^^ `x` is a `*const` pointer, so the data it refers to cannot be borrowed as mutable
diff --git a/tests/ui/borrowck/borrow-raw-address-of-mutability-ok.rs b/tests/ui/borrowck/borrow-raw-address-of-mutability-ok.rs
index 7b0232a9d4550..ed8c5502a75b8 100644
--- a/tests/ui/borrowck/borrow-raw-address-of-mutability-ok.rs
+++ b/tests/ui/borrowck/borrow-raw-address-of-mutability-ok.rs
@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(raw_ref_op)]
-
 fn mutable_address_of() {
     let mut x = 0;
     let y = &raw mut x;
diff --git a/tests/ui/borrowck/borrow-raw-address-of-mutability.rs b/tests/ui/borrowck/borrow-raw-address-of-mutability.rs
index 320c54b806a72..2c5d636d096d4 100644
--- a/tests/ui/borrowck/borrow-raw-address-of-mutability.rs
+++ b/tests/ui/borrowck/borrow-raw-address-of-mutability.rs
@@ -1,5 +1,3 @@
-#![feature(raw_ref_op)]
-
 fn mutable_address_of() {
     let x = 0;
     let y = &raw mut x;                 //~ ERROR cannot borrow
diff --git a/tests/ui/borrowck/borrow-raw-address-of-mutability.stderr b/tests/ui/borrowck/borrow-raw-address-of-mutability.stderr
index 4b5b368287e16..f81a8c99376f0 100644
--- a/tests/ui/borrowck/borrow-raw-address-of-mutability.stderr
+++ b/tests/ui/borrowck/borrow-raw-address-of-mutability.stderr
@@ -1,5 +1,5 @@
 error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
-  --> $DIR/borrow-raw-address-of-mutability.rs:5:13
+  --> $DIR/borrow-raw-address-of-mutability.rs:3:13
    |
 LL |     let y = &raw mut x;
    |             ^^^^^^^^^^ cannot borrow as mutable
@@ -10,7 +10,7 @@ LL |     let mut x = 0;
    |         +++
 
 error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
-  --> $DIR/borrow-raw-address-of-mutability.rs:11:17
+  --> $DIR/borrow-raw-address-of-mutability.rs:9:17
    |
 LL |         let y = &raw mut x;
    |                 ^^^^^^^^^^ cannot borrow as mutable
@@ -21,7 +21,7 @@ LL |     let mut x = 0;
    |         +++
 
 error[E0596]: cannot borrow `f` as mutable, as it is not declared as mutable
-  --> $DIR/borrow-raw-address-of-mutability.rs:21:5
+  --> $DIR/borrow-raw-address-of-mutability.rs:19:5
    |
 LL |         let y = &raw mut x;
    |                          - calling `f` requires mutable binding due to mutable borrow of `x`
@@ -35,7 +35,7 @@ LL |     let mut f = || {
    |         +++
 
 error[E0596]: cannot borrow `x` as mutable, as it is a captured variable in a `Fn` closure
-  --> $DIR/borrow-raw-address-of-mutability.rs:29:17
+  --> $DIR/borrow-raw-address-of-mutability.rs:27:17
    |
 LL | fn make_fn<F: Fn()>(f: F) -> F { f }
    |                        - change this to accept `FnMut` instead of `Fn`
@@ -48,7 +48,7 @@ LL |         let y = &raw mut x;
    |                 ^^^^^^^^^^ cannot borrow as mutable
 
 error[E0596]: cannot borrow `x` as mutable, as it is a captured variable in a `Fn` closure
-  --> $DIR/borrow-raw-address-of-mutability.rs:37:17
+  --> $DIR/borrow-raw-address-of-mutability.rs:35:17
    |
 LL | fn make_fn<F: Fn()>(f: F) -> F { f }
    |                        - change this to accept `FnMut` instead of `Fn`
diff --git a/tests/ui/consts/const-address-of-interior-mut.rs b/tests/ui/consts/const-address-of-interior-mut.rs
index 60c7c31daca78..930fa0c492f35 100644
--- a/tests/ui/consts/const-address-of-interior-mut.rs
+++ b/tests/ui/consts/const-address-of-interior-mut.rs
@@ -1,5 +1,3 @@
-#![feature(raw_ref_op)]
-
 use std::cell::Cell;
 
 const A: () = { let x = Cell::new(2); &raw const x; };      //~ ERROR interior mutability
diff --git a/tests/ui/consts/const-address-of-interior-mut.stderr b/tests/ui/consts/const-address-of-interior-mut.stderr
index 12c8917d740fa..203745f0b019d 100644
--- a/tests/ui/consts/const-address-of-interior-mut.stderr
+++ b/tests/ui/consts/const-address-of-interior-mut.stderr
@@ -1,5 +1,5 @@
 error[E0658]: cannot borrow here, since the borrowed element may contain interior mutability
-  --> $DIR/const-address-of-interior-mut.rs:5:39
+  --> $DIR/const-address-of-interior-mut.rs:3:39
    |
 LL | const A: () = { let x = Cell::new(2); &raw const x; };
    |                                       ^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL | const A: () = { let x = Cell::new(2); &raw const x; };
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: cannot borrow here, since the borrowed element may contain interior mutability
-  --> $DIR/const-address-of-interior-mut.rs:7:40
+  --> $DIR/const-address-of-interior-mut.rs:5:40
    |
 LL | static B: () = { let x = Cell::new(2); &raw const x; };
    |                                        ^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL | static B: () = { let x = Cell::new(2); &raw const x; };
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: cannot borrow here, since the borrowed element may contain interior mutability
-  --> $DIR/const-address-of-interior-mut.rs:9:44
+  --> $DIR/const-address-of-interior-mut.rs:7:44
    |
 LL | static mut C: () = { let x = Cell::new(2); &raw const x; };
    |                                            ^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL | static mut C: () = { let x = Cell::new(2); &raw const x; };
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: cannot borrow here, since the borrowed element may contain interior mutability
-  --> $DIR/const-address-of-interior-mut.rs:13:13
+  --> $DIR/const-address-of-interior-mut.rs:11:13
    |
 LL |     let y = &raw const x;
    |             ^^^^^^^^^^^^
diff --git a/tests/ui/consts/const-address-of-mut.rs b/tests/ui/consts/const-address-of-mut.rs
index 0018bf18e419b..c3f37843d3c15 100644
--- a/tests/ui/consts/const-address-of-mut.rs
+++ b/tests/ui/consts/const-address-of-mut.rs
@@ -1,5 +1,3 @@
-#![feature(raw_ref_op)]
-
 const A: () = { let mut x = 2; &raw mut x; };           //~ mutable pointer
 
 static B: () = { let mut x = 2; &raw mut x; };          //~ mutable pointer
diff --git a/tests/ui/consts/const-address-of-mut.stderr b/tests/ui/consts/const-address-of-mut.stderr
index 95a91ff463f69..d4243485de159 100644
--- a/tests/ui/consts/const-address-of-mut.stderr
+++ b/tests/ui/consts/const-address-of-mut.stderr
@@ -1,5 +1,5 @@
 error[E0658]: raw mutable pointers are not allowed in constants
-  --> $DIR/const-address-of-mut.rs:3:32
+  --> $DIR/const-address-of-mut.rs:1:32
    |
 LL | const A: () = { let mut x = 2; &raw mut x; };
    |                                ^^^^^^^^^^
@@ -9,7 +9,7 @@ LL | const A: () = { let mut x = 2; &raw mut x; };
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: raw mutable pointers are not allowed in statics
-  --> $DIR/const-address-of-mut.rs:5:33
+  --> $DIR/const-address-of-mut.rs:3:33
    |
 LL | static B: () = { let mut x = 2; &raw mut x; };
    |                                 ^^^^^^^^^^
@@ -19,7 +19,7 @@ LL | static B: () = { let mut x = 2; &raw mut x; };
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: raw mutable pointers are not allowed in constant functions
-  --> $DIR/const-address-of-mut.rs:9:13
+  --> $DIR/const-address-of-mut.rs:7:13
    |
 LL |     let y = &raw mut x;
    |             ^^^^^^^^^^
diff --git a/tests/ui/consts/const-address-of.rs b/tests/ui/consts/const-address-of.rs
index 4eb3c3840ba48..39ed430e17ea6 100644
--- a/tests/ui/consts/const-address-of.rs
+++ b/tests/ui/consts/const-address-of.rs
@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(raw_ref_op)]
-
 const A: *const i32 = &raw const *&2;
 static B: () = { &raw const *&2; };
 static mut C: *const i32 = &raw const *&2;
diff --git a/tests/ui/consts/const-mut-refs/const_mut_address_of.rs b/tests/ui/consts/const-mut-refs/const_mut_address_of.rs
index 66a4ec50c11de..437bdc88722c0 100644
--- a/tests/ui/consts/const-mut-refs/const_mut_address_of.rs
+++ b/tests/ui/consts/const-mut-refs/const_mut_address_of.rs
@@ -1,6 +1,5 @@
 //@ check-pass
 #![feature(const_mut_refs)]
-#![feature(raw_ref_op)]
 
 struct Foo {
     x: usize
diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs b/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs
index 93197d5bce494..10339ee6798e8 100644
--- a/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs
+++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final.rs
@@ -1,5 +1,4 @@
 #![feature(const_mut_refs)]
-#![feature(raw_ref_op)]
 
 const NULL: *mut i32 = std::ptr::null_mut();
 const A: *const i32 = &4;
diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr b/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr
index 59e6aa4011c23..00a8421076b88 100644
--- a/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr
+++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final.stderr
@@ -1,11 +1,11 @@
 error[E0764]: mutable references are not allowed in the final value of constants
-  --> $DIR/mut_ref_in_final.rs:10:21
+  --> $DIR/mut_ref_in_final.rs:9:21
    |
 LL | const B: *mut i32 = &mut 4;
    |                     ^^^^^^
 
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/mut_ref_in_final.rs:16:40
+  --> $DIR/mut_ref_in_final.rs:15:40
    |
 LL | const B3: Option<&mut i32> = Some(&mut 42);
    |                              ----------^^-
@@ -15,7 +15,7 @@ LL | const B3: Option<&mut i32> = Some(&mut 42);
    |                              using this value as a constant requires that borrow lasts for `'static`
 
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/mut_ref_in_final.rs:19:42
+  --> $DIR/mut_ref_in_final.rs:18:42
    |
 LL | const B4: Option<&mut i32> = helper(&mut 42);
    |                              ------------^^-
@@ -25,7 +25,7 @@ LL | const B4: Option<&mut i32> = helper(&mut 42);
    |                              using this value as a constant requires that borrow lasts for `'static`
 
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/mut_ref_in_final.rs:34:65
+  --> $DIR/mut_ref_in_final.rs:33:65
    |
 LL | const FOO: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
    |                                  -------------------------------^^--
@@ -35,7 +35,7 @@ LL | const FOO: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
    |                                  using this value as a constant requires that borrow lasts for `'static`
 
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/mut_ref_in_final.rs:37:67
+  --> $DIR/mut_ref_in_final.rs:36:67
    |
 LL | static FOO2: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
    |                                    -------------------------------^^--
@@ -45,7 +45,7 @@ LL | static FOO2: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
    |                                    using this value as a static requires that borrow lasts for `'static`
 
 error[E0716]: temporary value dropped while borrowed
-  --> $DIR/mut_ref_in_final.rs:40:71
+  --> $DIR/mut_ref_in_final.rs:39:71
    |
 LL | static mut FOO3: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
    |                                        -------------------------------^^--
@@ -55,25 +55,25 @@ LL | static mut FOO3: NotAMutex<&mut i32> = NotAMutex(UnsafeCell::new(&mut 42));
    |                                        using this value as a static requires that borrow lasts for `'static`
 
 error[E0764]: mutable references are not allowed in the final value of statics
-  --> $DIR/mut_ref_in_final.rs:53:53
+  --> $DIR/mut_ref_in_final.rs:52:53
    |
 LL | static RAW_MUT_CAST_S: SyncPtr<i32> = SyncPtr { x : &mut 42 as *mut _ as *const _ };
    |                                                     ^^^^^^^
 
 error[E0764]: mutable references are not allowed in the final value of statics
-  --> $DIR/mut_ref_in_final.rs:55:54
+  --> $DIR/mut_ref_in_final.rs:54:54
    |
 LL | static RAW_MUT_COERCE_S: SyncPtr<i32> = SyncPtr { x: &mut 0 };
    |                                                      ^^^^^^
 
 error[E0764]: mutable references are not allowed in the final value of constants
-  --> $DIR/mut_ref_in_final.rs:57:52
+  --> $DIR/mut_ref_in_final.rs:56:52
    |
 LL | const RAW_MUT_CAST_C: SyncPtr<i32> = SyncPtr { x : &mut 42 as *mut _ as *const _ };
    |                                                    ^^^^^^^
 
 error[E0764]: mutable references are not allowed in the final value of constants
-  --> $DIR/mut_ref_in_final.rs:59:53
+  --> $DIR/mut_ref_in_final.rs:58:53
    |
 LL | const RAW_MUT_COERCE_C: SyncPtr<i32> = SyncPtr { x: &mut 0 };
    |                                                     ^^^^^^
diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs
index c12c22447b59c..e208845e74702 100644
--- a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs
+++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.rs
@@ -2,7 +2,6 @@
 //@ normalize-stderr-test: "( 0x[0-9a-f][0-9a-f] │)? ([0-9a-f][0-9a-f] |__ |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> " HEX_DUMP"
 //@ normalize-stderr-test: "HEX_DUMP\s*\n\s*HEX_DUMP" -> "HEX_DUMP"
 #![feature(const_mut_refs, const_refs_to_static)]
-#![feature(raw_ref_op)]
 
 use std::sync::Mutex;
 
diff --git a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr
index ea9dccf0173cc..4ea6fa62475e8 100644
--- a/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr
+++ b/tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr
@@ -1,5 +1,5 @@
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mut_ref_in_final_dynamic_check.rs:20:1
+  --> $DIR/mut_ref_in_final_dynamic_check.rs:19:1
    |
 LL | const MUT: Option<&mut i32> = helper();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered reference to mutable memory in `const`
@@ -10,7 +10,7 @@ LL | const MUT: Option<&mut i32> = helper();
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mut_ref_in_final_dynamic_check.rs:27:1
+  --> $DIR/mut_ref_in_final_dynamic_check.rs:26:1
    |
 LL | const INT2PTR: Option<&mut i32> = helper_int2ptr();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered a dangling reference (0x2a[noalloc] has no provenance)
@@ -21,7 +21,7 @@ LL | const INT2PTR: Option<&mut i32> = helper_int2ptr();
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mut_ref_in_final_dynamic_check.rs:29:1
+  --> $DIR/mut_ref_in_final_dynamic_check.rs:28:1
    |
 LL | static INT2PTR_STATIC: Option<&mut i32> = helper_int2ptr();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered a dangling reference (0x2a[noalloc] has no provenance)
@@ -32,7 +32,7 @@ LL | static INT2PTR_STATIC: Option<&mut i32> = helper_int2ptr();
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mut_ref_in_final_dynamic_check.rs:36:1
+  --> $DIR/mut_ref_in_final_dynamic_check.rs:35:1
    |
 LL | const DANGLING: Option<&mut i32> = helper_dangling();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered a dangling reference (use-after-free)
@@ -43,7 +43,7 @@ LL | const DANGLING: Option<&mut i32> = helper_dangling();
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/mut_ref_in_final_dynamic_check.rs:37:1
+  --> $DIR/mut_ref_in_final_dynamic_check.rs:36:1
    |
 LL | static DANGLING_STATIC: Option<&mut i32> = helper_dangling();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered a dangling reference (use-after-free)
diff --git a/tests/ui/consts/min_const_fn/address_of.rs b/tests/ui/consts/min_const_fn/address_of.rs
index aa75423ca4d64..dc481e17ba38e 100644
--- a/tests/ui/consts/min_const_fn/address_of.rs
+++ b/tests/ui/consts/min_const_fn/address_of.rs
@@ -1,5 +1,3 @@
-#![feature(raw_ref_op)]
-
 const fn mutable_address_of_in_const() {
     let mut a = 0;
     let b = &raw mut a;         //~ ERROR mutable pointer
diff --git a/tests/ui/consts/min_const_fn/address_of.stderr b/tests/ui/consts/min_const_fn/address_of.stderr
index 143760c0943d2..dd6fe6486d49c 100644
--- a/tests/ui/consts/min_const_fn/address_of.stderr
+++ b/tests/ui/consts/min_const_fn/address_of.stderr
@@ -1,5 +1,5 @@
 error[E0658]: raw mutable pointers are not allowed in constant functions
-  --> $DIR/address_of.rs:5:13
+  --> $DIR/address_of.rs:3:13
    |
 LL |     let b = &raw mut a;
    |             ^^^^^^^^^^
@@ -9,7 +9,7 @@ LL |     let b = &raw mut a;
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: raw mutable pointers are not allowed in constant functions
-  --> $DIR/address_of.rs:13:17
+  --> $DIR/address_of.rs:11:17
    |
 LL |         let b = &raw mut a;
    |                 ^^^^^^^^^^
diff --git a/tests/ui/consts/min_const_fn/address_of_const.rs b/tests/ui/consts/min_const_fn/address_of_const.rs
index 4280d0745c1ab..1520622679fb1 100644
--- a/tests/ui/consts/min_const_fn/address_of_const.rs
+++ b/tests/ui/consts/min_const_fn/address_of_const.rs
@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(raw_ref_op)]
-
 const fn const_address_of_in_const() {
     let mut a = 0;
     let b = &raw const a;
diff --git a/tests/ui/consts/qualif-indirect-mutation-fail.rs b/tests/ui/consts/qualif-indirect-mutation-fail.rs
index 420e32128a4b9..a99d0633ba130 100644
--- a/tests/ui/consts/qualif-indirect-mutation-fail.rs
+++ b/tests/ui/consts/qualif-indirect-mutation-fail.rs
@@ -2,7 +2,6 @@
 #![feature(const_mut_refs)]
 #![feature(const_precise_live_drops)]
 #![feature(const_swap)]
-#![feature(raw_ref_op)]
 
 // Mutable borrow of a field with drop impl.
 pub const fn f() {
diff --git a/tests/ui/consts/qualif-indirect-mutation-fail.stderr b/tests/ui/consts/qualif-indirect-mutation-fail.stderr
index 458dc2071c48e..21c872ed13f20 100644
--- a/tests/ui/consts/qualif-indirect-mutation-fail.stderr
+++ b/tests/ui/consts/qualif-indirect-mutation-fail.stderr
@@ -1,5 +1,5 @@
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:15:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:14:9
    |
 LL |     let mut x = None;
    |         ^^^^^ the destructor for this type cannot be evaluated in constants
@@ -16,13 +16,13 @@ note: inside `std::ptr::drop_in_place::<String> - shim(Some(String))`
 note: inside `std::ptr::drop_in_place::<Option<String>> - shim(Some(Option<String>))`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 note: inside `A1`
-  --> $DIR/qualif-indirect-mutation-fail.rs:21:1
+  --> $DIR/qualif-indirect-mutation-fail.rs:20:1
    |
 LL | };
    | ^
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:31:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:30:9
    |
 LL |     let _z = x;
    |         ^^ the destructor for this type cannot be evaluated in constants
@@ -39,49 +39,49 @@ note: inside `std::ptr::drop_in_place::<String> - shim(Some(String))`
 note: inside `std::ptr::drop_in_place::<Option<String>> - shim(Some(Option<String>))`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 note: inside `A2`
-  --> $DIR/qualif-indirect-mutation-fail.rs:32:1
+  --> $DIR/qualif-indirect-mutation-fail.rs:31:1
    |
 LL | };
    | ^
 
 error[E0493]: destructor of `(u32, Option<String>)` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:9:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:8:9
    |
 LL |     let mut a: (u32, Option<String>) = (0, None);
    |         ^^^^^ the destructor for this type cannot be evaluated in constant functions
 
 error[E0493]: destructor of `Option<T>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:36:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:35:9
    |
 LL |     let x: Option<T> = None;
    |         ^ the destructor for this type cannot be evaluated in constant functions
 
 error[E0493]: destructor of `Option<T>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:44:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:43:9
    |
 LL |     let _y = x;
    |         ^^ the destructor for this type cannot be evaluated in constant functions
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:52:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:51:9
    |
 LL |     let mut y: Option<String> = None;
    |         ^^^^^ the destructor for this type cannot be evaluated in constant functions
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:49:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:48:9
    |
 LL |     let mut x: Option<String> = None;
    |         ^^^^^ the destructor for this type cannot be evaluated in constant functions
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:62:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:61:9
    |
 LL |     let y: Option<String> = None;
    |         ^ the destructor for this type cannot be evaluated in constant functions
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
-  --> $DIR/qualif-indirect-mutation-fail.rs:59:9
+  --> $DIR/qualif-indirect-mutation-fail.rs:58:9
    |
 LL |     let x: Option<String> = None;
    |         ^ the destructor for this type cannot be evaluated in constant functions
diff --git a/tests/ui/lint/lint-unnecessary-parens.fixed b/tests/ui/lint/lint-unnecessary-parens.fixed
index 089aa1b7ab7de..a8c8dd1d512fb 100644
--- a/tests/ui/lint/lint-unnecessary-parens.fixed
+++ b/tests/ui/lint/lint-unnecessary-parens.fixed
@@ -1,7 +1,6 @@
 //@ run-rustfix
 
 #![deny(unused_parens)]
-#![feature(raw_ref_op)]
 #![allow(while_true)] // for rustfix
 
 #[derive(Eq, PartialEq)]
diff --git a/tests/ui/lint/lint-unnecessary-parens.rs b/tests/ui/lint/lint-unnecessary-parens.rs
index dc77ee003523e..02aa78283c78f 100644
--- a/tests/ui/lint/lint-unnecessary-parens.rs
+++ b/tests/ui/lint/lint-unnecessary-parens.rs
@@ -1,7 +1,6 @@
 //@ run-rustfix
 
 #![deny(unused_parens)]
-#![feature(raw_ref_op)]
 #![allow(while_true)] // for rustfix
 
 #[derive(Eq, PartialEq)]
diff --git a/tests/ui/lint/lint-unnecessary-parens.stderr b/tests/ui/lint/lint-unnecessary-parens.stderr
index c9422437a9fcd..f2e5debd6e08f 100644
--- a/tests/ui/lint/lint-unnecessary-parens.stderr
+++ b/tests/ui/lint/lint-unnecessary-parens.stderr
@@ -1,5 +1,5 @@
 error: unnecessary parentheses around `return` value
-  --> $DIR/lint-unnecessary-parens.rs:14:12
+  --> $DIR/lint-unnecessary-parens.rs:13:12
    |
 LL |     return (1);
    |            ^ ^
@@ -16,7 +16,7 @@ LL +     return 1;
    |
 
 error: unnecessary parentheses around `return` value
-  --> $DIR/lint-unnecessary-parens.rs:17:12
+  --> $DIR/lint-unnecessary-parens.rs:16:12
    |
 LL |     return (X { y });
    |            ^       ^
@@ -28,7 +28,7 @@ LL +     return X { y };
    |
 
 error: unnecessary parentheses around type
-  --> $DIR/lint-unnecessary-parens.rs:20:46
+  --> $DIR/lint-unnecessary-parens.rs:19:46
    |
 LL | pub fn unused_parens_around_return_type() -> (u32) {
    |                                              ^   ^
@@ -40,7 +40,7 @@ LL + pub fn unused_parens_around_return_type() -> u32 {
    |
 
 error: unnecessary parentheses around block return value
-  --> $DIR/lint-unnecessary-parens.rs:26:9
+  --> $DIR/lint-unnecessary-parens.rs:25:9
    |
 LL |         (5)
    |         ^ ^
@@ -52,7 +52,7 @@ LL +         5
    |
 
 error: unnecessary parentheses around block return value
-  --> $DIR/lint-unnecessary-parens.rs:28:5
+  --> $DIR/lint-unnecessary-parens.rs:27:5
    |
 LL |     (5)
    |     ^ ^
@@ -64,7 +64,7 @@ LL +     5
    |
 
 error: unnecessary parentheses around `if` condition
-  --> $DIR/lint-unnecessary-parens.rs:40:7
+  --> $DIR/lint-unnecessary-parens.rs:39:7
    |
 LL |     if(true) {}
    |       ^    ^
@@ -76,7 +76,7 @@ LL +     if true {}
    |
 
 error: unnecessary parentheses around `while` condition
-  --> $DIR/lint-unnecessary-parens.rs:41:10
+  --> $DIR/lint-unnecessary-parens.rs:40:10
    |
 LL |     while(true) {}
    |          ^    ^
@@ -88,7 +88,7 @@ LL +     while true {}
    |
 
 error: unnecessary parentheses around `for` iterator expression
-  --> $DIR/lint-unnecessary-parens.rs:42:13
+  --> $DIR/lint-unnecessary-parens.rs:41:13
    |
 LL |     for _ in(e) {}
    |             ^ ^
@@ -100,7 +100,7 @@ LL +     for _ in e {}
    |
 
 error: unnecessary parentheses around `match` scrutinee expression
-  --> $DIR/lint-unnecessary-parens.rs:43:10
+  --> $DIR/lint-unnecessary-parens.rs:42:10
    |
 LL |     match(1) { _ => ()}
    |          ^ ^
@@ -112,7 +112,7 @@ LL +     match 1 { _ => ()}
    |
 
 error: unnecessary parentheses around `return` value
-  --> $DIR/lint-unnecessary-parens.rs:44:11
+  --> $DIR/lint-unnecessary-parens.rs:43:11
    |
 LL |     return(1);
    |           ^ ^
@@ -124,7 +124,7 @@ LL +     return 1;
    |
 
 error: unnecessary parentheses around assigned value
-  --> $DIR/lint-unnecessary-parens.rs:75:31
+  --> $DIR/lint-unnecessary-parens.rs:74:31
    |
 LL | pub const CONST_ITEM: usize = (10);
    |                               ^  ^
@@ -136,7 +136,7 @@ LL + pub const CONST_ITEM: usize = 10;
    |
 
 error: unnecessary parentheses around assigned value
-  --> $DIR/lint-unnecessary-parens.rs:76:33
+  --> $DIR/lint-unnecessary-parens.rs:75:33
    |
 LL | pub static STATIC_ITEM: usize = (10);
    |                                 ^  ^
@@ -148,7 +148,7 @@ LL + pub static STATIC_ITEM: usize = 10;
    |
 
 error: unnecessary parentheses around function argument
-  --> $DIR/lint-unnecessary-parens.rs:80:9
+  --> $DIR/lint-unnecessary-parens.rs:79:9
    |
 LL |     bar((true));
    |         ^    ^
@@ -160,7 +160,7 @@ LL +     bar(true);
    |
 
 error: unnecessary parentheses around `if` condition
-  --> $DIR/lint-unnecessary-parens.rs:82:8
+  --> $DIR/lint-unnecessary-parens.rs:81:8
    |
 LL |     if (true) {}
    |        ^    ^
@@ -172,7 +172,7 @@ LL +     if true {}
    |
 
 error: unnecessary parentheses around `while` condition
-  --> $DIR/lint-unnecessary-parens.rs:83:11
+  --> $DIR/lint-unnecessary-parens.rs:82:11
    |
 LL |     while (true) {}
    |           ^    ^
@@ -184,7 +184,7 @@ LL +     while true {}
    |
 
 error: unnecessary parentheses around `match` scrutinee expression
-  --> $DIR/lint-unnecessary-parens.rs:84:11
+  --> $DIR/lint-unnecessary-parens.rs:83:11
    |
 LL |     match (true) {
    |           ^    ^
@@ -196,7 +196,7 @@ LL +     match true {
    |
 
 error: unnecessary parentheses around `let` scrutinee expression
-  --> $DIR/lint-unnecessary-parens.rs:87:16
+  --> $DIR/lint-unnecessary-parens.rs:86:16
    |
 LL |     if let 1 = (1) {}
    |                ^ ^
@@ -208,7 +208,7 @@ LL +     if let 1 = 1 {}
    |
 
 error: unnecessary parentheses around `let` scrutinee expression
-  --> $DIR/lint-unnecessary-parens.rs:88:19
+  --> $DIR/lint-unnecessary-parens.rs:87:19
    |
 LL |     while let 1 = (2) {}
    |                   ^ ^
@@ -220,7 +220,7 @@ LL +     while let 1 = 2 {}
    |
 
 error: unnecessary parentheses around method argument
-  --> $DIR/lint-unnecessary-parens.rs:104:24
+  --> $DIR/lint-unnecessary-parens.rs:103:24
    |
 LL |     X { y: false }.foo((true));
    |                        ^    ^
@@ -232,7 +232,7 @@ LL +     X { y: false }.foo(true);
    |
 
 error: unnecessary parentheses around assigned value
-  --> $DIR/lint-unnecessary-parens.rs:106:18
+  --> $DIR/lint-unnecessary-parens.rs:105:18
    |
 LL |     let mut _a = (0);
    |                  ^ ^
@@ -244,7 +244,7 @@ LL +     let mut _a = 0;
    |
 
 error: unnecessary parentheses around assigned value
-  --> $DIR/lint-unnecessary-parens.rs:107:10
+  --> $DIR/lint-unnecessary-parens.rs:106:10
    |
 LL |     _a = (0);
    |          ^ ^
@@ -256,7 +256,7 @@ LL +     _a = 0;
    |
 
 error: unnecessary parentheses around assigned value
-  --> $DIR/lint-unnecessary-parens.rs:108:11
+  --> $DIR/lint-unnecessary-parens.rs:107:11
    |
 LL |     _a += (1);
    |           ^ ^
@@ -268,7 +268,7 @@ LL +     _a += 1;
    |
 
 error: unnecessary parentheses around pattern
-  --> $DIR/lint-unnecessary-parens.rs:110:8
+  --> $DIR/lint-unnecessary-parens.rs:109:8
    |
 LL |     let(mut _a) = 3;
    |        ^      ^
@@ -280,7 +280,7 @@ LL +     let mut _a = 3;
    |
 
 error: unnecessary parentheses around pattern
-  --> $DIR/lint-unnecessary-parens.rs:111:9
+  --> $DIR/lint-unnecessary-parens.rs:110:9
    |
 LL |     let (mut _a) = 3;
    |         ^      ^
@@ -292,7 +292,7 @@ LL +     let mut _a = 3;
    |
 
 error: unnecessary parentheses around pattern
-  --> $DIR/lint-unnecessary-parens.rs:112:8
+  --> $DIR/lint-unnecessary-parens.rs:111:8
    |
 LL |     let( mut _a) = 3;
    |        ^^      ^
@@ -304,7 +304,7 @@ LL +     let mut _a = 3;
    |
 
 error: unnecessary parentheses around pattern
-  --> $DIR/lint-unnecessary-parens.rs:114:8
+  --> $DIR/lint-unnecessary-parens.rs:113:8
    |
 LL |     let(_a) = 3;
    |        ^  ^
@@ -316,7 +316,7 @@ LL +     let _a = 3;
    |
 
 error: unnecessary parentheses around pattern
-  --> $DIR/lint-unnecessary-parens.rs:115:9
+  --> $DIR/lint-unnecessary-parens.rs:114:9
    |
 LL |     let (_a) = 3;
    |         ^  ^
@@ -328,7 +328,7 @@ LL +     let _a = 3;
    |
 
 error: unnecessary parentheses around pattern
-  --> $DIR/lint-unnecessary-parens.rs:116:8
+  --> $DIR/lint-unnecessary-parens.rs:115:8
    |
 LL |     let( _a) = 3;
    |        ^^  ^
@@ -340,7 +340,7 @@ LL +     let _a = 3;
    |
 
 error: unnecessary parentheses around block return value
-  --> $DIR/lint-unnecessary-parens.rs:122:9
+  --> $DIR/lint-unnecessary-parens.rs:121:9
    |
 LL |         (unit!() - One)
    |         ^             ^
@@ -352,7 +352,7 @@ LL +         unit!() - One
    |
 
 error: unnecessary parentheses around block return value
-  --> $DIR/lint-unnecessary-parens.rs:124:9
+  --> $DIR/lint-unnecessary-parens.rs:123:9
    |
 LL |         (unit![] - One)
    |         ^             ^
@@ -364,7 +364,7 @@ LL +         unit![] - One
    |
 
 error: unnecessary parentheses around block return value
-  --> $DIR/lint-unnecessary-parens.rs:127:9
+  --> $DIR/lint-unnecessary-parens.rs:126:9
    |
 LL |         (unit! {} - One)
    |         ^              ^
@@ -376,7 +376,7 @@ LL +         unit! {} - One
    |
 
 error: unnecessary parentheses around assigned value
-  --> $DIR/lint-unnecessary-parens.rs:132:14
+  --> $DIR/lint-unnecessary-parens.rs:131:14
    |
 LL |     let _r = (&x);
    |              ^  ^
@@ -388,7 +388,7 @@ LL +     let _r = &x;
    |
 
 error: unnecessary parentheses around assigned value
-  --> $DIR/lint-unnecessary-parens.rs:133:14
+  --> $DIR/lint-unnecessary-parens.rs:132:14
    |
 LL |     let _r = (&mut x);
    |              ^      ^
diff --git a/tests/ui/lint/unused/lint-unused-mut-variables.rs b/tests/ui/lint/unused/lint-unused-mut-variables.rs
index f0c7dff666e29..bc38af9867cd9 100644
--- a/tests/ui/lint/unused/lint-unused-mut-variables.rs
+++ b/tests/ui/lint/unused/lint-unused-mut-variables.rs
@@ -3,7 +3,7 @@
 // Exercise the unused_mut attribute in some positive and negative cases
 
 #![warn(unused_mut)]
-#![feature(async_closure, raw_ref_op)]
+#![feature(async_closure)]
 
 async fn baz_async(
     mut a: i32,
diff --git a/tests/ui/macros/stringify.rs b/tests/ui/macros/stringify.rs
index 37409dd066d5d..f405cd253deb5 100644
--- a/tests/ui/macros/stringify.rs
+++ b/tests/ui/macros/stringify.rs
@@ -14,7 +14,6 @@
 #![feature(let_chains)]
 #![feature(more_qualified_paths)]
 #![feature(never_patterns)]
-#![feature(raw_ref_op)]
 #![feature(trait_alias)]
 #![feature(try_blocks)]
 #![feature(type_ascription)]
diff --git a/tests/ui/mir/mir_raw_fat_ptr.rs b/tests/ui/mir/mir_raw_fat_ptr.rs
index a5a48587e3bbe..96c030b70e50f 100644
--- a/tests/ui/mir/mir_raw_fat_ptr.rs
+++ b/tests/ui/mir/mir_raw_fat_ptr.rs
@@ -2,7 +2,6 @@
 // check raw fat pointer ops in mir
 // FIXME: please improve this when we get monomorphization support
 
-#![feature(raw_ref_op)]
 #![allow(ambiguous_wide_pointer_comparisons)]
 
 use std::mem;
diff --git a/tests/ui/mir/mir_raw_fat_ptr.stderr b/tests/ui/mir/mir_raw_fat_ptr.stderr
index a9e9dd66ebdfa..cd99d566654f9 100644
--- a/tests/ui/mir/mir_raw_fat_ptr.stderr
+++ b/tests/ui/mir/mir_raw_fat_ptr.stderr
@@ -1,5 +1,5 @@
 warning: method `foo` is never used
-  --> $DIR/mir_raw_fat_ptr.rs:101:16
+  --> $DIR/mir_raw_fat_ptr.rs:100:16
    |
 LL | trait Foo { fn foo(&self) -> usize; }
    |       ---      ^^^
diff --git a/tests/ui/packed/packed-struct-address-of-element.rs b/tests/ui/packed/packed-struct-address-of-element.rs
index 3fc27d4a96a76..5d7c0b3d8b1b1 100644
--- a/tests/ui/packed/packed-struct-address-of-element.rs
+++ b/tests/ui/packed/packed-struct-address-of-element.rs
@@ -1,6 +1,5 @@
 //@ run-pass
 #![allow(dead_code)]
-#![feature(raw_ref_op)]
 //@ ignore-emscripten weird assertion?
 
 #[repr(packed)]
diff --git a/tests/ui/raw-ref-op/feature-raw-ref-op.rs b/tests/ui/raw-ref-op/feature-raw-ref-op.rs
deleted file mode 100644
index 0a44b1cde40b7..0000000000000
--- a/tests/ui/raw-ref-op/feature-raw-ref-op.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-// gate-test-raw_ref_op
-
-macro_rules! is_expr {
-    ($e:expr) => {}
-}
-
-is_expr!(&raw const a);         //~ ERROR raw address of syntax is experimental
-is_expr!(&raw mut a);           //~ ERROR raw address of syntax is experimental
-
-#[cfg(FALSE)]
-fn cfgd_out() {
-    let mut a = 0;
-    &raw const a;               //~ ERROR raw address of syntax is experimental
-    &raw mut a;                 //~ ERROR raw address of syntax is experimental
-}
-
-fn main() {
-    let mut y = 123;
-    let x = &raw const y;       //~ ERROR raw address of syntax is experimental
-    let x = &raw mut y;         //~ ERROR raw address of syntax is experimental
-}
diff --git a/tests/ui/raw-ref-op/feature-raw-ref-op.stderr b/tests/ui/raw-ref-op/feature-raw-ref-op.stderr
deleted file mode 100644
index 4ffd0c90e48b3..0000000000000
--- a/tests/ui/raw-ref-op/feature-raw-ref-op.stderr
+++ /dev/null
@@ -1,63 +0,0 @@
-error[E0658]: raw address of syntax is experimental
-  --> $DIR/feature-raw-ref-op.rs:13:5
-   |
-LL |     &raw const a;
-   |     ^^^^^^^^^^
-   |
-   = note: see issue #64490 <https://github.com/rust-lang/rust/issues/64490> for more information
-   = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: raw address of syntax is experimental
-  --> $DIR/feature-raw-ref-op.rs:14:5
-   |
-LL |     &raw mut a;
-   |     ^^^^^^^^
-   |
-   = note: see issue #64490 <https://github.com/rust-lang/rust/issues/64490> for more information
-   = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: raw address of syntax is experimental
-  --> $DIR/feature-raw-ref-op.rs:19:13
-   |
-LL |     let x = &raw const y;
-   |             ^^^^^^^^^^
-   |
-   = note: see issue #64490 <https://github.com/rust-lang/rust/issues/64490> for more information
-   = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: raw address of syntax is experimental
-  --> $DIR/feature-raw-ref-op.rs:20:13
-   |
-LL |     let x = &raw mut y;
-   |             ^^^^^^^^
-   |
-   = note: see issue #64490 <https://github.com/rust-lang/rust/issues/64490> for more information
-   = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: raw address of syntax is experimental
-  --> $DIR/feature-raw-ref-op.rs:7:10
-   |
-LL | is_expr!(&raw const a);
-   |          ^^^^^^^^^^
-   |
-   = note: see issue #64490 <https://github.com/rust-lang/rust/issues/64490> for more information
-   = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: raw address of syntax is experimental
-  --> $DIR/feature-raw-ref-op.rs:8:10
-   |
-LL | is_expr!(&raw mut a);
-   |          ^^^^^^^^
-   |
-   = note: see issue #64490 <https://github.com/rust-lang/rust/issues/64490> for more information
-   = help: add `#![feature(raw_ref_op)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 6 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/raw-ref-op/raw-ref-op.rs b/tests/ui/raw-ref-op/raw-ref-op.rs
index 70b7a5a480671..0989a6005dc56 100644
--- a/tests/ui/raw-ref-op/raw-ref-op.rs
+++ b/tests/ui/raw-ref-op/raw-ref-op.rs
@@ -1,7 +1,5 @@
 //@ run-pass
 
-#![feature(raw_ref_op)]
-
 fn main() {
     let mut x = 123;
     let c_p = &raw const x;
diff --git a/tests/ui/raw-ref-op/raw-ref-temp-deref.rs b/tests/ui/raw-ref-op/raw-ref-temp-deref.rs
index 5270bdb7a2b53..a0078bbc1cdf5 100644
--- a/tests/ui/raw-ref-op/raw-ref-temp-deref.rs
+++ b/tests/ui/raw-ref-op/raw-ref-temp-deref.rs
@@ -1,7 +1,7 @@
 //@ check-pass
 // Check that taking the address of a place that contains a dereference is
 // allowed.
-#![feature(raw_ref_op, type_ascription)]
+#![feature(type_ascription)]
 
 const PAIR_REF: &(i32, i64) = &(1, 2);
 
diff --git a/tests/ui/raw-ref-op/raw-ref-temp.rs b/tests/ui/raw-ref-op/raw-ref-temp.rs
index 10e47cb34c58d..70f67602af2f1 100644
--- a/tests/ui/raw-ref-op/raw-ref-temp.rs
+++ b/tests/ui/raw-ref-op/raw-ref-temp.rs
@@ -1,5 +1,5 @@
 // Ensure that we don't allow taking the address of temporary values
-#![feature(raw_ref_op, type_ascription)]
+#![feature(type_ascription)]
 
 const FOUR: u64 = 4;
 
diff --git a/tests/ui/raw-ref-op/unusual_locations.rs b/tests/ui/raw-ref-op/unusual_locations.rs
index badf529cb45a2..eb40fa8a7ee89 100644
--- a/tests/ui/raw-ref-op/unusual_locations.rs
+++ b/tests/ui/raw-ref-op/unusual_locations.rs
@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![feature(raw_ref_op)]
-
 const USES_PTR: () = { let u = (); &raw const u; };
 static ALSO_USES_PTR: () = { let u = (); &raw const u; };
 
diff --git a/tests/ui/sanitizer/thread.rs b/tests/ui/sanitizer/thread.rs
index 9d9ad6ee51867..566774d6b1d64 100644
--- a/tests/ui/sanitizer/thread.rs
+++ b/tests/ui/sanitizer/thread.rs
@@ -20,7 +20,6 @@
 //@ error-pattern: Location is heap block of size 4
 //@ error-pattern: allocated by main thread
 
-#![feature(raw_ref_op)]
 #![feature(rustc_private)]
 extern crate libc;
 
diff --git a/tests/ui/static/raw-ref-extern-static.rs b/tests/ui/static/raw-ref-extern-static.rs
index 95a53a8640d37..81bc5990efe1c 100644
--- a/tests/ui/static/raw-ref-extern-static.rs
+++ b/tests/ui/static/raw-ref-extern-static.rs
@@ -1,5 +1,4 @@
 //@ check-pass
-#![feature(raw_ref_op)]
 use std::ptr;
 
 // see https://github.com/rust-lang/rust/issues/125833
diff --git a/tests/ui/static/raw-ref-static-mut.rs b/tests/ui/static/raw-ref-static-mut.rs
index 6855cc7b050b5..d4159fc65caa2 100644
--- a/tests/ui/static/raw-ref-static-mut.rs
+++ b/tests/ui/static/raw-ref-static-mut.rs
@@ -1,5 +1,4 @@
 //@ check-pass
-#![feature(raw_ref_op)]
 use std::ptr;
 
 // see https://github.com/rust-lang/rust/issues/125833
diff --git a/tests/ui/unpretty/expanded-exhaustive.rs b/tests/ui/unpretty/expanded-exhaustive.rs
index 29472df897a1f..279d723a26c51 100644
--- a/tests/ui/unpretty/expanded-exhaustive.rs
+++ b/tests/ui/unpretty/expanded-exhaustive.rs
@@ -19,7 +19,6 @@
 #![feature(never_type)]
 #![feature(pattern_types)]
 #![feature(prelude_import)]
-#![feature(raw_ref_op)]
 #![feature(specialization)]
 #![feature(trace_macros)]
 #![feature(trait_alias)]
diff --git a/tests/ui/unpretty/expanded-exhaustive.stdout b/tests/ui/unpretty/expanded-exhaustive.stdout
index cf2f6f8cbaa99..149659693ae67 100644
--- a/tests/ui/unpretty/expanded-exhaustive.stdout
+++ b/tests/ui/unpretty/expanded-exhaustive.stdout
@@ -20,7 +20,6 @@
 #![feature(never_type)]
 #![feature(pattern_types)]
 #![feature(prelude_import)]
-#![feature(raw_ref_op)]
 #![feature(specialization)]
 #![feature(trace_macros)]
 #![feature(trait_alias)]

From b8464961a2681585a6231b93cd7e85e50022c2b3 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 13 Jul 2024 13:56:05 +0200
Subject: [PATCH 408/685] soft-deprecate the addr_of macros

---
 library/core/src/ptr/mod.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 25d8f4a0adbd9..3fe5212cea779 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -2209,6 +2209,9 @@ impl<F: FnPtr> fmt::Debug for F {
 
 /// Creates a `const` raw pointer to a place, without creating an intermediate reference.
 ///
+/// `addr_of!(expr)` is equivalent to `&raw const expr`. The macro is *soft-deprecated*;
+/// use `&raw const` instead.
+///
 /// Creating a reference with `&`/`&mut` is only allowed if the pointer is properly aligned
 /// and points to initialized data. For cases where those requirements do not hold,
 /// raw pointers should be used instead. However, `&expr as *const _` creates a reference
@@ -2283,6 +2286,9 @@ pub macro addr_of($place:expr) {
 
 /// Creates a `mut` raw pointer to a place, without creating an intermediate reference.
 ///
+/// `addr_of_mut!(expr)` is equivalent to `&raw mut expr`. The macro is *soft-deprecated*;
+/// use `&raw mut` instead.
+///
 /// Creating a reference with `&`/`&mut` is only allowed if the pointer is properly aligned
 /// and points to initialized data. For cases where those requirements do not hold,
 /// raw pointers should be used instead. However, `&mut expr as *mut _` creates a reference

From 35709be02d43b40e7f720408f8a88bf6e9d5501d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 12 Aug 2024 10:57:57 +0200
Subject: [PATCH 409/685] rename AddressOf -> RawBorrow inside the compiler

---
 compiler/rustc_borrowck/src/def_use.rs         |  4 ++--
 compiler/rustc_borrowck/src/lib.rs             |  2 +-
 .../src/polonius/loan_invalidations.rs         |  2 +-
 compiler/rustc_borrowck/src/type_check/mod.rs  |  6 +++---
 .../rustc_codegen_cranelift/src/analyze.rs     |  2 +-
 compiler/rustc_codegen_cranelift/src/base.rs   |  2 +-
 compiler/rustc_codegen_ssa/src/mir/analyze.rs  |  4 ++--
 compiler/rustc_codegen_ssa/src/mir/rvalue.rs   |  6 +++---
 .../rustc_const_eval/src/check_consts/check.rs | 10 +++++-----
 .../src/check_consts/qualifs.rs                |  2 +-
 .../src/check_consts/resolver.rs               |  4 ++--
 .../rustc_const_eval/src/interpret/step.rs     |  2 +-
 compiler/rustc_hir_typeck/src/cast.rs          |  2 +-
 compiler/rustc_middle/src/mir/pretty.rs        |  2 +-
 compiler/rustc_middle/src/mir/statement.rs     |  2 +-
 compiler/rustc_middle/src/mir/syntax.rs        |  8 ++++----
 compiler/rustc_middle/src/mir/tcx.rs           |  2 +-
 compiler/rustc_middle/src/mir/visit.rs         | 18 +++++++++---------
 compiler/rustc_middle/src/thir.rs              |  2 +-
 compiler/rustc_middle/src/thir/visit.rs        |  2 +-
 .../src/build/custom/parse/instruction.rs      |  4 ++--
 .../rustc_mir_build/src/build/expr/as_place.rs |  2 +-
 .../src/build/expr/as_rvalue.rs                |  2 +-
 .../rustc_mir_build/src/build/expr/category.rs |  2 +-
 .../rustc_mir_build/src/build/expr/into.rs     |  4 ++--
 compiler/rustc_mir_build/src/check_unsafety.rs |  4 ++--
 compiler/rustc_mir_build/src/thir/cx/expr.rs   |  4 ++--
 .../src/thir/pattern/check_match.rs            |  2 +-
 compiler/rustc_mir_build/src/thir/print.rs     |  4 ++--
 .../rustc_mir_dataflow/src/elaborate_drops.rs  |  2 +-
 .../src/impls/borrowed_locals.rs               |  2 +-
 .../src/impls/initialized.rs                   |  2 +-
 .../rustc_mir_dataflow/src/impls/liveness.rs   |  4 ++--
 .../src/move_paths/builder.rs                  |  2 +-
 .../rustc_mir_dataflow/src/value_analysis.rs   |  2 +-
 compiler/rustc_mir_transform/src/add_retag.rs  |  4 ++--
 .../rustc_mir_transform/src/check_alignment.rs |  2 +-
 .../src/deduce_param_attrs.rs                  |  2 +-
 compiler/rustc_mir_transform/src/dest_prop.rs  |  2 +-
 compiler/rustc_mir_transform/src/gvn.rs        |  4 ++--
 .../rustc_mir_transform/src/instsimplify.rs    |  2 +-
 .../src/known_panics_lint.rs                   | 10 +++++-----
 .../rustc_mir_transform/src/large_enums.rs     |  4 ++--
 .../rustc_mir_transform/src/promote_consts.rs  |  2 +-
 compiler/rustc_mir_transform/src/ref_prop.rs   |  2 +-
 .../src/shim/async_destructor_ctor.rs          |  4 ++--
 compiler/rustc_mir_transform/src/ssa.rs        |  8 ++++----
 compiler/rustc_mir_transform/src/validate.rs   |  2 +-
 .../rustc_smir/src/rustc_smir/convert/mir.rs   |  2 +-
 compiler/rustc_ty_utils/src/consts.rs          |  6 +++---
 .../clippy_utils/src/qualify_min_const_fn.rs   |  2 +-
 51 files changed, 92 insertions(+), 92 deletions(-)

diff --git a/compiler/rustc_borrowck/src/def_use.rs b/compiler/rustc_borrowck/src/def_use.rs
index 1f0b0981c8f29..e07d7dd309ae2 100644
--- a/compiler/rustc_borrowck/src/def_use.rs
+++ b/compiler/rustc_borrowck/src/def_use.rs
@@ -55,8 +55,8 @@ pub fn categorize(context: PlaceContext) -> Option<DefUse> {
         PlaceContext::NonMutatingUse(NonMutatingUseContext::PlaceMention) |
         PlaceContext::NonUse(NonUseContext::AscribeUserTy(_)) |
 
-        PlaceContext::MutatingUse(MutatingUseContext::AddressOf) |
-        PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf) |
+        PlaceContext::MutatingUse(MutatingUseContext::RawBorrow) |
+        PlaceContext::NonMutatingUse(NonMutatingUseContext::RawBorrow) |
         PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect) |
         PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) |
         PlaceContext::NonMutatingUse(NonMutatingUseContext::Move) |
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 30dd45d847c9b..a529df76bcbc7 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -1242,7 +1242,7 @@ impl<'mir, 'tcx> MirBorrowckCtxt<'_, 'mir, '_, 'tcx> {
                 );
             }
 
-            &Rvalue::AddressOf(mutability, place) => {
+            &Rvalue::RawPtr(mutability, place) => {
                 let access_kind = match mutability {
                     Mutability::Mut => (
                         Deep,
diff --git a/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs
index f090da031a04b..a57041cd04c52 100644
--- a/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs
+++ b/compiler/rustc_borrowck/src/polonius/loan_invalidations.rs
@@ -269,7 +269,7 @@ impl<'cx, 'tcx> LoanInvalidationsGenerator<'cx, 'tcx> {
                 self.access_place(location, place, access_kind, LocalMutationIsAllowed::No);
             }
 
-            &Rvalue::AddressOf(mutability, place) => {
+            &Rvalue::RawPtr(mutability, place) => {
                 let access_kind = match mutability {
                     Mutability::Mut => (
                         Deep,
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index a2669da1b04e8..6983cda6ddf3b 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -756,7 +756,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
             PlaceContext::MutatingUse(_) => ty::Invariant,
             PlaceContext::NonUse(StorageDead | StorageLive | VarDebugInfo) => ty::Invariant,
             PlaceContext::NonMutatingUse(
-                Inspect | Copy | Move | PlaceMention | SharedBorrow | FakeBorrow | AddressOf
+                Inspect | Copy | Move | PlaceMention | SharedBorrow | FakeBorrow | RawBorrow
                 | Projection,
             ) => ty::Covariant,
             PlaceContext::NonUse(AscribeUserTy(variance)) => variance,
@@ -2468,7 +2468,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 self.check_operand(right, location);
             }
 
-            Rvalue::AddressOf(..)
+            Rvalue::RawPtr(..)
             | Rvalue::ThreadLocalRef(..)
             | Rvalue::Len(..)
             | Rvalue::Discriminant(..)
@@ -2485,7 +2485,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             | Rvalue::ThreadLocalRef(_)
             | Rvalue::Repeat(..)
             | Rvalue::Ref(..)
-            | Rvalue::AddressOf(..)
+            | Rvalue::RawPtr(..)
             | Rvalue::Len(..)
             | Rvalue::Cast(..)
             | Rvalue::ShallowInitBox(..)
diff --git a/compiler/rustc_codegen_cranelift/src/analyze.rs b/compiler/rustc_codegen_cranelift/src/analyze.rs
index c5762638a6b13..72380f50385a1 100644
--- a/compiler/rustc_codegen_cranelift/src/analyze.rs
+++ b/compiler/rustc_codegen_cranelift/src/analyze.rs
@@ -25,7 +25,7 @@ pub(crate) fn analyze(fx: &FunctionCx<'_, '_, '_>) -> IndexVec<Local, SsaKind> {
         for stmt in bb.statements.iter() {
             match &stmt.kind {
                 Assign(place_and_rval) => match &place_and_rval.1 {
-                    Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
+                    Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
                         flag_map[place.local] = SsaKind::NotSsa;
                     }
                     _ => {}
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index 9bc7b57c53745..f1d885bf1bce8 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -595,7 +595,7 @@ fn codegen_stmt<'tcx>(
                     let val = cplace.to_cvalue(fx);
                     lval.write_cvalue(fx, val)
                 }
-                Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
+                Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
                     let place = codegen_place(fx, place);
                     let ref_ = place.place_ref(fx, lval.layout());
                     lval.write_cvalue(fx, ref_);
diff --git a/compiler/rustc_codegen_ssa/src/mir/analyze.rs b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
index 6794365c9beef..c8cf341628c32 100644
--- a/compiler/rustc_codegen_ssa/src/mir/analyze.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
@@ -220,14 +220,14 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>
                 | MutatingUseContext::SetDiscriminant
                 | MutatingUseContext::AsmOutput
                 | MutatingUseContext::Borrow
-                | MutatingUseContext::AddressOf
+                | MutatingUseContext::RawBorrow
                 | MutatingUseContext::Projection,
             )
             | PlaceContext::NonMutatingUse(
                 NonMutatingUseContext::Inspect
                 | NonMutatingUseContext::SharedBorrow
                 | NonMutatingUseContext::FakeBorrow
-                | NonMutatingUseContext::AddressOf
+                | NonMutatingUseContext::RawBorrow
                 | NonMutatingUseContext::Projection,
             ) => {
                 self.locals[local] = LocalKind::Memory;
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 3c2c29ac7f7d2..d94c6f8ddcec3 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -584,7 +584,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             mir::Rvalue::CopyForDeref(place) => {
                 self.codegen_operand(bx, &mir::Operand::Copy(place))
             }
-            mir::Rvalue::AddressOf(mutability, place) => {
+            mir::Rvalue::RawPtr(mutability, place) => {
                 let mk_ptr =
                     move |tcx: TyCtxt<'tcx>, ty: Ty<'tcx>| Ty::new_ptr(tcx, ty, mutability);
                 self.codegen_place_to_pointer(bx, place, mk_ptr)
@@ -813,7 +813,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         cg_value.len(bx.cx())
     }
 
-    /// Codegen an `Rvalue::AddressOf` or `Rvalue::Ref`
+    /// Codegen an `Rvalue::RawPtr` or `Rvalue::Ref`
     fn codegen_place_to_pointer(
         &mut self,
         bx: &mut Bx,
@@ -1085,7 +1085,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
             mir::Rvalue::Ref(..) |
             mir::Rvalue::CopyForDeref(..) |
-            mir::Rvalue::AddressOf(..) |
+            mir::Rvalue::RawPtr(..) |
             mir::Rvalue::Len(..) |
             mir::Rvalue::Cast(..) | // (*)
             mir::Rvalue::ShallowInitBox(..) | // (*)
diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index 32a9247bcc70a..86a5afa65ba87 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -431,13 +431,13 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     return;
                 }
             }
-            Rvalue::AddressOf(mutbl, place) => {
+            Rvalue::RawPtr(mutbl, place) => {
                 if let Some(reborrowed_place_ref) = place_as_reborrow(self.tcx, self.body, place) {
                     let ctx = match mutbl {
                         Mutability::Not => {
-                            PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf)
+                            PlaceContext::NonMutatingUse(NonMutatingUseContext::RawBorrow)
                         }
-                        Mutability::Mut => PlaceContext::MutatingUse(MutatingUseContext::AddressOf),
+                        Mutability::Mut => PlaceContext::MutatingUse(MutatingUseContext::RawBorrow),
                     };
                     self.visit_local(reborrowed_place_ref.local, ctx, location);
                     self.visit_projection(reborrowed_place_ref, ctx, location);
@@ -472,7 +472,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
             }
 
             Rvalue::Ref(_, BorrowKind::Mut { .. }, place)
-            | Rvalue::AddressOf(Mutability::Mut, place) => {
+            | Rvalue::RawPtr(Mutability::Mut, place) => {
                 // Inside mutable statics, we allow arbitrary mutable references.
                 // We've allowed `static mut FOO = &mut [elements];` for a long time (the exact
                 // reasons why are lost to history), and there is no reason to restrict that to
@@ -493,7 +493,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
             }
 
             Rvalue::Ref(_, BorrowKind::Shared | BorrowKind::Fake(_), place)
-            | Rvalue::AddressOf(Mutability::Not, place) => {
+            | Rvalue::RawPtr(Mutability::Not, place) => {
                 let borrowed_place_has_mut_interior = qualifs::in_place::<HasMutInterior, _>(
                     self.ccx,
                     &mut |local| self.qualifs.has_mut_interior(self.ccx, local, location),
diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
index c0f2d113c7e31..c566dc7fa844d 100644
--- a/compiler/rustc_const_eval/src/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
@@ -291,7 +291,7 @@ where
             in_operand::<Q, _>(cx, in_local, lhs) || in_operand::<Q, _>(cx, in_local, rhs)
         }
 
-        Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
+        Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
             // Special-case reborrows to be more like a copy of the reference.
             if let Some((place_base, ProjectionElem::Deref)) = place.as_ref().last_projection() {
                 let base_ty = place_base.ty(cx.body, cx.tcx).ty;
diff --git a/compiler/rustc_const_eval/src/check_consts/resolver.rs b/compiler/rustc_const_eval/src/check_consts/resolver.rs
index ea3a5264357c9..681184f7fbcde 100644
--- a/compiler/rustc_const_eval/src/check_consts/resolver.rs
+++ b/compiler/rustc_const_eval/src/check_consts/resolver.rs
@@ -96,7 +96,7 @@ where
     }
 
     fn address_of_allows_mutation(&self) -> bool {
-        // Exact set of permissions granted by AddressOf is undecided. Conservatively assume that
+        // Exact set of permissions granted by RawPtr is undecided. Conservatively assume that
         // it might allow mutation until resolution of #56604.
         true
     }
@@ -170,7 +170,7 @@ where
         self.super_rvalue(rvalue, location);
 
         match rvalue {
-            mir::Rvalue::AddressOf(_mt, borrowed_place) => {
+            mir::Rvalue::RawPtr(_mt, borrowed_place) => {
                 if !borrowed_place.is_indirect() && self.address_of_allows_mutation() {
                     let place_ty = borrowed_place.ty(self.ccx.body, self.ccx.tcx).ty;
                     if Q::in_any_value_of_ty(self.ccx, place_ty) {
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index aaee6f6d247f8..70cfba1922c6e 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -234,7 +234,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 self.write_immediate(*val, &dest)?;
             }
 
-            AddressOf(_, place) => {
+            RawPtr(_, place) => {
                 // Figure out whether this is an addr_of of an already raw place.
                 let place_base_raw = if place.is_indirect_first_projection() {
                     let ty = self.frame().body.local_decls[place.local].ty;
diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs
index 7cd97166ed1e9..03a76d44cc987 100644
--- a/compiler/rustc_hir_typeck/src/cast.rs
+++ b/compiler/rustc_hir_typeck/src/cast.rs
@@ -967,7 +967,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                 // need to special-case obtaining a raw pointer
                 // from a region pointer to a vector.
 
-                // Coerce to a raw pointer so that we generate AddressOf in MIR.
+                // Coerce to a raw pointer so that we generate RawPtr in MIR.
                 let array_ptr_type = Ty::new_ptr(fcx.tcx, m_expr.ty, m_expr.mutbl);
                 fcx.coerce(self.expr, self.expr_ty, array_ptr_type, AllowTwoPhase::No, None)
                     .unwrap_or_else(|_| {
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 5dd0e69cf1fe6..212eda666ca05 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1038,7 +1038,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
 
             CopyForDeref(ref place) => write!(fmt, "deref_copy {place:#?}"),
 
-            AddressOf(mutability, ref place) => {
+            RawPtr(mutability, ref place) => {
                 write!(fmt, "&raw {mut_str} {place:?}", mut_str = mutability.ptr_str())
             }
 
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index 3009ca8d8097a..bc7dfa6205e71 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -423,7 +423,7 @@ impl<'tcx> Rvalue<'tcx> {
             | Rvalue::Repeat(_, _)
             | Rvalue::Ref(_, _, _)
             | Rvalue::ThreadLocalRef(_)
-            | Rvalue::AddressOf(_, _)
+            | Rvalue::RawPtr(_, _)
             | Rvalue::Len(_)
             | Rvalue::Cast(
                 CastKind::IntToInt
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index 1119ff6ff3d60..51b4154ddab78 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -1293,14 +1293,14 @@ pub enum Rvalue<'tcx> {
     /// nature of this operation?
     ThreadLocalRef(DefId),
 
-    /// Creates a pointer with the indicated mutability to the place.
+    /// Creates a raw pointer with the indicated mutability to the place.
     ///
-    /// This is generated by pointer casts like `&v as *const _` or raw address of expressions like
-    /// `&raw v` or `addr_of!(v)`.
+    /// This is generated by pointer casts like `&v as *const _` or raw borrow expressions like
+    /// `&raw const v`.
     ///
     /// Like with references, the semantics of this operation are heavily dependent on the aliasing
     /// model.
-    AddressOf(Mutability, Place<'tcx>),
+    RawPtr(Mutability, Place<'tcx>),
 
     /// Yields the length of the place, as a `usize`.
     ///
diff --git a/compiler/rustc_middle/src/mir/tcx.rs b/compiler/rustc_middle/src/mir/tcx.rs
index 1075344dc00f3..8d57d0d865469 100644
--- a/compiler/rustc_middle/src/mir/tcx.rs
+++ b/compiler/rustc_middle/src/mir/tcx.rs
@@ -170,7 +170,7 @@ impl<'tcx> Rvalue<'tcx> {
                 let place_ty = place.ty(local_decls, tcx).ty;
                 Ty::new_ref(tcx, reg, place_ty, bk.to_mutbl_lossy())
             }
-            Rvalue::AddressOf(mutability, ref place) => {
+            Rvalue::RawPtr(mutability, ref place) => {
                 let place_ty = place.ty(local_decls, tcx).ty;
                 Ty::new_ptr(tcx, place_ty, mutability)
             }
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index 3921176873c81..bfb129495ce83 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -682,13 +682,13 @@ macro_rules! make_mir_visitor {
                         );
                     }
 
-                    Rvalue::AddressOf(m, path) => {
+                    Rvalue::RawPtr(m, path) => {
                         let ctx = match m {
                             Mutability::Mut => PlaceContext::MutatingUse(
-                                MutatingUseContext::AddressOf
+                                MutatingUseContext::RawBorrow
                             ),
                             Mutability::Not => PlaceContext::NonMutatingUse(
-                                NonMutatingUseContext::AddressOf
+                                NonMutatingUseContext::RawBorrow
                             ),
                         };
                         self.visit_place(path, ctx, location);
@@ -1299,8 +1299,8 @@ pub enum NonMutatingUseContext {
     /// FIXME: do we need to distinguish shallow and deep fake borrows? In fact, do we need to
     /// distinguish fake and normal deep borrows?
     FakeBorrow,
-    /// AddressOf for *const pointer.
-    AddressOf,
+    /// `&raw const`.
+    RawBorrow,
     /// PlaceMention statement.
     ///
     /// This statement is executed as a check that the `Place` is live without reading from it,
@@ -1333,8 +1333,8 @@ pub enum MutatingUseContext {
     Drop,
     /// Mutable borrow.
     Borrow,
-    /// AddressOf for *mut pointer.
-    AddressOf,
+    /// `&raw mut`.
+    RawBorrow,
     /// Used as base for another place, e.g., `x` in `x.y`. Could potentially mutate the place.
     /// For example, the projection `x.y` is marked as a mutation in these cases:
     /// ```ignore (illustrative)
@@ -1386,8 +1386,8 @@ impl PlaceContext {
     pub fn is_address_of(&self) -> bool {
         matches!(
             self,
-            PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf)
-                | PlaceContext::MutatingUse(MutatingUseContext::AddressOf)
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::RawBorrow)
+                | PlaceContext::MutatingUse(MutatingUseContext::RawBorrow)
         )
     }
 
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index f2ea32275f9b1..aca1390935ef1 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -407,7 +407,7 @@ pub enum ExprKind<'tcx> {
         arg: ExprId,
     },
     /// A `&raw [const|mut] $place_expr` raw borrow resulting in type `*[const|mut] T`.
-    AddressOf {
+    RawBorrow {
         mutability: hir::Mutability,
         arg: ExprId,
     },
diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
index f198881043739..e246ecebbec0b 100644
--- a/compiler/rustc_middle/src/thir/visit.rs
+++ b/compiler/rustc_middle/src/thir/visit.rs
@@ -92,7 +92,7 @@ pub fn walk_expr<'thir, 'tcx: 'thir, V: Visitor<'thir, 'tcx>>(
         }
         VarRef { id: _ } | UpvarRef { closure_def_id: _, var_hir_id: _ } => {}
         Borrow { arg, borrow_kind: _ } => visitor.visit_expr(&visitor.thir()[arg]),
-        AddressOf { arg, mutability: _ } => visitor.visit_expr(&visitor.thir()[arg]),
+        RawBorrow { arg, mutability: _ } => visitor.visit_expr(&visitor.thir()[arg]),
         Break { value, label: _ } => {
             if let Some(value) = value {
                 visitor.visit_expr(&visitor.thir()[value])
diff --git a/compiler/rustc_mir_build/src/build/custom/parse/instruction.rs b/compiler/rustc_mir_build/src/build/custom/parse/instruction.rs
index 56896d945e5f3..0b13ceb574d04 100644
--- a/compiler/rustc_mir_build/src/build/custom/parse/instruction.rs
+++ b/compiler/rustc_mir_build/src/build/custom/parse/instruction.rs
@@ -244,8 +244,8 @@ impl<'tcx, 'body> ParseCtxt<'tcx, 'body> {
             ExprKind::Borrow { borrow_kind, arg } => Ok(
                 Rvalue::Ref(self.tcx.lifetimes.re_erased, *borrow_kind, self.parse_place(*arg)?)
             ),
-            ExprKind::AddressOf { mutability, arg } => Ok(
-                Rvalue::AddressOf(*mutability, self.parse_place(*arg)?)
+            ExprKind::RawBorrow { mutability, arg } => Ok(
+                Rvalue::RawPtr(*mutability, self.parse_place(*arg)?)
             ),
             ExprKind::Binary { op, lhs, rhs } =>  Ok(
                 Rvalue::BinaryOp(*op, Box::new((self.parse_operand(*lhs)?, self.parse_operand(*rhs)?)))
diff --git a/compiler/rustc_mir_build/src/build/expr/as_place.rs b/compiler/rustc_mir_build/src/build/expr/as_place.rs
index b80d9de70c8da..07784982631f8 100644
--- a/compiler/rustc_mir_build/src/build/expr/as_place.rs
+++ b/compiler/rustc_mir_build/src/build/expr/as_place.rs
@@ -542,7 +542,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | ExprKind::PointerCoercion { .. }
             | ExprKind::Repeat { .. }
             | ExprKind::Borrow { .. }
-            | ExprKind::AddressOf { .. }
+            | ExprKind::RawBorrow { .. }
             | ExprKind::Match { .. }
             | ExprKind::If { .. }
             | ExprKind::Loop { .. }
diff --git a/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs
index 379d2140c09c5..0c9571da3cf7f 100644
--- a/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs
+++ b/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs
@@ -512,7 +512,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | ExprKind::NeverToAny { .. }
             | ExprKind::Use { .. }
             | ExprKind::Borrow { .. }
-            | ExprKind::AddressOf { .. }
+            | ExprKind::RawBorrow { .. }
             | ExprKind::Adt { .. }
             | ExprKind::Loop { .. }
             | ExprKind::LogicalOp { .. }
diff --git a/compiler/rustc_mir_build/src/build/expr/category.rs b/compiler/rustc_mir_build/src/build/expr/category.rs
index e07ba6b6e9383..e0349e3e3f668 100644
--- a/compiler/rustc_mir_build/src/build/expr/category.rs
+++ b/compiler/rustc_mir_build/src/build/expr/category.rs
@@ -51,7 +51,7 @@ impl Category {
             | ExprKind::Use { .. }
             | ExprKind::Adt { .. }
             | ExprKind::Borrow { .. }
-            | ExprKind::AddressOf { .. }
+            | ExprKind::RawBorrow { .. }
             | ExprKind::Yield { .. }
             | ExprKind::Call { .. }
             | ExprKind::InlineAsm { .. } => Some(Category::Rvalue(RvalueFunc::Into)),
diff --git a/compiler/rustc_mir_build/src/build/expr/into.rs b/compiler/rustc_mir_build/src/build/expr/into.rs
index 01b32b8e05e49..1c805ed20cc36 100644
--- a/compiler/rustc_mir_build/src/build/expr/into.rs
+++ b/compiler/rustc_mir_build/src/build/expr/into.rs
@@ -303,12 +303,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 this.cfg.push_assign(block, source_info, destination, borrow);
                 block.unit()
             }
-            ExprKind::AddressOf { mutability, arg } => {
+            ExprKind::RawBorrow { mutability, arg } => {
                 let place = match mutability {
                     hir::Mutability::Not => this.as_read_only_place(block, arg),
                     hir::Mutability::Mut => this.as_place(block, arg),
                 };
-                let address_of = Rvalue::AddressOf(mutability, unpack!(block = place));
+                let address_of = Rvalue::RawPtr(mutability, unpack!(block = place));
                 this.cfg.push_assign(block, source_info, destination, address_of);
                 block.unit()
             }
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index 9b85ad0ad0891..e4e5844d2ef8e 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -397,7 +397,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
             | ExprKind::Scope { .. }
             | ExprKind::Cast { .. } => {}
 
-            ExprKind::AddressOf { .. }
+            ExprKind::RawBorrow { .. }
             | ExprKind::Adt { .. }
             | ExprKind::Array { .. }
             | ExprKind::Binary { .. }
@@ -498,7 +498,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                     }
                 }
             }
-            ExprKind::AddressOf { arg, .. } => {
+            ExprKind::RawBorrow { arg, .. } => {
                 if let ExprKind::Scope { value: arg, .. } = self.thir[arg].kind
                 // THIR desugars UNSAFE_STATIC into *UNSAFE_STATIC_REF, where
                 // UNSAFE_STATIC_REF holds the addr of the UNSAFE_STATIC, so: take two steps
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index d4de5fac96eb0..2cbaed2cc6258 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -143,7 +143,7 @@ impl<'tcx> Cx<'tcx> {
                 arg: self.thir.exprs.push(expr),
             },
             Adjust::Borrow(AutoBorrow::RawPtr(mutability)) => {
-                ExprKind::AddressOf { mutability, arg: self.thir.exprs.push(expr) }
+                ExprKind::RawBorrow { mutability, arg: self.thir.exprs.push(expr) }
             }
             Adjust::DynStar => ExprKind::Cast { source: self.thir.exprs.push(expr) },
         };
@@ -396,7 +396,7 @@ impl<'tcx> Cx<'tcx> {
             }
 
             hir::ExprKind::AddrOf(hir::BorrowKind::Raw, mutability, arg) => {
-                ExprKind::AddressOf { mutability, arg: self.mirror_expr(arg) }
+                ExprKind::RawBorrow { mutability, arg: self.mirror_expr(arg) }
             }
 
             hir::ExprKind::Block(blk, _) => ExprKind::Block { block: self.mirror_block(blk) },
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index 85b9dacb1293c..bc1acd51c6911 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -325,7 +325,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             Assign { .. } | AssignOp { .. } | InlineAsm { .. } | Let { .. } => true,
 
             // These evaluate to a value.
-            AddressOf { .. }
+            RawBorrow { .. }
             | Adt { .. }
             | Array { .. }
             | Binary { .. }
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
index 2d4b39e7b08f3..ce7774f594882 100644
--- a/compiler/rustc_mir_build/src/thir/print.rs
+++ b/compiler/rustc_mir_build/src/thir/print.rs
@@ -379,8 +379,8 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 self.print_expr(*arg, depth_lvl + 2);
                 print_indented!(self, ")", depth_lvl);
             }
-            AddressOf { mutability, arg } => {
-                print_indented!(self, "AddressOf {", depth_lvl);
+            RawBorrow { mutability, arg } => {
+                print_indented!(self, "RawBorrow {", depth_lvl);
                 print_indented!(self, format!("mutability: {:?}", mutability), depth_lvl + 1);
                 print_indented!(self, "arg:", depth_lvl + 1);
                 self.print_expr(*arg, depth_lvl + 2);
diff --git a/compiler/rustc_mir_dataflow/src/elaborate_drops.rs b/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
index 2ec3b53bc9814..d7e738b8829e0 100644
--- a/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
+++ b/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
@@ -703,7 +703,7 @@ where
             statements: vec![
                 self.assign(
                     ptr,
-                    Rvalue::AddressOf(Mutability::Mut, tcx.mk_place_index(self.place, cur)),
+                    Rvalue::RawPtr(Mutability::Mut, tcx.mk_place_index(self.place, cur)),
                 ),
                 self.assign(
                     cur.into(),
diff --git a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
index 885fdd0d58bea..e8e78fb8a89ee 100644
--- a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
@@ -94,7 +94,7 @@ where
         match rvalue {
             // We ignore fake borrows as these get removed after analysis and shouldn't effect
             // the layout of generators.
-            Rvalue::AddressOf(_, borrowed_place)
+            Rvalue::RawPtr(_, borrowed_place)
             | Rvalue::Ref(_, BorrowKind::Mut { .. } | BorrowKind::Shared, borrowed_place) => {
                 if !borrowed_place.is_indirect() {
                     self.trans.gen_(borrowed_place.local);
diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
index 7822fb17f7298..ddfd0739358d1 100644
--- a/compiler/rustc_mir_dataflow/src/impls/initialized.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
@@ -351,7 +351,7 @@ impl<'tcx> GenKillAnalysis<'tcx> for MaybeInitializedPlaces<'_, '_, 'tcx> {
             && let Some((_, rvalue)) = statement.kind.as_assign()
             && let mir::Rvalue::Ref(_, mir::BorrowKind::Mut { .. }, place)
                 // FIXME: Does `&raw const foo` allow mutation? See #90413.
-                | mir::Rvalue::AddressOf(_, place) = rvalue
+                | mir::Rvalue::RawPtr(_, place) = rvalue
             && let LookupResult::Exact(mpi) = self.move_data().rev_lookup.find(place.as_ref())
         {
             on_all_children_bits(self.move_data(), mpi, |child| {
diff --git a/compiler/rustc_mir_dataflow/src/impls/liveness.rs b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
index 48bdb1316012f..24a4b32ceb7c4 100644
--- a/compiler/rustc_mir_dataflow/src/impls/liveness.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
@@ -189,13 +189,13 @@ impl DefUse {
 
             // All other contexts are uses...
             PlaceContext::MutatingUse(
-                MutatingUseContext::AddressOf
+                MutatingUseContext::RawBorrow
                 | MutatingUseContext::Borrow
                 | MutatingUseContext::Drop
                 | MutatingUseContext::Retag,
             )
             | PlaceContext::NonMutatingUse(
-                NonMutatingUseContext::AddressOf
+                NonMutatingUseContext::RawBorrow
                 | NonMutatingUseContext::Copy
                 | NonMutatingUseContext::Inspect
                 | NonMutatingUseContext::Move
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index 86091379f5a92..14390723ba4b6 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -432,7 +432,7 @@ impl<'b, 'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> Gatherer<'b, 'a, 'tcx, F> {
             }
             Rvalue::CopyForDeref(..) => unreachable!(),
             Rvalue::Ref(..)
-            | Rvalue::AddressOf(..)
+            | Rvalue::RawPtr(..)
             | Rvalue::Discriminant(..)
             | Rvalue::Len(..)
             | Rvalue::NullaryOp(
diff --git a/compiler/rustc_mir_dataflow/src/value_analysis.rs b/compiler/rustc_mir_dataflow/src/value_analysis.rs
index 139fd592f69a3..2b20a35b61e29 100644
--- a/compiler/rustc_mir_dataflow/src/value_analysis.rs
+++ b/compiler/rustc_mir_dataflow/src/value_analysis.rs
@@ -177,7 +177,7 @@ pub trait ValueAnalysis<'tcx> {
         match rvalue {
             Rvalue::Use(operand) => self.handle_operand(operand, state),
             Rvalue::CopyForDeref(place) => self.handle_operand(&Operand::Copy(*place), state),
-            Rvalue::Ref(..) | Rvalue::AddressOf(..) => {
+            Rvalue::Ref(..) | Rvalue::RawPtr(..) => {
                 // We don't track such places.
                 ValueOrPlace::TOP
             }
diff --git a/compiler/rustc_mir_transform/src/add_retag.rs b/compiler/rustc_mir_transform/src/add_retag.rs
index 16977a63c598e..12a68790374e5 100644
--- a/compiler/rustc_mir_transform/src/add_retag.rs
+++ b/compiler/rustc_mir_transform/src/add_retag.rs
@@ -131,9 +131,9 @@ impl<'tcx> MirPass<'tcx> for AddRetag {
                             // Ptr-creating operations already do their own internal retagging, no
                             // need to also add a retag statement.
                             // *Except* if we are deref'ing a Box, because those get desugared to directly working
-                            // with the inner raw pointer! That's relevant for `AddressOf` as Miri otherwise makes it
+                            // with the inner raw pointer! That's relevant for `RawPtr` as Miri otherwise makes it
                             // a NOP when the original pointer is already raw.
-                            Rvalue::AddressOf(_mutbl, place) => {
+                            Rvalue::RawPtr(_mutbl, place) => {
                                 // Using `is_box_global` here is a bit sketchy: if this code is
                                 // generic over the allocator, we'll not add a retag! This is a hack
                                 // to make Stacked Borrows compatible with custom allocator code.
diff --git a/compiler/rustc_mir_transform/src/check_alignment.rs b/compiler/rustc_mir_transform/src/check_alignment.rs
index a1dbd7dc50ec7..5dfdcfc8b9446 100644
--- a/compiler/rustc_mir_transform/src/check_alignment.rs
+++ b/compiler/rustc_mir_transform/src/check_alignment.rs
@@ -71,7 +71,7 @@ struct PointerFinder<'tcx, 'a> {
 impl<'tcx, 'a> Visitor<'tcx> for PointerFinder<'tcx, 'a> {
     fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) {
         // We want to only check reads and writes to Places, so we specifically exclude
-        // Borrows and AddressOf.
+        // Borrow and RawBorrow.
         match context {
             PlaceContext::MutatingUse(
                 MutatingUseContext::Store
diff --git a/compiler/rustc_mir_transform/src/deduce_param_attrs.rs b/compiler/rustc_mir_transform/src/deduce_param_attrs.rs
index 370e930b74098..71af099199ea9 100644
--- a/compiler/rustc_mir_transform/src/deduce_param_attrs.rs
+++ b/compiler/rustc_mir_transform/src/deduce_param_attrs.rs
@@ -40,7 +40,7 @@ impl<'tcx> Visitor<'tcx> for DeduceReadOnly {
                 // This is a mutation, so mark it as such.
                 true
             }
-            PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf) => {
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::RawBorrow) => {
                 // Whether mutating though a `&raw const` is allowed is still undecided, so we
                 // disable any sketchy `readonly` optimizations for now.
                 // But we only need to do this if the pointer would point into the argument.
diff --git a/compiler/rustc_mir_transform/src/dest_prop.rs b/compiler/rustc_mir_transform/src/dest_prop.rs
index 054cdbc6bad9f..ed924761892c7 100644
--- a/compiler/rustc_mir_transform/src/dest_prop.rs
+++ b/compiler/rustc_mir_transform/src/dest_prop.rs
@@ -576,7 +576,7 @@ impl WriteInfo {
                     Rvalue::ThreadLocalRef(_)
                     | Rvalue::NullaryOp(_, _)
                     | Rvalue::Ref(_, _, _)
-                    | Rvalue::AddressOf(_, _)
+                    | Rvalue::RawPtr(_, _)
                     | Rvalue::Len(_)
                     | Rvalue::Discriminant(_)
                     | Rvalue::CopyForDeref(_) => (),
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index e16911d79c378..90e3ba26a438e 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -45,7 +45,7 @@
 //!
 //! # Handling of references
 //!
-//! We handle references by assigning a different "provenance" index to each Ref/AddressOf rvalue.
+//! We handle references by assigning a different "provenance" index to each Ref/RawPtr rvalue.
 //! This ensure that we do not spuriously merge borrows that should not be merged. Meanwhile, we
 //! consider all the derefs of an immutable reference to a freeze type to give the same value:
 //! ```ignore (MIR)
@@ -832,7 +832,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 self.simplify_place_projection(place, location);
                 return self.new_pointer(*place, AddressKind::Ref(borrow_kind));
             }
-            Rvalue::AddressOf(mutbl, ref mut place) => {
+            Rvalue::RawPtr(mutbl, ref mut place) => {
                 self.simplify_place_projection(place, location);
                 return self.new_pointer(*place, AddressKind::Address(mutbl));
             }
diff --git a/compiler/rustc_mir_transform/src/instsimplify.rs b/compiler/rustc_mir_transform/src/instsimplify.rs
index 1589653968c2e..3ec553d0ba0c5 100644
--- a/compiler/rustc_mir_transform/src/instsimplify.rs
+++ b/compiler/rustc_mir_transform/src/instsimplify.rs
@@ -141,7 +141,7 @@ impl<'tcx> InstSimplifyContext<'tcx, '_> {
 
     /// Transform `&(*a)` ==> `a`.
     fn simplify_ref_deref(&self, source_info: &SourceInfo, rvalue: &mut Rvalue<'tcx>) {
-        if let Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) = rvalue {
+        if let Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) = rvalue {
             if let Some((base, ProjectionElem::Deref)) = place.as_ref().last_projection() {
                 if rvalue.ty(self.local_decls, self.tcx) != base.ty(self.local_decls, self.tcx).ty {
                     return;
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
index 7202cc2d0427e..7eed47cf2398e 100644
--- a/compiler/rustc_mir_transform/src/known_panics_lint.rs
+++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -419,8 +419,8 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
             }
 
             // Do not try creating references (#67862)
-            Rvalue::AddressOf(_, place) | Rvalue::Ref(_, _, place) => {
-                trace!("skipping AddressOf | Ref for {:?}", place);
+            Rvalue::RawPtr(_, place) | Rvalue::Ref(_, _, place) => {
+                trace!("skipping RawPtr | Ref for {:?}", place);
 
                 // This may be creating mutable references or immutable references to cells.
                 // If that happens, the pointed to value could be mutated via that reference.
@@ -616,7 +616,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                 ImmTy::from_scalar(Scalar::from_target_usize(len, self), layout).into()
             }
 
-            Ref(..) | AddressOf(..) => return None,
+            Ref(..) | RawPtr(..) => return None,
 
             NullaryOp(ref null_op, ty) => {
                 let op_layout = self.use_ecx(|this| this.ecx.layout_of(ty))?;
@@ -969,9 +969,9 @@ impl<'tcx> Visitor<'tcx> for CanConstProp {
             // mutation.
             | NonMutatingUse(NonMutatingUseContext::SharedBorrow)
             | NonMutatingUse(NonMutatingUseContext::FakeBorrow)
-            | NonMutatingUse(NonMutatingUseContext::AddressOf)
+            | NonMutatingUse(NonMutatingUseContext::RawBorrow)
             | MutatingUse(MutatingUseContext::Borrow)
-            | MutatingUse(MutatingUseContext::AddressOf) => {
+            | MutatingUse(MutatingUseContext::RawBorrow) => {
                 trace!("local {:?} can't be propagated because it's used: {:?}", local, context);
                 self.can_const_prop[local] = ConstPropMode::NoPropagation;
             }
diff --git a/compiler/rustc_mir_transform/src/large_enums.rs b/compiler/rustc_mir_transform/src/large_enums.rs
index e407929c9a7fd..cbc3169f2f10a 100644
--- a/compiler/rustc_mir_transform/src/large_enums.rs
+++ b/compiler/rustc_mir_transform/src/large_enums.rs
@@ -214,7 +214,7 @@ impl EnumSizeOpt {
                         source_info,
                         kind: StatementKind::Assign(Box::new((
                             dst,
-                            Rvalue::AddressOf(Mutability::Mut, *lhs),
+                            Rvalue::RawPtr(Mutability::Mut, *lhs),
                         ))),
                     };
 
@@ -238,7 +238,7 @@ impl EnumSizeOpt {
                         source_info,
                         kind: StatementKind::Assign(Box::new((
                             src,
-                            Rvalue::AddressOf(Mutability::Not, *rhs),
+                            Rvalue::RawPtr(Mutability::Not, *rhs),
                         ))),
                     };
 
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
index 48a3266ae6f0d..6e84914ef972c 100644
--- a/compiler/rustc_mir_transform/src/promote_consts.rs
+++ b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -551,7 +551,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                 self.validate_operand(rhs)?;
             }
 
-            Rvalue::AddressOf(_, place) => {
+            Rvalue::RawPtr(_, place) => {
                 // We accept `&raw *`, i.e., raw reborrows -- creating a raw pointer is
                 // no problem, only using it is.
                 if let Some((place_base, ProjectionElem::Deref)) = place.as_ref().last_projection()
diff --git a/compiler/rustc_mir_transform/src/ref_prop.rs b/compiler/rustc_mir_transform/src/ref_prop.rs
index 76e65099e9028..973a191d786e1 100644
--- a/compiler/rustc_mir_transform/src/ref_prop.rs
+++ b/compiler/rustc_mir_transform/src/ref_prop.rs
@@ -227,7 +227,7 @@ fn compute_replacement<'tcx>(
                     }
                 }
             }
-            Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
+            Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
                 let mut place = *place;
                 // Try to see through `place` in order to collapse reborrow chains.
                 if place.projection.first() == Some(&PlaceElem::Deref)
diff --git a/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs b/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
index ea4f5fca59e67..9c3f903e0eab7 100644
--- a/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
+++ b/compiler/rustc_mir_transform/src/shim/async_destructor_ctor.rs
@@ -343,7 +343,7 @@ impl<'tcx> AsyncDestructorCtorShimBuilder<'tcx> {
                 .tcx
                 .mk_place_elems(&[PlaceElem::Deref, PlaceElem::Field(field, field_ty)]),
         };
-        self.put_temp_rvalue(Rvalue::AddressOf(Mutability::Mut, place))
+        self.put_temp_rvalue(Rvalue::RawPtr(Mutability::Mut, place))
     }
 
     /// If given Self is an enum puts `to_drop: *mut FieldTy` on top of
@@ -363,7 +363,7 @@ impl<'tcx> AsyncDestructorCtorShimBuilder<'tcx> {
                 PlaceElem::Field(field, field_ty),
             ]),
         };
-        self.put_temp_rvalue(Rvalue::AddressOf(Mutability::Mut, place))
+        self.put_temp_rvalue(Rvalue::RawPtr(Mutability::Mut, place))
     }
 
     /// If given Self is an enum puts `to_drop: *mut FieldTy` on top of
diff --git a/compiler/rustc_mir_transform/src/ssa.rs b/compiler/rustc_mir_transform/src/ssa.rs
index fb870425f6ef8..76591f526250c 100644
--- a/compiler/rustc_mir_transform/src/ssa.rs
+++ b/compiler/rustc_mir_transform/src/ssa.rs
@@ -2,9 +2,9 @@
 //! 1/ They are only assigned-to once, either as a function parameter, or in an assign statement;
 //! 2/ This single assignment dominates all uses;
 //!
-//! As we do not track indirect assignments, a local that has its address taken (either by
-//! AddressOf or by borrowing) is considered non-SSA. However, it is UB to modify through an
-//! immutable borrow of a `Freeze` local. Those can still be considered to be SSA.
+//! As we do not track indirect assignments, a local that has its address taken (via a borrow or raw
+//! borrow operator) is considered non-SSA. However, it is UB to modify through an immutable borrow
+//! of a `Freeze` local. Those can still be considered to be SSA.
 
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_index::bit_set::BitSet;
@@ -262,7 +262,7 @@ impl<'tcx> Visitor<'tcx> for SsaVisitor<'tcx, '_> {
             PlaceContext::MutatingUse(MutatingUseContext::Projection)
             | PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection) => bug!(),
             // Anything can happen with raw pointers, so remove them.
-            PlaceContext::NonMutatingUse(NonMutatingUseContext::AddressOf)
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::RawBorrow)
             | PlaceContext::MutatingUse(_) => {
                 self.assignments[local] = Set1::Many;
             }
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index 491ae1c0d083f..36908036796c1 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -1345,7 +1345,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             }
             Rvalue::Repeat(_, _)
             | Rvalue::ThreadLocalRef(_)
-            | Rvalue::AddressOf(_, _)
+            | Rvalue::RawPtr(_, _)
             | Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::UbChecks, _)
             | Rvalue::Discriminant(_) => {}
         }
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
index da705e6f9598a..c442ca861d35b 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/mir.rs
@@ -174,7 +174,7 @@ impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> {
             ThreadLocalRef(def_id) => {
                 stable_mir::mir::Rvalue::ThreadLocalRef(tables.crate_item(*def_id))
             }
-            AddressOf(mutability, place) => {
+            RawPtr(mutability, place) => {
                 stable_mir::mir::Rvalue::AddressOf(mutability.stable(tables), place.stable(tables))
             }
             Len(place) => stable_mir::mir::Rvalue::Len(place.stable(tables)),
diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
index 2492688352342..4ded935b801d3 100644
--- a/compiler/rustc_ty_utils/src/consts.rs
+++ b/compiler/rustc_ty_utils/src/consts.rs
@@ -192,7 +192,7 @@ fn recurse_build<'tcx>(
         ExprKind::Borrow { arg, .. } => {
             let arg_node = &body.exprs[*arg];
 
-            // Skip reborrows for now until we allow Deref/Borrow/AddressOf
+            // Skip reborrows for now until we allow Deref/Borrow/RawBorrow
             // expressions.
             // FIXME(generic_const_exprs): Verify/explain why this is sound
             if let ExprKind::Deref { arg } = arg_node.kind {
@@ -202,7 +202,7 @@ fn recurse_build<'tcx>(
             }
         }
         // FIXME(generic_const_exprs): We may want to support these.
-        ExprKind::AddressOf { .. } | ExprKind::Deref { .. } => maybe_supported_error(
+        ExprKind::RawBorrow { .. } | ExprKind::Deref { .. } => maybe_supported_error(
             GenericConstantTooComplexSub::AddressAndDerefNotSupported(node.span),
         )?,
         ExprKind::Repeat { .. } | ExprKind::Array { .. } => {
@@ -343,7 +343,7 @@ impl<'a, 'tcx> IsThirPolymorphic<'a, 'tcx> {
             | thir::ExprKind::VarRef { .. }
             | thir::ExprKind::UpvarRef { .. }
             | thir::ExprKind::Borrow { .. }
-            | thir::ExprKind::AddressOf { .. }
+            | thir::ExprKind::RawBorrow { .. }
             | thir::ExprKind::Break { .. }
             | thir::ExprKind::Continue { .. }
             | thir::ExprKind::Return { .. }
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
index 553af913ef9df..95fbf0b2ea20a 100644
--- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
+++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
@@ -110,7 +110,7 @@ fn check_rvalue<'tcx>(
 ) -> McfResult {
     match rvalue {
         Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
-        Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
+        Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
             check_place(tcx, *place, span, body, msrv)
         },
         Rvalue::CopyForDeref(place) => check_place(tcx, *place, span, body, msrv),

From 43e1145c80d1c2f4e159885d382659ace3a1bc5d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 12 Aug 2024 10:57:57 +0200
Subject: [PATCH 410/685] rename AddressOf -> RawBorrow inside the compiler

---
 clippy_utils/src/qualify_min_const_fn.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_utils/src/qualify_min_const_fn.rs b/clippy_utils/src/qualify_min_const_fn.rs
index 553af913ef9df..95fbf0b2ea20a 100644
--- a/clippy_utils/src/qualify_min_const_fn.rs
+++ b/clippy_utils/src/qualify_min_const_fn.rs
@@ -110,7 +110,7 @@ fn check_rvalue<'tcx>(
 ) -> McfResult {
     match rvalue {
         Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
-        Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
+        Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
             check_place(tcx, *place, span, body, msrv)
         },
         Rvalue::CopyForDeref(place) => check_place(tcx, *place, span, body, msrv),

From 17995d5cc2e75b65b8bd6b77ad30b0c764500c0c Mon Sep 17 00:00:00 2001
From: Jack Wrenn <jack@wrenn.fyi>
Date: Wed, 14 Aug 2024 20:10:28 +0000
Subject: [PATCH 411/685] safe transmute: forbid reference lifetime extension

Modifies `BikeshedIntrinsicFrom` to forbid lifetime extensions on
references. This static check can be opted out of with the
`Assume::lifetimes` flag.

Fixes #129097
---
 .../src/traits/select/confirmation.rs         | 176 ++++++++++--------
 compiler/rustc_transmute/src/layout/mod.rs    |  13 +-
 compiler/rustc_transmute/src/layout/tree.rs   | 141 ++++++++------
 compiler/rustc_transmute/src/lib.rs           |   2 +-
 .../src/maybe_transmutable/mod.rs             |   7 +-
 .../accept_assume_lifetime_extension.rs       |  91 +++++++++
 .../accept_unexercised_lifetime_extension.rs  |  68 +++++++
 .../references/reject_lifetime_extension.rs   |  91 +++++++++
 .../reject_lifetime_extension.stderr          |  78 ++++++++
 9 files changed, 535 insertions(+), 132 deletions(-)
 create mode 100644 tests/ui/transmutability/references/accept_assume_lifetime_extension.rs
 create mode 100644 tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs
 create mode 100644 tests/ui/transmutability/references/reject_lifetime_extension.rs
 create mode 100644 tests/ui/transmutability/references/reject_lifetime_extension.stderr

diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 0d7ceca430174..f19cd19c99a83 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -17,8 +17,7 @@ use rustc_infer::infer::{DefineOpaqueTypes, HigherRankedType, InferOk};
 use rustc_infer::traits::ObligationCauseCode;
 use rustc_middle::traits::{BuiltinImplSource, SignatureMismatchData};
 use rustc_middle::ty::{
-    self, GenericArgs, GenericArgsRef, GenericParamDefKind, ToPolyTraitRef, TraitPredicate, Ty,
-    TyCtxt, Upcast,
+    self, GenericArgs, GenericArgsRef, GenericParamDefKind, ToPolyTraitRef, Ty, TyCtxt, Upcast,
 };
 use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::DefId;
@@ -292,90 +291,120 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         &mut self,
         obligation: &PolyTraitObligation<'tcx>,
     ) -> Result<Vec<PredicateObligation<'tcx>>, SelectionError<'tcx>> {
-        use rustc_transmute::{Answer, Condition};
-        #[instrument(level = "debug", skip(tcx, obligation, predicate))]
+        use rustc_transmute::{Answer, Assume, Condition};
+
+        /// Generate sub-obligations for reference-to-reference transmutations.
+        fn reference_obligations<'tcx>(
+            tcx: TyCtxt<'tcx>,
+            obligation: &PolyTraitObligation<'tcx>,
+            (src_lifetime, src_ty, src_mut): (ty::Region<'tcx>, Ty<'tcx>, Mutability),
+            (dst_lifetime, dst_ty, dst_mut): (ty::Region<'tcx>, Ty<'tcx>, Mutability),
+            assume: Assume,
+        ) -> Vec<PredicateObligation<'tcx>> {
+            let make_transmute_obl = |src, dst| {
+                let transmute_trait = obligation.predicate.def_id();
+                let assume = obligation.predicate.skip_binder().trait_ref.args.const_at(2);
+                let trait_ref = ty::TraitRef::new(
+                    tcx,
+                    transmute_trait,
+                    [
+                        ty::GenericArg::from(dst),
+                        ty::GenericArg::from(src),
+                        ty::GenericArg::from(assume),
+                    ],
+                );
+                Obligation::with_depth(
+                    tcx,
+                    obligation.cause.clone(),
+                    obligation.recursion_depth + 1,
+                    obligation.param_env,
+                    obligation.predicate.rebind(trait_ref),
+                )
+            };
+
+            let make_freeze_obl = |ty| {
+                let trait_ref = ty::TraitRef::new(
+                    tcx,
+                    tcx.require_lang_item(LangItem::Freeze, None),
+                    [ty::GenericArg::from(ty)],
+                );
+                Obligation::with_depth(
+                    tcx,
+                    obligation.cause.clone(),
+                    obligation.recursion_depth + 1,
+                    obligation.param_env,
+                    trait_ref,
+                )
+            };
+
+            let make_outlives_obl = |target, region| {
+                let outlives = ty::OutlivesPredicate(target, region);
+                Obligation::with_depth(
+                    tcx,
+                    obligation.cause.clone(),
+                    obligation.recursion_depth + 1,
+                    obligation.param_env,
+                    obligation.predicate.rebind(outlives),
+                )
+            };
+
+            // Given a transmutation from `&'a (mut) Src` and `&'dst (mut) Dst`,
+            // it is always the case that `Src` must be transmutable into `Dst`,
+            // and that that `'src` must outlive `'dst`.
+            let mut obls = vec![make_transmute_obl(src_ty, dst_ty)];
+            if !assume.lifetimes {
+                obls.push(make_outlives_obl(src_lifetime, dst_lifetime));
+            }
+
+            // Given a transmutation from `&Src`, both `Src` and `Dst` must be
+            // `Freeze`, otherwise, using the transmuted value could lead to
+            // data races.
+            if src_mut == Mutability::Not {
+                obls.extend([make_freeze_obl(src_ty), make_freeze_obl(dst_ty)])
+            }
+
+            // Given a transmutation into `&'dst mut Dst`, it also must be the
+            // case that `Dst` is transmutable into `Src`. For example,
+            // transmuting bool -> u8 is OK as long as you can't update that u8
+            // to be > 1, because you could later transmute the u8 back to a
+            // bool and get undefined behavior. It also must be the case that
+            // `'dst` lives exactly as long as `'src`.
+            if dst_mut == Mutability::Mut {
+                obls.push(make_transmute_obl(dst_ty, src_ty));
+                if !assume.lifetimes {
+                    obls.push(make_outlives_obl(dst_lifetime, src_lifetime));
+                }
+            }
+
+            obls
+        }
+
+        /// Flatten the `Condition` tree into a conjunction of obligations.
+        #[instrument(level = "debug", skip(tcx, obligation))]
         fn flatten_answer_tree<'tcx>(
             tcx: TyCtxt<'tcx>,
             obligation: &PolyTraitObligation<'tcx>,
-            predicate: TraitPredicate<'tcx>,
             cond: Condition<rustc_transmute::layout::rustc::Ref<'tcx>>,
+            assume: Assume,
         ) -> Vec<PredicateObligation<'tcx>> {
             match cond {
                 // FIXME(bryangarza): Add separate `IfAny` case, instead of treating as `IfAll`
                 // Not possible until the trait solver supports disjunctions of obligations
                 Condition::IfAll(conds) | Condition::IfAny(conds) => conds
                     .into_iter()
-                    .flat_map(|cond| flatten_answer_tree(tcx, obligation, predicate, cond))
+                    .flat_map(|cond| flatten_answer_tree(tcx, obligation, cond, assume))
                     .collect(),
-                Condition::IfTransmutable { src, dst } => {
-                    let transmute_trait = obligation.predicate.def_id();
-                    let assume_const = predicate.trait_ref.args.const_at(2);
-                    let make_transmute_obl = |from_ty, to_ty| {
-                        let trait_ref = ty::TraitRef::new(
-                            tcx,
-                            transmute_trait,
-                            [
-                                ty::GenericArg::from(to_ty),
-                                ty::GenericArg::from(from_ty),
-                                ty::GenericArg::from(assume_const),
-                            ],
-                        );
-                        Obligation::with_depth(
-                            tcx,
-                            obligation.cause.clone(),
-                            obligation.recursion_depth + 1,
-                            obligation.param_env,
-                            trait_ref,
-                        )
-                    };
-
-                    let make_freeze_obl = |ty| {
-                        let trait_ref = ty::TraitRef::new(
-                            tcx,
-                            tcx.require_lang_item(LangItem::Freeze, None),
-                            [ty::GenericArg::from(ty)],
-                        );
-                        Obligation::with_depth(
-                            tcx,
-                            obligation.cause.clone(),
-                            obligation.recursion_depth + 1,
-                            obligation.param_env,
-                            trait_ref,
-                        )
-                    };
-
-                    let mut obls = vec![];
-
-                    // If the source is a shared reference, it must be `Freeze`;
-                    // otherwise, transmuting could lead to data races.
-                    if src.mutability == Mutability::Not {
-                        obls.extend([make_freeze_obl(src.ty), make_freeze_obl(dst.ty)])
-                    }
-
-                    // If Dst is mutable, check bidirectionally.
-                    // For example, transmuting bool -> u8 is OK as long as you can't update that u8
-                    // to be > 1, because you could later transmute the u8 back to a bool and get UB.
-                    match dst.mutability {
-                        Mutability::Not => obls.push(make_transmute_obl(src.ty, dst.ty)),
-                        Mutability::Mut => obls.extend([
-                            make_transmute_obl(src.ty, dst.ty),
-                            make_transmute_obl(dst.ty, src.ty),
-                        ]),
-                    }
-
-                    obls
-                }
+                Condition::IfTransmutable { src, dst } => reference_obligations(
+                    tcx,
+                    obligation,
+                    (src.lifetime, src.ty, src.mutability),
+                    (dst.lifetime, dst.ty, dst.mutability),
+                    assume,
+                ),
             }
         }
 
-        // We erase regions here because transmutability calls layout queries,
-        // which does not handle inference regions and doesn't particularly
-        // care about other regions. Erasing late-bound regions is equivalent
-        // to instantiating the binder with placeholders then erasing those
-        // placeholder regions.
-        let predicate = self
-            .tcx()
-            .erase_regions(self.tcx().instantiate_bound_regions_with_erased(obligation.predicate));
+        let predicate = obligation.predicate.skip_binder();
 
         let Some(assume) = rustc_transmute::Assume::from_const(
             self.infcx.tcx,
@@ -387,6 +416,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         let dst = predicate.trait_ref.args.type_at(0);
         let src = predicate.trait_ref.args.type_at(1);
+
         debug!(?src, ?dst);
         let mut transmute_env = rustc_transmute::TransmuteTypeEnv::new(self.infcx);
         let maybe_transmutable = transmute_env.is_transmutable(
@@ -397,7 +427,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         let fully_flattened = match maybe_transmutable {
             Answer::No(_) => Err(Unimplemented)?,
-            Answer::If(cond) => flatten_answer_tree(self.tcx(), obligation, predicate, cond),
+            Answer::If(cond) => flatten_answer_tree(self.tcx(), obligation, cond, assume),
             Answer::Yes => vec![],
         };
 
diff --git a/compiler/rustc_transmute/src/layout/mod.rs b/compiler/rustc_transmute/src/layout/mod.rs
index bbf155581f98b..1cf9e0b9b70ed 100644
--- a/compiler/rustc_transmute/src/layout/mod.rs
+++ b/compiler/rustc_transmute/src/layout/mod.rs
@@ -63,7 +63,9 @@ pub mod rustc {
     use std::fmt::{self, Write};
 
     use rustc_middle::mir::Mutability;
-    use rustc_middle::ty::{self, Ty};
+    use rustc_middle::ty::layout::{LayoutCx, LayoutError};
+    use rustc_middle::ty::{self, Ty, TyCtxt};
+    use rustc_target::abi::Layout;
 
     /// A reference in the layout.
     #[derive(Debug, Hash, Eq, PartialEq, Clone, Copy)]
@@ -120,4 +122,13 @@ pub mod rustc {
             self != &Self::Primitive
         }
     }
+
+    pub(crate) fn layout_of<'tcx>(
+        cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
+        ty: Ty<'tcx>,
+    ) -> Result<Layout<'tcx>, &'tcx LayoutError<'tcx>> {
+        use rustc_middle::ty::layout::LayoutOf;
+        let ty = cx.tcx.erase_regions(ty);
+        cx.layout_of(ty).map(|tl| tl.layout)
+    }
 }
diff --git a/compiler/rustc_transmute/src/layout/tree.rs b/compiler/rustc_transmute/src/layout/tree.rs
index 5c25f913ffe38..7c73f74e6290b 100644
--- a/compiler/rustc_transmute/src/layout/tree.rs
+++ b/compiler/rustc_transmute/src/layout/tree.rs
@@ -171,10 +171,12 @@ where
 
 #[cfg(feature = "rustc")]
 pub(crate) mod rustc {
-    use rustc_middle::ty::layout::{HasTyCtxt, LayoutCx, LayoutError, LayoutOf};
+    use rustc_middle::ty::layout::{HasTyCtxt, LayoutCx, LayoutError};
     use rustc_middle::ty::{self, AdtDef, AdtKind, List, ScalarInt, Ty, TyCtxt, TypeVisitableExt};
     use rustc_span::ErrorGuaranteed;
-    use rustc_target::abi::{FieldsShape, Size, TyAndLayout, Variants};
+    use rustc_target::abi::{
+        FieldIdx, FieldsShape, Layout, Size, TyAndLayout, VariantIdx, Variants,
+    };
 
     use super::Tree;
     use crate::layout::rustc::{Def, Ref};
@@ -202,20 +204,18 @@ pub(crate) mod rustc {
     }
 
     impl<'tcx> Tree<Def<'tcx>, Ref<'tcx>> {
-        pub fn from_ty(
-            ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>,
-            cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
-        ) -> Result<Self, Err> {
+        pub fn from_ty(ty: Ty<'tcx>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>) -> Result<Self, Err> {
             use rustc_target::abi::HasDataLayout;
+            let layout = ty_layout(cx, ty);
 
-            if let Err(e) = ty_and_layout.ty.error_reported() {
+            if let Err(e) = ty.error_reported() {
                 return Err(Err::TypeError(e));
             }
 
             let target = cx.tcx.data_layout();
             let pointer_size = target.pointer_size;
 
-            match ty_and_layout.ty.kind() {
+            match ty.kind() {
                 ty::Bool => Ok(Self::bool()),
 
                 ty::Float(nty) => {
@@ -233,32 +233,30 @@ pub(crate) mod rustc {
                     Ok(Self::number(width as _))
                 }
 
-                ty::Tuple(members) => Self::from_tuple(ty_and_layout, members, cx),
+                ty::Tuple(members) => Self::from_tuple((ty, layout), members, cx),
 
                 ty::Array(inner_ty, len) => {
-                    let FieldsShape::Array { stride, count } = &ty_and_layout.fields else {
+                    let FieldsShape::Array { stride, count } = &layout.fields else {
                         return Err(Err::NotYetSupported);
                     };
-                    let inner_ty_and_layout = cx.layout_of(*inner_ty)?;
-                    assert_eq!(*stride, inner_ty_and_layout.size);
-                    let elt = Tree::from_ty(inner_ty_and_layout, cx)?;
+                    let inner_layout = ty_layout(cx, *inner_ty);
+                    assert_eq!(*stride, inner_layout.size);
+                    let elt = Tree::from_ty(*inner_ty, cx)?;
                     Ok(std::iter::repeat(elt)
                         .take(*count as usize)
                         .fold(Tree::unit(), |tree, elt| tree.then(elt)))
                 }
 
-                ty::Adt(adt_def, _args_ref) if !ty_and_layout.ty.is_box() => {
-                    match adt_def.adt_kind() {
-                        AdtKind::Struct => Self::from_struct(ty_and_layout, *adt_def, cx),
-                        AdtKind::Enum => Self::from_enum(ty_and_layout, *adt_def, cx),
-                        AdtKind::Union => Self::from_union(ty_and_layout, *adt_def, cx),
-                    }
-                }
+                ty::Adt(adt_def, _args_ref) if !ty.is_box() => match adt_def.adt_kind() {
+                    AdtKind::Struct => Self::from_struct((ty, layout), *adt_def, cx),
+                    AdtKind::Enum => Self::from_enum((ty, layout), *adt_def, cx),
+                    AdtKind::Union => Self::from_union((ty, layout), *adt_def, cx),
+                },
 
                 ty::Ref(lifetime, ty, mutability) => {
-                    let ty_and_layout = cx.layout_of(*ty)?;
-                    let align = ty_and_layout.align.abi.bytes_usize();
-                    let size = ty_and_layout.size.bytes_usize();
+                    let layout = ty_layout(cx, *ty);
+                    let align = layout.align.abi.bytes_usize();
+                    let size = layout.size.bytes_usize();
                     Ok(Tree::Ref(Ref {
                         lifetime: *lifetime,
                         ty: *ty,
@@ -274,21 +272,20 @@ pub(crate) mod rustc {
 
         /// Constructs a `Tree` from a tuple.
         fn from_tuple(
-            ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>,
+            (ty, layout): (Ty<'tcx>, Layout<'tcx>),
             members: &'tcx List<Ty<'tcx>>,
             cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
         ) -> Result<Self, Err> {
-            match &ty_and_layout.fields {
+            match &layout.fields {
                 FieldsShape::Primitive => {
                     assert_eq!(members.len(), 1);
                     let inner_ty = members[0];
-                    let inner_ty_and_layout = cx.layout_of(inner_ty)?;
-                    assert_eq!(ty_and_layout.layout, inner_ty_and_layout.layout);
-                    Self::from_ty(inner_ty_and_layout, cx)
+                    let inner_layout = ty_layout(cx, inner_ty);
+                    Self::from_ty(inner_ty, cx)
                 }
                 FieldsShape::Arbitrary { offsets, .. } => {
                     assert_eq!(offsets.len(), members.len());
-                    Self::from_variant(Def::Primitive, None, ty_and_layout, ty_and_layout.size, cx)
+                    Self::from_variant(Def::Primitive, None, (ty, layout), layout.size, cx)
                 }
                 FieldsShape::Array { .. } | FieldsShape::Union(_) => Err(Err::NotYetSupported),
             }
@@ -300,13 +297,13 @@ pub(crate) mod rustc {
         ///
         /// Panics if `def` is not a struct definition.
         fn from_struct(
-            ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>,
+            (ty, layout): (Ty<'tcx>, Layout<'tcx>),
             def: AdtDef<'tcx>,
             cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
         ) -> Result<Self, Err> {
             assert!(def.is_struct());
             let def = Def::Adt(def);
-            Self::from_variant(def, None, ty_and_layout, ty_and_layout.size, cx)
+            Self::from_variant(def, None, (ty, layout), layout.size, cx)
         }
 
         /// Constructs a `Tree` from an enum.
@@ -315,19 +312,18 @@ pub(crate) mod rustc {
         ///
         /// Panics if `def` is not an enum definition.
         fn from_enum(
-            ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>,
+            (ty, layout): (Ty<'tcx>, Layout<'tcx>),
             def: AdtDef<'tcx>,
             cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
         ) -> Result<Self, Err> {
             assert!(def.is_enum());
-            let layout = ty_and_layout.layout;
 
             // Computes the variant of a given index.
             let layout_of_variant = |index| {
-                let tag = cx.tcx.tag_for_variant((ty_and_layout.ty, index));
+                let tag = cx.tcx.tag_for_variant((cx.tcx.erase_regions(ty), index));
                 let variant_def = Def::Variant(def.variant(index));
-                let variant_ty_and_layout = ty_and_layout.for_variant(&cx, index);
-                Self::from_variant(variant_def, tag, variant_ty_and_layout, layout.size, cx)
+                let variant_layout = ty_variant(cx, (ty, layout), index);
+                Self::from_variant(variant_def, tag, (ty, variant_layout), layout.size, cx)
             };
 
             // We consider three kinds of enums, each demanding a different
@@ -385,21 +381,20 @@ pub(crate) mod rustc {
         fn from_variant(
             def: Def<'tcx>,
             tag: Option<ScalarInt>,
-            ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>,
+            (ty, layout): (Ty<'tcx>, Layout<'tcx>),
             total_size: Size,
             cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
         ) -> Result<Self, Err> {
             // This constructor does not support non-`FieldsShape::Arbitrary`
             // layouts.
-            let FieldsShape::Arbitrary { offsets, memory_index } = ty_and_layout.layout.fields()
-            else {
+            let FieldsShape::Arbitrary { offsets, memory_index } = layout.fields() else {
                 return Err(Err::NotYetSupported);
             };
 
             // When this function is invoked with enum variants,
             // `ty_and_layout.size` does not encompass the entire size of the
             // enum. We rely on `total_size` for this.
-            assert!(ty_and_layout.size <= total_size);
+            assert!(layout.size <= total_size);
 
             let mut size = Size::ZERO;
             let mut struct_tree = Self::def(def);
@@ -412,17 +407,18 @@ pub(crate) mod rustc {
 
             // Append the fields, in memory order, to the layout.
             let inverse_memory_index = memory_index.invert_bijective_mapping();
-            for (memory_idx, field_idx) in inverse_memory_index.iter_enumerated() {
+            for (memory_idx, &field_idx) in inverse_memory_index.iter_enumerated() {
                 // Add interfield padding.
-                let padding_needed = offsets[*field_idx] - size;
+                let padding_needed = offsets[field_idx] - size;
                 let padding = Self::padding(padding_needed.bytes_usize());
 
-                let field_ty_and_layout = ty_and_layout.field(&cx, field_idx.as_usize());
-                let field_tree = Self::from_ty(field_ty_and_layout, cx)?;
+                let field_ty = ty_field(cx, (ty, layout), field_idx);
+                let field_layout = ty_layout(cx, field_ty);
+                let field_tree = Self::from_ty(field_ty, cx)?;
 
                 struct_tree = struct_tree.then(padding).then(field_tree);
 
-                size += padding_needed + field_ty_and_layout.size;
+                size += padding_needed + field_layout.size;
             }
 
             // Add trailing padding.
@@ -457,28 +453,27 @@ pub(crate) mod rustc {
         ///
         /// Panics if `def` is not a union definition.
         fn from_union(
-            ty_and_layout: TyAndLayout<'tcx, Ty<'tcx>>,
+            (ty, layout): (Ty<'tcx>, Layout<'tcx>),
             def: AdtDef<'tcx>,
             cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
         ) -> Result<Self, Err> {
             assert!(def.is_union());
 
-            let union_layout = ty_and_layout.layout;
-
             // This constructor does not support non-`FieldsShape::Union`
             // layouts. Fields of this shape are all placed at offset 0.
-            let FieldsShape::Union(fields) = union_layout.fields() else {
+            let FieldsShape::Union(fields) = layout.fields() else {
                 return Err(Err::NotYetSupported);
             };
 
             let fields = &def.non_enum_variant().fields;
             let fields = fields.iter_enumerated().try_fold(
                 Self::uninhabited(),
-                |fields, (idx, ref field_def)| {
+                |fields, (idx, field_def)| {
                     let field_def = Def::Field(field_def);
-                    let field_ty_and_layout = ty_and_layout.field(&cx, idx.as_usize());
-                    let field = Self::from_ty(field_ty_and_layout, cx)?;
-                    let trailing_padding_needed = union_layout.size - field_ty_and_layout.size;
+                    let field_ty = ty_field(cx, (ty, layout), idx);
+                    let field_layout = ty_layout(cx, field_ty);
+                    let field = Self::from_ty(field_ty, cx)?;
+                    let trailing_padding_needed = layout.size - field_layout.size;
                     let trailing_padding = Self::padding(trailing_padding_needed.bytes_usize());
                     let field_and_padding = field.then(trailing_padding);
                     Result::<Self, Err>::Ok(fields.or(field_and_padding))
@@ -488,4 +483,44 @@ pub(crate) mod rustc {
             Ok(Self::def(Def::Adt(def)).then(fields))
         }
     }
+
+    pub(crate) fn ty_layout<'tcx>(cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ty: Ty<'tcx>) -> Layout<'tcx> {
+        crate::layout::rustc::layout_of(cx, ty).unwrap()
+    }
+
+    fn ty_field<'tcx>(
+        cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
+        (ty, layout): (Ty<'tcx>, Layout<'tcx>),
+        i: FieldIdx,
+    ) -> Ty<'tcx> {
+        match ty.kind() {
+            ty::Adt(def, args) => {
+                match layout.variants {
+                    Variants::Single { index } => {
+                        let field = &def.variant(index).fields[i];
+                        field.ty(cx.tcx, args)
+                    }
+                    // Discriminant field for enums (where applicable).
+                    Variants::Multiple { tag, .. } => {
+                        assert_eq!(i.as_usize(), 0);
+                        ty::layout::PrimitiveExt::to_ty(&tag.primitive(), cx.tcx)
+                    }
+                }
+            }
+            ty::Tuple(fields) => fields[i.as_usize()],
+            kind @ _ => unimplemented!(
+                "only a subset of `Ty::ty_and_layout_field`'s functionality is implemented. implementation needed for {:?}",
+                kind
+            ),
+        }
+    }
+
+    fn ty_variant<'tcx>(
+        cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
+        (ty, layout): (Ty<'tcx>, Layout<'tcx>),
+        i: VariantIdx,
+    ) -> Layout<'tcx> {
+        let ty = cx.tcx.erase_regions(ty);
+        TyAndLayout { ty, layout }.for_variant(&cx, i).layout
+    }
 }
diff --git a/compiler/rustc_transmute/src/lib.rs b/compiler/rustc_transmute/src/lib.rs
index 31664ee6c4f7e..bdc98bcea5eb0 100644
--- a/compiler/rustc_transmute/src/lib.rs
+++ b/compiler/rustc_transmute/src/lib.rs
@@ -9,7 +9,7 @@ pub(crate) use rustc_data_structures::fx::{FxIndexMap as Map, FxIndexSet as Set}
 pub mod layout;
 mod maybe_transmutable;
 
-#[derive(Default)]
+#[derive(Copy, Clone, Debug, Default)]
 pub struct Assume {
     pub alignment: bool,
     pub lifetimes: bool,
diff --git a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
index 7c66a827db9a3..1f3c4e3c817de 100644
--- a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
+++ b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
@@ -30,7 +30,7 @@ where
 // FIXME: Nix this cfg, so we can write unit tests independently of rustc
 #[cfg(feature = "rustc")]
 mod rustc {
-    use rustc_middle::ty::layout::{LayoutCx, LayoutOf};
+    use rustc_middle::ty::layout::LayoutCx;
     use rustc_middle::ty::{ParamEnv, Ty, TyCtxt};
 
     use super::*;
@@ -45,10 +45,9 @@ mod rustc {
 
             let layout_cx = LayoutCx { tcx: context, param_env: ParamEnv::reveal_all() };
             let layout_of = |ty| {
-                layout_cx
-                    .layout_of(ty)
+                crate::layout::rustc::layout_of(layout_cx, ty)
                     .map_err(|_| Err::NotYetSupported)
-                    .and_then(|tl| Tree::from_ty(tl, layout_cx))
+                    .and_then(|_| Tree::from_ty(ty, layout_cx))
             };
 
             // Convert `src` and `dst` from their rustc representations, to `Tree`-based
diff --git a/tests/ui/transmutability/references/accept_assume_lifetime_extension.rs b/tests/ui/transmutability/references/accept_assume_lifetime_extension.rs
new file mode 100644
index 0000000000000..3bdd7256791ec
--- /dev/null
+++ b/tests/ui/transmutability/references/accept_assume_lifetime_extension.rs
@@ -0,0 +1,91 @@
+//@ check-pass
+
+//! Accept lifetime extensions with `Assume::LIFETIMES`.
+
+#![feature(transmutability, core_intrinsics)]
+
+use std::mem::{Assume, BikeshedIntrinsicFrom};
+
+unsafe fn transmute<Src, Dst>(src: Src) -> Dst
+where
+    Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::LIFETIMES) }>,
+{
+    core::intrinsics::transmute_unchecked(src)
+}
+
+mod bare {
+    use super::*;
+
+    fn extend_bare<'a>(src: &'a u8) -> &'static u8 {
+        unsafe { transmute(src) }
+    }
+}
+
+mod nested {
+    use super::*;
+
+    fn extend_nested<'a>(src: &'a &'a u8) -> &'a &'static u8 {
+        unsafe { transmute(src) }
+    }
+}
+
+mod tuple {
+    use super::*;
+
+    fn extend_unit<'a>(src: (&'a u8,)) -> (&'static u8,) {
+        unsafe { transmute(src) }
+    }
+
+    fn extend_pair<'a>(src: (&'a u8, u8)) -> (&'static u8, u8) {
+        unsafe { transmute(src) }
+    }
+}
+
+mod r#struct {
+    use super::*;
+
+    struct Struct<'a>(&'a u8);
+
+    fn extend_struct<'a>(src: Struct<'a>) -> Struct<'static> {
+        unsafe { transmute(src) }
+    }
+}
+
+mod r#enum {
+    use super::*;
+
+    enum Single<'a> {
+        A(&'a u8),
+    }
+
+    fn extend_single<'a>(src: Single<'a>) -> Single<'static> {
+        unsafe { transmute(src) }
+    }
+
+    enum Multi<'a> {
+        A(&'a u8),
+        B,
+        C,
+    }
+
+    fn extend_multi<'a>(src: Multi<'a>) -> Multi<'static> {
+        unsafe { transmute(src) }
+    }
+}
+
+mod hrtb {
+    use super::*;
+
+    fn call_extend_hrtb<'a>(src: &'a u8) -> &'static u8 {
+        unsafe { extend_hrtb(src) }
+    }
+
+    unsafe fn extend_hrtb<'a>(src: &'a u8) -> &'static u8
+    where
+        for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8, { Assume::LIFETIMES }>,
+    {
+        core::intrinsics::transmute_unchecked(src)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs b/tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs
new file mode 100644
index 0000000000000..559ee23a44606
--- /dev/null
+++ b/tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs
@@ -0,0 +1,68 @@
+//@ check-pass
+
+//! Accept lifetime extensions of un-exercised lifetimes.
+
+#![feature(transmutability, core_intrinsics)]
+
+use std::mem::{Assume, BikeshedIntrinsicFrom};
+
+unsafe fn transmute<Src, Dst>(src: Src) -> Dst
+where
+    Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>,
+{
+    core::intrinsics::transmute_unchecked(src)
+}
+
+enum Void {}
+
+mod phantom {
+    use super::*;
+    use std::marker::PhantomData;
+
+    fn extend_bare<'a>(src: PhantomData<&'a u8>) -> PhantomData<&'static u8> {
+        unsafe { transmute(src) }
+    }
+}
+
+
+mod tuple {
+    use super::*;
+
+    fn extend_pair<'a>(src: (&'a u8, Void)) -> (&'static u8, Void) {
+        unsafe { transmute(src) }
+    }
+}
+
+mod r#struct {
+    use super::*;
+
+    struct Struct<'a>(&'a u8, Void);
+
+    fn extend_struct<'a>(src: Struct<'a>) -> Struct<'static> {
+        unsafe { transmute(src) }
+    }
+}
+
+mod r#enum {
+    use super::*;
+
+    enum Single<'a> {
+        A(&'a u8, Void),
+    }
+
+    fn extend_single<'a>(src: Single<'a>) -> Single<'static> {
+        unsafe { transmute(src) }
+    }
+
+    enum Multi<'a> {
+        A(&'a u8, Void),
+        B,
+        C,
+    }
+
+    fn extend_multi<'a>(src: Multi<'a>) -> Multi<'static> {
+        unsafe { transmute(src) }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/transmutability/references/reject_lifetime_extension.rs b/tests/ui/transmutability/references/reject_lifetime_extension.rs
new file mode 100644
index 0000000000000..79bb4e1e55694
--- /dev/null
+++ b/tests/ui/transmutability/references/reject_lifetime_extension.rs
@@ -0,0 +1,91 @@
+//@ check-fail
+
+//! Reject lifetime extensions.
+
+#![feature(transmutability, core_intrinsics)]
+
+use std::mem::{Assume, BikeshedIntrinsicFrom};
+
+unsafe fn transmute<Src, Dst>(src: Src) -> Dst
+where
+    Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>,
+{
+    core::intrinsics::transmute_unchecked(src)
+}
+
+mod bare {
+    use super::*;
+
+    fn extend_bare<'a>(src: &'a u8) -> &'static u8 {
+        unsafe { transmute(src) } //~ ERROR lifetime may not live long enough
+    }
+}
+
+mod nested {
+    use super::*;
+
+    fn extend_nested<'a>(src: &'a &'a u8) -> &'a &'static u8 {
+        unsafe { transmute(src) } //~ ERROR lifetime may not live long enough
+    }
+}
+
+mod tuple {
+    use super::*;
+
+    fn extend_unit<'a>(src: (&'a u8,)) -> (&'static u8,) {
+        unsafe { transmute(src) } //~ ERROR lifetime may not live long enough
+    }
+
+    fn extend_pair<'a>(src: (&'a u8, u8)) -> (&'static u8, u8) {
+        unsafe { transmute(src) } //~ ERROR lifetime may not live long enough
+    }
+}
+
+mod r#struct {
+    use super::*;
+
+    struct Struct<'a>(&'a u8);
+
+    fn extend_struct<'a>(src: Struct<'a>) -> Struct<'static> {
+        unsafe { transmute(src) } //~ ERROR lifetime may not live long enough
+    }
+}
+
+mod r#enum {
+    use super::*;
+
+    enum Single<'a> {
+        A(&'a u8),
+    }
+
+    fn extend_single<'a>(src: Single<'a>) -> Single<'static> {
+        unsafe { transmute(src) } //~ ERROR lifetime may not live long enough
+    }
+
+    enum Multi<'a> {
+        A(&'a u8),
+        B,
+        C,
+    }
+
+    fn extend_multi<'a>(src: Multi<'a>) -> Multi<'static> {
+        unsafe { transmute(src) } //~ ERROR lifetime may not live long enough
+    }
+}
+
+mod hrtb {
+    use super::*;
+
+    fn call_extend_hrtb<'a>(src: &'a u8) -> &'static u8 {
+        unsafe { extend_hrtb(src) } //~ ERROR borrowed data escapes outside of function
+    }
+
+    unsafe fn extend_hrtb<'a>(src: &'a u8) -> &'static u8
+    where
+        for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8>,
+    {
+        core::intrinsics::transmute_unchecked(src)
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/transmutability/references/reject_lifetime_extension.stderr b/tests/ui/transmutability/references/reject_lifetime_extension.stderr
new file mode 100644
index 0000000000000..df1b81f26d2ba
--- /dev/null
+++ b/tests/ui/transmutability/references/reject_lifetime_extension.stderr
@@ -0,0 +1,78 @@
+error: lifetime may not live long enough
+  --> $DIR/reject_lifetime_extension.rs:20:18
+   |
+LL |     fn extend_bare<'a>(src: &'a u8) -> &'static u8 {
+   |                    -- lifetime `'a` defined here
+LL |         unsafe { transmute(src) }
+   |                  ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
+
+error: lifetime may not live long enough
+  --> $DIR/reject_lifetime_extension.rs:28:18
+   |
+LL |     fn extend_nested<'a>(src: &'a &'a u8) -> &'a &'static u8 {
+   |                      -- lifetime `'a` defined here
+LL |         unsafe { transmute(src) }
+   |                  ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
+
+error: lifetime may not live long enough
+  --> $DIR/reject_lifetime_extension.rs:36:18
+   |
+LL |     fn extend_unit<'a>(src: (&'a u8,)) -> (&'static u8,) {
+   |                    -- lifetime `'a` defined here
+LL |         unsafe { transmute(src) }
+   |                  ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
+
+error: lifetime may not live long enough
+  --> $DIR/reject_lifetime_extension.rs:40:18
+   |
+LL |     fn extend_pair<'a>(src: (&'a u8, u8)) -> (&'static u8, u8) {
+   |                    -- lifetime `'a` defined here
+LL |         unsafe { transmute(src) }
+   |                  ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
+
+error: lifetime may not live long enough
+  --> $DIR/reject_lifetime_extension.rs:50:18
+   |
+LL |     fn extend_struct<'a>(src: Struct<'a>) -> Struct<'static> {
+   |                      -- lifetime `'a` defined here
+LL |         unsafe { transmute(src) }
+   |                  ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
+
+error: lifetime may not live long enough
+  --> $DIR/reject_lifetime_extension.rs:62:18
+   |
+LL |     fn extend_single<'a>(src: Single<'a>) -> Single<'static> {
+   |                      -- lifetime `'a` defined here
+LL |         unsafe { transmute(src) }
+   |                  ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
+
+error: lifetime may not live long enough
+  --> $DIR/reject_lifetime_extension.rs:72:18
+   |
+LL |     fn extend_multi<'a>(src: Multi<'a>) -> Multi<'static> {
+   |                     -- lifetime `'a` defined here
+LL |         unsafe { transmute(src) }
+   |                  ^^^^^^^^^^^^^^ returning this value requires that `'a` must outlive `'static`
+
+error[E0521]: borrowed data escapes outside of function
+  --> $DIR/reject_lifetime_extension.rs:80:18
+   |
+LL |     fn call_extend_hrtb<'a>(src: &'a u8) -> &'static u8 {
+   |                         --  --- `src` is a reference that is only valid in the function body
+   |                         |
+   |                         lifetime `'a` defined here
+LL |         unsafe { extend_hrtb(src) }
+   |                  ^^^^^^^^^^^^^^^^
+   |                  |
+   |                  `src` escapes the function body here
+   |                  argument requires that `'a` must outlive `'static`
+   |
+note: due to current limitations in the borrow checker, this implies a `'static` lifetime
+  --> $DIR/reject_lifetime_extension.rs:85:25
+   |
+LL |         for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8>,
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 8 previous errors
+
+For more information about this error, try `rustc --explain E0521`.

From 42b9cb1cb508045541a62178835e5884a14dac7b Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Wed, 7 Aug 2024 02:02:57 -0500
Subject: [PATCH 412/685] Switch to using the v2 resolver in most workspaces

Pinning the resolver to v1 was done in 5abff3753a7c ("Explicit set
workspace.resolver ...") in order to suppress warnings. Since there is
no specific reason not to use the new resolver and since it fixes
issues, change to `resolver = "2"` everywhere except library and
submodules.
---
 Cargo.toml                                                      | 2 +-
 .../docker/host-x86_64/test-various/uefi_qemu_test/Cargo.toml   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 131feec70abcd..d4b84250fc469 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace]
-resolver = "1"
+resolver = "2"
 members = [
   "compiler/rustc",
   "src/etc/test-float-parse",
diff --git a/src/ci/docker/host-x86_64/test-various/uefi_qemu_test/Cargo.toml b/src/ci/docker/host-x86_64/test-various/uefi_qemu_test/Cargo.toml
index 2d17cf7d47a8b..976245f5bdd06 100644
--- a/src/ci/docker/host-x86_64/test-various/uefi_qemu_test/Cargo.toml
+++ b/src/ci/docker/host-x86_64/test-various/uefi_qemu_test/Cargo.toml
@@ -4,7 +4,7 @@ version = "0.0.0"
 edition = "2021"
 
 [workspace]
-resolver = "1"
+resolver = "2"
 
 [dependencies]
 r-efi = "4.1.0"

From f69e74e2f50f1a6bf9aa5acb5b91d5da5311ba5c Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Wed, 7 Aug 2024 02:03:57 -0500
Subject: [PATCH 413/685] Update some dependency versions that allow better
 licensing

With the new resolver, a few dependencies get brought in twice with
different licenses. For example, all dependencies from `wasm-tools`
gained Apache-2.0 and MIT options, and with the v2 resolver we were
using one version from before and one version from after this change.
This made tidy's license check difficult.

Update some minimum versions to remove duplicate dependencies and smooth
out license checking.
---
 compiler/rustc_codegen_llvm/Cargo.toml | 2 +-
 compiler/rustc_codegen_ssa/Cargo.toml  | 2 +-
 src/bootstrap/Cargo.toml               | 2 +-
 src/tools/run-make-support/Cargo.toml  | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/Cargo.toml b/compiler/rustc_codegen_llvm/Cargo.toml
index dad4722d620f3..a93baf88413a1 100644
--- a/compiler/rustc_codegen_llvm/Cargo.toml
+++ b/compiler/rustc_codegen_llvm/Cargo.toml
@@ -12,7 +12,7 @@ bitflags = "2.4.1"
 itertools = "0.12"
 libc = "0.2"
 measureme = "11"
-object = { version = "0.36.2", default-features = false, features = ["std", "read"] }
+object = { version = "0.36.3", default-features = false, features = ["std", "read"] }
 rustc-demangle = "0.1.21"
 rustc_ast = { path = "../rustc_ast" }
 rustc_attr = { path = "../rustc_attr" }
diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml
index 0af34a1b9fa62..e3033b332caee 100644
--- a/compiler/rustc_codegen_ssa/Cargo.toml
+++ b/compiler/rustc_codegen_ssa/Cargo.toml
@@ -41,7 +41,7 @@ tempfile = "3.2"
 thin-vec = "0.2.12"
 thorin-dwp = "0.7"
 tracing = "0.1"
-wasm-encoder = "0.210.0"
+wasm-encoder = "0.215.0"
 # tidy-alphabetical-end
 
 [target.'cfg(unix)'.dependencies]
diff --git a/src/bootstrap/Cargo.toml b/src/bootstrap/Cargo.toml
index 84262c115b120..07f7444aaff64 100644
--- a/src/bootstrap/Cargo.toml
+++ b/src/bootstrap/Cargo.toml
@@ -47,7 +47,7 @@ fd-lock = "4.0"
 home = "0.5"
 ignore = "0.4"
 libc = "0.2"
-object = { version = "0.32", default-features = false, features = ["archive", "coff", "read_core", "unaligned"] }
+object = { version = "0.36.3", default-features = false, features = ["archive", "coff", "read_core", "unaligned"] }
 opener = "0.5"
 semver = "1.0"
 serde = "1.0"
diff --git a/src/tools/run-make-support/Cargo.toml b/src/tools/run-make-support/Cargo.toml
index eae6022b803fd..1a13d56b0e42f 100644
--- a/src/tools/run-make-support/Cargo.toml
+++ b/src/tools/run-make-support/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2021"
 bstr = "1.6.0"
 object = "0.36.2"
 similar = "2.5.0"
-wasmparser = { version = "0.214", default-features = false, features = ["std"] }
+wasmparser = { version = "0.215", default-features = false, features = ["std"] }
 regex = "1.8" # 1.8 to avoid memchr 2.6.0, as 2.5.0 is pinned in the workspace
 gimli = "0.31.0"
 build_helper = { path = "../build_helper" }

From 7240da01ee4fdc33308e9f869b63449af776040e Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Wed, 7 Aug 2024 02:09:12 -0500
Subject: [PATCH 414/685] Run `cargo update` with the new v2 resolver

v2 resolves some dependencies differently, and we adjusted some
dependency versions. Run `cargo update` to make sure everything is in
sync.
---
 Cargo.lock               | 657 +++++++++++++++++++--------------------
 src/bootstrap/Cargo.lock | 207 ++++++------
 2 files changed, 437 insertions(+), 427 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3ad21b0abf920..ac347d02af700 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -125,9 +125,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.6.14"
+version = "0.6.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418c75fa768af9c03be99d17643f93f79bbba589895012a80e3452a19ddda15b"
+checksum = "64e15c1ab1f89faffbf04a634d5e1962e9074f2741eef6d97f3c4e322426d526"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -140,42 +140,42 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.7"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "038dfcf04a5feb68e9c60b21c9625a54c2c0616e79b72b0fd87075a056ae1d1b"
+checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
 
 [[package]]
 name = "anstyle-lossy"
-version = "1.1.1"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fcff6599f06e21b0165c85052ccd6e67dc388ddd1c516a9dc5f55dc8cacf004"
+checksum = "f45c79b3b9413932fc255f2c19ca0d48eaab72c4ea1913bafaebf289cbc099f2"
 dependencies = [
  "anstyle",
 ]
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
+checksum = "eb47de1e80c2b463c735db5b217a0ddc39d612e7ac9e2e96a5aed1f57616c1cb"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391"
+checksum = "6d36fc52c7f6c869915e99412912f22093507da8d9e942ceaf66fe4b7c14422a"
 dependencies = [
  "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "anstyle-svg"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbbf0bf947d663010f0b4132f28ca08da9151f3b9035fa7578a38de521c1d1aa"
+checksum = "962f6d5681926dbe5503b71057202d6723a33abe464c983b1d160bca3095a3bb"
 dependencies = [
  "anstream",
  "anstyle",
@@ -186,9 +186,9 @@ dependencies = [
 
 [[package]]
 name = "anstyle-wincon"
-version = "3.0.3"
+version = "3.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61a38449feb7068f52bb06c12759005cf459ee52bb4adc1d5a7c4322d716fb19"
+checksum = "5bf74e1b6e971609db8ca7a9ce79fd5768ab6ae46441c572e46cf596f59e57f8"
 dependencies = [
  "anstyle",
  "windows-sys 0.52.0",
@@ -209,14 +209,14 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "de11a9d32db3327f981143bdf699ade4d637c6887b13b97e6e91a9154666963c"
 dependencies = [
- "object 0.36.2",
+ "object 0.36.3",
 ]
 
 [[package]]
 name = "arrayvec"
-version = "0.7.4"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
 
 [[package]]
 name = "autocfg"
@@ -271,9 +271,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "block-buffer"
@@ -291,7 +291,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6798148dccfbff0fae41c7574d2fa8f1ef3492fba0face179de5d8d447d67b05"
 dependencies = [
  "memchr",
- "regex-automata 0.3.7",
+ "regex-automata 0.3.9",
  "serde",
 ]
 
@@ -351,15 +351,15 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.6.0"
+version = "1.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
+checksum = "8318a53db07bb3f8dca91a600466bdb3f2eaadeedfdbcf02e1accbad9271ba50"
 
 [[package]]
 name = "camino"
-version = "1.1.7"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0ec6b951b160caa93cc0c7b209e5a3bff7aae9062213451ac99493cd844c239"
+checksum = "8b96ec4966b5813e2c0507c1f86115c8c5abaadc3980879c3424042a02fd1ad3"
 dependencies = [
  "serde",
 ]
@@ -420,9 +420,12 @@ version = "0.1.0"
 
 [[package]]
 name = "cc"
-version = "1.0.99"
+version = "1.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c51067fd44124faa7f870b4b1c969379ad32b2ba805aa959430ceaa384f695"
+checksum = "72db2f7947ecee9b03b510377e8bb9077afa27176fdbff55c51027e976fdcc48"
+dependencies = [
+ "shlex",
+]
 
 [[package]]
 name = "cfg-if"
@@ -432,9 +435,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "cfg_aliases"
-version = "0.1.1"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chrono"
@@ -446,7 +449,7 @@ dependencies = [
  "iana-time-zone",
  "num-traits",
  "serde",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -483,9 +486,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.7"
+version = "4.5.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5db83dced34638ad474f39f250d7fea9598bdd239eaced1bdf45d597da0f433f"
+checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -503,9 +506,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.7"
+version = "4.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7e204572485eb3fbf28f871612191521df159bc3e15a9f5064c66dba3a8c05f"
+checksum = "216aec2b177652e3846684cbfe25c9964d18ec45234f0f5da5157b207ed1aab6"
 dependencies = [
  "anstream",
  "anstyle",
@@ -516,30 +519,30 @@ dependencies = [
 
 [[package]]
 name = "clap_complete"
-version = "4.5.6"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbca90c87c2a04da41e95d1856e8bcd22f159bdbfa147314d2ce5218057b0e58"
+checksum = "1ee158892bd7ce77aa15c208abbdb73e155d191c287a659b57abd5adb92feb03"
 dependencies = [
  "clap",
 ]
 
 [[package]]
 name = "clap_derive"
-version = "4.5.5"
+version = "4.5.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c780290ccf4fb26629baa7a1081e68ced113f1d3ec302fa5948f1c381ebf06c6"
+checksum = "501d359d5f3dcaf6ecdeee48833ae73ec6e42723a1e52419c79abf9507eec0a0"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b82cf0babdbd58558212896d1a4272303a57bdb245c2bf1147185fb45640e70"
+checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
 [[package]]
 name = "clippy"
@@ -559,7 +562,7 @@ dependencies = [
  "regex",
  "rustc_tools_util",
  "serde",
- "syn 2.0.67",
+ "syn 2.0.75",
  "tempfile",
  "termize",
  "tokio",
@@ -671,7 +674,7 @@ dependencies = [
  "nom",
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -688,9 +691,9 @@ dependencies = [
 
 [[package]]
 name = "colorchoice"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b6a852b24ab71dffc585bcb46eaf7959d175cb865a7152e35b348d1b2960422"
+checksum = "d3fd119d74b830634cea2a0f58bbd0d54540518a14397557951e79340abc28c0"
 
 [[package]]
 name = "colored"
@@ -750,9 +753,9 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "coverage-dump"
@@ -768,9 +771,9 @@ dependencies = [
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.12"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+checksum = "51e852e6dc9a5bed1fae92dd2375037bf2b768725bf3be87811edee3249d09ad"
 dependencies = [
  "libc",
 ]
@@ -830,12 +833,12 @@ dependencies = [
 
 [[package]]
 name = "ctrlc"
-version = "3.4.4"
+version = "3.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "672465ae37dc1bc6380a6547a8883d5dd397b0f1faaad4f265726cc7042a5345"
+checksum = "90eeab0aa92f3f9b4e87f258c72b139c207d251f9cbc1080a0086b86a8870dd3"
 dependencies = [
  "nix",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -855,9 +858,9 @@ dependencies = [
 
 [[package]]
 name = "curl-sys"
-version = "0.4.72+curl-8.6.0"
+version = "0.4.74+curl-8.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29cbdc8314c447d11e8fd156dcdd031d9e02a7a976163e396b548c03153bc9ea"
+checksum = "8af10b986114528fcdc4b63b6f5f021b7057618411046a4de2ba0f0149a097bf"
 dependencies = [
  "cc",
  "libc",
@@ -870,9 +873,9 @@ dependencies = [
 
 [[package]]
 name = "darling"
-version = "0.20.9"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83b2eb4d90d12bdda5ed17de686c2acb4c57914f8f921b8da7e112b5a36f3fe1"
+checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
  "darling_core",
  "darling_macro",
@@ -880,27 +883,27 @@ dependencies = [
 
 [[package]]
 name = "darling_core"
-version = "0.20.9"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622687fe0bac72a04e5599029151f5796111b90f1baaa9b544d807a5e31cd120"
+checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5"
 dependencies = [
  "fnv",
  "ident_case",
  "proc-macro2",
  "quote",
  "strsim",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.20.9"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "733cabb43482b1a1b53eee8583c2b9e8684d592215ea83efd305dd31bc2f0178"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
  "darling_core",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -926,7 +929,7 @@ version = "0.1.82"
 dependencies = [
  "itertools",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -946,7 +949,7 @@ checksum = "62d671cc41a825ebabc75757b62d3d168c577f9149b2d49ece1dad1f72119d25"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -967,7 +970,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -977,7 +980,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "206868b8242f27cecce124c19fd88157fbd0dd334df2587f36417bafbc85097b"
 dependencies = [
  "derive_builder_core",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -988,7 +991,7 @@ checksum = "5f33878137e4dafd7fa914ad4e259e18a4e8e532b9617a2d0150262bf53abfce"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -1000,7 +1003,7 @@ dependencies = [
  "darling",
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -1078,7 +1081,7 @@ checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -1089,9 +1092,9 @@ checksum = "59f8e79d1fbf76bdfbde321e902714bf6c49df88a7dda6fc682fc2979226962d"
 
 [[package]]
 name = "either"
-version = "1.12.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dca9240753cf90908d7e4aac30f630662b02aebaa1b58a3cadabdb23385b58b"
+checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
 [[package]]
 name = "elasticlunr-rs"
@@ -1131,9 +1134,9 @@ checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
 
 [[package]]
 name = "env_filter"
-version = "0.1.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a009aa4810eb158359dda09d0c87378e4bbb89b5a801f016885a4707ba24f7ea"
+checksum = "4f2c92ceda6ceec50f43169f9ee8424fe2db276791afde7b2cd8bc084cb376ab"
 dependencies = [
  "log",
  "regex",
@@ -1141,9 +1144,9 @@ dependencies = [
 
 [[package]]
 name = "env_logger"
-version = "0.11.3"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38b35839ba51819680ba087cd351788c9a3c476841207e0b8cee0b04722343b9"
+checksum = "e13fa619b91fb2381732789fc5de83b45675e882f66623b7d8cb4f643017018d"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1219,21 +1222,21 @@ dependencies = [
 
 [[package]]
 name = "filetime"
-version = "0.2.23"
+version = "0.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
+checksum = "bf401df4a4e3872c4fe8151134cf483738e74b67fc934d6532c882b3d24a4550"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall 0.4.1",
- "windows-sys 0.52.0",
+ "libredox",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
 name = "flate2"
-version = "1.0.30"
+version = "1.0.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae"
+checksum = "7f211bbe8e69bbd0cfdea405084f128ae8b4aaa6b0b522fc8f2b009084797920"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -1369,7 +1372,7 @@ checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -1587,7 +1590,7 @@ dependencies = [
  "markup5ever",
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -1719,7 +1722,7 @@ checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -1856,9 +1859,9 @@ dependencies = [
 
 [[package]]
 name = "is_terminal_polyfill"
-version = "1.70.0"
+version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8478577c03552c21db0e2724ffb8986a5ce7af88107e6be5d2ee6e158c12800"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
 [[package]]
 name = "itertools"
@@ -1887,18 +1890,18 @@ dependencies = [
 
 [[package]]
 name = "jobserver"
-version = "0.1.31"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
 dependencies = [
  "libc",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.69"
+version = "0.3.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
 dependencies = [
  "wasm-bindgen",
 ]
@@ -1965,9 +1968,9 @@ checksum = "baff4b617f7df3d896f97fe922b64817f6cd9a756bb81d40f8883f2f66dcb401"
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.157"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "374af5f94e54fa97cf75e945cce8a6b201e88a1a07e688b47dfd2a59c66dbd86"
 
 [[package]]
 name = "libdbus-sys"
@@ -2000,12 +2003,12 @@ dependencies = [
 
 [[package]]
 name = "libloading"
-version = "0.8.3"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19"
+checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
  "cfg-if",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -2020,15 +2023,16 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "libc",
+ "redox_syscall",
 ]
 
 [[package]]
 name = "libz-sys"
-version = "1.1.18"
+version = "1.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c15da26e5af7e25c90b37a2d75cdbf940cf4a55316de9d84c679c9b8bfabf82e"
+checksum = "fdc53a7799a7496ebc9fd29f31f7df80e83c9bda5299768af5f9e59eeea74647"
 dependencies = [
  "cc",
  "libc",
@@ -2092,9 +2096,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.21"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "lzma-sys"
@@ -2169,7 +2173,7 @@ dependencies = [
  "log",
  "memchr",
  "once_cell",
- "opener 0.7.1",
+ "opener 0.7.2",
  "pulldown-cmark 0.10.3",
  "regex",
  "serde",
@@ -2226,9 +2230,9 @@ checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
 [[package]]
 name = "mime_guess"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
 dependencies = [
  "mime",
  "unicase",
@@ -2301,11 +2305,11 @@ checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 
 [[package]]
 name = "nix"
-version = "0.28.0"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -2323,11 +2327,11 @@ dependencies = [
 
 [[package]]
 name = "normpath"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5831952a9476f2fed74b77d74182fa5ddc4d21c72ec45a333b250e3ed0272804"
+checksum = "c8911957c4b1549ac0dc74e30db9c8b0e66ddcd6d7acc33098f4c63a64a6d7ed"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -2342,11 +2346,11 @@ dependencies = [
 
 [[package]]
 name = "nu-ansi-term"
-version = "0.50.0"
+version = "0.50.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd2800e1520bdc966782168a627aa5d1ad92e33b984bf7c7615d31280c83ff14"
+checksum = "d4a28e057d01f97e61255210fcff094d74ed0466038633e95017f5beb68e4399"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2460,9 +2464,9 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.36.2"
+version = "0.36.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f203fa8daa7bb185f760ae12bd8e097f63d17041dcdcaf675ac54cdf863170e"
+checksum = "27b64972346851a39438c60b341ebc01bba47464ae329e55cf343eb93964efd9"
 dependencies = [
  "crc32fast",
  "flate2",
@@ -2470,7 +2474,7 @@ dependencies = [
  "indexmap",
  "memchr",
  "ruzstd 0.7.0",
- "wasmparser 0.214.0",
+ "wasmparser",
 ]
 
 [[package]]
@@ -2513,14 +2517,14 @@ dependencies = [
 
 [[package]]
 name = "opener"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8df34be653210fbe9ffaff41d3b92721c56ce82dfee58ee684f9afb5e3a90c0"
+checksum = "d0812e5e4df08da354c851a3376fead46db31c2214f849d3de356d774d057681"
 dependencies = [
  "bstr",
  "dbus",
  "normpath",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -2531,9 +2535,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 
 [[package]]
 name = "openssl-sys"
-version = "0.9.102"
+version = "0.9.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2"
+checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6"
 dependencies = [
  "cc",
  "libc",
@@ -2621,9 +2625,9 @@ checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall 0.5.2",
+ "redox_syscall",
  "smallvec",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -2658,9 +2662,9 @@ dependencies = [
 
 [[package]]
 name = "pest"
-version = "2.7.10"
+version = "2.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "560131c633294438da9f7c4b08189194b20946c8274c6b9e38881a7874dc8ee8"
+checksum = "cd53dff83f26735fdc1ca837098ccf133605d794cdae66acfc2bfac3ec809d95"
 dependencies = [
  "memchr",
  "thiserror",
@@ -2669,9 +2673,9 @@ dependencies = [
 
 [[package]]
 name = "pest_derive"
-version = "2.7.10"
+version = "2.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26293c9193fbca7b1a3bf9b79dc1e388e927e6cacaa78b4a3ab705a1d3d41459"
+checksum = "2a548d2beca6773b1c244554d36fcf8548a8a58e74156968211567250e48e49a"
 dependencies = [
  "pest",
  "pest_generator",
@@ -2679,22 +2683,22 @@ dependencies = [
 
 [[package]]
 name = "pest_generator"
-version = "2.7.10"
+version = "2.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ec22af7d3fb470a85dd2ca96b7c577a1eb4ef6f1683a9fe9a8c16e136c04687"
+checksum = "3c93a82e8d145725dcbaf44e5ea887c8a869efdcc28706df2d08c69e17077183"
 dependencies = [
  "pest",
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
 name = "pest_meta"
-version = "2.7.10"
+version = "2.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7a240022f37c361ec1878d646fc5b7d7c4d28d5946e1a80ad5a7a4f4ca0bdcd"
+checksum = "a941429fea7e08bedec25e4f6785b6ffaacc6b755da98df5ef3e7dcf4a124c4f"
 dependencies = [
  "once_cell",
  "pest",
@@ -2789,9 +2793,9 @@ dependencies = [
 
 [[package]]
 name = "portable-atomic"
-version = "1.6.0"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
+checksum = "da544ee218f0d287a911e9c99a39a8c9bc8fcad3cb8db5959940044ecfc67265"
 
 [[package]]
 name = "powerfmt"
@@ -2801,9 +2805,12 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "ppv-lite86"
-version = "0.2.17"
+version = "0.2.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+checksum = "77957b295656769bb8ad2b6a6b09d897d94f05c41b069aede1fcdaa675eaea04"
+dependencies = [
+ "zerocopy",
+]
 
 [[package]]
 name = "precomputed-hash"
@@ -2861,7 +2868,7 @@ version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "memchr",
  "unicase",
 ]
@@ -2872,7 +2879,7 @@ version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76979bea66e7875e7509c4ec5300112b316af87fa7a252ca91c448b32dfe3993"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "memchr",
  "pulldown-cmark-escape 0.10.1",
  "unicase",
@@ -2880,11 +2887,11 @@ dependencies = [
 
 [[package]]
 name = "pulldown-cmark"
-version = "0.11.0"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8746739f11d39ce5ad5c2520a9b75285310dbfe78c541ccf832d38615765aec0"
+checksum = "cb4e75767fbc9d92b90e4d0c011f61358cde9513b31ef07ea3631b15ffc3b4fd"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "memchr",
  "pulldown-cmark-escape 0.11.0",
  "unicase",
@@ -2984,20 +2991,11 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
-dependencies = [
- "bitflags 1.3.2",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.5.2"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
+checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
 ]
 
 [[package]]
@@ -3013,13 +3011,12 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.4"
+version = "1.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12de2eff854e5fa4b1295edd650e227e9d8fb0c9e90b12e7f36d6a6811791a29"
+checksum = "d0ab3ca65655bb1e41f2a8c8cd662eb4fb035e67c3f78da1d61dffe89d07300f"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.3.7",
  "regex-syntax 0.7.5",
 ]
 
@@ -3043,14 +3040,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.7"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49530408a136e16e5b486e883fbb6ba058e8e4e8ae6621a77b048b314336e629"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax 0.7.5",
-]
+checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
 
 [[package]]
 name = "regex-lite"
@@ -3120,7 +3112,7 @@ dependencies = [
  "quote",
  "rinja_parser",
  "serde",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -3147,11 +3139,11 @@ dependencies = [
  "bstr",
  "build_helper",
  "gimli 0.31.0",
- "object 0.36.2",
+ "object 0.36.3",
  "regex",
  "serde_json",
  "similar",
- "wasmparser 0.214.0",
+ "wasmparser",
 ]
 
 [[package]]
@@ -3235,7 +3227,7 @@ checksum = "e5c9f15eec8235d7cb775ee6f81891db79b98fd54ba1ad8fae565b88ef1ae4e2"
 name = "rustc_abi"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "rand",
  "rand_xoshiro",
  "rustc_data_structures",
@@ -3247,9 +3239,9 @@ dependencies = [
 
 [[package]]
 name = "rustc_apfloat"
-version = "0.2.0+llvm-462a31f5a5ab"
+version = "0.2.1+llvm-462a31f5a5ab"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "465187772033a5ee566f69fe008df03628fce549a0899aae76f0a0c2e34696be"
+checksum = "886d94c63c812a8037c4faca2607453a0fa4cf82f734665266876b022244543f"
 dependencies = [
  "bitflags 1.3.2",
  "smallvec",
@@ -3266,7 +3258,7 @@ dependencies = [
 name = "rustc_ast"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "memchr",
  "rustc_ast_ir",
  "rustc_data_structures",
@@ -3428,11 +3420,11 @@ dependencies = [
 name = "rustc_codegen_llvm"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "itertools",
  "libc",
  "measureme",
- "object 0.36.2",
+ "object 0.36.3",
  "rustc-demangle",
  "rustc_ast",
  "rustc_attr",
@@ -3465,13 +3457,13 @@ version = "0.0.0"
 dependencies = [
  "ar_archive_writer",
  "arrayvec",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "cc",
  "either",
  "itertools",
  "jobserver",
  "libc",
- "object 0.36.2",
+ "object 0.36.3",
  "pathdiff",
  "regex",
  "rustc_arena",
@@ -3501,7 +3493,7 @@ dependencies = [
  "thin-vec",
  "thorin-dwp",
  "tracing",
- "wasm-encoder 0.210.0",
+ "wasm-encoder",
  "windows 0.52.0",
 ]
 
@@ -3535,7 +3527,7 @@ name = "rustc_data_structures"
 version = "0.0.0"
 dependencies = [
  "arrayvec",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "either",
  "elsa",
  "ena",
@@ -3715,7 +3707,7 @@ dependencies = [
  "fluent-syntax",
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
  "unic-langid",
 ]
 
@@ -3849,7 +3841,7 @@ version = "0.0.0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -3998,7 +3990,7 @@ version = "0.0.0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
  "synstructure",
 ]
 
@@ -4006,7 +3998,7 @@ dependencies = [
 name = "rustc_metadata"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "libloading",
  "odht",
  "rustc_ast",
@@ -4036,7 +4028,7 @@ dependencies = [
 name = "rustc_middle"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "derive-where",
  "either",
  "field-offset",
@@ -4167,7 +4159,7 @@ dependencies = [
 name = "rustc_next_trait_solver"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "derive-where",
  "rustc_ast_ir",
  "rustc_data_structures",
@@ -4183,7 +4175,7 @@ dependencies = [
 name = "rustc_parse"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "rustc_ast",
  "rustc_ast_pretty",
  "rustc_data_structures",
@@ -4321,8 +4313,8 @@ dependencies = [
 name = "rustc_resolve"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
- "pulldown-cmark 0.11.0",
+ "bitflags 2.6.0",
+ "pulldown-cmark 0.11.2",
  "rustc_arena",
  "rustc_ast",
  "rustc_ast_pretty",
@@ -4349,7 +4341,7 @@ dependencies = [
 name = "rustc_sanitizers"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "rustc_data_structures",
  "rustc_hir",
  "rustc_middle",
@@ -4375,7 +4367,7 @@ dependencies = [
 name = "rustc_session"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "getopts",
  "libc",
  "rustc_ast",
@@ -4454,8 +4446,8 @@ dependencies = [
 name = "rustc_target"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
- "object 0.36.2",
+ "bitflags 2.6.0",
+ "object 0.36.3",
  "rustc_abi",
  "rustc_data_structures",
  "rustc_feature",
@@ -4557,7 +4549,7 @@ dependencies = [
 name = "rustc_type_ir"
 version = "0.0.0"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "derive-where",
  "indexmap",
  "rustc_ast_ir",
@@ -4577,7 +4569,7 @@ version = "0.0.0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
  "synstructure",
 ]
 
@@ -4677,7 +4669,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -4715,7 +4707,7 @@ version = "0.38.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
 dependencies = [
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -4811,41 +4803,42 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.203"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.203"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.117"
+version = "1.0.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
+checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed"
 dependencies = [
  "indexmap",
  "itoa",
+ "memchr",
  "ryu",
  "serde",
 ]
 
 [[package]]
 name = "serde_spanned"
-version = "0.6.6"
+version = "0.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79e674e01f999af37c49f70a6ede167a8a60b2503e56c5599532a65baa5969a0"
+checksum = "eb5b1b31579f3811bf615c144393417496f152e12ac8b7663bf664f4a815306d"
 dependencies = [
  "serde",
 ]
@@ -4895,9 +4888,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "similar"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640"
+checksum = "1de1d4f81173b03af4c0cbed3c898f6bff5b870e4a7f5d6f4057d62a7a4b686e"
 
 [[package]]
 name = "siphasher"
@@ -5089,9 +5082,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.67"
+version = "2.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff8655ed1d86f3af4ee3fd3263786bc14245ad17c4c7e85ba7187fb3ae028c90"
+checksum = "f6af063034fc1935ede7be0122941bafa9bacb949334d090b77ca98b5817c7d9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -5106,7 +5099,7 @@ checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -5143,14 +5136,15 @@ dependencies = [
 
 [[package]]
 name = "tempfile"
-version = "3.10.1"
+version = "3.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+checksum = "04cbcdd0c794ebb0d4cf35e88edd2f7d2c4c3e9a5a6dab322839b321c6a87a64"
 dependencies = [
  "cfg-if",
  "fastrand",
+ "once_cell",
  "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5223,22 +5217,22 @@ checksum = "a38c90d48152c236a3ab59271da4f4ae63d678c5d7ad6b7714d7cb9760be5e4b"
 
 [[package]]
 name = "thiserror"
-version = "1.0.61"
+version = "1.0.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -5336,9 +5330,9 @@ dependencies = [
 
 [[package]]
 name = "tinyvec"
-version = "1.6.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+checksum = "445e881f4f6d382d5f27c034e25eb92edd7c784ceab92a0937db7f2e9471b938"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -5351,9 +5345,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.38.0"
+version = "1.39.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a"
+checksum = "9babc99b9923bfa4804bd74722ff02c0381021eafa4db9949217e3be8e84fff5"
 dependencies = [
  "backtrace",
  "bytes",
@@ -5383,9 +5377,9 @@ dependencies = [
 
 [[package]]
 name = "toml_datetime"
-version = "0.6.6"
+version = "0.6.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
+checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
 dependencies = [
  "serde",
 ]
@@ -5429,7 +5423,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -5488,7 +5482,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b56c62d2c80033cb36fae448730a2f2ef99410fe3ecbffc916681a32f6807dbe"
 dependencies = [
- "nu-ansi-term 0.50.0",
+ "nu-ansi-term 0.50.1",
  "tracing-core",
  "tracing-log",
  "tracing-subscriber",
@@ -5628,7 +5622,7 @@ checksum = "1ed7f4237ba393424195053097c1516bd4590dc82b84f2f97c5c69e12704555b"
 dependencies = [
  "proc-macro-hack",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
  "unic-langid-impl",
 ]
 
@@ -5757,9 +5751,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.8.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314"
 dependencies = [
  "getrandom",
 ]
@@ -5778,9 +5772,9 @@ checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "walkdir"
@@ -5798,36 +5792,43 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
+[[package]]
+name = "wasi-preview1-component-adapter-provider"
+version = "23.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91d3d13afef569b9fc80cfbb807c87c16ef49bd3ac1a93285ea6a264b600d2d"
+
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
 dependencies = [
  "cfg-if",
+ "once_cell",
  "wasm-bindgen-macro",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -5835,36 +5836,38 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.92"
+version = "0.2.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
 
 [[package]]
 name = "wasm-component-ld"
-version = "0.5.4"
+version = "0.5.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "314d932d5e84c9678751b85498b1482b2f32f185744e449d3ce0b1d400376dad"
+checksum = "51449c63d1ce69f92b8465a084ed5b91f1a7eb583fa95796650a6bfcffc4f9cb"
 dependencies = [
  "anyhow",
  "clap",
  "lexopt",
  "tempfile",
- "wasmparser 0.210.0",
+ "wasi-preview1-component-adapter-provider",
+ "wasmparser",
  "wat",
  "wit-component",
+ "wit-parser",
 ]
 
 [[package]]
@@ -5876,27 +5879,19 @@ dependencies = [
 
 [[package]]
 name = "wasm-encoder"
-version = "0.210.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7e3764d9d6edabd8c9e16195e177be0d20f6ab942ad18af52860f12f82bc59a"
-dependencies = [
- "leb128",
-]
-
-[[package]]
-name = "wasm-encoder"
-version = "0.211.1"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e7d931a1120ef357f32b74547646b6fa68ea25e377772b72874b131a9ed70d4"
+checksum = "4fb56df3e06b8e6b77e37d2969a50ba51281029a9aeb3855e76b7f49b6418847"
 dependencies = [
  "leb128",
+ "wasmparser",
 ]
 
 [[package]]
 name = "wasm-metadata"
-version = "0.210.0"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "012729d1294907fcb0866f08460ab95426a6d0b176a599619b84cac7653452b4"
+checksum = "0c6bb07c5576b608f7a2a9baa2294c1a3584a249965d695a9814a496cb6d232f"
 dependencies = [
  "anyhow",
  "indexmap",
@@ -5904,52 +5899,42 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "spdx",
- "wasm-encoder 0.210.0",
- "wasmparser 0.210.0",
+ "wasm-encoder",
+ "wasmparser",
 ]
 
 [[package]]
 name = "wasmparser"
-version = "0.210.0"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7bbcd21e7581619d9f6ca00f8c4f08f1cacfe58bf63f83af57cd0476f1026f5"
+checksum = "53fbde0881f24199b81cf49b6ff8f9c145ac8eb1b7fc439adb5c099734f7d90e"
 dependencies = [
  "ahash",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "hashbrown",
  "indexmap",
  "semver",
  "serde",
 ]
 
-[[package]]
-name = "wasmparser"
-version = "0.214.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5309c1090e3e84dad0d382f42064e9933fdaedb87e468cc239f0eabea73ddcb6"
-dependencies = [
- "bitflags 2.5.0",
- "indexmap",
-]
-
 [[package]]
 name = "wast"
-version = "211.0.1"
+version = "215.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b25506dd82d00da6b14a87436b3d52b1d264083fa79cdb72a0d1b04a8595ccaa"
+checksum = "1ff1d00d893593249e60720be04a7c1f42f1c4dc3806a2869f4e66ab61eb54cb"
 dependencies = [
  "bumpalo",
  "leb128",
  "memchr",
  "unicode-width",
- "wasm-encoder 0.211.1",
+ "wasm-encoder",
 ]
 
 [[package]]
 name = "wat"
-version = "1.211.1"
+version = "1.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb716ca6c86eecac2d82541ffc39860118fc0af9309c4f2670637bea2e1bdd7d"
+checksum = "670bf4d9c8cf76ae242d70ded47c546525b6dafaa6871f9bcb065344bf2b4e3d"
 dependencies = [
  "wast",
 ]
@@ -5972,11 +5957,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5992,7 +5977,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
 dependencies = [
  "windows-core 0.52.0",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -6002,7 +5987,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143"
 dependencies = [
  "windows-core 0.57.0",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -6015,7 +6000,7 @@ dependencies = [
  "rayon",
  "serde",
  "serde_json",
- "syn 2.0.67",
+ "syn 2.0.75",
  "windows-metadata",
 ]
 
@@ -6025,7 +6010,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -6037,7 +6022,7 @@ dependencies = [
  "windows-implement",
  "windows-interface",
  "windows-result",
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -6048,7 +6033,7 @@ checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -6059,7 +6044,7 @@ checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -6074,7 +6059,7 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
 dependencies = [
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -6092,7 +6077,16 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.5",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
@@ -6112,18 +6106,18 @@ dependencies = [
 
 [[package]]
 name = "windows-targets"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.5",
- "windows_aarch64_msvc 0.52.5",
- "windows_i686_gnu 0.52.5",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
  "windows_i686_gnullvm",
- "windows_i686_msvc 0.52.5",
- "windows_x86_64_gnu 0.52.5",
- "windows_x86_64_gnullvm 0.52.5",
- "windows_x86_64_msvc 0.52.5",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]
 
 [[package]]
@@ -6134,9 +6128,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -6146,9 +6140,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -6158,15 +6152,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
 [[package]]
 name = "windows_i686_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -6176,9 +6170,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -6188,9 +6182,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -6200,9 +6194,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -6212,9 +6206,9 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.5"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "winnow"
@@ -6227,28 +6221,28 @@ dependencies = [
 
 [[package]]
 name = "wit-component"
-version = "0.210.0"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a450bdb5d032acf1fa0865451fa0c6f50e62f2d31eaa8dba967c2e2d068694a4"
+checksum = "f725e3885fc5890648be5c5cbc1353b755dc932aa5f1aa7de968b912a3280743"
 dependencies = [
  "anyhow",
- "bitflags 2.5.0",
+ "bitflags 2.6.0",
  "indexmap",
  "log",
  "serde",
  "serde_derive",
  "serde_json",
- "wasm-encoder 0.210.0",
+ "wasm-encoder",
  "wasm-metadata",
- "wasmparser 0.210.0",
+ "wasmparser",
  "wit-parser",
 ]
 
 [[package]]
 name = "wit-parser"
-version = "0.210.0"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60a965cbd439af19a4b44a54a97ab8957d86f02d01320efc9e31c1d3605c6710"
+checksum = "935a97eaffd57c3b413aa510f8f0b550a4a9fe7d59e79cd8b89a83dcb860321f"
 dependencies = [
  "anyhow",
  "id-arena",
@@ -6259,7 +6253,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "unicode-xid",
- "wasmparser 0.210.0",
+ "wasmparser",
 ]
 
 [[package]]
@@ -6317,28 +6311,29 @@ checksum = "28cc31741b18cb6f1d5ff12f5b7523e3d6eb0852bbbad19d73905511d9849b95"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
  "synstructure",
 ]
 
 [[package]]
 name = "zerocopy"
-version = "0.7.34"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae87e3fcd617500e5d106f0380cf7b77f3c6092aae37191433159dda23cfb087"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
+ "byteorder",
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.34"
+version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15e934569e47891f7d9411f1a451d947a60e000ab3bd24fbb970f000387d1b3b"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
 
 [[package]]
@@ -6358,15 +6353,15 @@ checksum = "0ea7b4a3637ea8669cedf0f1fd5c286a17f3de97b8dd5a70a6c167a1730e63a5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
  "synstructure",
 ]
 
 [[package]]
 name = "zerovec"
-version = "0.10.2"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb2cc8827d6c0994478a15c53f374f46fbd41bea663d809b14744bc42e6b109c"
+checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
 dependencies = [
  "yoke",
  "zerofrom",
@@ -6375,11 +6370,11 @@ dependencies = [
 
 [[package]]
 name = "zerovec-derive"
-version = "0.10.2"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97cf56601ee5052b4417d90c8755c6683473c926039908196cf35d99f893ebe7"
+checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.67",
+ "syn 2.0.75",
 ]
diff --git a/src/bootstrap/Cargo.lock b/src/bootstrap/Cargo.lock
index 60453764d82d3..357c6175152d4 100644
--- a/src/bootstrap/Cargo.lock
+++ b/src/bootstrap/Cargo.lock
@@ -4,30 +4,24 @@ version = 3
 
 [[package]]
 name = "aho-corasick"
-version = "1.1.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "anstyle"
-version = "1.0.4"
+version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7079075b41f533b8c61d2a4d073c4676e1f8b249ff94a393b0595db304e0dd87"
+checksum = "1bec1de6f59aedf83baf9ff929c98f2ad654b97c9510f4e70cf6f661d49fd5b1"
 
 [[package]]
 name = "bitflags"
-version = "1.3.2"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "bitflags"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07"
+checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
 
 [[package]]
 name = "block-buffer"
@@ -71,9 +65,9 @@ dependencies = [
 
 [[package]]
 name = "bstr"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c48f0051a4b4c5e0b6d365cd04af53aeaa209e3cc15ec2cdb69e73cc87fbd0dc"
+checksum = "40723b8fb387abc38f4f4a37c09073622e41dd12327033091ef8950659e6dc0c"
 dependencies = [
  "memchr",
  "regex-automata",
@@ -102,9 +96,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "clap"
-version = "4.4.13"
+version = "4.5.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52bdc885e4cacc7f7c9eedc1ef6da641603180c783c41a15c264944deeaab642"
+checksum = "ed6719fffa43d0d87e5fd8caeab59be1554fb028cd30edc88fc4369b17971019"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -112,9 +106,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.4.12"
+version = "4.5.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb7fb5e4e979aec3be7791562fcba452f94ad85e954da024396433e0e25a79e9"
+checksum = "216aec2b177652e3846684cbfe25c9964d18ec45234f0f5da5157b207ed1aab6"
 dependencies = [
  "anstyle",
  "clap_lex",
@@ -122,18 +116,18 @@ dependencies = [
 
 [[package]]
 name = "clap_complete"
-version = "4.4.6"
+version = "4.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97aeaa95557bd02f23fbb662f981670c3d20c5a26e69f7354b28f57092437fcd"
+checksum = "1ee158892bd7ce77aa15c208abbdb73e155d191c287a659b57abd5adb92feb03"
 dependencies = [
  "clap",
 ]
 
 [[package]]
 name = "clap_derive"
-version = "4.4.7"
+version = "4.5.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
+checksum = "501d359d5f3dcaf6ecdeee48833ae73ec6e42723a1e52419c79abf9507eec0a0"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -143,9 +137,9 @@ dependencies = [
 
 [[package]]
 name = "clap_lex"
-version = "0.6.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
+checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
 [[package]]
 name = "cmake"
@@ -158,15 +152,15 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.12"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+checksum = "51e852e6dc9a5bed1fae92dd2375037bf2b768725bf3be87811edee3249d09ad"
 dependencies = [
  "libc",
 ]
@@ -224,12 +218,12 @@ dependencies = [
 
 [[package]]
 name = "errno"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
+checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -240,19 +234,19 @@ checksum = "7e5768da2206272c81ef0b5e951a41862938a6070da63bcea197899942d3b947"
 dependencies = [
  "cfg-if",
  "rustix",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "filetime"
-version = "0.2.23"
+version = "0.2.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
+checksum = "bf401df4a4e3872c4fe8151134cf483738e74b67fc934d6532c882b3d24a4550"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall",
- "windows-sys",
+ "libredox",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -280,9 +274,9 @@ dependencies = [
 
 [[package]]
 name = "heck"
-version = "0.4.1"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "home"
@@ -290,14 +284,14 @@ version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "ignore"
-version = "0.4.21"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "747ad1b4ae841a78e8aba0d63adbfbeaea26b517b63705d47856b73015d27060"
+checksum = "b46810df39e66e925525d6e38ce1e7f6e1d208f72dc39757880fcb66e2c58af1"
 dependencies = [
  "crossbeam-deque",
  "globset",
@@ -311,9 +305,9 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "junction"
@@ -322,26 +316,37 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1c9c415a9b7b1e86cd5738f39d34c9e78c765da7fb1756dbd7d31b3b0d2e7afa"
 dependencies = [
  "scopeguard",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.157"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "374af5f94e54fa97cf75e945cce8a6b201e88a1a07e688b47dfd2a59c66dbd86"
+
+[[package]]
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags",
+ "libc",
+ "redox_syscall",
+]
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.12"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
 
 [[package]]
 name = "log"
-version = "0.4.20"
+version = "0.4.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "lzma-sys"
@@ -356,9 +361,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.7.1"
+version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "ntapi"
@@ -371,9 +376,9 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.32.2"
+version = "0.36.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+checksum = "27b64972346851a39438c60b341ebc01bba47464ae329e55cf343eb93964efd9"
 dependencies = [
  "memchr",
 ]
@@ -390,9 +395,9 @@ dependencies = [
 
 [[package]]
 name = "pkg-config"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69d3587f8a9e599cc7ec2c00e331f71c4e69a5f9a4b8a6efd5b07466b9736f9a"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
 
 [[package]]
 name = "pretty_assertions"
@@ -406,36 +411,36 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.76"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.35"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "redox_syscall"
-version = "0.4.1"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
 ]
 
 [[package]]
 name = "regex-automata"
-version = "0.4.3"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
+checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -444,28 +449,28 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.2"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
 
 [[package]]
 name = "rustix"
-version = "0.38.28"
+version = "0.38.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72e572a5e8ca657d7366229cdde4bd14c4eb5499a9573d4d366fe1b599daa316"
+checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
 dependencies = [
- "bitflags 2.4.1",
+ "bitflags",
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "ryu"
-version = "1.0.16"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "same-file"
@@ -484,24 +489,24 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "semver"
-version = "1.0.21"
+version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b97ed7a9823b74f99c7742f5336af7be5ecd3eeafcb1507d1fa93347b1d589b0"
+checksum = "61697e0a1c7e512e84a621326239844a24d8207b4669b41bc18b32ea5cbf988b"
 
 [[package]]
 name = "serde"
-version = "1.0.195"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02"
+checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.195"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c"
+checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -510,11 +515,12 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.111"
+version = "1.0.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "176e46fa42316f18edd598015a5166857fc835ec732f5215eac6b7bdbf0a84f4"
+checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed"
 dependencies = [
  "itoa",
+ "memchr",
  "ryu",
  "serde",
 ]
@@ -532,9 +538,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.48"
+version = "2.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
+checksum = "f6af063034fc1935ede7be0122941bafa9bacb949334d090b77ca98b5817c7d9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -556,9 +562,9 @@ dependencies = [
 
 [[package]]
 name = "tar"
-version = "0.4.40"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b16afcea1f22891c49a00c751c7b63b2233284064f11a200fc624137c51e2ddb"
+checksum = "cb797dad5fb5b76fcf519e702f4a589483b5ef06567f160c392832c1f5e44909"
 dependencies = [
  "filetime",
  "libc",
@@ -567,9 +573,9 @@ dependencies = [
 
 [[package]]
 name = "termcolor"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff1bc3d3f05aff0403e8ac0d92ced918ec05b666a43f83297ccef5bea8a3d449"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
 dependencies = [
  "winapi-util",
 ]
@@ -597,15 +603,15 @@ checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "walkdir"
-version = "2.4.0"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
 dependencies = [
  "same-file",
  "winapi-util",
@@ -629,11 +635,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.6"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
+checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
 dependencies = [
- "winapi",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -723,6 +729,15 @@ dependencies = [
  "windows-targets",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -789,9 +804,9 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
 name = "xattr"
-version = "1.2.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "914566e6413e7fa959cc394fb30e563ba80f3541fbd40816d4c05a0fc3f2a0f1"
+checksum = "8da84f1a25939b27f6820d92aed108f83ff920fdf11a7b19366c27c4cda81d4f"
 dependencies = [
  "libc",
  "linux-raw-sys",

From b1b1dd17d30c04faed44a7983fbde14f4dbb481b Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Wed, 7 Aug 2024 02:10:06 -0500
Subject: [PATCH 415/685] Adjust licensing exceptions for WASM components

Recent versions of wasm-tools are now Apache-2.0 or MIT or Apache-2.0
with the LLVM exception, rather than strictly Apache-2.0 with the LLVM
exception. The only component with the exception has moved to a new
dependency `wasi-preview1-component-adapter-provider`.
---
 src/tools/tidy/src/deps.rs | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs
index 89011bbb48f5c..28367f25267f1 100644
--- a/src/tools/tidy/src/deps.rs
+++ b/src/tools/tidy/src/deps.rs
@@ -98,13 +98,7 @@ const EXCEPTIONS: ExceptionList = &[
     ("ryu", "Apache-2.0 OR BSL-1.0"), // BSL is not acceptble, but we use it under Apache-2.0                       // cargo/... (because of serde)
     ("self_cell", "Apache-2.0"),                             // rustc (fluent translations)
     ("snap", "BSD-3-Clause"),                                // rustc
-    ("wasm-encoder", "Apache-2.0 WITH LLVM-exception"),      // rustc
-    ("wasm-metadata", "Apache-2.0 WITH LLVM-exception"),     // rustc
-    ("wasmparser", "Apache-2.0 WITH LLVM-exception"),        // rustc
-    ("wast", "Apache-2.0 WITH LLVM-exception"),              // rustc
-    ("wat", "Apache-2.0 WITH LLVM-exception"),               // rustc
-    ("wit-component", "Apache-2.0 WITH LLVM-exception"),     // rustc
-    ("wit-parser", "Apache-2.0 WITH LLVM-exception"),        // rustc
+    ("wasi-preview1-component-adapter-provider", "Apache-2.0 WITH LLVM-exception"), // rustc
     // tidy-alphabetical-end
 ];
 

From e93e61032962b80747ed869a21e887090ac63c90 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sat, 17 Aug 2024 17:42:20 -0400
Subject: [PATCH 416/685] Grep for enabled and clean up those hits

---
 tests/debuginfo/associated-types.rs         | 4 ----
 tests/debuginfo/borrowed-basic.rs           | 1 -
 tests/debuginfo/borrowed-unique-basic.rs    | 1 -
 tests/debuginfo/generic-struct.rs           | 4 ----
 tests/debuginfo/lexical-scope-with-macro.rs | 3 ---
 tests/debuginfo/method-on-generic-struct.rs | 4 ----
 tests/debuginfo/reference-debuginfo.rs      | 1 -
 tests/debuginfo/union-smoke.rs              | 4 ----
 8 files changed, 22 deletions(-)

diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs
index bc7a62082b763..f85aa2aca96fc 100644
--- a/tests/debuginfo/associated-types.rs
+++ b/tests/debuginfo/associated-types.rs
@@ -1,7 +1,3 @@
-// Some versions of the non-rust-enabled LLDB print the wrong generic
-// parameter type names in this test.
-//@ needs-rust-lldb
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs
index 397097cc19b0c..a684730305387 100644
--- a/tests/debuginfo/borrowed-basic.rs
+++ b/tests/debuginfo/borrowed-basic.rs
@@ -61,7 +61,6 @@
 // lldbg-check:[...] -1
 // lldbr-check:(isize) *int_ref = -1
 
-// NOTE: only rust-enabled lldb supports 32bit chars
 // lldbr-command:print *char_ref
 // lldbr-check:(char) *char_ref = 'a'
 
diff --git a/tests/debuginfo/borrowed-unique-basic.rs b/tests/debuginfo/borrowed-unique-basic.rs
index e952ec8cebb52..8059af7dcbbfa 100644
--- a/tests/debuginfo/borrowed-unique-basic.rs
+++ b/tests/debuginfo/borrowed-unique-basic.rs
@@ -66,7 +66,6 @@
 // lldbg-check:[...] -1
 // lldbr-check:(isize) *int_ref = -1
 
-// NOTE: only rust-enabled lldb supports 32bit chars
 // lldbr-command:print *char_ref
 // lldbr-check:(char) *char_ref = 97
 
diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs
index df01d33a0dc59..2817f8edc150c 100644
--- a/tests/debuginfo/generic-struct.rs
+++ b/tests/debuginfo/generic-struct.rs
@@ -1,7 +1,3 @@
-// Some versions of the non-rust-enabled LLDB print the wrong generic
-// parameter type names in this test.
-//@ needs-rust-lldb
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/lexical-scope-with-macro.rs b/tests/debuginfo/lexical-scope-with-macro.rs
index 7ea3dc62e4503..ad70da9e49385 100644
--- a/tests/debuginfo/lexical-scope-with-macro.rs
+++ b/tests/debuginfo/lexical-scope-with-macro.rs
@@ -1,5 +1,4 @@
 //@ min-lldb-version: 310
-//@ ignore-lldb FIXME #48807
 
 //@ compile-flags:-g
 
@@ -88,7 +87,6 @@
 // lldbr-check:(i32) b = 34
 // lldb-command:continue
 
-// Don't test this with rust-enabled lldb for now; see issue #48807
 // lldbg-command:print a
 // lldbg-check:[...] 110
 // lldbg-command:print b
@@ -109,7 +107,6 @@
 // lldbg-check:[...] 400
 // lldbg-command:continue
 
-
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs
index c20c1cec9db70..8c2c6a38c269e 100644
--- a/tests/debuginfo/method-on-generic-struct.rs
+++ b/tests/debuginfo/method-on-generic-struct.rs
@@ -1,7 +1,3 @@
-// Some versions of the non-rust-enabled LLDB print the wrong generic
-// parameter type names in this test.
-//@ needs-rust-lldb
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs
index c21a2f01f2f9c..b33b148f22320 100644
--- a/tests/debuginfo/reference-debuginfo.rs
+++ b/tests/debuginfo/reference-debuginfo.rs
@@ -68,7 +68,6 @@
 // lldbg-check:[...] -1
 // lldbr-check:(isize) *int_ref = -1
 
-// NOTE: only rust-enabled lldb supports 32bit chars
 // lldbr-command:print *char_ref
 // lldbr-check:(char) *char_ref = 'a'
 
diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs
index f14437b1c3fbe..4a9a91164a3b8 100644
--- a/tests/debuginfo/union-smoke.rs
+++ b/tests/debuginfo/union-smoke.rs
@@ -1,7 +1,5 @@
 //@ min-lldb-version: 310
 
-//@ ignore-gdb-version: 7.11.90 - 7.12.9
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
@@ -19,8 +17,6 @@
 // lldbg-check:[...] { a = { 0 = '\x02' 1 = '\x02' } b = 514 }
 // lldbr-check:(union_smoke::U) u = { a = { 0 = '\x02' 1 = '\x02' } b = 514 }
 
-// Don't test this with rust-enabled lldb for now; see
-// https://github.com/rust-lang-nursery/lldb/issues/18
 // lldbg-command:print union_smoke::SU
 // lldbg-check:[...] { a = { 0 = '\x01' 1 = '\x01' } b = 257 }
 

From 156088f8a86679ec5a342d5e7ebf17f468c805c1 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sat, 17 Aug 2024 18:00:49 -0400
Subject: [PATCH 417/685] Delete redundant gdb-version requirements and related
 comments

---
 tests/debuginfo/basic-types-globals.rs                    | 4 ----
 tests/debuginfo/borrowed-enum.rs                          | 2 --
 tests/debuginfo/coroutine-objects.rs                      | 2 --
 tests/debuginfo/embedded-visualizer.rs                    | 1 -
 tests/debuginfo/empty-string.rs                           | 2 --
 tests/debuginfo/gdb-pretty-struct-and-enums.rs            | 1 -
 tests/debuginfo/generic-enum-with-different-disr-sizes.rs | 3 ---
 tests/debuginfo/generic-struct-style-enum.rs              | 3 ---
 tests/debuginfo/generic-tuple-style-enum.rs               | 4 ----
 tests/debuginfo/issue-57822.rs                            | 2 --
 tests/debuginfo/numeric-types.rs                          | 1 -
 tests/debuginfo/packed-struct.rs                          | 1 -
 tests/debuginfo/pretty-huge-vec.rs                        | 1 -
 tests/debuginfo/pretty-std-collections.rs                 | 4 ----
 tests/debuginfo/pretty-std.rs                             | 1 -
 tests/debuginfo/pretty-uninitialized-vec.rs               | 1 -
 tests/debuginfo/rc_arc.rs                                 | 1 -
 tests/debuginfo/recursive-struct.rs                       | 3 ---
 tests/debuginfo/struct-in-enum.rs                         | 1 -
 tests/debuginfo/struct-style-enum.rs                      | 2 --
 tests/debuginfo/tuple-style-enum.rs                       | 2 --
 tests/debuginfo/unique-enum.rs                            | 2 --
 tests/debuginfo/unit-type.rs                              | 3 ---
 23 files changed, 47 deletions(-)

diff --git a/tests/debuginfo/basic-types-globals.rs b/tests/debuginfo/basic-types-globals.rs
index 515d70e193530..3440dd68ab4f9 100644
--- a/tests/debuginfo/basic-types-globals.rs
+++ b/tests/debuginfo/basic-types-globals.rs
@@ -1,8 +1,4 @@
-// Caveat - gdb doesn't know about UTF-32 character encoding and will print a
-// rust char as only its numerical value.
-
 //@ min-lldb-version: 310
-//@ min-gdb-version: 8.0
 
 //@ revisions: lto no-lto
 
diff --git a/tests/debuginfo/borrowed-enum.rs b/tests/debuginfo/borrowed-enum.rs
index 444adac8b0aa3..2f69742f0d4fd 100644
--- a/tests/debuginfo/borrowed-enum.rs
+++ b/tests/debuginfo/borrowed-enum.rs
@@ -1,5 +1,3 @@
-// Require a gdb or lldb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
 //@ min-lldb-version: 1800
 
 //@ compile-flags:-g
diff --git a/tests/debuginfo/coroutine-objects.rs b/tests/debuginfo/coroutine-objects.rs
index 746b7e40eda53..242c76c2989e3 100644
--- a/tests/debuginfo/coroutine-objects.rs
+++ b/tests/debuginfo/coroutine-objects.rs
@@ -1,5 +1,3 @@
-// Require a gdb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
 //@ min-lldb-version: 1800
 
 // LLDB (18.1+) now supports DW_TAG_variant_part, but there is some bug in either compiler or LLDB
diff --git a/tests/debuginfo/embedded-visualizer.rs b/tests/debuginfo/embedded-visualizer.rs
index 959dbba7fd73c..cbd8691394d54 100644
--- a/tests/debuginfo/embedded-visualizer.rs
+++ b/tests/debuginfo/embedded-visualizer.rs
@@ -1,5 +1,4 @@
 //@ compile-flags:-g
-//@ min-gdb-version: 8.1
 //@ ignore-lldb
 //@ ignore-windows-gnu: #128981
 
diff --git a/tests/debuginfo/empty-string.rs b/tests/debuginfo/empty-string.rs
index eac3448bfd510..41f7fa941b77a 100644
--- a/tests/debuginfo/empty-string.rs
+++ b/tests/debuginfo/empty-string.rs
@@ -1,8 +1,6 @@
 //@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
-//@ min-gdb-version: 8.1
-//@ ignore-gdb-version: 7.11.90 - 8.0.9
 //@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/gdb-pretty-struct-and-enums.rs b/tests/debuginfo/gdb-pretty-struct-and-enums.rs
index 15f0fe8e261f5..08e01333a376e 100644
--- a/tests/debuginfo/gdb-pretty-struct-and-enums.rs
+++ b/tests/debuginfo/gdb-pretty-struct-and-enums.rs
@@ -1,6 +1,5 @@
 //@ ignore-lldb
 //@ ignore-android: FIXME(#10381)
-//@ min-gdb-version: 8.1
 
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs
index 03118a11aadd6..1f973e10141f6 100644
--- a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs
+++ b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs
@@ -1,9 +1,6 @@
 //@ ignore-lldb: FIXME(#27089)
 //@ min-lldb-version: 310
 
-// Require a gdb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/generic-struct-style-enum.rs b/tests/debuginfo/generic-struct-style-enum.rs
index 7be1922d26710..68d44b858090e 100644
--- a/tests/debuginfo/generic-struct-style-enum.rs
+++ b/tests/debuginfo/generic-struct-style-enum.rs
@@ -1,8 +1,5 @@
 //@ min-lldb-version: 310
 
-// Require a gdb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
-
 //@ compile-flags:-g
 
 // gdb-command:set print union on
diff --git a/tests/debuginfo/generic-tuple-style-enum.rs b/tests/debuginfo/generic-tuple-style-enum.rs
index feb62a1f5d1f6..15b9cec071a71 100644
--- a/tests/debuginfo/generic-tuple-style-enum.rs
+++ b/tests/debuginfo/generic-tuple-style-enum.rs
@@ -1,7 +1,3 @@
-// Require a gdb or lldb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
-//@ needs-rust-lldb
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/issue-57822.rs b/tests/debuginfo/issue-57822.rs
index cadd9b542e9cb..8a8cf41ab1fbe 100644
--- a/tests/debuginfo/issue-57822.rs
+++ b/tests/debuginfo/issue-57822.rs
@@ -1,8 +1,6 @@
 // This test makes sure that the LLDB pretty printer does not throw an exception
 // for nested closures and coroutines.
 
-// Require a gdb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
 //@ min-lldb-version: 1800
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/numeric-types.rs b/tests/debuginfo/numeric-types.rs
index 6f45b69e5e34c..9d232578979f9 100644
--- a/tests/debuginfo/numeric-types.rs
+++ b/tests/debuginfo/numeric-types.rs
@@ -1,6 +1,5 @@
 //@ compile-flags:-g
 
-//@ min-gdb-version: 8.1
 //@ ignore-windows-gnu: #128981
 
 // Tests the visualizations for `NonZero<T>`, `Wrapping<T>` and
diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs
index cfff4c27d7057..5b804fa6c1de0 100644
--- a/tests/debuginfo/packed-struct.rs
+++ b/tests/debuginfo/packed-struct.rs
@@ -1,5 +1,4 @@
 //@ min-lldb-version: 310
-//@ ignore-gdb-version: 7.11.90 - 7.12.9
 
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/pretty-huge-vec.rs b/tests/debuginfo/pretty-huge-vec.rs
index b88e5db1acb8c..874670e58b17c 100644
--- a/tests/debuginfo/pretty-huge-vec.rs
+++ b/tests/debuginfo/pretty-huge-vec.rs
@@ -1,7 +1,6 @@
 //@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
-//@ min-gdb-version: 8.1
 //@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs
index 3ec00886e2f40..87b631946f35d 100644
--- a/tests/debuginfo/pretty-std-collections.rs
+++ b/tests/debuginfo/pretty-std-collections.rs
@@ -2,10 +2,6 @@
 //@ ignore-windows-gnu: #128981
 //@ compile-flags:-g
 
-// The pretty printers being tested here require the patch from
-// https://sourceware.org/bugzilla/show_bug.cgi?id=21763
-//@ min-gdb-version: 8.1
-
 //@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/pretty-std.rs b/tests/debuginfo/pretty-std.rs
index e33d0b237be0a..d7c640a5bea3e 100644
--- a/tests/debuginfo/pretty-std.rs
+++ b/tests/debuginfo/pretty-std.rs
@@ -2,7 +2,6 @@
 //@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
-//@ min-gdb-version: 7.7
 //@ min-lldb-version: 1800
 //@ min-cdb-version: 10.0.18317.1001
 
diff --git a/tests/debuginfo/pretty-uninitialized-vec.rs b/tests/debuginfo/pretty-uninitialized-vec.rs
index ddb751161d8ce..0f72f2a5dd266 100644
--- a/tests/debuginfo/pretty-uninitialized-vec.rs
+++ b/tests/debuginfo/pretty-uninitialized-vec.rs
@@ -1,7 +1,6 @@
 //@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
-//@ min-gdb-version: 8.1
 //@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/rc_arc.rs b/tests/debuginfo/rc_arc.rs
index 688dc625ce44d..f636c60702cde 100644
--- a/tests/debuginfo/rc_arc.rs
+++ b/tests/debuginfo/rc_arc.rs
@@ -1,7 +1,6 @@
 //@ ignore-windows-gnu: #128981
 //@ compile-flags:-g
 
-//@ min-gdb-version: 8.1
 //@ min-cdb-version: 10.0.18317.1001
 
 // === GDB TESTS ==================================================================================
diff --git a/tests/debuginfo/recursive-struct.rs b/tests/debuginfo/recursive-struct.rs
index d6f5b9f2868d8..a97eb295eb437 100644
--- a/tests/debuginfo/recursive-struct.rs
+++ b/tests/debuginfo/recursive-struct.rs
@@ -1,8 +1,5 @@
 //@ ignore-lldb
 
-// Require a gdb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
-
 //@ compile-flags:-g
 
 // gdb-command:run
diff --git a/tests/debuginfo/struct-in-enum.rs b/tests/debuginfo/struct-in-enum.rs
index 8d7ad93e0a214..bc2c59fe4aa99 100644
--- a/tests/debuginfo/struct-in-enum.rs
+++ b/tests/debuginfo/struct-in-enum.rs
@@ -1,5 +1,4 @@
 //@ min-lldb-version: 1800
-//@ ignore-gdb-version: 7.11.90 - 7.12.9
 
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/struct-style-enum.rs b/tests/debuginfo/struct-style-enum.rs
index 7c5846ea350f5..c3cfb29994e74 100644
--- a/tests/debuginfo/struct-style-enum.rs
+++ b/tests/debuginfo/struct-style-enum.rs
@@ -1,5 +1,3 @@
-// Require a gdb or lldb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
 //@ min-lldb-version: 1800
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/tuple-style-enum.rs b/tests/debuginfo/tuple-style-enum.rs
index f231f3e059874..2a11bfe70656b 100644
--- a/tests/debuginfo/tuple-style-enum.rs
+++ b/tests/debuginfo/tuple-style-enum.rs
@@ -1,5 +1,3 @@
-// Require a gdb or lldb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
 //@ min-lldb-version: 1800
 
 //@ compile-flags:-g
diff --git a/tests/debuginfo/unique-enum.rs b/tests/debuginfo/unique-enum.rs
index fcfbe856123e7..6990f18788c7d 100644
--- a/tests/debuginfo/unique-enum.rs
+++ b/tests/debuginfo/unique-enum.rs
@@ -1,5 +1,3 @@
-// Require a gdb or lldb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
 //@ min-lldb-version: 1800
 
 //@ compile-flags:-g
diff --git a/tests/debuginfo/unit-type.rs b/tests/debuginfo/unit-type.rs
index 60b105fc53d09..42c0ff11f7113 100644
--- a/tests/debuginfo/unit-type.rs
+++ b/tests/debuginfo/unit-type.rs
@@ -1,8 +1,5 @@
 //@ compile-flags:-g
 
-// We only test Rust-aware versions of GDB:
-//@ min-gdb-version: 8.2
-
 // === GDB TESTS ===================================================================================
 
 // gdb-command: run

From e2523c18427db0a6b28b7dc8c12a5a65011bef49 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sat, 17 Aug 2024 18:09:27 -0400
Subject: [PATCH 418/685] Clean up compiletest

---
 src/tools/compiletest/src/command-list.rs |  1 -
 src/tools/compiletest/src/common.rs       |  6 ----
 src/tools/compiletest/src/header/needs.rs |  7 +----
 src/tools/compiletest/src/lib.rs          | 36 +++++++----------------
 src/tools/compiletest/src/runtest.rs      | 20 ++-----------
 src/tools/compiletest/src/tests.rs        |  8 ++---
 6 files changed, 19 insertions(+), 59 deletions(-)

diff --git a/src/tools/compiletest/src/command-list.rs b/src/tools/compiletest/src/command-list.rs
index 50c909793f5e1..e4e6ddcd22cbc 100644
--- a/src/tools/compiletest/src/command-list.rs
+++ b/src/tools/compiletest/src/command-list.rs
@@ -142,7 +142,6 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "needs-relocation-model-pic",
     "needs-run-enabled",
     "needs-rust-lld",
-    "needs-rust-lldb",
     "needs-sanitizer-address",
     "needs-sanitizer-cfi",
     "needs-sanitizer-dataflow",
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 70ebefe3f417f..5831f7c3cf283 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -296,15 +296,9 @@ pub struct Config {
     /// Version of GDB, encoded as ((major * 1000) + minor) * 1000 + patch
     pub gdb_version: Option<u32>,
 
-    /// Whether GDB has native rust support
-    pub gdb_native_rust: bool,
-
     /// Version of LLDB
     pub lldb_version: Option<u32>,
 
-    /// Whether LLDB has native rust support
-    pub lldb_native_rust: bool,
-
     /// Version of LLVM
     pub llvm_version: Option<u32>,
 
diff --git a/src/tools/compiletest/src/header/needs.rs b/src/tools/compiletest/src/header/needs.rs
index 5b2665f7d0ba7..8f935d5b74441 100644
--- a/src/tools/compiletest/src/header/needs.rs
+++ b/src/tools/compiletest/src/header/needs.rs
@@ -1,4 +1,4 @@
-use crate::common::{Config, Debugger, Sanitizer};
+use crate::common::{Config, Sanitizer};
 use crate::header::IgnoreDecision;
 
 pub(super) fn handle_needs(
@@ -114,11 +114,6 @@ pub(super) fn handle_needs(
             condition: cache.rust_lld,
             ignore_reason: "ignored on targets without Rust's LLD",
         },
-        Need {
-            name: "needs-rust-lldb",
-            condition: config.debugger != Some(Debugger::Lldb) || config.lldb_native_rust,
-            ignore_reason: "ignored on targets without Rust's LLDB",
-        },
         Need {
             name: "needs-dlltool",
             condition: cache.dlltool,
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 6acf46f919624..7018362af5410 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -194,14 +194,8 @@ pub fn parse_config(args: Vec<String>) -> Config {
     let target = opt_str2(matches.opt_str("target"));
     let android_cross_path = opt_path(matches, "android-cross-path");
     let (cdb, cdb_version) = analyze_cdb(matches.opt_str("cdb"), &target);
-    let (gdb, gdb_version, gdb_native_rust) =
-        analyze_gdb(matches.opt_str("gdb"), &target, &android_cross_path);
-    let (lldb_version, lldb_native_rust) = matches
-        .opt_str("lldb-version")
-        .as_deref()
-        .and_then(extract_lldb_version)
-        .map(|(v, b)| (Some(v), b))
-        .unwrap_or((None, false));
+    let (gdb, gdb_version) = analyze_gdb(matches.opt_str("gdb"), &target, &android_cross_path);
+    let lldb_version = matches.opt_str("lldb-version").as_deref().and_then(extract_lldb_version);
     let color = match matches.opt_str("color").as_deref() {
         Some("auto") | None => ColorConfig::AutoColor,
         Some("always") => ColorConfig::AlwaysColor,
@@ -298,9 +292,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
         cdb_version,
         gdb,
         gdb_version,
-        gdb_native_rust,
         lldb_version,
-        lldb_native_rust,
         llvm_version,
         system_llvm: matches.opt_present("system-llvm"),
         android_cross_path,
@@ -1035,19 +1027,17 @@ fn extract_cdb_version(full_version_line: &str) -> Option<[u16; 4]> {
     Some([major, minor, patch, build])
 }
 
-/// Returns (Path to GDB, GDB Version, GDB has Rust Support)
+/// Returns (Path to GDB, GDB Version)
 fn analyze_gdb(
     gdb: Option<String>,
     target: &str,
     android_cross_path: &PathBuf,
-) -> (Option<String>, Option<u32>, bool) {
+) -> (Option<String>, Option<u32>) {
     #[cfg(not(windows))]
     const GDB_FALLBACK: &str = "gdb";
     #[cfg(windows)]
     const GDB_FALLBACK: &str = "gdb.exe";
 
-    const MIN_GDB_WITH_RUST: u32 = 7011010;
-
     let fallback_gdb = || {
         if is_android_gdb_target(target) {
             let mut gdb_path = match android_cross_path.to_str() {
@@ -1076,12 +1066,10 @@ fn analyze_gdb(
 
     let version = match version_line {
         Some(line) => extract_gdb_version(&line),
-        None => return (None, None, false),
+        None => return (None, None),
     };
 
-    let gdb_native_rust = version.map_or(false, |v| v >= MIN_GDB_WITH_RUST);
-
-    (Some(gdb), version, gdb_native_rust)
+    (Some(gdb), version)
 }
 
 fn extract_gdb_version(full_version_line: &str) -> Option<u32> {
@@ -1131,8 +1119,8 @@ fn extract_gdb_version(full_version_line: &str) -> Option<u32> {
     Some(((major * 1000) + minor) * 1000 + patch)
 }
 
-/// Returns (LLDB version, LLDB is rust-enabled)
-fn extract_lldb_version(full_version_line: &str) -> Option<(u32, bool)> {
+/// Returns LLDB version
+fn extract_lldb_version(full_version_line: &str) -> Option<u32> {
     // Extract the major LLDB version from the given version string.
     // LLDB version strings are different for Apple and non-Apple platforms.
     // The Apple variant looks like this:
@@ -1149,9 +1137,7 @@ fn extract_lldb_version(full_version_line: &str) -> Option<(u32, bool)> {
     // There doesn't seem to be a way to correlate the Apple version
     // with the upstream version, and since the tests were originally
     // written against Apple versions, we make a fake Apple version by
-    // multiplying the first number by 100.  This is a hack, but
-    // normally fine because the only non-Apple version we test is
-    // rust-enabled.
+    // multiplying the first number by 100. This is a hack.
 
     let full_version_line = full_version_line.trim();
 
@@ -1160,12 +1146,12 @@ fn extract_lldb_version(full_version_line: &str) -> Option<(u32, bool)> {
     {
         if let Some(idx) = apple_ver.find(not_a_digit) {
             let version: u32 = apple_ver[..idx].parse().unwrap();
-            return Some((version, full_version_line.contains("rust-enabled")));
+            return Some(version);
         }
     } else if let Some(lldb_ver) = full_version_line.strip_prefix("lldb version ") {
         if let Some(idx) = lldb_ver.find(not_a_digit) {
             let version: u32 = lldb_ver[..idx].parse().ok()?;
-            return Some((version * 100, full_version_line.contains("rust-enabled")));
+            return Some(version * 100);
         }
     }
     None
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 394f24e6f359b..eca21e559896a 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -856,12 +856,10 @@ impl<'test> TestCx<'test> {
     }
 
     fn run_debuginfo_gdb_test_no_opt(&self) {
-        let prefixes = &["gdb"];
-
         let dbg_cmds = DebuggerCommands::parse_from(
             &self.testpaths.file,
             self.config,
-            prefixes,
+            &["gdb"],
             self.revision,
         )
         .unwrap_or_else(|e| self.fatal(&e));
@@ -1043,9 +1041,7 @@ impl<'test> TestCx<'test> {
                 .push_str(&format!("file {}\n", exe_file.to_str().unwrap().replace(r"\", r"\\")));
 
             // Force GDB to print values in the Rust format.
-            if self.config.gdb_native_rust {
-                script_str.push_str("set language rust\n");
-            }
+            script_str.push_str("set language rust\n");
 
             // Add line breakpoints
             for line in &dbg_cmds.breakpoint_lines {
@@ -1130,21 +1126,11 @@ impl<'test> TestCx<'test> {
             }
         }
 
-        let prefixes = if self.config.lldb_native_rust {
-            static PREFIXES: &[&str] = &["lldb", "lldbr"];
-            println!("NOTE: compiletest thinks it is using LLDB with native rust support");
-            PREFIXES
-        } else {
-            static PREFIXES: &[&str] = &["lldb", "lldbg"];
-            println!("NOTE: compiletest thinks it is using LLDB without native rust support");
-            PREFIXES
-        };
-
         // Parse debugger commands etc from test files
         let dbg_cmds = DebuggerCommands::parse_from(
             &self.testpaths.file,
             self.config,
-            prefixes,
+            &["lldb"],
             self.revision,
         )
         .unwrap_or_else(|e| self.fatal(&e));
diff --git a/src/tools/compiletest/src/tests.rs b/src/tools/compiletest/src/tests.rs
index 4292f234adc78..7c2e7b0f023cc 100644
--- a/src/tools/compiletest/src/tests.rs
+++ b/src/tools/compiletest/src/tests.rs
@@ -48,12 +48,12 @@ fn test_extract_gdb_version() {
 #[test]
 fn test_extract_lldb_version() {
     // Apple variants
-    assert_eq!(extract_lldb_version("LLDB-179.5"), Some((179, false)));
-    assert_eq!(extract_lldb_version("lldb-300.2.51"), Some((300, false)));
+    assert_eq!(extract_lldb_version("LLDB-179.5"), Some(179));
+    assert_eq!(extract_lldb_version("lldb-300.2.51"), Some(300));
 
     // Upstream versions
-    assert_eq!(extract_lldb_version("lldb version 6.0.1"), Some((600, false)));
-    assert_eq!(extract_lldb_version("lldb version 9.0.0"), Some((900, false)));
+    assert_eq!(extract_lldb_version("lldb version 6.0.1"), Some(600));
+    assert_eq!(extract_lldb_version("lldb version 9.0.0"), Some(900));
 }
 
 #[test]

From c5fdc90a733187564c3a5dc2567cdb232738b7f7 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sat, 17 Aug 2024 18:55:13 -0400
Subject: [PATCH 419/685] Delete min-lldb-version: 310

---
 tests/debuginfo/basic-types-globals-metadata.rs             | 3 +--
 tests/debuginfo/basic-types-globals.rs                      | 2 --
 tests/debuginfo/basic-types-metadata.rs                     | 3 +--
 tests/debuginfo/basic-types-mut-globals.rs                  | 2 --
 tests/debuginfo/basic-types.rs                              | 2 --
 tests/debuginfo/borrowed-basic.rs                           | 1 -
 tests/debuginfo/borrowed-c-style-enum.rs                    | 1 -
 tests/debuginfo/borrowed-struct.rs                          | 1 -
 tests/debuginfo/borrowed-tuple.rs                           | 2 --
 tests/debuginfo/borrowed-unique-basic.rs                    | 2 --
 tests/debuginfo/box.rs                                      | 2 --
 tests/debuginfo/boxed-struct.rs                             | 2 --
 tests/debuginfo/by-value-self-argument-in-trait-impl.rs     | 2 --
 tests/debuginfo/c-style-enum-in-composite.rs                | 2 --
 tests/debuginfo/c-style-enum.rs                             | 1 -
 tests/debuginfo/closure-in-generic-function.rs              | 2 --
 tests/debuginfo/constant-debug-locs.rs                      | 2 --
 tests/debuginfo/constant-in-match-pattern.rs                | 2 --
 tests/debuginfo/coroutine-locals.rs                         | 2 --
 tests/debuginfo/cross-crate-spans.rs                        | 2 --
 tests/debuginfo/cross-crate-type-uniquing.rs                | 2 --
 tests/debuginfo/destructured-fn-argument.rs                 | 2 --
 tests/debuginfo/destructured-for-loop-variable.rs           | 2 --
 tests/debuginfo/destructured-local.rs                       | 2 --
 tests/debuginfo/drop-locations.rs                           | 1 -
 tests/debuginfo/empty-string.rs                             | 1 -
 tests/debuginfo/enum-thinlto.rs                             | 2 --
 tests/debuginfo/evec-in-struct.rs                           | 2 --
 tests/debuginfo/extern-c-fn.rs                              | 2 --
 tests/debuginfo/function-arguments.rs                       | 2 --
 tests/debuginfo/generic-enum-with-different-disr-sizes.rs   | 1 -
 tests/debuginfo/generic-function.rs                         | 2 --
 tests/debuginfo/generic-functions-nested.rs                 | 2 --
 tests/debuginfo/generic-static-method-on-struct-and-enum.rs | 2 --
 tests/debuginfo/generic-struct-style-enum.rs                | 2 --
 tests/debuginfo/include_string.rs                           | 1 -
 tests/debuginfo/issue-13213.rs                              | 1 -
 tests/debuginfo/issue-14411.rs                              | 2 --
 tests/debuginfo/issue-22656.rs                              | 1 -
 tests/debuginfo/issue-7712.rs                               | 1 -
 tests/debuginfo/lexical-scope-in-for-loop.rs                | 2 --
 tests/debuginfo/lexical-scope-in-if.rs                      | 2 --
 tests/debuginfo/lexical-scope-in-match.rs                   | 2 --
 tests/debuginfo/lexical-scope-in-parameterless-closure.rs   | 2 --
 tests/debuginfo/lexical-scope-in-stack-closure.rs           | 2 --
 tests/debuginfo/lexical-scope-in-unconditional-loop.rs      | 2 --
 tests/debuginfo/lexical-scope-in-unique-closure.rs          | 2 --
 tests/debuginfo/lexical-scope-in-while.rs                   | 2 --
 tests/debuginfo/lexical-scope-with-macro.rs                 | 2 --
 tests/debuginfo/lexical-scopes-in-block-expression.rs       | 2 --
 tests/debuginfo/method-on-struct.rs                         | 2 --
 tests/debuginfo/method-on-trait.rs                          | 2 --
 tests/debuginfo/method-on-tuple-struct.rs                   | 2 --
 tests/debuginfo/multi-byte-chars.rs                         | 2 --
 tests/debuginfo/multi-cgu.rs                                | 3 ---
 tests/debuginfo/multiple-functions-equal-var-names.rs       | 2 --
 tests/debuginfo/multiple-functions.rs                       | 2 --
 tests/debuginfo/name-shadowing-and-scope-nesting.rs         | 2 --
 tests/debuginfo/packed-struct-with-destructor.rs            | 2 --
 tests/debuginfo/packed-struct.rs                            | 2 --
 tests/debuginfo/pretty-huge-vec.rs                          | 1 -
 tests/debuginfo/pretty-std-collections.rs                   | 2 --
 tests/debuginfo/pretty-uninitialized-vec.rs                 | 1 -
 tests/debuginfo/reference-debuginfo.rs                      | 1 -
 tests/debuginfo/self-in-default-method.rs                   | 2 --
 tests/debuginfo/self-in-generic-default-method.rs           | 2 --
 tests/debuginfo/shadowed-argument.rs                        | 2 --
 tests/debuginfo/shadowed-variable.rs                        | 1 -
 tests/debuginfo/should-fail.rs                              | 2 --
 tests/debuginfo/simple-lexical-scope.rs                     | 2 --
 tests/debuginfo/simple-struct.rs                            | 2 --
 tests/debuginfo/simple-tuple.rs                             | 2 --
 tests/debuginfo/static-method-on-struct-and-enum.rs         | 2 --
 tests/debuginfo/struct-in-struct.rs                         | 2 --
 tests/debuginfo/struct-namespace.rs                         | 1 -
 tests/debuginfo/struct-with-destructor.rs                   | 2 --
 tests/debuginfo/trait-pointers.rs                           | 2 --
 tests/debuginfo/tuple-in-struct.rs                          | 2 --
 tests/debuginfo/tuple-in-tuple.rs                           | 2 --
 tests/debuginfo/tuple-struct.rs                             | 2 --
 tests/debuginfo/union-smoke.rs                              | 2 --
 tests/debuginfo/unreachable-locals.rs                       | 2 --
 tests/debuginfo/var-captured-in-nested-closure.rs           | 2 --
 tests/debuginfo/var-captured-in-sendable-closure.rs         | 2 --
 tests/debuginfo/var-captured-in-stack-closure.rs            | 2 --
 tests/debuginfo/vec-slices.rs                               | 1 -
 tests/debuginfo/vec.rs                                      | 2 --
 87 files changed, 2 insertions(+), 158 deletions(-)

diff --git a/tests/debuginfo/basic-types-globals-metadata.rs b/tests/debuginfo/basic-types-globals-metadata.rs
index 8819db86cedec..53fc550a2dc8c 100644
--- a/tests/debuginfo/basic-types-globals-metadata.rs
+++ b/tests/debuginfo/basic-types-globals-metadata.rs
@@ -1,6 +1,5 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
+
 // gdb-command:run
 // gdb-command:whatis basic_types_globals_metadata::B
 // gdb-check:type = bool
diff --git a/tests/debuginfo/basic-types-globals.rs b/tests/debuginfo/basic-types-globals.rs
index 3440dd68ab4f9..41b69939650da 100644
--- a/tests/debuginfo/basic-types-globals.rs
+++ b/tests/debuginfo/basic-types-globals.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ revisions: lto no-lto
 
 //@ compile-flags:-g
diff --git a/tests/debuginfo/basic-types-metadata.rs b/tests/debuginfo/basic-types-metadata.rs
index 9bfbdc8670115..6b7cfbdebca92 100644
--- a/tests/debuginfo/basic-types-metadata.rs
+++ b/tests/debuginfo/basic-types-metadata.rs
@@ -1,6 +1,5 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
+
 // gdb-command:run
 // gdb-command:whatis unit
 // gdb-check:type = ()
diff --git a/tests/debuginfo/basic-types-mut-globals.rs b/tests/debuginfo/basic-types-mut-globals.rs
index af0963177f54d..f6a2399d230a8 100644
--- a/tests/debuginfo/basic-types-mut-globals.rs
+++ b/tests/debuginfo/basic-types-mut-globals.rs
@@ -4,8 +4,6 @@
 // about UTF-32 character encoding and will print a rust char as only
 // its numerical value.
 
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // gdb-command:run
diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs
index e78c2746fec88..b032186cf29fa 100644
--- a/tests/debuginfo/basic-types.rs
+++ b/tests/debuginfo/basic-types.rs
@@ -4,8 +4,6 @@
 // about UTF-32 character encoding and will print a rust char as only
 // its numerical value.
 
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs
index a684730305387..9a1c5472c2e9d 100644
--- a/tests/debuginfo/borrowed-basic.rs
+++ b/tests/debuginfo/borrowed-basic.rs
@@ -1,5 +1,4 @@
 //@ compile-flags:-g
-//@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/borrowed-c-style-enum.rs b/tests/debuginfo/borrowed-c-style-enum.rs
index 95554211522a1..af932fad16a08 100644
--- a/tests/debuginfo/borrowed-c-style-enum.rs
+++ b/tests/debuginfo/borrowed-c-style-enum.rs
@@ -1,5 +1,4 @@
 //@ compile-flags:-g
-//@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/borrowed-struct.rs b/tests/debuginfo/borrowed-struct.rs
index f74a6b5796f5b..6868290963c9a 100644
--- a/tests/debuginfo/borrowed-struct.rs
+++ b/tests/debuginfo/borrowed-struct.rs
@@ -1,5 +1,4 @@
 //@ compile-flags:-g
-//@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/borrowed-tuple.rs b/tests/debuginfo/borrowed-tuple.rs
index 8f11f545ca79d..ec81e5b607baa 100644
--- a/tests/debuginfo/borrowed-tuple.rs
+++ b/tests/debuginfo/borrowed-tuple.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/borrowed-unique-basic.rs b/tests/debuginfo/borrowed-unique-basic.rs
index 8059af7dcbbfa..2c4492e8eb21e 100644
--- a/tests/debuginfo/borrowed-unique-basic.rs
+++ b/tests/debuginfo/borrowed-unique-basic.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/box.rs b/tests/debuginfo/box.rs
index bc6928ada3a53..248d00687e896 100644
--- a/tests/debuginfo/box.rs
+++ b/tests/debuginfo/box.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/boxed-struct.rs b/tests/debuginfo/boxed-struct.rs
index d31b912ab8c61..c7a8a4bd3d14b 100644
--- a/tests/debuginfo/boxed-struct.rs
+++ b/tests/debuginfo/boxed-struct.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
index 985f84881c729..e23b459a57257 100644
--- a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
+++ b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/c-style-enum-in-composite.rs b/tests/debuginfo/c-style-enum-in-composite.rs
index bd025c2ae8c13..5aaa8b8853a74 100644
--- a/tests/debuginfo/c-style-enum-in-composite.rs
+++ b/tests/debuginfo/c-style-enum-in-composite.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs
index d39576bd3878b..471449af3dd01 100644
--- a/tests/debuginfo/c-style-enum.rs
+++ b/tests/debuginfo/c-style-enum.rs
@@ -1,5 +1,4 @@
 //@ ignore-aarch64
-//@ min-lldb-version: 310
 
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/closure-in-generic-function.rs b/tests/debuginfo/closure-in-generic-function.rs
index ef0f2b0b464b4..d4608dc284a12 100644
--- a/tests/debuginfo/closure-in-generic-function.rs
+++ b/tests/debuginfo/closure-in-generic-function.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/constant-debug-locs.rs b/tests/debuginfo/constant-debug-locs.rs
index d834d9909859d..81115fc3c3847 100644
--- a/tests/debuginfo/constant-debug-locs.rs
+++ b/tests/debuginfo/constant-debug-locs.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 #![allow(dead_code, unused_variables)]
diff --git a/tests/debuginfo/constant-in-match-pattern.rs b/tests/debuginfo/constant-in-match-pattern.rs
index f34284be16402..952db216debf1 100644
--- a/tests/debuginfo/constant-in-match-pattern.rs
+++ b/tests/debuginfo/constant-in-match-pattern.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 #![allow(dead_code, unused_variables)]
diff --git a/tests/debuginfo/coroutine-locals.rs b/tests/debuginfo/coroutine-locals.rs
index c019998040b93..f3593adc9453a 100644
--- a/tests/debuginfo/coroutine-locals.rs
+++ b/tests/debuginfo/coroutine-locals.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs
index 7344901ec31c0..34e3daebb80da 100644
--- a/tests/debuginfo/cross-crate-spans.rs
+++ b/tests/debuginfo/cross-crate-spans.rs
@@ -1,8 +1,6 @@
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
 
-//@ min-lldb-version: 310
-
 //@ aux-build:cross_crate_spans.rs
 extern crate cross_crate_spans;
 
diff --git a/tests/debuginfo/cross-crate-type-uniquing.rs b/tests/debuginfo/cross-crate-type-uniquing.rs
index 88f8bac5d6f4f..28ebc34388467 100644
--- a/tests/debuginfo/cross-crate-type-uniquing.rs
+++ b/tests/debuginfo/cross-crate-type-uniquing.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ aux-build:cross_crate_debuginfo_type_uniquing.rs
 extern crate cross_crate_debuginfo_type_uniquing;
 
diff --git a/tests/debuginfo/destructured-fn-argument.rs b/tests/debuginfo/destructured-fn-argument.rs
index 783cafb43b35a..db86fe5b92330 100644
--- a/tests/debuginfo/destructured-fn-argument.rs
+++ b/tests/debuginfo/destructured-fn-argument.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs
index 7636a8d0ad526..73f03ec40b63a 100644
--- a/tests/debuginfo/destructured-for-loop-variable.rs
+++ b/tests/debuginfo/destructured-for-loop-variable.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/destructured-local.rs b/tests/debuginfo/destructured-local.rs
index 06f1355dcfe64..f4d960f78812f 100644
--- a/tests/debuginfo/destructured-local.rs
+++ b/tests/debuginfo/destructured-local.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/drop-locations.rs b/tests/debuginfo/drop-locations.rs
index 2db087dda7967..a55cf7b50a81a 100644
--- a/tests/debuginfo/drop-locations.rs
+++ b/tests/debuginfo/drop-locations.rs
@@ -1,5 +1,4 @@
 //@ ignore-android
-//@ min-lldb-version: 310
 //@ ignore-test: #128971
 
 #![allow(unused)]
diff --git a/tests/debuginfo/empty-string.rs b/tests/debuginfo/empty-string.rs
index 41f7fa941b77a..014465c27cabd 100644
--- a/tests/debuginfo/empty-string.rs
+++ b/tests/debuginfo/empty-string.rs
@@ -1,7 +1,6 @@
 //@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
-//@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/enum-thinlto.rs b/tests/debuginfo/enum-thinlto.rs
index ff39c09e2a5d0..d30ff7dde3892 100644
--- a/tests/debuginfo/enum-thinlto.rs
+++ b/tests/debuginfo/enum-thinlto.rs
@@ -1,5 +1,3 @@
-// Require a gdb that can read DW_TAG_variant_part.
-//@ min-gdb-version: 8.2
 //@ min-lldb-version: 1800
 //@ compile-flags:-g -Z thinlto
 
diff --git a/tests/debuginfo/evec-in-struct.rs b/tests/debuginfo/evec-in-struct.rs
index 9552dba17f6fc..f09471e753051 100644
--- a/tests/debuginfo/evec-in-struct.rs
+++ b/tests/debuginfo/evec-in-struct.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/extern-c-fn.rs b/tests/debuginfo/extern-c-fn.rs
index b45a073ed0503..0531d7461885c 100644
--- a/tests/debuginfo/extern-c-fn.rs
+++ b/tests/debuginfo/extern-c-fn.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/function-arguments.rs b/tests/debuginfo/function-arguments.rs
index b0afa1d077200..bbf397caacd50 100644
--- a/tests/debuginfo/function-arguments.rs
+++ b/tests/debuginfo/function-arguments.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs
index 1f973e10141f6..e723543a37b20 100644
--- a/tests/debuginfo/generic-enum-with-different-disr-sizes.rs
+++ b/tests/debuginfo/generic-enum-with-different-disr-sizes.rs
@@ -1,5 +1,4 @@
 //@ ignore-lldb: FIXME(#27089)
-//@ min-lldb-version: 310
 
 //@ compile-flags:-g
 
diff --git a/tests/debuginfo/generic-function.rs b/tests/debuginfo/generic-function.rs
index fce1a3f3ec523..6c1d0d5d7dbd0 100644
--- a/tests/debuginfo/generic-function.rs
+++ b/tests/debuginfo/generic-function.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/generic-functions-nested.rs b/tests/debuginfo/generic-functions-nested.rs
index eee0c1511822e..1aac6591738b0 100644
--- a/tests/debuginfo/generic-functions-nested.rs
+++ b/tests/debuginfo/generic-functions-nested.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/generic-static-method-on-struct-and-enum.rs b/tests/debuginfo/generic-static-method-on-struct-and-enum.rs
index 98608e3291485..79fe2144cf4bc 100644
--- a/tests/debuginfo/generic-static-method-on-struct-and-enum.rs
+++ b/tests/debuginfo/generic-static-method-on-struct-and-enum.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // gdb-command:run
diff --git a/tests/debuginfo/generic-struct-style-enum.rs b/tests/debuginfo/generic-struct-style-enum.rs
index 68d44b858090e..a5529ab8027d1 100644
--- a/tests/debuginfo/generic-struct-style-enum.rs
+++ b/tests/debuginfo/generic-struct-style-enum.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // gdb-command:set print union on
diff --git a/tests/debuginfo/include_string.rs b/tests/debuginfo/include_string.rs
index 628ac92fe3410..3ee02c554cbdd 100644
--- a/tests/debuginfo/include_string.rs
+++ b/tests/debuginfo/include_string.rs
@@ -1,4 +1,3 @@
-//@ min-lldb-version: 310
 //@ ignore-gdb-version: 15.0 - 99.0
 // ^ test temporarily disabled as it fails under gdb 15
 
diff --git a/tests/debuginfo/issue-13213.rs b/tests/debuginfo/issue-13213.rs
index 7ef9178ce9d96..b43a6f90ffc09 100644
--- a/tests/debuginfo/issue-13213.rs
+++ b/tests/debuginfo/issue-13213.rs
@@ -1,4 +1,3 @@
-//@ min-lldb-version: 310
 //@ ignore-cdb: Fails with exit code 0xc0000135 ("the application failed to initialize properly")
 
 //@ aux-build:issue-13213-aux.rs
diff --git a/tests/debuginfo/issue-14411.rs b/tests/debuginfo/issue-14411.rs
index 3258fec1e870d..7da5fb16d44ac 100644
--- a/tests/debuginfo/issue-14411.rs
+++ b/tests/debuginfo/issue-14411.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // No debugger interaction required: just make sure it compiles without
diff --git a/tests/debuginfo/issue-22656.rs b/tests/debuginfo/issue-22656.rs
index 5a5442acd95f3..199de531d0b44 100644
--- a/tests/debuginfo/issue-22656.rs
+++ b/tests/debuginfo/issue-22656.rs
@@ -2,7 +2,6 @@
 // when trying to handle a Vec<> or anything else that contains zero-sized
 // fields.
 
-//@ min-lldb-version: 310
 //@ ignore-gdb
 
 //@ compile-flags:-g
diff --git a/tests/debuginfo/issue-7712.rs b/tests/debuginfo/issue-7712.rs
index 35e6b10c4e584..11143f79161a8 100644
--- a/tests/debuginfo/issue-7712.rs
+++ b/tests/debuginfo/issue-7712.rs
@@ -1,5 +1,4 @@
 //@ compile-flags:-C debuginfo=1
-//@ min-lldb-version: 310
 
 pub trait TraitWithDefaultMethod : Sized {
     fn method(self) {
diff --git a/tests/debuginfo/lexical-scope-in-for-loop.rs b/tests/debuginfo/lexical-scope-in-for-loop.rs
index 1b1f106fecec7..d5594b6bc62fa 100644
--- a/tests/debuginfo/lexical-scope-in-for-loop.rs
+++ b/tests/debuginfo/lexical-scope-in-for-loop.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/lexical-scope-in-if.rs b/tests/debuginfo/lexical-scope-in-if.rs
index d472a50f69774..e35eb3715a9ba 100644
--- a/tests/debuginfo/lexical-scope-in-if.rs
+++ b/tests/debuginfo/lexical-scope-in-if.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/lexical-scope-in-match.rs b/tests/debuginfo/lexical-scope-in-match.rs
index d5f0fcbe89272..cffda426aefa6 100644
--- a/tests/debuginfo/lexical-scope-in-match.rs
+++ b/tests/debuginfo/lexical-scope-in-match.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/lexical-scope-in-parameterless-closure.rs b/tests/debuginfo/lexical-scope-in-parameterless-closure.rs
index fa2cd281c8077..dd6da95d388c5 100644
--- a/tests/debuginfo/lexical-scope-in-parameterless-closure.rs
+++ b/tests/debuginfo/lexical-scope-in-parameterless-closure.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-C debuginfo=1
 
 // gdb-command:run
diff --git a/tests/debuginfo/lexical-scope-in-stack-closure.rs b/tests/debuginfo/lexical-scope-in-stack-closure.rs
index 92582e10c42d4..51fb16c594fac 100644
--- a/tests/debuginfo/lexical-scope-in-stack-closure.rs
+++ b/tests/debuginfo/lexical-scope-in-stack-closure.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs
index b1af018f3eb0a..344e1893c865b 100644
--- a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs
+++ b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/lexical-scope-in-unique-closure.rs b/tests/debuginfo/lexical-scope-in-unique-closure.rs
index a08c2af05ccbd..443c4209b75bc 100644
--- a/tests/debuginfo/lexical-scope-in-unique-closure.rs
+++ b/tests/debuginfo/lexical-scope-in-unique-closure.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/lexical-scope-in-while.rs b/tests/debuginfo/lexical-scope-in-while.rs
index bd885b5b10c12..864900711a9f3 100644
--- a/tests/debuginfo/lexical-scope-in-while.rs
+++ b/tests/debuginfo/lexical-scope-in-while.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/lexical-scope-with-macro.rs b/tests/debuginfo/lexical-scope-with-macro.rs
index ad70da9e49385..6e8f87cc2d7fc 100644
--- a/tests/debuginfo/lexical-scope-with-macro.rs
+++ b/tests/debuginfo/lexical-scope-with-macro.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs
index 46af09f093439..310e9ae2a93e6 100644
--- a/tests/debuginfo/lexical-scopes-in-block-expression.rs
+++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/method-on-struct.rs b/tests/debuginfo/method-on-struct.rs
index eef1b1043b81d..d92259b7ab118 100644
--- a/tests/debuginfo/method-on-struct.rs
+++ b/tests/debuginfo/method-on-struct.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/method-on-trait.rs b/tests/debuginfo/method-on-trait.rs
index ff4f6c5e131ee..b4ff61b38b05f 100644
--- a/tests/debuginfo/method-on-trait.rs
+++ b/tests/debuginfo/method-on-trait.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/method-on-tuple-struct.rs b/tests/debuginfo/method-on-tuple-struct.rs
index cb8014cace5d7..0a4beecb06796 100644
--- a/tests/debuginfo/method-on-tuple-struct.rs
+++ b/tests/debuginfo/method-on-tuple-struct.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/multi-byte-chars.rs b/tests/debuginfo/multi-byte-chars.rs
index 8fb066c718573..2ab98d265b846 100644
--- a/tests/debuginfo/multi-byte-chars.rs
+++ b/tests/debuginfo/multi-byte-chars.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // This test checks whether debuginfo generation can handle multi-byte UTF-8
diff --git a/tests/debuginfo/multi-cgu.rs b/tests/debuginfo/multi-cgu.rs
index 32fd68958773b..69460c40e6221 100644
--- a/tests/debuginfo/multi-cgu.rs
+++ b/tests/debuginfo/multi-cgu.rs
@@ -1,9 +1,6 @@
 // This test case makes sure that we get proper break points for binaries
 // compiled with multiple codegen units. (see #39160)
 
-
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g -Ccodegen-units=2
 
 // === GDB TESTS ===============================================================
diff --git a/tests/debuginfo/multiple-functions-equal-var-names.rs b/tests/debuginfo/multiple-functions-equal-var-names.rs
index 2d9caf75290a3..8ea3d5df2b04b 100644
--- a/tests/debuginfo/multiple-functions-equal-var-names.rs
+++ b/tests/debuginfo/multiple-functions-equal-var-names.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/multiple-functions.rs b/tests/debuginfo/multiple-functions.rs
index 5c01a42705110..c1a357499f0fc 100644
--- a/tests/debuginfo/multiple-functions.rs
+++ b/tests/debuginfo/multiple-functions.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/name-shadowing-and-scope-nesting.rs b/tests/debuginfo/name-shadowing-and-scope-nesting.rs
index 8813793e59e48..1a46a2d3890d1 100644
--- a/tests/debuginfo/name-shadowing-and-scope-nesting.rs
+++ b/tests/debuginfo/name-shadowing-and-scope-nesting.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/packed-struct-with-destructor.rs b/tests/debuginfo/packed-struct-with-destructor.rs
index e3138b1185fac..a7683781b7047 100644
--- a/tests/debuginfo/packed-struct-with-destructor.rs
+++ b/tests/debuginfo/packed-struct-with-destructor.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs
index 5b804fa6c1de0..670482ef41e61 100644
--- a/tests/debuginfo/packed-struct.rs
+++ b/tests/debuginfo/packed-struct.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/pretty-huge-vec.rs b/tests/debuginfo/pretty-huge-vec.rs
index 874670e58b17c..093fbc5b12d2e 100644
--- a/tests/debuginfo/pretty-huge-vec.rs
+++ b/tests/debuginfo/pretty-huge-vec.rs
@@ -1,7 +1,6 @@
 //@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
-//@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs
index 87b631946f35d..14f64e83cffc5 100644
--- a/tests/debuginfo/pretty-std-collections.rs
+++ b/tests/debuginfo/pretty-std-collections.rs
@@ -2,8 +2,6 @@
 //@ ignore-windows-gnu: #128981
 //@ compile-flags:-g
 
-//@ min-lldb-version: 310
-
 // === GDB TESTS ===================================================================================
 
 // gdb-command: run
diff --git a/tests/debuginfo/pretty-uninitialized-vec.rs b/tests/debuginfo/pretty-uninitialized-vec.rs
index 0f72f2a5dd266..cea2f26ef58f2 100644
--- a/tests/debuginfo/pretty-uninitialized-vec.rs
+++ b/tests/debuginfo/pretty-uninitialized-vec.rs
@@ -1,7 +1,6 @@
 //@ ignore-windows-gnu: #128981
 //@ ignore-android: FIXME(#10381)
 //@ compile-flags:-g
-//@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs
index b33b148f22320..514228c699810 100644
--- a/tests/debuginfo/reference-debuginfo.rs
+++ b/tests/debuginfo/reference-debuginfo.rs
@@ -3,7 +3,6 @@
 // and leaves codegen to create a ladder of allocations so as `*a == b`.
 //
 //@ compile-flags:-g -Zmir-enable-passes=+ReferencePropagation,-ConstDebugInfo
-//@ min-lldb-version: 310
 
 // === GDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/self-in-default-method.rs b/tests/debuginfo/self-in-default-method.rs
index e5a53bb618db6..9507e2c04a251 100644
--- a/tests/debuginfo/self-in-default-method.rs
+++ b/tests/debuginfo/self-in-default-method.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/self-in-generic-default-method.rs b/tests/debuginfo/self-in-generic-default-method.rs
index 8c6abad837712..4cb68f6fed8df 100644
--- a/tests/debuginfo/self-in-generic-default-method.rs
+++ b/tests/debuginfo/self-in-generic-default-method.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/shadowed-argument.rs b/tests/debuginfo/shadowed-argument.rs
index e7bc731336e59..f85910652c8af 100644
--- a/tests/debuginfo/shadowed-argument.rs
+++ b/tests/debuginfo/shadowed-argument.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/shadowed-variable.rs b/tests/debuginfo/shadowed-variable.rs
index 3cc5fe14cb2b9..87c85a9e1e263 100644
--- a/tests/debuginfo/shadowed-variable.rs
+++ b/tests/debuginfo/shadowed-variable.rs
@@ -1,4 +1,3 @@
-//@ min-lldb-version: 310
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/should-fail.rs b/tests/debuginfo/should-fail.rs
index 0f153394a4422..bc9b83fc2427d 100644
--- a/tests/debuginfo/should-fail.rs
+++ b/tests/debuginfo/should-fail.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 // == Test [gdb|lldb]-[command|check] are parsed correctly ===
 //@ should-fail
 //@ needs-run-enabled
diff --git a/tests/debuginfo/simple-lexical-scope.rs b/tests/debuginfo/simple-lexical-scope.rs
index 4156e68f8b13c..148ad589deca5 100644
--- a/tests/debuginfo/simple-lexical-scope.rs
+++ b/tests/debuginfo/simple-lexical-scope.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs
index 77bfb8a0676b1..65bfb84cdcd46 100644
--- a/tests/debuginfo/simple-struct.rs
+++ b/tests/debuginfo/simple-struct.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags: -g -Zmir-enable-passes=-CheckAlignment
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs
index eb1d5ab3c3d3a..6dadf9236556a 100644
--- a/tests/debuginfo/simple-tuple.rs
+++ b/tests/debuginfo/simple-tuple.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/static-method-on-struct-and-enum.rs b/tests/debuginfo/static-method-on-struct-and-enum.rs
index b4ec454357267..defced1441caf 100644
--- a/tests/debuginfo/static-method-on-struct-and-enum.rs
+++ b/tests/debuginfo/static-method-on-struct-and-enum.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/struct-in-struct.rs b/tests/debuginfo/struct-in-struct.rs
index 75141e28e4988..2e32633fa87e6 100644
--- a/tests/debuginfo/struct-in-struct.rs
+++ b/tests/debuginfo/struct-in-struct.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/struct-namespace.rs b/tests/debuginfo/struct-namespace.rs
index 3cae51e83ddbd..83f2962140aa1 100644
--- a/tests/debuginfo/struct-namespace.rs
+++ b/tests/debuginfo/struct-namespace.rs
@@ -1,6 +1,5 @@
 //@ ignore-gdb
 //@ compile-flags:-g
-//@ min-lldb-version: 310
 
 // Check that structs get placed in the correct namespace
 
diff --git a/tests/debuginfo/struct-with-destructor.rs b/tests/debuginfo/struct-with-destructor.rs
index 17dc6edd36574..05a4b7572831e 100644
--- a/tests/debuginfo/struct-with-destructor.rs
+++ b/tests/debuginfo/struct-with-destructor.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/trait-pointers.rs b/tests/debuginfo/trait-pointers.rs
index 2b4dde4d3a0c7..71da71b897ad9 100644
--- a/tests/debuginfo/trait-pointers.rs
+++ b/tests/debuginfo/trait-pointers.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 // gdb-command:run
 // lldb-command:run
diff --git a/tests/debuginfo/tuple-in-struct.rs b/tests/debuginfo/tuple-in-struct.rs
index afda586c1544c..a74d6203f5f5d 100644
--- a/tests/debuginfo/tuple-in-struct.rs
+++ b/tests/debuginfo/tuple-in-struct.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // gdb-command:run
diff --git a/tests/debuginfo/tuple-in-tuple.rs b/tests/debuginfo/tuple-in-tuple.rs
index 24147e6ce0e45..0d7ffc6347016 100644
--- a/tests/debuginfo/tuple-in-tuple.rs
+++ b/tests/debuginfo/tuple-in-tuple.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/tuple-struct.rs b/tests/debuginfo/tuple-struct.rs
index 8c546be07c37d..abfbfac22eb88 100644
--- a/tests/debuginfo/tuple-struct.rs
+++ b/tests/debuginfo/tuple-struct.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs
index 4a9a91164a3b8..41bd81c9e8ae6 100644
--- a/tests/debuginfo/union-smoke.rs
+++ b/tests/debuginfo/union-smoke.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/unreachable-locals.rs b/tests/debuginfo/unreachable-locals.rs
index 72effc1039133..d4416387e0b9e 100644
--- a/tests/debuginfo/unreachable-locals.rs
+++ b/tests/debuginfo/unreachable-locals.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/var-captured-in-nested-closure.rs b/tests/debuginfo/var-captured-in-nested-closure.rs
index 5183245ad5dc1..bed2a57e1f9e9 100644
--- a/tests/debuginfo/var-captured-in-nested-closure.rs
+++ b/tests/debuginfo/var-captured-in-nested-closure.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/var-captured-in-sendable-closure.rs b/tests/debuginfo/var-captured-in-sendable-closure.rs
index 094639ebf20c2..59909b758266d 100644
--- a/tests/debuginfo/var-captured-in-sendable-closure.rs
+++ b/tests/debuginfo/var-captured-in-sendable-closure.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/var-captured-in-stack-closure.rs b/tests/debuginfo/var-captured-in-stack-closure.rs
index ca10cdcb518e5..5ac804464333c 100644
--- a/tests/debuginfo/var-captured-in-stack-closure.rs
+++ b/tests/debuginfo/var-captured-in-stack-closure.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================
diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs
index 18ff6c743228e..a846316852800 100644
--- a/tests/debuginfo/vec-slices.rs
+++ b/tests/debuginfo/vec-slices.rs
@@ -1,4 +1,3 @@
-//@ min-lldb-version: 310
 //@ ignore-gdb-version: 15.0 - 99.0
 // ^ test temporarily disabled as it fails under gdb 15
 
diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs
index 7b9054639a8d9..24b7ae9c39427 100644
--- a/tests/debuginfo/vec.rs
+++ b/tests/debuginfo/vec.rs
@@ -1,5 +1,3 @@
-//@ min-lldb-version: 310
-
 //@ compile-flags:-g
 
 // === GDB TESTS ===================================================================================

From 41d06f41158b9efaaaeed141bd9a8315527410ec Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 18 Aug 2024 16:59:58 -0400
Subject: [PATCH 420/685] Delete lldbr annotations

---
 tests/debuginfo/associated-types.rs           |  9 ----
 tests/debuginfo/basic-types.rs                | 17 -------
 tests/debuginfo/borrowed-basic.rs             | 16 ------
 tests/debuginfo/borrowed-c-style-enum.rs      |  3 --
 tests/debuginfo/borrowed-enum.rs              |  3 --
 tests/debuginfo/borrowed-struct.rs            |  7 ---
 tests/debuginfo/borrowed-tuple.rs             |  3 --
 tests/debuginfo/borrowed-unique-basic.rs      | 16 ------
 tests/debuginfo/box.rs                        |  2 -
 tests/debuginfo/boxed-struct.rs               |  2 -
 .../by-value-self-argument-in-trait-impl.rs   |  3 --
 tests/debuginfo/c-style-enum-in-composite.rs  |  7 ---
 tests/debuginfo/c-style-enum.rs               |  7 ---
 .../debuginfo/closure-in-generic-function.rs  |  4 --
 tests/debuginfo/cross-crate-spans.rs          |  6 ---
 tests/debuginfo/destructured-fn-argument.rs   | 49 -------------------
 .../destructured-for-loop-variable.rs         | 24 ---------
 tests/debuginfo/destructured-local.rs         | 43 ----------------
 tests/debuginfo/enum-thinlto.rs               |  1 -
 tests/debuginfo/evec-in-struct.rs             |  5 --
 tests/debuginfo/extern-c-fn.rs                |  4 --
 tests/debuginfo/function-arguments.rs         |  4 --
 tests/debuginfo/generic-function.rs           |  6 ---
 tests/debuginfo/generic-functions-nested.rs   |  8 ---
 .../generic-method-on-generic-struct.rs       | 19 -------
 tests/debuginfo/generic-struct.rs             |  4 --
 tests/debuginfo/generic-tuple-style-enum.rs   |  4 --
 tests/debuginfo/include_string.rs             |  3 --
 tests/debuginfo/issue-22656.rs                |  3 --
 tests/debuginfo/lexical-scope-in-for-loop.rs  |  7 ---
 tests/debuginfo/lexical-scope-in-if.rs        | 16 ------
 tests/debuginfo/lexical-scope-in-match.rs     | 18 -------
 .../lexical-scope-in-stack-closure.rs         |  6 ---
 .../lexical-scope-in-unconditional-loop.rs    | 13 -----
 .../lexical-scope-in-unique-closure.rs        |  6 ---
 tests/debuginfo/lexical-scope-in-while.rs     | 13 -----
 tests/debuginfo/lexical-scope-with-macro.rs   |  8 ---
 .../lexical-scopes-in-block-expression.rs     | 48 ------------------
 tests/debuginfo/method-on-generic-struct.rs   | 15 ------
 tests/debuginfo/method-on-struct.rs           | 15 ------
 tests/debuginfo/method-on-trait.rs            | 15 ------
 tests/debuginfo/method-on-tuple-struct.rs     | 15 ------
 tests/debuginfo/multi-cgu.rs                  |  2 -
 .../multiple-functions-equal-var-names.rs     |  3 --
 tests/debuginfo/multiple-functions.rs         |  3 --
 .../name-shadowing-and-scope-nesting.rs       | 12 -----
 .../packed-struct-with-destructor.rs          |  8 ---
 tests/debuginfo/packed-struct.rs              |  6 ---
 tests/debuginfo/pretty-std-collections.rs     |  4 --
 tests/debuginfo/reference-debuginfo.rs        | 17 -------
 .../regression-bad-location-list-67992.rs     |  1 -
 tests/debuginfo/self-in-default-method.rs     | 15 ------
 .../self-in-generic-default-method.rs         | 15 ------
 tests/debuginfo/shadowed-argument.rs          |  6 ---
 tests/debuginfo/shadowed-variable.rs          | 10 ----
 tests/debuginfo/simple-lexical-scope.rs       |  7 ---
 tests/debuginfo/simple-struct.rs              |  6 ---
 tests/debuginfo/simple-tuple.rs               |  7 ---
 .../static-method-on-struct-and-enum.rs       |  5 --
 tests/debuginfo/struct-in-struct.rs           |  8 ---
 tests/debuginfo/struct-namespace.rs           |  4 --
 tests/debuginfo/struct-style-enum.rs          |  4 --
 tests/debuginfo/struct-with-destructor.rs     |  4 --
 tests/debuginfo/tuple-in-tuple.rs             |  7 ---
 tests/debuginfo/tuple-struct.rs               |  6 ---
 tests/debuginfo/tuple-style-enum.rs           |  4 --
 tests/debuginfo/union-smoke.rs                |  1 -
 tests/debuginfo/unique-enum.rs                |  3 --
 .../var-captured-in-nested-closure.rs         | 12 -----
 .../var-captured-in-sendable-closure.rs       |  3 --
 .../var-captured-in-stack-closure.rs          | 10 ----
 tests/debuginfo/vec-slices.rs                 |  6 ---
 tests/debuginfo/vec.rs                        |  1 -
 73 files changed, 677 deletions(-)

diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs
index f85aa2aca96fc..54ea047d36c42 100644
--- a/tests/debuginfo/associated-types.rs
+++ b/tests/debuginfo/associated-types.rs
@@ -38,41 +38,32 @@
 
 // lldb-command:v arg
 // lldbg-check:[...] { b = -1, b1 = 0 }
-// lldbr-check:(associated_types::Struct<i32>) arg = { b = -1, b1 = 0 }
 // lldb-command:continue
 
 // lldb-command:v inferred
 // lldbg-check:[...] 1
-// lldbr-check:(i64) inferred = 1
 // lldb-command:v explicitly
 // lldbg-check:[...] 1
-// lldbr-check:(i64) explicitly = 1
 // lldb-command:continue
 
 // lldb-command:v arg
 // lldbg-check:[...] 2
-// lldbr-check:(i64) arg = 2
 // lldb-command:continue
 
 // lldb-command:v arg
 // lldbg-check:[...] (4, 5)
-// lldbr-check:((i32, i64)) arg = { = 4 = 5 }
 // lldb-command:continue
 
 // lldb-command:v a
 // lldbg-check:[...] 6
-// lldbr-check:(i32) a = 6
 // lldb-command:v b
 // lldbg-check:[...] 7
-// lldbr-check:(i64) b = 7
 // lldb-command:continue
 
 // lldb-command:v a
 // lldbg-check:[...] 8
-// lldbr-check:(i64) a = 8
 // lldb-command:v b
 // lldbg-check:[...] 9
-// lldbr-check:(i32) b = 9
 // lldb-command:continue
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs
index b032186cf29fa..656c49ee001b6 100644
--- a/tests/debuginfo/basic-types.rs
+++ b/tests/debuginfo/basic-types.rs
@@ -47,48 +47,31 @@
 // lldb-command:run
 // lldb-command:v b
 // lldbg-check:[...] false
-// lldbr-check:(bool) b = false
 // lldb-command:v i
 // lldbg-check:[...] -1
-// lldbr-check:(isize) i = -1
-
-// NOTE: only rust-enabled lldb supports 32bit chars
-// lldbr-command:print c
-// lldbr-check:(char) c = 'a'
 
 // lldb-command:v i8
 // lldbg-check:[...] 'D'
-// lldbr-check:(i8) i8 = 68
 // lldb-command:v i16
 // lldbg-check:[...] -16
-// lldbr-check:(i16) i16 = -16
 // lldb-command:v i32
 // lldbg-check:[...] -32
-// lldbr-check:(i32) i32 = -32
 // lldb-command:v i64
 // lldbg-check:[...] -64
-// lldbr-check:(i64) i64 = -64
 // lldb-command:v u
 // lldbg-check:[...] 1
-// lldbr-check:(usize) u = 1
 // lldb-command:v u8
 // lldbg-check:[...] 'd'
-// lldbr-check:(u8) u8 = 100
 // lldb-command:v u16
 // lldbg-check:[...] 16
-// lldbr-check:(u16) u16 = 16
 // lldb-command:v u32
 // lldbg-check:[...] 32
-// lldbr-check:(u32) u32 = 32
 // lldb-command:v u64
 // lldbg-check:[...] 64
-// lldbr-check:(u64) u64 = 64
 // lldb-command:v f32
 // lldbg-check:[...] 2.5
-// lldbr-check:(f32) f32 = 2.5
 // lldb-command:v f64
 // lldbg-check:[...] 3.5
-// lldbr-check:(f64) f64 = 3.5
 
 // === CDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs
index 9a1c5472c2e9d..e51f5912fc213 100644
--- a/tests/debuginfo/borrowed-basic.rs
+++ b/tests/debuginfo/borrowed-basic.rs
@@ -54,62 +54,46 @@
 // lldb-command:run
 // lldb-command:v *bool_ref
 // lldbg-check:[...] true
-// lldbr-check:(bool) *bool_ref = true
 
 // lldb-command:v *int_ref
 // lldbg-check:[...] -1
-// lldbr-check:(isize) *int_ref = -1
 
-// lldbr-command:print *char_ref
-// lldbr-check:(char) *char_ref = 'a'
 
 // lldb-command:v *i8_ref
 // lldbg-check:[...] 'D'
-// lldbr-check:(i8) *i8_ref = 68
 
 // lldb-command:v *i16_ref
 // lldbg-check:[...] -16
-// lldbr-check:(i16) *i16_ref = -16
 
 // lldb-command:v *i32_ref
 // lldbg-check:[...] -32
-// lldbr-check:(i32) *i32_ref = -32
 
 // lldb-command:v *i64_ref
 // lldbg-check:[...] -64
-// lldbr-check:(i64) *i64_ref = -64
 
 // lldb-command:v *uint_ref
 // lldbg-check:[...] 1
-// lldbr-check:(usize) *uint_ref = 1
 
 // lldb-command:v *u8_ref
 // lldbg-check:[...] 'd'
-// lldbr-check:(u8) *u8_ref = 100
 
 // lldb-command:v *u16_ref
 // lldbg-check:[...] 16
-// lldbr-check:(u16) *u16_ref = 16
 
 // lldb-command:v *u32_ref
 // lldbg-check:[...] 32
-// lldbr-check:(u32) *u32_ref = 32
 
 // lldb-command:v *u64_ref
 // lldbg-check:[...] 64
-// lldbr-check:(u64) *u64_ref = 64
 
 // lldb-command:v *f16_ref
 // lldbg-check:[...] 1.5
-// lldbr-check:(f16) *f16_ref = 1.5
 
 // lldb-command:v *f32_ref
 // lldbg-check:[...] 2.5
-// lldbr-check:(f32) *f32_ref = 2.5
 
 // lldb-command:v *f64_ref
 // lldbg-check:[...] 3.5
-// lldbr-check:(f64) *f64_ref = 3.5
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/borrowed-c-style-enum.rs b/tests/debuginfo/borrowed-c-style-enum.rs
index af932fad16a08..6d771cf679277 100644
--- a/tests/debuginfo/borrowed-c-style-enum.rs
+++ b/tests/debuginfo/borrowed-c-style-enum.rs
@@ -20,15 +20,12 @@
 
 // lldb-command:v *the_a_ref
 // lldbg-check:[...] TheA
-// lldbr-check:(borrowed_c_style_enum::ABC) *the_a_ref = borrowed_c_style_enum::ABC::TheA
 
 // lldb-command:v *the_b_ref
 // lldbg-check:[...] TheB
-// lldbr-check:(borrowed_c_style_enum::ABC) *the_b_ref = borrowed_c_style_enum::ABC::TheB
 
 // lldb-command:v *the_c_ref
 // lldbg-check:[...] TheC
-// lldbr-check:(borrowed_c_style_enum::ABC) *the_c_ref = borrowed_c_style_enum::ABC::TheC
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/borrowed-enum.rs b/tests/debuginfo/borrowed-enum.rs
index 2f69742f0d4fd..8782e28e4ec10 100644
--- a/tests/debuginfo/borrowed-enum.rs
+++ b/tests/debuginfo/borrowed-enum.rs
@@ -22,13 +22,10 @@
 
 // lldb-command:v *the_a_ref
 // lldbg-check:(borrowed_enum::ABC) *the_a_ref = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 }
-// lldbr-check:(borrowed_enum::ABC::TheA) *the_a_ref = TheA { TheA: 0, TheB: 8970181431921507452 }
 // lldb-command:v *the_b_ref
 // lldbg-check:(borrowed_enum::ABC) *the_b_ref = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 }
-// lldbr-check:(borrowed_enum::ABC::TheB) *the_b_ref = { = 0 = 286331153 = 286331153 }
 // lldb-command:v *univariant_ref
 // lldbg-check:(borrowed_enum::Univariant) *univariant_ref = { value = { 0 = 4820353753753434 } }
-// lldbr-check:(borrowed_enum::Univariant) *univariant_ref = { TheOnlyCase = { = 4820353753753434 } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/borrowed-struct.rs b/tests/debuginfo/borrowed-struct.rs
index 6868290963c9a..e9b751465629c 100644
--- a/tests/debuginfo/borrowed-struct.rs
+++ b/tests/debuginfo/borrowed-struct.rs
@@ -32,31 +32,24 @@
 
 // lldb-command:v *stack_val_ref
 // lldbg-check:[...] { x = 10 y = 23.5 }
-// lldbr-check:(borrowed_struct::SomeStruct) *stack_val_ref = (x = 10, y = 23.5)
 
 // lldb-command:v *stack_val_interior_ref_1
 // lldbg-check:[...] 10
-// lldbr-check:(isize) *stack_val_interior_ref_1 = 10
 
 // lldb-command:v *stack_val_interior_ref_2
 // lldbg-check:[...] 23.5
-// lldbr-check:(f64) *stack_val_interior_ref_2 = 23.5
 
 // lldb-command:v *ref_to_unnamed
 // lldbg-check:[...] { x = 11 y = 24.5 }
-// lldbr-check:(borrowed_struct::SomeStruct) *ref_to_unnamed = (x = 11, y = 24.5)
 
 // lldb-command:v *unique_val_ref
 // lldbg-check:[...] { x = 13 y = 26.5 }
-// lldbr-check:(borrowed_struct::SomeStruct) *unique_val_ref = (x = 13, y = 26.5)
 
 // lldb-command:v *unique_val_interior_ref_1
 // lldbg-check:[...] 13
-// lldbr-check:(isize) *unique_val_interior_ref_1 = 13
 
 // lldb-command:v *unique_val_interior_ref_2
 // lldbg-check:[...] 26.5
-// lldbr-check:(f64) *unique_val_interior_ref_2 = 26.5
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/borrowed-tuple.rs b/tests/debuginfo/borrowed-tuple.rs
index ec81e5b607baa..720d6048f8333 100644
--- a/tests/debuginfo/borrowed-tuple.rs
+++ b/tests/debuginfo/borrowed-tuple.rs
@@ -20,15 +20,12 @@
 
 // lldb-command:v *stack_val_ref
 // lldbg-check:[...] { 0 = -14 1 = -19 }
-// lldbr-check:((i16, f32)) *stack_val_ref = { 0 = -14 1 = -19 }
 
 // lldb-command:v *ref_to_unnamed
 // lldbg-check:[...] { 0 = -15 1 = -20 }
-// lldbr-check:((i16, f32)) *ref_to_unnamed = { 0 = -15 1 = -20 }
 
 // lldb-command:v *unique_val_ref
 // lldbg-check:[...] { 0 = -17 1 = -22 }
-// lldbr-check:((i16, f32)) *unique_val_ref = { 0 = -17 1 = -22 }
 
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/borrowed-unique-basic.rs b/tests/debuginfo/borrowed-unique-basic.rs
index 2c4492e8eb21e..8b2690e025b03 100644
--- a/tests/debuginfo/borrowed-unique-basic.rs
+++ b/tests/debuginfo/borrowed-unique-basic.rs
@@ -58,62 +58,46 @@
 
 // lldb-command:v *bool_ref
 // lldbg-check:[...] true
-// lldbr-check:(bool) *bool_ref = true
 
 // lldb-command:v *int_ref
 // lldbg-check:[...] -1
-// lldbr-check:(isize) *int_ref = -1
 
-// lldbr-command:print *char_ref
-// lldbr-check:(char) *char_ref = 97
 
 // lldb-command:v *i8_ref
 // lldbg-check:[...] 68
-// lldbr-check:(i8) *i8_ref = 68
 
 // lldb-command:v *i16_ref
 // lldbg-check:[...] -16
-// lldbr-check:(i16) *i16_ref = -16
 
 // lldb-command:v *i32_ref
 // lldbg-check:[...] -32
-// lldbr-check:(i32) *i32_ref = -32
 
 // lldb-command:v *i64_ref
 // lldbg-check:[...] -64
-// lldbr-check:(i64) *i64_ref = -64
 
 // lldb-command:v *uint_ref
 // lldbg-check:[...] 1
-// lldbr-check:(usize) *uint_ref = 1
 
 // lldb-command:v *u8_ref
 // lldbg-check:[...] 100
-// lldbr-check:(u8) *u8_ref = 100
 
 // lldb-command:v *u16_ref
 // lldbg-check:[...] 16
-// lldbr-check:(u16) *u16_ref = 16
 
 // lldb-command:v *u32_ref
 // lldbg-check:[...] 32
-// lldbr-check:(u32) *u32_ref = 32
 
 // lldb-command:v *u64_ref
 // lldbg-check:[...] 64
-// lldbr-check:(u64) *u64_ref = 64
 
 // lldb-command:v *f16_ref
 // lldbg-check:[...] 1.5
-// lldbr-check:(f16) *f16_ref = 1.5
 
 // lldb-command:v *f32_ref
 // lldbg-check:[...] 2.5
-// lldbr-check:(f32) *f32_ref = 2.5
 
 // lldb-command:v *f64_ref
 // lldbg-check:[...] 3.5
-// lldbr-check:(f64) *f64_ref = 3.5
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/box.rs b/tests/debuginfo/box.rs
index 248d00687e896..40f0cd524448b 100644
--- a/tests/debuginfo/box.rs
+++ b/tests/debuginfo/box.rs
@@ -15,10 +15,8 @@
 // lldb-command:run
 // lldb-command:v *a
 // lldbg-check:[...] 1
-// lldbr-check:(i32) *a = 1
 // lldb-command:v *b
 // lldbg-check:[...] { 0 = 2 1 = 3.5 }
-// lldbr-check:((i32, f64)) *b = { 0 = 2 1 = 3.5 }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/boxed-struct.rs b/tests/debuginfo/boxed-struct.rs
index c7a8a4bd3d14b..b4349122a3a88 100644
--- a/tests/debuginfo/boxed-struct.rs
+++ b/tests/debuginfo/boxed-struct.rs
@@ -17,11 +17,9 @@
 
 // lldb-command:v *boxed_with_padding
 // lldbg-check:[...] { x = 99 y = 999 z = 9999 w = 99999 }
-// lldbr-check:(boxed_struct::StructWithSomePadding) *boxed_with_padding = { x = 99 y = 999 z = 9999 w = 99999 }
 
 // lldb-command:v *boxed_with_dtor
 // lldbg-check:[...] { x = 77 y = 777 z = 7777 w = 77777 }
-// lldbr-check:(boxed_struct::StructWithDestructor) *boxed_with_dtor = { x = 77 y = 777 z = 7777 w = 77777 }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
index e23b459a57257..69a051b444df9 100644
--- a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
+++ b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
@@ -23,17 +23,14 @@
 
 // lldb-command:v self
 // lldbg-check:[...] 1111
-// lldbr-check:(isize) self = 1111
 // lldb-command:continue
 
 // lldb-command:v self
 // lldbg-check:[...] { x = 2222 y = 3333 }
-// lldbr-check:(by_value_self_argument_in_trait_impl::Struct) self = { x = 2222 y = 3333 }
 // lldb-command:continue
 
 // lldb-command:v self
 // lldbg-check:[...] { 0 = 4444.5 1 = 5555 2 = 6666 3 = 7777.5 }
-// lldbr-check:((f64, isize, isize, f64)) self = { 0 = 4444.5 1 = 5555 2 = 6666 3 = 7777.5 }
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/c-style-enum-in-composite.rs b/tests/debuginfo/c-style-enum-in-composite.rs
index 5aaa8b8853a74..4cd40c20cebd3 100644
--- a/tests/debuginfo/c-style-enum-in-composite.rs
+++ b/tests/debuginfo/c-style-enum-in-composite.rs
@@ -31,31 +31,24 @@
 
 // lldb-command:v tuple_interior_padding
 // lldbg-check:[...] { 0 = 0 1 = OneHundred }
-// lldbr-check:((i16, c_style_enum_in_composite::AnEnum)) tuple_interior_padding = { 0 = 0 1 = OneHundred }
 
 // lldb-command:v tuple_padding_at_end
 // lldbg-check:[...] { 0 = { 0 = 1 1 = OneThousand } 1 = 2 }
-// lldbr-check:(((u64, c_style_enum_in_composite::AnEnum), u64)) tuple_padding_at_end = { 0 = { 0 = 1 1 = OneThousand } 1 = 2 }
 
 // lldb-command:v tuple_different_enums
 // lldbg-check:[...] { 0 = OneThousand 1 = MountainView 2 = OneMillion 3 = Vienna }
-// lldbr-check:((c_style_enum_in_composite::AnEnum, c_style_enum_in_composite::AnotherEnum, c_style_enum_in_composite::AnEnum, c_style_enum_in_composite::AnotherEnum)) tuple_different_enums = { 0 = c_style_enum_in_composite::AnEnum::OneThousand 1 = c_style_enum_in_composite::AnotherEnum::MountainView 2 = c_style_enum_in_composite::AnEnum::OneMillion 3 = c_style_enum_in_composite::AnotherEnum::Vienna }
 
 // lldb-command:v padded_struct
 // lldbg-check:[...] { a = 3 b = OneMillion c = 4 d = Toronto e = 5 }
-// lldbr-check:(c_style_enum_in_composite::PaddedStruct) padded_struct = { a = 3 b = c_style_enum_in_composite::AnEnum::OneMillion c = 4 d = Toronto e = 5 }
 
 // lldb-command:v packed_struct
 // lldbg-check:[...] { a = 6 b = OneHundred c = 7 d = Vienna e = 8 }
-// lldbr-check:(c_style_enum_in_composite::PackedStruct) packed_struct = { a = 6 b = c_style_enum_in_composite::AnEnum::OneHundred c = 7 d = Vienna e = 8 }
 
 // lldb-command:v non_padded_struct
 // lldbg-check:[...] { a = OneMillion b = MountainView c = OneThousand d = Toronto }
-// lldbr-check:(c_style_enum_in_composite::NonPaddedStruct) non_padded_struct = { a = c_style_enum_in_composite::AnEnum::OneMillion, b = c_style_enum_in_composite::AnotherEnum::MountainView, c = c_style_enum_in_composite::AnEnum::OneThousand, d = c_style_enum_in_composite::AnotherEnum::Toronto }
 
 // lldb-command:v struct_with_drop
 // lldbg-check:[...] { 0 = { a = OneHundred b = Vienna } 1 = 9 }
-// lldbr-check:((c_style_enum_in_composite::StructWithDrop, i64)) struct_with_drop = { 0 = { a = c_style_enum_in_composite::AnEnum::OneHundred b = c_style_enum_in_composite::AnotherEnum::Vienna } 1 = 9 }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs
index 471449af3dd01..a148c8d384534 100644
--- a/tests/debuginfo/c-style-enum.rs
+++ b/tests/debuginfo/c-style-enum.rs
@@ -67,31 +67,24 @@
 
 // lldb-command:v auto_one
 // lldbg-check:[...] One
-// lldbr-check:(c_style_enum::AutoDiscriminant) auto_one = c_style_enum::AutoDiscriminant::One
 
 // lldb-command:v auto_two
 // lldbg-check:[...] Two
-// lldbr-check:(c_style_enum::AutoDiscriminant) auto_two = c_style_enum::AutoDiscriminant::Two
 
 // lldb-command:v auto_three
 // lldbg-check:[...] Three
-// lldbr-check:(c_style_enum::AutoDiscriminant) auto_three = c_style_enum::AutoDiscriminant::Three
 
 // lldb-command:v manual_one_hundred
 // lldbg-check:[...] OneHundred
-// lldbr-check:(c_style_enum::ManualDiscriminant) manual_one_hundred = c_style_enum::ManualDiscriminant::OneHundred
 
 // lldb-command:v manual_one_thousand
 // lldbg-check:[...] OneThousand
-// lldbr-check:(c_style_enum::ManualDiscriminant) manual_one_thousand = c_style_enum::ManualDiscriminant::OneThousand
 
 // lldb-command:v manual_one_million
 // lldbg-check:[...] OneMillion
-// lldbr-check:(c_style_enum::ManualDiscriminant) manual_one_million = c_style_enum::ManualDiscriminant::OneMillion
 
 // lldb-command:v single_variant
 // lldbg-check:[...] TheOnlyVariant
-// lldbr-check:(c_style_enum::SingleVariant) single_variant = c_style_enum::SingleVariant::TheOnlyVariant
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
diff --git a/tests/debuginfo/closure-in-generic-function.rs b/tests/debuginfo/closure-in-generic-function.rs
index d4608dc284a12..2baaf1b79e9d0 100644
--- a/tests/debuginfo/closure-in-generic-function.rs
+++ b/tests/debuginfo/closure-in-generic-function.rs
@@ -23,18 +23,14 @@
 
 // lldb-command:v x
 // lldbg-check:[...] 0.5
-// lldbr-check:(f64) x = 0.5
 // lldb-command:v y
 // lldbg-check:[...] 10
-// lldbr-check:(i32) y = 10
 // lldb-command:continue
 
 // lldb-command:v *x
 // lldbg-check:[...] 29
-// lldbr-check:(i32) *x = 29
 // lldb-command:v *y
 // lldbg-check:[...] 110
-// lldbr-check:(i32) *y = 110
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs
index 34e3daebb80da..5e8b27d4d55ec 100644
--- a/tests/debuginfo/cross-crate-spans.rs
+++ b/tests/debuginfo/cross-crate-spans.rs
@@ -37,24 +37,18 @@ extern crate cross_crate_spans;
 
 // lldb-command:v result
 // lldbg-check:[...] { 0 = 17 1 = 17 }
-// lldbr-check:((u32, u32)) result = { 0 = 17 1 = 17 }
 // lldb-command:v a_variable
 // lldbg-check:[...] 123456789
-// lldbr-check:(u32) a_variable = 123456789
 // lldb-command:v another_variable
 // lldbg-check:[...] 123456789.5
-// lldbr-check:(f64) another_variable = 123456789.5
 // lldb-command:continue
 
 // lldb-command:v result
 // lldbg-check:[...] { 0 = 1212 1 = 1212 }
-// lldbr-check:((i16, i16)) result = { 0 = 1212 1 = 1212 }
 // lldb-command:v a_variable
 // lldbg-check:[...] 123456789
-// lldbr-check:(u32) a_variable = 123456789
 // lldb-command:v another_variable
 // lldbg-check:[...] 123456789.5
-// lldbr-check:(f64) another_variable = 123456789.5
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/destructured-fn-argument.rs b/tests/debuginfo/destructured-fn-argument.rs
index db86fe5b92330..aef4e4baae1ec 100644
--- a/tests/debuginfo/destructured-fn-argument.rs
+++ b/tests/debuginfo/destructured-fn-argument.rs
@@ -155,195 +155,146 @@
 
 // lldb-command:v a
 // lldbg-check:[...] 1
-// lldbr-check:(isize) a = 1
 // lldb-command:v b
 // lldbg-check:[...] false
-// lldbr-check:(bool) b = false
 // lldb-command:continue
 
 // lldb-command:v a
 // lldbg-check:[...] 2
-// lldbr-check:(isize) a = 2
 // lldb-command:v b
 // lldbg-check:[...] 3
-// lldbr-check:(u16) b = 3
 // lldb-command:v c
 // lldbg-check:[...] 4
-// lldbr-check:(u16) c = 4
 // lldb-command:continue
 
 // lldb-command:v a
 // lldbg-check:[...] 5
-// lldbr-check:(isize) a = 5
 // lldb-command:v b
 // lldbg-check:[...] { 0 = 6 1 = 7 }
-// lldbr-check:((u32, u32)) b = { 0 = 6 1 = 7 }
 // lldb-command:continue
 
 // lldb-command:v h
 // lldbg-check:[...] 8
-// lldbr-check:(i16) h = 8
 // lldb-command:v i
 // lldbg-check:[...] { a = 9 b = 10 }
-// lldbr-check:(destructured_fn_argument::Struct) i = { a = 9 b = 10 }
 // lldb-command:v j
 // lldbg-check:[...] 11
-// lldbr-check:(i16) j = 11
 // lldb-command:continue
 
 // lldb-command:v k
 // lldbg-check:[...] 12
-// lldbr-check:(i64) k = 12
 // lldb-command:v l
 // lldbg-check:[...] 13
-// lldbr-check:(i32) l = 13
 // lldb-command:continue
 
 // lldb-command:v m
 // lldbg-check:[...] 14
-// lldbr-check:(isize) m = 14
 // lldb-command:v n
 // lldbg-check:[...] 16
-// lldbr-check:(i32) n = 16
 // lldb-command:continue
 
 // lldb-command:v o
 // lldbg-check:[...] 18
-// lldbr-check:(i32) o = 18
 // lldb-command:continue
 
 // lldb-command:v p
 // lldbg-check:[...] 19
-// lldbr-check:(i64) p = 19
 // lldb-command:v q
 // lldbg-check:[...] 20
-// lldbr-check:(i32) q = 20
 // lldb-command:v r
 // lldbg-check:[...] { a = 21 b = 22 }
-// lldbr-check:(destructured_fn_argument::Struct) r = { a = 21, b = 22 }
 // lldb-command:continue
 
 // lldb-command:v s
 // lldbg-check:[...] 24
-// lldbr-check:(i32) s = 24
 // lldb-command:v t
 // lldbg-check:[...] 23
-// lldbr-check:(i64) t = 23
 // lldb-command:continue
 
 // lldb-command:v u
 // lldbg-check:[...] 25
-// lldbr-check:(i16) u = 25
 // lldb-command:v v
 // lldbg-check:[...] 26
-// lldbr-check:(i32) v = 26
 // lldb-command:v w
 // lldbg-check:[...] 27
-// lldbr-check:(i64) w = 27
 // lldb-command:v x
 // lldbg-check:[...] 28
-// lldbr-check:(i32) x = 28
 // lldb-command:v y
 // lldbg-check:[...] 29
-// lldbr-check:(i64) y = 29
 // lldb-command:v z
 // lldbg-check:[...] 30
-// lldbr-check:(i32) z = 30
 // lldb-command:v ae
 // lldbg-check:[...] 31
-// lldbr-check:(i64) ae = 31
 // lldb-command:v oe
 // lldbg-check:[...] 32
-// lldbr-check:(i32) oe = 32
 // lldb-command:v ue
 // lldbg-check:[...] 33
-// lldbr-check:(u16) ue = 33
 // lldb-command:continue
 
 // lldb-command:v aa
 // lldbg-check:[...] { 0 = 34 1 = 35 }
-// lldbr-check:((isize, isize)) aa = { 0 = 34 1 = 35 }
 // lldb-command:continue
 
 // lldb-command:v bb
 // lldbg-check:[...] { 0 = 36 1 = 37 }
-// lldbr-check:((isize, isize)) bb = { 0 = 36 1 = 37 }
 // lldb-command:continue
 
 // lldb-command:v cc
 // lldbg-check:[...] 38
-// lldbr-check:(isize) cc = 38
 // lldb-command:continue
 
 // lldb-command:v dd
 // lldbg-check:[...] { 0 = 40 1 = 41 2 = 42 }
-// lldbr-check:((isize, isize, isize)) dd = { 0 = 40 1 = 41 2 = 42 }
 // lldb-command:continue
 
 // lldb-command:v *ee
 // lldbg-check:[...] { 0 = 43 1 = 44 2 = 45 }
-// lldbr-check:((isize, isize, isize)) *ee = { 0 = 43 1 = 44 2 = 45 }
 // lldb-command:continue
 
 // lldb-command:v *ff
 // lldbg-check:[...] 46
-// lldbr-check:(isize) *ff = 46
 // lldb-command:v gg
 // lldbg-check:[...] { 0 = 47 1 = 48 }
-// lldbr-check:((isize, isize)) gg = { 0 = 47 1 = 48 }
 // lldb-command:continue
 
 // lldb-command:v *hh
 // lldbg-check:[...] 50
-// lldbr-check:(i32) *hh = 50
 // lldb-command:continue
 
 // lldb-command:v ii
 // lldbg-check:[...] 51
-// lldbr-check:(i32) ii = 51
 // lldb-command:continue
 
 // lldb-command:v *jj
 // lldbg-check:[...] 52
-// lldbr-check:(i32) *jj = 52
 // lldb-command:continue
 
 // lldb-command:v kk
 // lldbg-check:[...] 53
-// lldbr-check:(f64) kk = 53
 // lldb-command:v ll
 // lldbg-check:[...] 54
-// lldbr-check:(isize) ll = 54
 // lldb-command:continue
 
 // lldb-command:v mm
 // lldbg-check:[...] 55
-// lldbr-check:(f64) mm = 55
 // lldb-command:v *nn
 // lldbg-check:[...] 56
-// lldbr-check:(isize) *nn = 56
 // lldb-command:continue
 
 // lldb-command:v oo
 // lldbg-check:[...] 57
-// lldbr-check:(isize) oo = 57
 // lldb-command:v pp
 // lldbg-check:[...] 58
-// lldbr-check:(isize) pp = 58
 // lldb-command:v qq
 // lldbg-check:[...] 59
-// lldbr-check:(isize) qq = 59
 // lldb-command:continue
 
 // lldb-command:v rr
 // lldbg-check:[...] 60
-// lldbr-check:(isize) rr = 60
 // lldb-command:v ss
 // lldbg-check:[...] 61
-// lldbr-check:(isize) ss = 61
 // lldb-command:v tt
 // lldbg-check:[...] 62
-// lldbr-check:(isize) tt = 62
 // lldb-command:continue
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs
index 73f03ec40b63a..6a43f8ca19993 100644
--- a/tests/debuginfo/destructured-for-loop-variable.rs
+++ b/tests/debuginfo/destructured-for-loop-variable.rs
@@ -78,89 +78,65 @@
 // DESTRUCTURED STRUCT
 // lldb-command:v x
 // lldbg-check:[...] 400
-// lldbr-check:(i16) x = 400
 // lldb-command:v y
 // lldbg-check:[...] 401.5
-// lldbr-check:(f32) y = 401.5
 // lldb-command:v z
 // lldbg-check:[...] true
-// lldbr-check:(bool) z = true
 // lldb-command:continue
 
 // DESTRUCTURED TUPLE
 // lldb-command:v _i8
 // lldbg-check:[...] 0x6f
-// lldbr-check:(i8) _i8 = 111
 // lldb-command:v _u8
 // lldbg-check:[...] 0x70
-// lldbr-check:(u8) _u8 = 112
 // lldb-command:v _i16
 // lldbg-check:[...] -113
-// lldbr-check:(i16) _i16 = -113
 // lldb-command:v _u16
 // lldbg-check:[...] 114
-// lldbr-check:(u16) _u16 = 114
 // lldb-command:v _i32
 // lldbg-check:[...] -115
-// lldbr-check:(i32) _i32 = -115
 // lldb-command:v _u32
 // lldbg-check:[...] 116
-// lldbr-check:(u32) _u32 = 116
 // lldb-command:v _i64
 // lldbg-check:[...] -117
-// lldbr-check:(i64) _i64 = -117
 // lldb-command:v _u64
 // lldbg-check:[...] 118
-// lldbr-check:(u64) _u64 = 118
 // lldb-command:v _f32
 // lldbg-check:[...] 119.5
-// lldbr-check:(f32) _f32 = 119.5
 // lldb-command:v _f64
 // lldbg-check:[...] 120.5
-// lldbr-check:(f64) _f64 = 120.5
 // lldb-command:continue
 
 // MORE COMPLEX CASE
 // lldb-command:v v1
 // lldbg-check:[...] 80000
-// lldbr-check:(i32) v1 = 80000
 // lldb-command:v x1
 // lldbg-check:[...] 8000
-// lldbr-check:(i16) x1 = 8000
 // lldb-command:v *y1
 // lldbg-check:[...] 80001.5
-// lldbr-check:(f32) *y1 = 80001.5
 // lldb-command:v z1
 // lldbg-check:[...] false
-// lldbr-check:(bool) z1 = false
 // lldb-command:v *x2
 // lldbg-check:[...] -30000
-// lldbr-check:(i16) *x2 = -30000
 // lldb-command:v y2
 // lldbg-check:[...] -300001.5
-// lldbr-check:(f32) y2 = -300001.5
 // lldb-command:v *z2
 // lldbg-check:[...] true
-// lldbr-check:(bool) *z2 = true
 // lldb-command:v v2
 // lldbg-check:[...] 854237.5
-// lldbr-check:(f64) v2 = 854237.5
 // lldb-command:continue
 
 // SIMPLE IDENTIFIER
 // lldb-command:v i
 // lldbg-check:[...] 1234
-// lldbr-check:(i32) i = 1234
 // lldb-command:continue
 
 // lldb-command:v simple_struct_ident
 // lldbg-check:[...] { x = 3537 y = 35437.5 z = true }
-// lldbr-check:(destructured_for_loop_variable::Struct) simple_struct_ident = { x = 3537 y = 35437.5 z = true }
 // lldb-command:continue
 
 // lldb-command:v simple_tuple_ident
 // lldbg-check:[...] { 0 = 34903493 1 = 232323 }
-// lldbr-check:((u32, i64)) simple_tuple_ident = { 0 = 34903493 1 = 232323 }
 // lldb-command:continue
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/destructured-local.rs b/tests/debuginfo/destructured-local.rs
index f4d960f78812f..b74bf8745eaac 100644
--- a/tests/debuginfo/destructured-local.rs
+++ b/tests/debuginfo/destructured-local.rs
@@ -121,156 +121,113 @@
 
 // lldb-command:v a
 // lldbg-check:[...] 1
-// lldbr-check:(isize) a = 1
 // lldb-command:v b
 // lldbg-check:[...] false
-// lldbr-check:(bool) b = false
 
 // lldb-command:v c
 // lldbg-check:[...] 2
-// lldbr-check:(isize) c = 2
 // lldb-command:v d
 // lldbg-check:[...] 3
-// lldbr-check:(u16) d = 3
 // lldb-command:v e
 // lldbg-check:[...] 4
-// lldbr-check:(u16) e = 4
 
 // lldb-command:v f
 // lldbg-check:[...] 5
-// lldbr-check:(isize) f = 5
 // lldb-command:v g
 // lldbg-check:[...] { 0 = 6 1 = 7 }
-// lldbr-check:((u32, u32)) g = { 0 = 6 1 = 7 }
 
 // lldb-command:v h
 // lldbg-check:[...] 8
-// lldbr-check:(i16) h = 8
 // lldb-command:v i
 // lldbg-check:[...] { a = 9 b = 10 }
-// lldbr-check:(destructured_local::Struct) i = { a = 9 b = 10 }
 // lldb-command:v j
 // lldbg-check:[...] 11
-// lldbr-check:(i16) j = 11
 
 // lldb-command:v k
 // lldbg-check:[...] 12
-// lldbr-check:(i64) k = 12
 // lldb-command:v l
 // lldbg-check:[...] 13
-// lldbr-check:(i32) l = 13
 
 // lldb-command:v m
 // lldbg-check:[...] 14
-// lldbr-check:(i32) m = 14
 // lldb-command:v n
 // lldbg-check:[...] 16
-// lldbr-check:(i32) n = 16
 
 // lldb-command:v o
 // lldbg-check:[...] 18
-// lldbr-check:(i32) o = 18
 
 // lldb-command:v p
 // lldbg-check:[...] 19
-// lldbr-check:(i64) p = 19
 // lldb-command:v q
 // lldbg-check:[...] 20
-// lldbr-check:(i32) q = 20
 // lldb-command:v r
 // lldbg-check:[...] { a = 21 b = 22 }
-// lldbr-check:(destructured_local::Struct) r = { a = 21 b = 22 }
 
 // lldb-command:v s
 // lldbg-check:[...] 24
-// lldbr-check:(i32) s = 24
 // lldb-command:v t
 // lldbg-check:[...] 23
-// lldbr-check:(i64) t = 23
 
 // lldb-command:v u
 // lldbg-check:[...] 25
-// lldbr-check:(i32) u = 25
 // lldb-command:v v
 // lldbg-check:[...] 26
-// lldbr-check:(i32) v = 26
 // lldb-command:v w
 // lldbg-check:[...] 27
-// lldbr-check:(i32) w = 27
 // lldb-command:v x
 // lldbg-check:[...] 28
-// lldbr-check:(i32) x = 28
 // lldb-command:v y
 // lldbg-check:[...] 29
-// lldbr-check:(i64) y = 29
 // lldb-command:v z
 // lldbg-check:[...] 30
-// lldbr-check:(i32) z = 30
 // lldb-command:v ae
 // lldbg-check:[...] 31
-// lldbr-check:(i64) ae = 31
 // lldb-command:v oe
 // lldbg-check:[...] 32
-// lldbr-check:(i32) oe = 32
 // lldb-command:v ue
 // lldbg-check:[...] 33
-// lldbr-check:(i32) ue = 33
 
 // lldb-command:v aa
 // lldbg-check:[...] { 0 = 34 1 = 35 }
-// lldbr-check:((i32, i32)) aa = { 0 = 34 1 = 35 }
 
 // lldb-command:v bb
 // lldbg-check:[...] { 0 = 36 1 = 37 }
-// lldbr-check:((i32, i32)) bb = { 0 = 36 1 = 37 }
 
 // lldb-command:v cc
 // lldbg-check:[...] 38
-// lldbr-check:(i32) cc = 38
 
 // lldb-command:v dd
 // lldbg-check:[...] { 0 = 40 1 = 41 2 = 42 }
-// lldbr-check:((i32, i32, i32)) dd = { 0 = 40 1 = 41 2 = 42}
 
 // lldb-command:v *ee
 // lldbg-check:[...] { 0 = 43 1 = 44 2 = 45 }
-// lldbr-check:((i32, i32, i32)) *ee = { 0 = 43 1 = 44 2 = 45}
 
 // lldb-command:v *ff
 // lldbg-check:[...] 46
-// lldbr-check:(i32) *ff = 46
 
 // lldb-command:v gg
 // lldbg-check:[...] { 0 = 47 1 = 48 }
-// lldbr-check:((i32, i32)) gg = { 0 = 47 1 = 48 }
 
 // lldb-command:v *hh
 // lldbg-check:[...] 50
-// lldbr-check:(i32) *hh = 50
 
 // lldb-command:v ii
 // lldbg-check:[...] 51
-// lldbr-check:(i32) ii = 51
 
 // lldb-command:v *jj
 // lldbg-check:[...] 52
-// lldbr-check:(i32) *jj = 52
 
 // lldb-command:v kk
 // lldbg-check:[...] 53
-// lldbr-check:(f64) kk = 53
 
 // lldb-command:v ll
 // lldbg-check:[...] 54
-// lldbr-check:(isize) ll = 54
 
 // lldb-command:v mm
 // lldbg-check:[...] 55
-// lldbr-check:(f64) mm = 55
 
 // lldb-command:v *nn
 // lldbg-check:[...] 56
-// lldbr-check:(isize) *nn = 56
 
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/enum-thinlto.rs b/tests/debuginfo/enum-thinlto.rs
index d30ff7dde3892..8c3a20a2da4c0 100644
--- a/tests/debuginfo/enum-thinlto.rs
+++ b/tests/debuginfo/enum-thinlto.rs
@@ -14,7 +14,6 @@
 
 // lldb-command:v *abc
 // lldbg-check:(enum_thinlto::ABC) *abc = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 }
-// lldbr-check:(enum_thinlto::ABC) *abc = (x = 0, y = 8970181431921507452)
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/evec-in-struct.rs b/tests/debuginfo/evec-in-struct.rs
index f09471e753051..020c6e7d15426 100644
--- a/tests/debuginfo/evec-in-struct.rs
+++ b/tests/debuginfo/evec-in-struct.rs
@@ -25,22 +25,17 @@
 
 // lldb-command:v no_padding1
 // lldbg-check:[...] { x = { [0] = 0 [1] = 1 [2] = 2 } y = -3 z = { [0] = 4.5 [1] = 5.5 } }
-// lldbr-check:(evec_in_struct::NoPadding1) no_padding1 = { x = { [0] = 0 [1] = 1 [2] = 2 } y = -3 z = { [0] = 4.5 [1] = 5.5 } }
 // lldb-command:v no_padding2
 // lldbg-check:[...] { x = { [0] = 6 [1] = 7 [2] = 8 } y = { [0] = { [0] = 9 [1] = 10 } [1] = { [0] = 11 [1] = 12 } } }
-// lldbr-check:(evec_in_struct::NoPadding2) no_padding2 = { x = { [0] = 6 [1] = 7 [2] = 8 } y = { [0] = { [0] = 9 [1] = 10 } [1] = { [0] = 11 [1] = 12 } } }
 
 // lldb-command:v struct_internal_padding
 // lldbg-check:[...] { x = { [0] = 13 [1] = 14 } y = { [0] = 15 [1] = 16 } }
-// lldbr-check:(evec_in_struct::StructInternalPadding) struct_internal_padding = { x = { [0] = 13 [1] = 14 } y = { [0] = 15 [1] = 16 } }
 
 // lldb-command:v single_vec
 // lldbg-check:[...] { x = { [0] = 17 [1] = 18 [2] = 19 [3] = 20 [4] = 21 } }
-// lldbr-check:(evec_in_struct::SingleVec) single_vec = { x = { [0] = 17 [1] = 18 [2] = 19 [3] = 20 [4] = 21 } }
 
 // lldb-command:v struct_padded_at_end
 // lldbg-check:[...] { x = { [0] = 22 [1] = 23 } y = { [0] = 24 [1] = 25 } }
-// lldbr-check:(evec_in_struct::StructPaddedAtEnd) struct_padded_at_end = { x = { [0] = 22 [1] = 23 } y = { [0] = 24 [1] = 25 } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/extern-c-fn.rs b/tests/debuginfo/extern-c-fn.rs
index 0531d7461885c..d81ab356c1e9f 100644
--- a/tests/debuginfo/extern-c-fn.rs
+++ b/tests/debuginfo/extern-c-fn.rs
@@ -21,16 +21,12 @@
 
 // lldb-command:v len
 // lldbg-check:[...] 20
-// lldbr-check:(i32) len = 20
 // lldb-command:v local0
 // lldbg-check:[...] 19
-// lldbr-check:(i32) local0 = 19
 // lldb-command:v local1
 // lldbg-check:[...] true
-// lldbr-check:(bool) local1 = true
 // lldb-command:v local2
 // lldbg-check:[...] 20.5
-// lldbr-check:(f64) local2 = 20.5
 
 // lldb-command:continue
 
diff --git a/tests/debuginfo/function-arguments.rs b/tests/debuginfo/function-arguments.rs
index bbf397caacd50..9befadf5dc15c 100644
--- a/tests/debuginfo/function-arguments.rs
+++ b/tests/debuginfo/function-arguments.rs
@@ -22,18 +22,14 @@
 
 // lldb-command:v x
 // lldbg-check:[...] 111102
-// lldbr-check:(isize) x = 111102
 // lldb-command:v y
 // lldbg-check:[...] true
-// lldbr-check:(bool) y = true
 // lldb-command:continue
 
 // lldb-command:v a
 // lldbg-check:[...] 2000
-// lldbr-check:(i32) a = 2000
 // lldb-command:v b
 // lldbg-check:[...] 3000
-// lldbr-check:(i64) b = 3000
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/generic-function.rs b/tests/debuginfo/generic-function.rs
index 6c1d0d5d7dbd0..47f695b8fbe9a 100644
--- a/tests/debuginfo/generic-function.rs
+++ b/tests/debuginfo/generic-function.rs
@@ -28,26 +28,20 @@
 
 // lldb-command:v *t0
 // lldbg-check:[...] 1
-// lldbr-check:(i32) *t0 = 1
 // lldb-command:v *t1
 // lldbg-check:[...] 2.5
-// lldbr-check:(f64) *t1 = 2.5
 // lldb-command:continue
 
 // lldb-command:v *t0
 // lldbg-check:[...] 3.5
-// lldbr-check:(f64) *t0 = 3.5
 // lldb-command:v *t1
 // lldbg-check:[...] 4
-// lldbr-check:(u16) *t1 = 4
 // lldb-command:continue
 
 // lldb-command:v *t0
 // lldbg-check:[...] 5
-// lldbr-check:(i32) *t0 = 5
 // lldb-command:v *t1
 // lldbg-check:[...] { a = 6 b = 7.5 }
-// lldbr-check:(generic_function::Struct) *t1 = { a = 6 b = 7.5 }
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/generic-functions-nested.rs b/tests/debuginfo/generic-functions-nested.rs
index 1aac6591738b0..500a42f3dc8c8 100644
--- a/tests/debuginfo/generic-functions-nested.rs
+++ b/tests/debuginfo/generic-functions-nested.rs
@@ -35,34 +35,26 @@
 
 // lldb-command:v x
 // lldbg-check:[...] -1
-// lldbr-check:(i32) x = -1
 // lldb-command:v y
 // lldbg-check:[...] 1
-// lldbr-check:(i32) y = 1
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] -1
-// lldbr-check:(i32) x = -1
 // lldb-command:v y
 // lldbg-check:[...] 2.5
-// lldbr-check:(f64) y = 2.5
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] -2.5
-// lldbr-check:(f64) x = -2.5
 // lldb-command:v y
 // lldbg-check:[...] 1
-// lldbr-check:(i32) y = 1
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] -2.5
-// lldbr-check:(f64) x = -2.5
 // lldb-command:v y
 // lldbg-check:[...] 2.5
-// lldbr-check:(f64) y = 2.5
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/generic-method-on-generic-struct.rs b/tests/debuginfo/generic-method-on-generic-struct.rs
index 0f72e2b092be7..071d436b0895a 100644
--- a/tests/debuginfo/generic-method-on-generic-struct.rs
+++ b/tests/debuginfo/generic-method-on-generic-struct.rs
@@ -1,9 +1,5 @@
 //@ compile-flags:-g
 
-// Some versions of the non-rust-enabled LLDB print the wrong generic
-// parameter type names in this test.
-//@ needs-rust-lldb
-
 // === GDB TESTS ===================================================================================
 
 // gdb-command:run
@@ -61,61 +57,46 @@
 // STACK BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { x = { 0 = 8888, 1 = -8888 } }
-// lldbr-check:(generic_method_on_generic_struct::Struct<(u32, i32)>) *self = { x = { 0 = 8888 1 = -8888 } }
 // lldb-command:v arg1
 // lldbg-check:[...] -1
-// lldbr-check:(isize) arg1 = -1
 // lldb-command:v arg2
 // lldbg-check:[...] 2
-// lldbr-check:(u16) arg2 = 2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { x = { 0 = 8888, 1 = -8888 } }
-// lldbr-check:(generic_method_on_generic_struct::Struct<(u32, i32)>) self = { x = { 0 = 8888, 1 = -8888 } }
 // lldb-command:v arg1
 // lldbg-check:[...] -3
-// lldbr-check:(isize) arg1 = -3
 // lldb-command:v arg2
 // lldbg-check:[...] -4
-// lldbr-check:(i16) arg2 = -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { x = 1234.5 }
-// lldbr-check:(generic_method_on_generic_struct::Struct<f64>) *self = { x = 1234.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -5
-// lldbr-check:(isize) arg1 = -5
 // lldb-command:v arg2
 // lldbg-check:[...] -6
-// lldbr-check:(i32) arg2 = -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { x = 1234.5 }
-// lldbr-check:(generic_method_on_generic_struct::Struct<f64>) self = { x = 1234.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -7
-// lldbr-check:(isize) arg1 = -7
 // lldb-command:v arg2
 // lldbg-check:[...] -8
-// lldbr-check:(i64) arg2 = -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
 // lldbg-check:[...] { x = 1234.5 }
-// lldbr-check:(generic_method_on_generic_struct::Struct<f64>) *self = { x = 1234.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -9
-// lldbr-check:(isize) arg1 = -9
 // lldb-command:v arg2
 // lldbg-check:[...] -10.5
-// lldbr-check:(f32) arg2 = -10.5
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs
index 2817f8edc150c..49ec4ac1c177b 100644
--- a/tests/debuginfo/generic-struct.rs
+++ b/tests/debuginfo/generic-struct.rs
@@ -19,17 +19,13 @@
 
 // lldb-command:v int_int
 // lldbg-check:[...] AGenericStruct<i32, i32> { key: 0, value: 1 }
-// lldbr-check:(generic_struct::AGenericStruct<i32, i32>) int_int = AGenericStruct<i32, i32> { key: 0, value: 1 }
 // lldb-command:v int_float
 // lldbg-check:[...] AGenericStruct<i32, f64> { key: 2, value: 3.5 }
-// lldbr-check:(generic_struct::AGenericStruct<i32, f64>) int_float = AGenericStruct<i32, f64> { key: 2, value: 3.5 }
 // lldb-command:v float_int
 // lldbg-check:[...] AGenericStruct<f64, i32> { key: 4.5, value: 5 }
-// lldbr-check:(generic_struct::AGenericStruct<f64, i32>) float_int = AGenericStruct<f64, i32> { key: 4.5, value: 5 }
 
 // lldb-command:v float_int_float
 // lldbg-check:[...] AGenericStruct<f64, generic_struct::AGenericStruct<i32, f64>> { key: 6.5, value: AGenericStruct<i32, f64> { key: 7, value: 8.5 } }
-// lldbr-check:(generic_struct::AGenericStruct<f64, generic_struct::AGenericStruct<i32, f64>>) float_int_float = AGenericStruct<f64, generic_struct::AGenericStruct<i32, f64>> { key: 6.5, value: AGenericStruct<i32, f64> { key: 7, value: 8.5 } }
 
 // === CDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/generic-tuple-style-enum.rs b/tests/debuginfo/generic-tuple-style-enum.rs
index 15b9cec071a71..4a5996645cb47 100644
--- a/tests/debuginfo/generic-tuple-style-enum.rs
+++ b/tests/debuginfo/generic-tuple-style-enum.rs
@@ -23,16 +23,12 @@
 // lldb-command:run
 
 // lldb-command:v case1
-// lldbr-check:(generic_tuple_style_enum::Regular<u16, u32, u64>::Case1) case1 = { __0 = 0 __1 = 31868 __2 = 31868 __3 = 31868 __4 = 31868 }
 
 // lldb-command:v case2
-// lldbr-check:(generic_tuple_style_enum::Regular<i16, i32, i64>::Case2) case2 = Regular<i16, i32, i64>::Case2 { Case1: 0, Case2: 286331153, Case3: 286331153 }
 
 // lldb-command:v case3
-// lldbr-check:(generic_tuple_style_enum::Regular<i16, i32, i64>::Case3) case3 = Regular<i16, i32, i64>::Case3 { Case1: 0, Case2: 6438275382588823897 }
 
 // lldb-command:v univariant
-// lldbr-check:(generic_tuple_style_enum::Univariant<i64>) univariant = Univariant<i64> { TheOnlyCase: Univariant<i64>::TheOnlyCase(-1) }
 
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
diff --git a/tests/debuginfo/include_string.rs b/tests/debuginfo/include_string.rs
index 3ee02c554cbdd..5bf7cb69cc123 100644
--- a/tests/debuginfo/include_string.rs
+++ b/tests/debuginfo/include_string.rs
@@ -18,13 +18,10 @@
 
 // lldb-command:v string1.length
 // lldbg-check:[...] 48
-// lldbr-check:(usize) length = 48
 // lldb-command:v string2.length
 // lldbg-check:[...] 49
-// lldbr-check:(usize) length = 49
 // lldb-command:v string3.length
 // lldbg-check:[...] 50
-// lldbr-check:(usize) length = 50
 
 // lldb-command:continue
 
diff --git a/tests/debuginfo/issue-22656.rs b/tests/debuginfo/issue-22656.rs
index 199de531d0b44..5198d34c7b8be 100644
--- a/tests/debuginfo/issue-22656.rs
+++ b/tests/debuginfo/issue-22656.rs
@@ -11,11 +11,8 @@
 
 // lldb-command:v v
 // lldbg-check:[...] size=3 { [0] = 1 [1] = 2 [2] = 3 }
-// lldbr-check:(alloc::vec::Vec<i32>) v = size=3 { [0] = 1 [1] = 2 [2] = 3 }
 // lldb-command:v zs
 // lldbg-check:[...] { x = y = 123 z = w = 456 }
-// lldbr-check:(issue_22656::StructWithZeroSizedField) zs = { x = y = 123 z = w = 456 }
-// lldbr-command:continue
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
diff --git a/tests/debuginfo/lexical-scope-in-for-loop.rs b/tests/debuginfo/lexical-scope-in-for-loop.rs
index d5594b6bc62fa..acfddaab89c72 100644
--- a/tests/debuginfo/lexical-scope-in-for-loop.rs
+++ b/tests/debuginfo/lexical-scope-in-for-loop.rs
@@ -44,40 +44,33 @@
 // FIRST ITERATION
 // lldb-command:v x
 // lldbg-check:[...] 1
-// lldbr-check:(i32) x = 1
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] -1
-// lldbr-check:(i32) x = -1
 // lldb-command:continue
 
 // SECOND ITERATION
 // lldb-command:v x
 // lldbg-check:[...] 2
-// lldbr-check:(i32) x = 2
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] -2
-// lldbr-check:(i32) x = -2
 // lldb-command:continue
 
 // THIRD ITERATION
 // lldb-command:v x
 // lldbg-check:[...] 3
-// lldbr-check:(i32) x = 3
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] -3
-// lldbr-check:(i32) x = -3
 // lldb-command:continue
 
 // AFTER LOOP
 // lldb-command:v x
 // lldbg-check:[...] 1000000
-// lldbr-check:(i32) x = 1000000
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-in-if.rs b/tests/debuginfo/lexical-scope-in-if.rs
index e35eb3715a9ba..d1c5884843c4e 100644
--- a/tests/debuginfo/lexical-scope-in-if.rs
+++ b/tests/debuginfo/lexical-scope-in-if.rs
@@ -68,73 +68,57 @@
 // BEFORE if
 // lldb-command:v x
 // lldbg-check:[...] 999
-// lldbr-check:(i32) x = 999
 // lldb-command:v y
 // lldbg-check:[...] -1
-// lldbr-check:(i32) y = -1
 // lldb-command:continue
 
 // AT BEGINNING of 'then' block
 // lldb-command:v x
 // lldbg-check:[...] 999
-// lldbr-check:(i32) x = 999
 // lldb-command:v y
 // lldbg-check:[...] -1
-// lldbr-check:(i32) y = -1
 // lldb-command:continue
 
 // AFTER 1st redeclaration of 'x'
 // lldb-command:v x
 // lldbg-check:[...] 1001
-// lldbr-check:(i32) x = 1001
 // lldb-command:v y
 // lldbg-check:[...] -1
-// lldbr-check:(i32) y = -1
 // lldb-command:continue
 
 // AFTER 2st redeclaration of 'x'
 // lldb-command:v x
 // lldbg-check:[...] 1002
-// lldbr-check:(i32) x = 1002
 // lldb-command:v y
 // lldbg-check:[...] 1003
-// lldbr-check:(i32) y = 1003
 // lldb-command:continue
 
 // AFTER 1st if expression
 // lldb-command:v x
 // lldbg-check:[...] 999
-// lldbr-check:(i32) x = 999
 // lldb-command:v y
 // lldbg-check:[...] -1
-// lldbr-check:(i32) y = -1
 // lldb-command:continue
 
 // BEGINNING of else branch
 // lldb-command:v x
 // lldbg-check:[...] 999
-// lldbr-check:(i32) x = 999
 // lldb-command:v y
 // lldbg-check:[...] -1
-// lldbr-check:(i32) y = -1
 // lldb-command:continue
 
 // BEGINNING of else branch
 // lldb-command:v x
 // lldbg-check:[...] 1004
-// lldbr-check:(i32) x = 1004
 // lldb-command:v y
 // lldbg-check:[...] 1005
-// lldbr-check:(i32) y = 1005
 // lldb-command:continue
 
 // BEGINNING of else branch
 // lldb-command:v x
 // lldbg-check:[...] 999
-// lldbr-check:(i32) x = 999
 // lldb-command:v y
 // lldbg-check:[...] -1
-// lldbr-check:(i32) y = -1
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-in-match.rs b/tests/debuginfo/lexical-scope-in-match.rs
index cffda426aefa6..754616b1a54b3 100644
--- a/tests/debuginfo/lexical-scope-in-match.rs
+++ b/tests/debuginfo/lexical-scope-in-match.rs
@@ -63,72 +63,54 @@
 
 // lldb-command:v shadowed
 // lldbg-check:[...] 231
-// lldbr-check:(i32) shadowed = 231
 // lldb-command:v not_shadowed
 // lldbg-check:[...] 232
-// lldbr-check:(i32) not_shadowed = 232
 // lldb-command:continue
 
 // lldb-command:v shadowed
 // lldbg-check:[...] 233
-// lldbr-check:(i32) shadowed = 233
 // lldb-command:v not_shadowed
 // lldbg-check:[...] 232
-// lldbr-check:(i32) not_shadowed = 232
 // lldb-command:v local_to_arm
 // lldbg-check:[...] 234
-// lldbr-check:(i32) local_to_arm = 234
 // lldb-command:continue
 
 // lldb-command:v shadowed
 // lldbg-check:[...] 236
-// lldbr-check:(i32) shadowed = 236
 // lldb-command:v not_shadowed
 // lldbg-check:[...] 232
-// lldbr-check:(i32) not_shadowed = 232
 // lldb-command:continue
 
 // lldb-command:v shadowed
 // lldbg-check:[...] 237
-// lldbr-check:(isize) shadowed = 237
 // lldb-command:v not_shadowed
 // lldbg-check:[...] 232
-// lldbr-check:(i32) not_shadowed = 232
 // lldb-command:v local_to_arm
 // lldbg-check:[...] 238
-// lldbr-check:(isize) local_to_arm = 238
 // lldb-command:continue
 
 // lldb-command:v shadowed
 // lldbg-check:[...] 239
-// lldbr-check:(isize) shadowed = 239
 // lldb-command:v not_shadowed
 // lldbg-check:[...] 232
-// lldbr-check:(i32) not_shadowed = 232
 // lldb-command:continue
 
 // lldb-command:v shadowed
 // lldbg-check:[...] 241
-// lldbr-check:(isize) shadowed = 241
 // lldb-command:v not_shadowed
 // lldbg-check:[...] 232
-// lldbr-check:(i32) not_shadowed = 232
 // lldb-command:continue
 
 // lldb-command:v shadowed
 // lldbg-check:[...] 243
-// lldbr-check:(i32) shadowed = 243
 // lldb-command:v *local_to_arm
 // lldbg-check:[...] 244
-// lldbr-check:(i32) *local_to_arm = 244
 // lldb-command:continue
 
 // lldb-command:v shadowed
 // lldbg-check:[...] 231
-// lldbr-check:(i32) shadowed = 231
 // lldb-command:v not_shadowed
 // lldbg-check:[...] 232
-// lldbr-check:(i32) not_shadowed = 232
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-in-stack-closure.rs b/tests/debuginfo/lexical-scope-in-stack-closure.rs
index 51fb16c594fac..301423080e68f 100644
--- a/tests/debuginfo/lexical-scope-in-stack-closure.rs
+++ b/tests/debuginfo/lexical-scope-in-stack-closure.rs
@@ -35,32 +35,26 @@
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 1000
-// lldbr-check:(isize) x = 1000
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 2.5
-// lldbr-check:(f64) x = 2.5
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] true
-// lldbr-check:(bool) x = true
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs
index 344e1893c865b..1d111dab5c949 100644
--- a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs
+++ b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs
@@ -67,69 +67,56 @@
 // FIRST ITERATION
 // lldb-command:v x
 // lldbg-check:[...] 0
-// lldbr-check:(i32) x = 0
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 1
-// lldbr-check:(i32) x = 1
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 101
-// lldbr-check:(i32) x = 101
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 101
-// lldbr-check:(i32) x = 101
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] -987
-// lldbr-check:(i32) x = -987
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 101
-// lldbr-check:(i32) x = 101
 // lldb-command:continue
 
 
 // SECOND ITERATION
 // lldb-command:v x
 // lldbg-check:[...] 1
-// lldbr-check:(i32) x = 1
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 2
-// lldbr-check:(i32) x = 2
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 102
-// lldbr-check:(i32) x = 102
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 102
-// lldbr-check:(i32) x = 102
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] -987
-// lldbr-check:(i32) x = -987
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 102
-// lldbr-check:(i32) x = 102
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 2
-// lldbr-check:(i32) x = 2
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-in-unique-closure.rs b/tests/debuginfo/lexical-scope-in-unique-closure.rs
index 443c4209b75bc..d6cf39c77ae13 100644
--- a/tests/debuginfo/lexical-scope-in-unique-closure.rs
+++ b/tests/debuginfo/lexical-scope-in-unique-closure.rs
@@ -35,32 +35,26 @@
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 1000
-// lldbr-check:(isize) x = 1000
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 2.5
-// lldbr-check:(f64) x = 2.5
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] true
-// lldbr-check:(bool) x = true
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/lexical-scope-in-while.rs b/tests/debuginfo/lexical-scope-in-while.rs
index 864900711a9f3..faef8b44a2979 100644
--- a/tests/debuginfo/lexical-scope-in-while.rs
+++ b/tests/debuginfo/lexical-scope-in-while.rs
@@ -67,69 +67,56 @@
 // FIRST ITERATION
 // lldb-command:v x
 // lldbg-check:[...] 0
-// lldbr-check:(i32) x = 0
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 1
-// lldbr-check:(i32) x = 1
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 101
-// lldbr-check:(i32) x = 101
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 101
-// lldbr-check:(i32) x = 101
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] -987
-// lldbr-check:(i32) x = -987
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 101
-// lldbr-check:(i32) x = 101
 // lldb-command:continue
 
 
 // SECOND ITERATION
 // lldb-command:v x
 // lldbg-check:[...] 1
-// lldbr-check:(i32) x = 1
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 2
-// lldbr-check:(i32) x = 2
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 102
-// lldbr-check:(i32) x = 102
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 102
-// lldbr-check:(i32) x = 102
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] -987
-// lldbr-check:(i32) x = -987
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 102
-// lldbr-check:(i32) x = 102
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 2
-// lldbr-check:(i32) x = 2
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-with-macro.rs b/tests/debuginfo/lexical-scope-with-macro.rs
index 6e8f87cc2d7fc..5f8838c782bb5 100644
--- a/tests/debuginfo/lexical-scope-with-macro.rs
+++ b/tests/debuginfo/lexical-scope-with-macro.rs
@@ -55,34 +55,26 @@
 
 // lldb-command:v a
 // lldbg-check:[...] 10
-// lldbr-check:(i32) a = 10
 // lldb-command:v b
 // lldbg-check:[...] 34
-// lldbr-check:(i32) b = 34
 // lldb-command:continue
 
 // lldb-command:v a
 // lldbg-check:[...] 890242
-// lldbr-check:(i32) a = 10
 // lldb-command:v b
 // lldbg-check:[...] 34
-// lldbr-check:(i32) b = 34
 // lldb-command:continue
 
 // lldb-command:v a
 // lldbg-check:[...] 10
-// lldbr-check:(i32) a = 10
 // lldb-command:v b
 // lldbg-check:[...] 34
-// lldbr-check:(i32) b = 34
 // lldb-command:continue
 
 // lldb-command:v a
 // lldbg-check:[...] 102
-// lldbr-check:(i32) a = 10
 // lldb-command:v b
 // lldbg-check:[...] 34
-// lldbr-check:(i32) b = 34
 // lldb-command:continue
 
 // lldbg-command:print a
diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs
index 310e9ae2a93e6..f90c3dd327bc4 100644
--- a/tests/debuginfo/lexical-scopes-in-block-expression.rs
+++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs
@@ -184,202 +184,154 @@
 // STRUCT EXPRESSION
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] 11
-// lldbr-check:(isize) val = 11
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // FUNCTION CALL
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] 12
-// lldbr-check:(isize) val = 12
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // TUPLE EXPRESSION
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] 13
-// lldbr-check:(isize) val = 13
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // VEC EXPRESSION
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] 14
-// lldbr-check:(isize) val = 14
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // REPEAT VEC EXPRESSION
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] 15
-// lldbr-check:(isize) val = 15
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // ASSIGNMENT EXPRESSION
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] 16
-// lldbr-check:(isize) val = 16
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 
 // ARITHMETIC EXPRESSION
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] 17
-// lldbr-check:(isize) val = 17
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // INDEX EXPRESSION
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] 18
-// lldbr-check:(isize) val = 18
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 // lldb-command:v val
 // lldbg-check:[...] -1
-// lldbr-check:(i32) val = -1
 // lldb-command:v ten
 // lldbg-check:[...] 10
-// lldbr-check:(isize) ten = 10
 // lldb-command:continue
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs
index 8c2c6a38c269e..27e83cbbe2232 100644
--- a/tests/debuginfo/method-on-generic-struct.rs
+++ b/tests/debuginfo/method-on-generic-struct.rs
@@ -57,61 +57,46 @@
 // STACK BY REF
 // lldb-command:v *self
 // lldbg-check:[...] Struct<(u32, i32)> { x: (8888, -8888) }
-// lldbr-check:(method_on_generic_struct::Struct<(u32, i32)>) *self = { x = { = 8888 = -8888 } }
 // lldb-command:v arg1
 // lldbg-check:[...] -1
-// lldbr-check:(isize) arg1 = -1
 // lldb-command:v arg2
 // lldbg-check:[...] -2
-// lldbr-check:(isize) arg2 = -2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
 // lldbg-check:[...] Struct<(u32, i32)> { x: (8888, -8888) }
-// lldbr-check:(method_on_generic_struct::Struct<(u32, i32)>) self = { x = { = 8888 = -8888 } }
 // lldb-command:v arg1
 // lldbg-check:[...] -3
-// lldbr-check:(isize) arg1 = -3
 // lldb-command:v arg2
 // lldbg-check:[...] -4
-// lldbr-check:(isize) arg2 = -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
 // lldbg-check:[...] Struct<f64> { x: 1234.5 }
-// lldbr-check:(method_on_generic_struct::Struct<f64>) *self = Struct<f64> { x: 1234.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -5
-// lldbr-check:(isize) arg1 = -5
 // lldb-command:v arg2
 // lldbg-check:[...] -6
-// lldbr-check:(isize) arg2 = -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
 // lldbg-check:[...] Struct<f64> { x: 1234.5 }
-// lldbr-check:(method_on_generic_struct::Struct<f64>) self = Struct<f64> { x: 1234.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -7
-// lldbr-check:(isize) arg1 = -7
 // lldb-command:v arg2
 // lldbg-check:[...] -8
-// lldbr-check:(isize) arg2 = -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
 // lldbg-check:[...] Struct<f64> { x: 1234.5 }
-// lldbr-check:(method_on_generic_struct::Struct<f64>) *self = Struct<f64> { x: 1234.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -9
-// lldbr-check:(isize) arg1 = -9
 // lldb-command:v arg2
 // lldbg-check:[...] -10
-// lldbr-check:(isize) arg2 = -10
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/method-on-struct.rs b/tests/debuginfo/method-on-struct.rs
index d92259b7ab118..307c6d92d489a 100644
--- a/tests/debuginfo/method-on-struct.rs
+++ b/tests/debuginfo/method-on-struct.rs
@@ -57,61 +57,46 @@
 // STACK BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { x = 100 }
-// lldbr-check:(method_on_struct::Struct) *self = Struct { x: 100 }
 // lldb-command:v arg1
 // lldbg-check:[...] -1
-// lldbr-check:(isize) arg1 = -1
 // lldb-command:v arg2
 // lldbg-check:[...] -2
-// lldbr-check:(isize) arg2 = -2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { x = 100 }
-// lldbr-check:(method_on_struct::Struct) self = Struct { x: 100 }
 // lldb-command:v arg1
 // lldbg-check:[...] -3
-// lldbr-check:(isize) arg1 = -3
 // lldb-command:v arg2
 // lldbg-check:[...] -4
-// lldbr-check:(isize) arg2 = -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { x = 200 }
-// lldbr-check:(method_on_struct::Struct) *self = Struct { x: 200 }
 // lldb-command:v arg1
 // lldbg-check:[...] -5
-// lldbr-check:(isize) arg1 = -5
 // lldb-command:v arg2
 // lldbg-check:[...] -6
-// lldbr-check:(isize) arg2 = -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { x = 200 }
-// lldbr-check:(method_on_struct::Struct) self = Struct { x: 200 }
 // lldb-command:v arg1
 // lldbg-check:[...] -7
-// lldbr-check:(isize) arg1 = -7
 // lldb-command:v arg2
 // lldbg-check:[...] -8
-// lldbr-check:(isize) arg2 = -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
 // lldbg-check:[...] { x = 200 }
-// lldbr-check:(method_on_struct::Struct) *self = Struct { x: 200 }
 // lldb-command:v arg1
 // lldbg-check:[...] -9
-// lldbr-check:(isize) arg1 = -9
 // lldb-command:v arg2
 // lldbg-check:[...] -10
-// lldbr-check:(isize) arg2 = -10
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/method-on-trait.rs b/tests/debuginfo/method-on-trait.rs
index b4ff61b38b05f..29087da0e6a67 100644
--- a/tests/debuginfo/method-on-trait.rs
+++ b/tests/debuginfo/method-on-trait.rs
@@ -57,61 +57,46 @@
 // STACK BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { x = 100 }
-// lldbr-check:(method_on_trait::Struct) *self = { x = 100 }
 // lldb-command:v arg1
 // lldbg-check:[...] -1
-// lldbr-check:(isize) arg1 = -1
 // lldb-command:v arg2
 // lldbg-check:[...] -2
-// lldbr-check:(isize) arg2 = -2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { x = 100 }
-// lldbr-check:(method_on_trait::Struct) self = { x = 100 }
 // lldb-command:v arg1
 // lldbg-check:[...] -3
-// lldbr-check:(isize) arg1 = -3
 // lldb-command:v arg2
 // lldbg-check:[...] -4
-// lldbr-check:(isize) arg2 = -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { x = 200 }
-// lldbr-check:(method_on_trait::Struct) *self = { x = 200 }
 // lldb-command:v arg1
 // lldbg-check:[...] -5
-// lldbr-check:(isize) arg1 = -5
 // lldb-command:v arg2
 // lldbg-check:[...] -6
-// lldbr-check:(isize) arg2 = -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { x = 200 }
-// lldbr-check:(method_on_trait::Struct) self = { x = 200 }
 // lldb-command:v arg1
 // lldbg-check:[...] -7
-// lldbr-check:(isize) arg1 = -7
 // lldb-command:v arg2
 // lldbg-check:[...] -8
-// lldbr-check:(isize) arg2 = -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
 // lldbg-check:[...] { x = 200 }
-// lldbr-check:(method_on_trait::Struct) *self = { x = 200 }
 // lldb-command:v arg1
 // lldbg-check:[...] -9
-// lldbr-check:(isize) arg1 = -9
 // lldb-command:v arg2
 // lldbg-check:[...] -10
-// lldbr-check:(isize) arg2 = -10
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/method-on-tuple-struct.rs b/tests/debuginfo/method-on-tuple-struct.rs
index 0a4beecb06796..7b8d30abf63c0 100644
--- a/tests/debuginfo/method-on-tuple-struct.rs
+++ b/tests/debuginfo/method-on-tuple-struct.rs
@@ -57,61 +57,46 @@
 // STACK BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { 0 = 100 1 = -100.5 }
-// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = { 0 = 100 1 = -100.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -1
-// lldbr-check:(isize) arg1 = -1
 // lldb-command:v arg2
 // lldbg-check:[...] -2
-// lldbr-check:(isize) arg2 = -2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { 0 = 100 1 = -100.5 }
-// lldbr-check:(method_on_tuple_struct::TupleStruct) self = { 0 = 100 1 = -100.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -3
-// lldbr-check:(isize) arg1 = -3
 // lldb-command:v arg2
 // lldbg-check:[...] -4
-// lldbr-check:(isize) arg2 = -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { 0 = 200 1 = -200.5 }
-// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = { 0 = 200 1 = -200.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -5
-// lldbr-check:(isize) arg1 = -5
 // lldb-command:v arg2
 // lldbg-check:[...] -6
-// lldbr-check:(isize) arg2 = -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { 0 = 200 1 = -200.5 }
-// lldbr-check:(method_on_tuple_struct::TupleStruct) self = { 0 = 200 1 = -200.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -7
-// lldbr-check:(isize) arg1 = -7
 // lldb-command:v arg2
 // lldbg-check:[...] -8
-// lldbr-check:(isize) arg2 = -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
 // lldbg-check:[...] { 0 = 200 1 = -200.5 }
-// lldbr-check:(method_on_tuple_struct::TupleStruct) *self = { 0 = 200 1 = -200.5 }
 // lldb-command:v arg1
 // lldbg-check:[...] -9
-// lldbr-check:(isize) arg1 = -9
 // lldb-command:v arg2
 // lldbg-check:[...] -10
-// lldbr-check:(isize) arg2 = -10
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/multi-cgu.rs b/tests/debuginfo/multi-cgu.rs
index 69460c40e6221..81735f2bc09a3 100644
--- a/tests/debuginfo/multi-cgu.rs
+++ b/tests/debuginfo/multi-cgu.rs
@@ -22,12 +22,10 @@
 
 // lldb-command:v xxx
 // lldbg-check:[...] 12345
-// lldbr-check:(u32) xxx = 12345
 // lldb-command:continue
 
 // lldb-command:v yyy
 // lldbg-check:[...] 67890
-// lldbr-check:(u64) yyy = 67890
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/multiple-functions-equal-var-names.rs b/tests/debuginfo/multiple-functions-equal-var-names.rs
index 8ea3d5df2b04b..cbf513ad0f71c 100644
--- a/tests/debuginfo/multiple-functions-equal-var-names.rs
+++ b/tests/debuginfo/multiple-functions-equal-var-names.rs
@@ -22,17 +22,14 @@
 
 // lldb-command:v abc
 // lldbg-check:[...] 10101
-// lldbr-check:(i32) abc = 10101
 // lldb-command:continue
 
 // lldb-command:v abc
 // lldbg-check:[...] 20202
-// lldbr-check:(i32) abc = 20202
 // lldb-command:continue
 
 // lldb-command:v abc
 // lldbg-check:[...] 30303
-// lldbr-check:(i32) abc = 30303
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/multiple-functions.rs b/tests/debuginfo/multiple-functions.rs
index c1a357499f0fc..a113ce17855cf 100644
--- a/tests/debuginfo/multiple-functions.rs
+++ b/tests/debuginfo/multiple-functions.rs
@@ -22,17 +22,14 @@
 
 // lldb-command:v a
 // lldbg-check:[...] 10101
-// lldbr-check:(i32) a = 10101
 // lldb-command:continue
 
 // lldb-command:v b
 // lldbg-check:[...] 20202
-// lldbr-check:(i32) b = 20202
 // lldb-command:continue
 
 // lldb-command:v c
 // lldbg-check:[...] 30303
-// lldbr-check:(i32) c = 30303
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/name-shadowing-and-scope-nesting.rs b/tests/debuginfo/name-shadowing-and-scope-nesting.rs
index 1a46a2d3890d1..9d1accd963be1 100644
--- a/tests/debuginfo/name-shadowing-and-scope-nesting.rs
+++ b/tests/debuginfo/name-shadowing-and-scope-nesting.rs
@@ -47,50 +47,38 @@
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:v y
 // lldbg-check:[...] true
-// lldbr-check:(bool) y = true
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10
-// lldbr-check:(i32) x = 10
 // lldb-command:v y
 // lldbg-check:[...] true
-// lldbr-check:(bool) y = true
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10.5
-// lldbr-check:(f64) x = 10.5
 // lldb-command:v y
 // lldbg-check:[...] 20
-// lldbr-check:(i32) y = 20
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] true
-// lldbr-check:(bool) x = true
 // lldb-command:v y
 // lldbg-check:[...] 2220
-// lldbr-check:(i32) y = 2220
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 203203.5
-// lldbr-check:(f64) x = 203203.5
 // lldb-command:v y
 // lldbg-check:[...] 2220
-// lldbr-check:(i32) y = 2220
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10.5
-// lldbr-check:(f64) x = 10.5
 // lldb-command:v y
 // lldbg-check:[...] 20
-// lldbr-check:(i32) y = 20
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/packed-struct-with-destructor.rs b/tests/debuginfo/packed-struct-with-destructor.rs
index a7683781b7047..f715fdaea6fe5 100644
--- a/tests/debuginfo/packed-struct-with-destructor.rs
+++ b/tests/debuginfo/packed-struct-with-destructor.rs
@@ -36,35 +36,27 @@
 
 // lldb-command:v packed
 // lldbg-check:[...] { x = 123 y = 234 z = 345 }
-// lldbr-check:(packed_struct_with_destructor::Packed) packed = { x = 123 y = 234 z = 345 }
 
 // lldb-command:v packedInPacked
 // lldbg-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } }
-// lldbr-check:(packed_struct_with_destructor::PackedInPacked) packedInPacked = { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } }
 
 // lldb-command:v packedInUnpacked
 // lldbg-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } }
-// lldbr-check:(packed_struct_with_destructor::PackedInUnpacked) packedInUnpacked = { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } }
 
 // lldb-command:v unpackedInPacked
 // lldbg-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 } c = { x = 543 y = 432 z = 321 } d = 210 }
-// lldbr-check:(packed_struct_with_destructor::UnpackedInPacked) unpackedInPacked = { a = 987 b = { x = 876 y = 765 z = 654 } c = { x = 543 y = 432 z = 321 } d = 210 }
 
 // lldb-command:v packedInPackedWithDrop
 // lldbg-check:[...] { a = 11 b = { x = 22 y = 33 z = 44 } c = 55 d = { x = 66 y = 77 z = 88 } }
-// lldbr-check:(packed_struct_with_destructor::PackedInPackedWithDrop) packedInPackedWithDrop = { a = 11 b = { x = 22 y = 33 z = 44 } c = 55 d = { x = 66 y = 77 z = 88 } }
 
 // lldb-command:v packedInUnpackedWithDrop
 // lldbg-check:[...] { a = -11 b = { x = -22 y = -33 z = -44 } c = -55 d = { x = -66 y = -77 z = -88 } }
-// lldbr-check:(packed_struct_with_destructor::PackedInUnpackedWithDrop) packedInUnpackedWithDrop = { a = -11 b = { x = -22 y = -33 z = -44 } c = -55 d = { x = -66 y = -77 z = -88 } }
 
 // lldb-command:v unpackedInPackedWithDrop
 // lldbg-check:[...] { a = 98 b = { x = 87 y = 76 z = 65 } c = { x = 54 y = 43 z = 32 } d = 21 }
-// lldbr-check:(packed_struct_with_destructor::UnpackedInPackedWithDrop) unpackedInPackedWithDrop = { a = 98 b = { x = 87 y = 76 z = 65 } c = { x = 54 y = 43 z = 32 } d = 21 }
 
 // lldb-command:v deeplyNested
 // lldbg-check:[...] { a = { a = 1 b = { x = 2 y = 3 z = 4 } c = 5 d = { x = 6 y = 7 z = 8 } } b = { a = 9 b = { x = 10 y = 11 z = 12 } c = { x = 13 y = 14 z = 15 } d = 16 } c = { a = 17 b = { x = 18 y = 19 z = 20 } c = 21 d = { x = 22 y = 23 z = 24 } } d = { a = 25 b = { x = 26 y = 27 z = 28 } c = 29 d = { x = 30 y = 31 z = 32 } } e = { a = 33 b = { x = 34 y = 35 z = 36 } c = { x = 37 y = 38 z = 39 } d = 40 } f = { a = 41 b = { x = 42 y = 43 z = 44 } c = 45 d = { x = 46 y = 47 z = 48 } } }
-// lldbr-check:(packed_struct_with_destructor::DeeplyNested) deeplyNested = { a = { a = 1 b = { x = 2 y = 3 z = 4 } c = 5 d = { x = 6 y = 7 z = 8 } } b = { a = 9 b = { x = 10 y = 11 z = 12 } c = { x = 13 y = 14 z = 15 } d = 16 } c = { a = 17 b = { x = 18 y = 19 z = 20 } c = 21 d = { x = 22 y = 23 z = 24 } } d = { a = 25 b = { x = 26 y = 27 z = 28 } c = 29 d = { x = 30 y = 31 z = 32 } } e = { a = 33 b = { x = 34 y = 35 z = 36 } c = { x = 37 y = 38 z = 39 } d = 40 } f = { a = 41 b = { x = 42 y = 43 z = 44 } c = 45 d = { x = 46 y = 47 z = 48 } } }
 
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs
index 670482ef41e61..5f5233e3732de 100644
--- a/tests/debuginfo/packed-struct.rs
+++ b/tests/debuginfo/packed-struct.rs
@@ -29,27 +29,21 @@
 
 // lldb-command:v packed
 // lldbg-check:[...] { x = 123 y = 234 z = 345 }
-// lldbr-check:(packed_struct::Packed) packed = { x = 123 y = 234 z = 345 }
 
 // lldb-command:v packedInPacked
 // lldbg-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } }
-// lldbr-check:(packed_struct::PackedInPacked) packedInPacked = { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } }
 
 // lldb-command:v packedInUnpacked
 // lldbg-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } }
-// lldbr-check:(packed_struct::PackedInUnpacked) packedInUnpacked = { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } }
 
 // lldb-command:v unpackedInPacked
 // lldbg-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 w = 543 } c = { x = 432 y = 321 z = 210 w = 109 } d = -98 }
-// lldbr-check:(packed_struct::UnpackedInPacked) unpackedInPacked = { a = 987 b = { x = 876 y = 765 z = 654 w = 543 } c = { x = 432 y = 321 z = 210 w = 109 } d = -98 }
 
 // lldb-command:expr sizeof(packed)
 // lldbg-check:[...] 14
-// lldbr-check:(usize) [...] 14
 
 // lldb-command:expr sizeof(packedInPacked)
 // lldbg-check:[...] 40
-// lldbr-check:(usize) [...] 40
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs
index 14f64e83cffc5..2489d6d413621 100644
--- a/tests/debuginfo/pretty-std-collections.rs
+++ b/tests/debuginfo/pretty-std-collections.rs
@@ -53,19 +53,15 @@
 
 // lldb-command:v vec_deque
 // lldbg-check:[...] size=3 { [0] = 5 [1] = 3 [2] = 7 }
-// lldbr-check:(alloc::collections::vec_deque::VecDeque<i32>) vec_deque = size=3 = { [0] = 5 [1] = 3 [2] = 7 }
 
 // lldb-command:v vec_deque2
 // lldbg-check:[...] size=7 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 [4] = 6 [5] = 7 [6] = 8 }
-// lldbr-check:(alloc::collections::vec_deque::VecDeque<i32>) vec_deque2 = size=7 = { [0] = 2 [1] = 3 [2] = 4 [3] = 5 [4] = 6 [5] = 7 [6] = 8 }
 
 // lldb-command:v hash_map
 // lldbg-check:[...] size=4 { [0] = { 0 = 1 1 = 10 } [1] = { 0 = 2 1 = 20 } [2] = { 0 = 3 1 = 30 } [3] = { 0 = 4 1 = 40 } }
-// lldbr-check:(std::collections::hash::map::HashMap<u64, u64, [...]>) hash_map = size=4 size=4 { [0] = { 0 = 1 1 = 10 } [1] = { 0 = 2 1 = 20 } [2] = { 0 = 3 1 = 30 } [3] = { 0 = 4 1 = 40 } }
 
 // lldb-command:v hash_set
 // lldbg-check:[...] size=4 { [0] = 1 [1] = 2 [2] = 3 [3] = 4 }
-// lldbr-check:(std::collections::hash::set::HashSet<u64, [...]>) hash_set = size=4 { [0] = 1 [1] = 2 [2] = 3 [3] = 4 }
 
 #![allow(unused_variables)]
 use std::collections::BTreeMap;
diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs
index 514228c699810..3889c1f5ba8f4 100644
--- a/tests/debuginfo/reference-debuginfo.rs
+++ b/tests/debuginfo/reference-debuginfo.rs
@@ -61,66 +61,49 @@
 // lldb-command:run
 // lldb-command:v *bool_ref
 // lldbg-check:[...] true
-// lldbr-check:(bool) *bool_ref = true
 
 // lldb-command:v *int_ref
 // lldbg-check:[...] -1
-// lldbr-check:(isize) *int_ref = -1
 
-// lldbr-command:print *char_ref
-// lldbr-check:(char) *char_ref = 'a'
 
 // lldb-command:v *i8_ref
 // lldbg-check:[...] 'D'
-// lldbr-check:(i8) *i8_ref = 68
 
 // lldb-command:v *i16_ref
 // lldbg-check:[...] -16
-// lldbr-check:(i16) *i16_ref = -16
 
 // lldb-command:v *i32_ref
 // lldbg-check:[...] -32
-// lldbr-check:(i32) *i32_ref = -32
 
 // lldb-command:v *i64_ref
 // lldbg-check:[...] -64
-// lldbr-check:(i64) *i64_ref = -64
 
 // lldb-command:v *uint_ref
 // lldbg-check:[...] 1
-// lldbr-check:(usize) *uint_ref = 1
 
 // lldb-command:v *u8_ref
 // lldbg-check:[...] 'd'
-// lldbr-check:(u8) *u8_ref = 100
 
 // lldb-command:v *u16_ref
 // lldbg-check:[...] 16
-// lldbr-check:(u16) *u16_ref = 16
 
 // lldb-command:v *u32_ref
 // lldbg-check:[...] 32
-// lldbr-check:(u32) *u32_ref = 32
 
 // lldb-command:v *u64_ref
 // lldbg-check:[...] 64
-// lldbr-check:(u64) *u64_ref = 64
 
 // lldb-command:v *f16_ref
 // lldbg-check:[...] 1.5
-// lldbr-check:(f16) *f16_ref = 1.5
 
 // lldb-command:v *f32_ref
 // lldbg-check:[...] 2.5
-// lldbr-check:(f32) *f32_ref = 2.5
 
 // lldb-command:v *f64_ref
 // lldbg-check:[...] 3.5
-// lldbr-check:(f64) *f64_ref = 3.5
 
 // lldb-command:v *f64_double_ref
 // lldbg-check:[...] 3.5
-// lldbr-check:(f64) **f64_double_ref = 3.5
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/regression-bad-location-list-67992.rs b/tests/debuginfo/regression-bad-location-list-67992.rs
index fe410942d51ed..6502cce3700f9 100644
--- a/tests/debuginfo/regression-bad-location-list-67992.rs
+++ b/tests/debuginfo/regression-bad-location-list-67992.rs
@@ -12,7 +12,6 @@
 // lldb-command:run
 // lldb-command:v a
 // lldbg-check:(regression_bad_location_list_67992::Foo) [...]
-// lldbr-check:(regression_bad_location_list_67992::Foo) a = [...]
 
 const ARRAY_SIZE: usize = 1024;
 
diff --git a/tests/debuginfo/self-in-default-method.rs b/tests/debuginfo/self-in-default-method.rs
index 9507e2c04a251..8c607d0121059 100644
--- a/tests/debuginfo/self-in-default-method.rs
+++ b/tests/debuginfo/self-in-default-method.rs
@@ -57,61 +57,46 @@
 // STACK BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { x = 100 }
-// lldbr-check:(self_in_default_method::Struct) *self = Struct { x: 100 }
 // lldb-command:v arg1
 // lldbg-check:[...] -1
-// lldbr-check:(isize) arg1 = -1
 // lldb-command:v arg2
 // lldbg-check:[...] -2
-// lldbr-check:(isize) arg2 = -2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { x = 100 }
-// lldbr-check:(self_in_default_method::Struct) self = Struct { x: 100 }
 // lldb-command:v arg1
 // lldbg-check:[...] -3
-// lldbr-check:(isize) arg1 = -3
 // lldb-command:v arg2
 // lldbg-check:[...] -4
-// lldbr-check:(isize) arg2 = -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { x = 200 }
-// lldbr-check:(self_in_default_method::Struct) *self = Struct { x: 200 }
 // lldb-command:v arg1
 // lldbg-check:[...] -5
-// lldbr-check:(isize) arg1 = -5
 // lldb-command:v arg2
 // lldbg-check:[...] -6
-// lldbr-check:(isize) arg2 = -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { x = 200 }
-// lldbr-check:(self_in_default_method::Struct) self = Struct { x: 200 }
 // lldb-command:v arg1
 // lldbg-check:[...] -7
-// lldbr-check:(isize) arg1 = -7
 // lldb-command:v arg2
 // lldbg-check:[...] -8
-// lldbr-check:(isize) arg2 = -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
 // lldbg-check:[...] { x = 200 }
-// lldbr-check:(self_in_default_method::Struct) *self = Struct { x: 200 }
 // lldb-command:v arg1
 // lldbg-check:[...] -9
-// lldbr-check:(isize) arg1 = -9
 // lldb-command:v arg2
 // lldbg-check:[...] -10
-// lldbr-check:(isize) arg2 = -10
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/self-in-generic-default-method.rs b/tests/debuginfo/self-in-generic-default-method.rs
index 4cb68f6fed8df..71d1f2d52d265 100644
--- a/tests/debuginfo/self-in-generic-default-method.rs
+++ b/tests/debuginfo/self-in-generic-default-method.rs
@@ -57,61 +57,46 @@
 // STACK BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { x = 987 }
-// lldbr-check:(self_in_generic_default_method::Struct) *self = Struct { x: 987 }
 // lldb-command:v arg1
 // lldbg-check:[...] -1
-// lldbr-check:(isize) arg1 = -1
 // lldb-command:v arg2
 // lldbg-check:[...] 2
-// lldbr-check:(u16) arg2 = 2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { x = 987 }
-// lldbr-check:(self_in_generic_default_method::Struct) self = Struct { x: 987 }
 // lldb-command:v arg1
 // lldbg-check:[...] -3
-// lldbr-check:(isize) arg1 = -3
 // lldb-command:v arg2
 // lldbg-check:[...] -4
-// lldbr-check:(i16) arg2 = -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
 // lldbg-check:[...] { x = 879 }
-// lldbr-check:(self_in_generic_default_method::Struct) *self = Struct { x: 879 }
 // lldb-command:v arg1
 // lldbg-check:[...] -5
-// lldbr-check:(isize) arg1 = -5
 // lldb-command:v arg2
 // lldbg-check:[...] -6
-// lldbr-check:(i32) arg2 = -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
 // lldbg-check:[...] { x = 879 }
-// lldbr-check:(self_in_generic_default_method::Struct) self = Struct { x: 879 }
 // lldb-command:v arg1
 // lldbg-check:[...] -7
-// lldbr-check:(isize) arg1 = -7
 // lldb-command:v arg2
 // lldbg-check:[...] -8
-// lldbr-check:(i64) arg2 = -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
 // lldbg-check:[...] { x = 879 }
-// lldbr-check:(self_in_generic_default_method::Struct) *self = Struct { x: 879 }
 // lldb-command:v arg1
 // lldbg-check:[...] -9
-// lldbr-check:(isize) arg1 = -9
 // lldb-command:v arg2
 // lldbg-check:[...] -10.5
-// lldbr-check:(f32) arg2 = -10.5
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/shadowed-argument.rs b/tests/debuginfo/shadowed-argument.rs
index f85910652c8af..b4da794ef9557 100644
--- a/tests/debuginfo/shadowed-argument.rs
+++ b/tests/debuginfo/shadowed-argument.rs
@@ -29,26 +29,20 @@
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:v y
 // lldbg-check:[...] true
-// lldbr-check:(bool) y = true
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10
-// lldbr-check:(i32) x = 10
 // lldb-command:v y
 // lldbg-check:[...] true
-// lldbr-check:(bool) y = true
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10.5
-// lldbr-check:(f64) x = 10.5
 // lldb-command:v y
 // lldbg-check:[...] 20
-// lldbr-check:(i32) y = 20
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/shadowed-variable.rs b/tests/debuginfo/shadowed-variable.rs
index 87c85a9e1e263..cbbad4c2b7cb6 100644
--- a/tests/debuginfo/shadowed-variable.rs
+++ b/tests/debuginfo/shadowed-variable.rs
@@ -40,42 +40,32 @@
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:v y
 // lldbg-check:[...] true
-// lldbr-check:(bool) y = true
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10
-// lldbr-check:(i32) x = 10
 // lldb-command:v y
 // lldbg-check:[...] true
-// lldbr-check:(bool) y = true
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10.5
-// lldbr-check:(f64) x = 10.5
 // lldb-command:v y
 // lldbg-check:[...] 20
-// lldbr-check:(i32) y = 20
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10.5
-// lldbr-check:(f64) x = 10.5
 // lldb-command:v y
 // lldbg-check:[...] 20
-// lldbr-check:(i32) y = 20
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 11.5
-// lldbr-check:(f64) x = 11.5
 // lldb-command:v y
 // lldbg-check:[...] 20
-// lldbr-check:(i32) y = 20
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/simple-lexical-scope.rs b/tests/debuginfo/simple-lexical-scope.rs
index 148ad589deca5..82737b04b6447 100644
--- a/tests/debuginfo/simple-lexical-scope.rs
+++ b/tests/debuginfo/simple-lexical-scope.rs
@@ -39,37 +39,30 @@
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10
-// lldbr-check:(i32) x = 10
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10
-// lldbr-check:(i32) x = 10
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10.5
-// lldbr-check:(f64) x = 10.5
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] 10
-// lldbr-check:(i32) x = 10
 // lldb-command:continue
 
 // lldb-command:v x
 // lldbg-check:[...] false
-// lldbr-check:(bool) x = false
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs
index 65bfb84cdcd46..9fe4d3c8d3fac 100644
--- a/tests/debuginfo/simple-struct.rs
+++ b/tests/debuginfo/simple-struct.rs
@@ -66,27 +66,21 @@
 
 // lldb-command:v no_padding16
 // lldbg-check:[...] { x = 10000 y = -10001 }
-// lldbr-check:(simple_struct::NoPadding16) no_padding16 = { x = 10000 y = -10001 }
 
 // lldb-command:v no_padding32
 // lldbg-check:[...] { x = -10002 y = -10003.5 z = 10004 }
-// lldbr-check:(simple_struct::NoPadding32) no_padding32 = { x = -10002 y = -10003.5 z = 10004 }
 
 // lldb-command:v no_padding64
 // lldbg-check:[...] { x = -10005.5 y = 10006 z = 10007 }
-// lldbr-check:(simple_struct::NoPadding64) no_padding64 = { x = -10005.5 y = 10006 z = 10007 }
 
 // lldb-command:v no_padding163264
 // lldbg-check:[...] { a = -10008 b = 10009 c = 10010 d = 10011 }
-// lldbr-check:(simple_struct::NoPadding163264) no_padding163264 = { a = -10008 b = 10009 c = 10010 d = 10011 }
 
 // lldb-command:v internal_padding
 // lldbg-check:[...] { x = 10012 y = -10013 }
-// lldbr-check:(simple_struct::InternalPadding) internal_padding = { x = 10012 y = -10013 }
 
 // lldb-command:v padding_at_end
 // lldbg-check:[...] { x = -10014 y = 10015 }
-// lldbr-check:(simple_struct::PaddingAtEnd) padding_at_end = { x = -10014 y = 10015 }
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs
index 6dadf9236556a..f267fc7d8d94c 100644
--- a/tests/debuginfo/simple-tuple.rs
+++ b/tests/debuginfo/simple-tuple.rs
@@ -62,27 +62,20 @@
 
 // lldb-command:v/d noPadding8
 // lldbg-check:[...] { 0 = -100 1 = 100 }
-// lldbr-check:((i8, u8)) noPadding8 = { 0 = -100 1 = 100 }
 // lldb-command:v noPadding16
 // lldbg-check:[...] { 0 = 0 1 = 1 2 = 2 }
-// lldbr-check:((i16, i16, u16)) noPadding16 = { 0 = 0 1 = 1 2 = 2 }
 // lldb-command:v noPadding32
 // lldbg-check:[...] { 0 = 3 1 = 4.5 2 = 5 }
-// lldbr-check:((i32, f32, u32)) noPadding32 = { 0 = 3 1 = 4.5 2 = 5 }
 // lldb-command:v noPadding64
 // lldbg-check:[...] { 0 = 6 1 = 7.5 2 = 8 }
-// lldbr-check:((i64, f64, u64)) noPadding64 = { 0 = 6 1 = 7.5 2 = 8 }
 
 // lldb-command:v internalPadding1
 // lldbg-check:[...] { 0 = 9 1 = 10 }
-// lldbr-check:((i16, i32)) internalPadding1 = { 0 = 9 1 = 10 }
 // lldb-command:v internalPadding2
 // lldbg-check:[...] { 0 = 11 1 = 12 2 = 13 3 = 14 }
-// lldbr-check:((i16, i32, u32, u64)) internalPadding2 = { 0 = 11 1 = 12 2 = 13 3 = 14 }
 
 // lldb-command:v paddingAtEnd
 // lldbg-check:[...] { 0 = 15 1 = 16 }
-// lldbr-check:((i32, i16)) paddingAtEnd = { 0 = 15 1 = 16 }
 
 
 // === CDB TESTS ==================================================================================
diff --git a/tests/debuginfo/static-method-on-struct-and-enum.rs b/tests/debuginfo/static-method-on-struct-and-enum.rs
index defced1441caf..5d2932e378dfd 100644
--- a/tests/debuginfo/static-method-on-struct-and-enum.rs
+++ b/tests/debuginfo/static-method-on-struct-and-enum.rs
@@ -28,22 +28,17 @@
 // STRUCT
 // lldb-command:v arg1
 // lldbg-check:[...] 1
-// lldbr-check:(isize) arg1 = 1
 // lldb-command:v arg2
 // lldbg-check:[...] 2
-// lldbr-check:(isize) arg2 = 2
 // lldb-command:continue
 
 // ENUM
 // lldb-command:v arg1
 // lldbg-check:[...] -3
-// lldbr-check:(isize) arg1 = -3
 // lldb-command:v arg2
 // lldbg-check:[...] 4.5
-// lldbr-check:(f64) arg2 = 4.5
 // lldb-command:v arg3
 // lldbg-check:[...] 5
-// lldbr-check:(usize) arg3 = 5
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/struct-in-struct.rs b/tests/debuginfo/struct-in-struct.rs
index 2e32633fa87e6..5dde8079f9aa2 100644
--- a/tests/debuginfo/struct-in-struct.rs
+++ b/tests/debuginfo/struct-in-struct.rs
@@ -20,35 +20,27 @@
 
 // lldb-command:v three_simple_structs
 // lldbg-check:[...] { x = { x = 1 } y = { x = 2 } z = { x = 3 } }
-// lldbr-check:(struct_in_struct::ThreeSimpleStructs) three_simple_structs = { x = { x = 1 } y = { x = 2 } z = { x = 3 } }
 
 // lldb-command:v internal_padding_parent
 // lldbg-check:[...] { x = { x = 4 y = 5 } y = { x = 6 y = 7 } z = { x = 8 y = 9 } }
-// lldbr-check:(struct_in_struct::InternalPaddingParent) internal_padding_parent = { x = { x = 4 y = 5 } y = { x = 6 y = 7 } z = { x = 8 y = 9 } }
 
 // lldb-command:v padding_at_end_parent
 // lldbg-check:[...] { x = { x = 10 y = 11 } y = { x = 12 y = 13 } z = { x = 14 y = 15 } }
-// lldbr-check:(struct_in_struct::PaddingAtEndParent) padding_at_end_parent = { x = { x = 10 y = 11 } y = { x = 12 y = 13 } z = { x = 14 y = 15 } }
 
 // lldb-command:v mixed
 // lldbg-check:[...] { x = { x = 16 y = 17 } y = { x = 18 y = 19 } z = { x = 20 } w = 21 }
-// lldbr-check:(struct_in_struct::Mixed) mixed = { x = { x = 16 y = 17 } y = { x = 18 y = 19 } z = { x = 20 } w = 21 }
 
 // lldb-command:v bag
 // lldbg-check:[...] { x = { x = 22 } }
-// lldbr-check:(struct_in_struct::Bag) bag = { x = { x = 22 } }
 
 // lldb-command:v bag_in_bag
 // lldbg-check:[...] { x = { x = { x = 23 } } }
-// lldbr-check:(struct_in_struct::BagInBag) bag_in_bag = { x = { x = { x = 23 } } }
 
 // lldb-command:v tjo
 // lldbg-check:[...] { x = { x = { x = { x = 24 } } } }
-// lldbr-check:(struct_in_struct::ThatsJustOverkill) tjo = { x = { x = { x = { x = 24 } } } }
 
 // lldb-command:v tree
 // lldbg-check:[...] { x = { x = 25 } y = { x = { x = 26 y = 27 } y = { x = 28 y = 29 } z = { x = 30 y = 31 } } z = { x = { x = { x = 32 } } } }
-// lldbr-check:(struct_in_struct::Tree) tree = { x = { x = 25 } y = { x = { x = 26 y = 27 } y = { x = 28 y = 29 } z = { x = 30 y = 31 } } z = { x = { x = { x = 32 } } } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/struct-namespace.rs b/tests/debuginfo/struct-namespace.rs
index 83f2962140aa1..aacc1d3825d74 100644
--- a/tests/debuginfo/struct-namespace.rs
+++ b/tests/debuginfo/struct-namespace.rs
@@ -6,17 +6,13 @@
 // lldb-command:run
 // lldb-command:v struct1
 // lldbg-check:(struct_namespace::Struct1)[...]
-// lldbr-check:(struct_namespace::Struct1) struct1 = Struct1 { a: 0, b: 1 }
 // lldb-command:v struct2
 // lldbg-check:(struct_namespace::Struct2)[...]
-// lldbr-check:(struct_namespace::Struct2) struct2 = { = 2 }
 
 // lldb-command:v mod1_struct1
 // lldbg-check:(struct_namespace::mod1::Struct1)[...]
-// lldbr-check:(struct_namespace::mod1::Struct1) mod1_struct1 = Struct1 { a: 3, b: 4 }
 // lldb-command:v mod1_struct2
 // lldbg-check:(struct_namespace::mod1::Struct2)[...]
-// lldbr-check:(struct_namespace::mod1::Struct2) mod1_struct2 = { = 5 }
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
diff --git a/tests/debuginfo/struct-style-enum.rs b/tests/debuginfo/struct-style-enum.rs
index c3cfb29994e74..c2f7fb688ed21 100644
--- a/tests/debuginfo/struct-style-enum.rs
+++ b/tests/debuginfo/struct-style-enum.rs
@@ -25,19 +25,15 @@
 
 // lldb-command:v case1
 // lldbg-check:(struct_style_enum::Regular) case1 = { value = { a = 0 b = 31868 c = 31868 d = 31868 e = 31868 } $discr$ = 0 }
-// lldbr-check:(struct_style_enum::Regular::Case1) case1 = { a = 0 b = 31868 c = 31868 d = 31868 e = 31868 }
 
 // lldb-command:v case2
 // lldbg-check:(struct_style_enum::Regular) case2 = { value = { a = 0 b = 286331153 c = 286331153 } $discr$ = 1 }
-// lldbr-check:(struct_style_enum::Regular::Case2) case2 = Case2 { Case1: 0, Case2: 286331153, Case3: 286331153 }
 
 // lldb-command:v case3
 // lldbg-check:(struct_style_enum::Regular) case3 = { value = { a = 0 b = 6438275382588823897 } $discr$ = 2 }
-// lldbr-check:(struct_style_enum::Regular::Case3) case3 = Case3 { Case1: 0, Case2: 6438275382588823897 }
 
 // lldb-command:v univariant
 // lldbg-check:(struct_style_enum::Univariant) univariant = { value = { a = -1 } }
-// lldbr-check:(struct_style_enum::Univariant) univariant = Univariant { TheOnlyCase: TheOnlyCase { a: -1 } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/struct-with-destructor.rs b/tests/debuginfo/struct-with-destructor.rs
index 05a4b7572831e..654a574ebb5e5 100644
--- a/tests/debuginfo/struct-with-destructor.rs
+++ b/tests/debuginfo/struct-with-destructor.rs
@@ -21,19 +21,15 @@
 // lldb-command:run
 // lldb-command:v simple
 // lldbg-check:[...] { x = 10 y = 20 }
-// lldbr-check:(struct_with_destructor::WithDestructor) simple = { x = 10 y = 20 }
 
 // lldb-command:v noDestructor
 // lldbg-check:[...] { a = { x = 10 y = 20 } guard = -1 }
-// lldbr-check:(struct_with_destructor::NoDestructorGuarded) noDestructor = { a = { x = 10 y = 20 } guard = -1 }
 
 // lldb-command:v withDestructor
 // lldbg-check:[...] { a = { x = 10 y = 20 } guard = -1 }
-// lldbr-check:(struct_with_destructor::WithDestructorGuarded) withDestructor = { a = { x = 10 y = 20 } guard = -1 }
 
 // lldb-command:v nested
 // lldbg-check:[...] { a = { a = { x = 7890 y = 9870 } } }
-// lldbr-check:(struct_with_destructor::NestedOuter) nested = { a = { a = { x = 7890 y = 9870 } } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/tuple-in-tuple.rs b/tests/debuginfo/tuple-in-tuple.rs
index 0d7ffc6347016..74ccaf14d00b1 100644
--- a/tests/debuginfo/tuple-in-tuple.rs
+++ b/tests/debuginfo/tuple-in-tuple.rs
@@ -28,27 +28,20 @@
 
 // lldb-command:v no_padding1
 // lldbg-check:[...] { 0 = { 0 = 0 1 = 1 } 1 = 2 2 = 3 }
-// lldbr-check:(((u32, u32), u32, u32)) no_padding1 = { 0 = { 0 = 0 1 = 1 } 1 = 2 2 = 3 }
 // lldb-command:v no_padding2
 // lldbg-check:[...] { 0 = 4 1 = { 0 = 5 1 = 6 } 2 = 7 }
-// lldbr-check:((u32, (u32, u32), u32)) no_padding2 = { 0 = 4 1 = { 0 = 5 1 = 6 } 2 = 7 }
 // lldb-command:v no_padding3
 // lldbg-check:[...] { 0 = 8 1 = 9 2 = { 0 = 10 1 = 11 } }
-// lldbr-check:((u32, u32, (u32, u32))) no_padding3 = { 0 = 8 1 = 9 2 = { 0 = 10 1 = 11 } }
 
 // lldb-command:v internal_padding1
 // lldbg-check:[...] { 0 = 12 1 = { 0 = 13 1 = 14 } }
-// lldbr-check:((i16, (i32, i32))) internal_padding1 = { 0 = 12 1 = { 0 = 13 1 = 14 } }
 // lldb-command:v internal_padding2
 // lldbg-check:[...] { 0 = 15 1 = { 0 = 16 1 = 17 } }
-// lldbr-check:((i16, (i16, i32))) internal_padding2 = { 0 = 15 1 = { 0 = 16 1 = 17 } }
 
 // lldb-command:v padding_at_end1
 // lldbg-check:[...] { 0 = 18 1 = { 0 = 19 1 = 20 } }
-// lldbr-check:((i32, (i32, i16))) padding_at_end1 = { 0 = 18 1 = { 0 = 19 1 = 20 } }
 // lldb-command:v padding_at_end2
 // lldbg-check:[...] { 0 = { 0 = 21 1 = 22 } 1 = 23 }
-// lldbr-check:(((i32, i16), i32)) padding_at_end2 = { 0 = { 0 = 21 1 = 22 } 1 = 23 }
 
 
 // === CDB TESTS ==================================================================================
diff --git a/tests/debuginfo/tuple-struct.rs b/tests/debuginfo/tuple-struct.rs
index abfbfac22eb88..f9755a8a0d5bd 100644
--- a/tests/debuginfo/tuple-struct.rs
+++ b/tests/debuginfo/tuple-struct.rs
@@ -29,27 +29,21 @@
 
 // lldb-command:v no_padding16
 // lldbg-check:[...] { 0 = 10000 1 = -10001 }
-// lldbr-check:(tuple_struct::NoPadding16) no_padding16 = { 0 = 10000 1 = -10001 }
 
 // lldb-command:v no_padding32
 // lldbg-check:[...] { 0 = -10002 1 = -10003.5 2 = 10004 }
-// lldbr-check:(tuple_struct::NoPadding32) no_padding32 = { 0 = -10002 1 = -10003.5 2 = 10004 }
 
 // lldb-command:v no_padding64
 // lldbg-check:[...] { 0 = -10005.5 1 = 10006 2 = 10007 }
-// lldbr-check:(tuple_struct::NoPadding64) no_padding64 = { 0 = -10005.5 1 = 10006 2 = 10007 }
 
 // lldb-command:v no_padding163264
 // lldbg-check:[...] { 0 = -10008 1 = 10009 2 = 10010 3 = 10011 }
-// lldbr-check:(tuple_struct::NoPadding163264) no_padding163264 = { 0 = -10008 1 = 10009 2 = 10010 3 = 10011 }
 
 // lldb-command:v internal_padding
 // lldbg-check:[...] { 0 = 10012 1 = -10013 }
-// lldbr-check:(tuple_struct::InternalPadding) internal_padding = { 0 = 10012 1 = -10013 }
 
 // lldb-command:v padding_at_end
 // lldbg-check:[...] { 0 = -10014 1 = 10015 }
-// lldbr-check:(tuple_struct::PaddingAtEnd) padding_at_end = { 0 = -10014 1 = 10015 }
 
 // This test case mainly makes sure that no field names are generated for tuple structs (as opposed
 // to all fields having the name "<unnamed_field>"). Otherwise they are handled the same a normal
diff --git a/tests/debuginfo/tuple-style-enum.rs b/tests/debuginfo/tuple-style-enum.rs
index 2a11bfe70656b..efdf8c6970e25 100644
--- a/tests/debuginfo/tuple-style-enum.rs
+++ b/tests/debuginfo/tuple-style-enum.rs
@@ -26,19 +26,15 @@
 
 // lldb-command:v case1
 // lldbg-check:(tuple_style_enum::Regular) case1 = { value = { 0 = 0 1 = 31868 2 = 31868 3 = 31868 4 = 31868 } $discr$ = 0 }
-// lldbr-check:(tuple_style_enum::Regular::Case1) case1 = { = 0 = 31868 = 31868 = 31868 = 31868 }
 
 // lldb-command:v case2
 // lldbg-check:(tuple_style_enum::Regular) case2 = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 }
-// lldbr-check:(tuple_style_enum::Regular::Case2) case2 = Case2 { Case1: 0, Case2: 286331153, Case3: 286331153 }
 
 // lldb-command:v case3
 // lldbg-check:(tuple_style_enum::Regular) case3 = { value = { 0 = 0 1 = 6438275382588823897 } $discr$ = 2 }
-// lldbr-check:(tuple_style_enum::Regular::Case3) case3 = Case3 { Case1: 0, Case2: 6438275382588823897 }
 
 // lldb-command:v univariant
 // lldbg-check:(tuple_style_enum::Univariant) univariant = { value = { 0 = -1 } }
-// lldbr-check:(tuple_style_enum::Univariant) univariant = { TheOnlyCase = { = -1 } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs
index 41bd81c9e8ae6..73617df10b137 100644
--- a/tests/debuginfo/union-smoke.rs
+++ b/tests/debuginfo/union-smoke.rs
@@ -13,7 +13,6 @@
 // lldb-command:run
 // lldb-command:v u
 // lldbg-check:[...] { a = { 0 = '\x02' 1 = '\x02' } b = 514 }
-// lldbr-check:(union_smoke::U) u = { a = { 0 = '\x02' 1 = '\x02' } b = 514 }
 
 // lldbg-command:print union_smoke::SU
 // lldbg-check:[...] { a = { 0 = '\x01' 1 = '\x01' } b = 257 }
diff --git a/tests/debuginfo/unique-enum.rs b/tests/debuginfo/unique-enum.rs
index 6990f18788c7d..b9ee480c851a5 100644
--- a/tests/debuginfo/unique-enum.rs
+++ b/tests/debuginfo/unique-enum.rs
@@ -22,15 +22,12 @@
 
 // lldb-command:v *the_a
 // lldbg-check:(unique_enum::ABC) *the_a = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 }
-// lldbr-check:(unique_enum::ABC::TheA) *the_a = TheA { TheA: 0, TheB: 8970181431921507452 }
 
 // lldb-command:v *the_b
 // lldbg-check:(unique_enum::ABC) *the_b = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 }
-// lldbr-check:(unique_enum::ABC::TheB) *the_b = { = 0 = 286331153 = 286331153 }
 
 // lldb-command:v *univariant
 // lldbg-check:(unique_enum::Univariant) *univariant = { value = { 0 = 123234 } }
-// lldbr-check:(unique_enum::Univariant) *univariant = { TheOnlyCase = { = 123234 } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/var-captured-in-nested-closure.rs b/tests/debuginfo/var-captured-in-nested-closure.rs
index bed2a57e1f9e9..0f544c24b5bcf 100644
--- a/tests/debuginfo/var-captured-in-nested-closure.rs
+++ b/tests/debuginfo/var-captured-in-nested-closure.rs
@@ -39,42 +39,30 @@
 
 // lldb-command:v variable
 // lldbg-check:[...] 1
-// lldbr-check:(isize) variable = 1
 // lldb-command:v constant
 // lldbg-check:[...] 2
-// lldbr-check:(isize) constant = 2
 // lldb-command:v a_struct
 // lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
-// lldbr-check:(var_captured_in_nested_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *struct_ref
 // lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
-// lldbr-check:(var_captured_in_nested_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *owned
 // lldbg-check:[...] 6
-// lldbr-check:(isize) *owned = 6
 // lldb-command:v closure_local
 // lldbg-check:[...] 8
-// lldbr-check:(isize) closure_local = 8
 // lldb-command:continue
 
 // lldb-command:v variable
 // lldbg-check:[...] 1
-// lldbr-check:(isize) variable = 1
 // lldb-command:v constant
 // lldbg-check:[...] 2
-// lldbr-check:(isize) constant = 2
 // lldb-command:v a_struct
 // lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
-// lldbr-check:(var_captured_in_nested_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *struct_ref
 // lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
-// lldbr-check:(var_captured_in_nested_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *owned
 // lldbg-check:[...] 6
-// lldbr-check:(isize) *owned = 6
 // lldb-command:v closure_local
 // lldbg-check:[...] 8
-// lldbr-check:(isize) closure_local = 8
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/var-captured-in-sendable-closure.rs b/tests/debuginfo/var-captured-in-sendable-closure.rs
index 59909b758266d..2d9e60744739b 100644
--- a/tests/debuginfo/var-captured-in-sendable-closure.rs
+++ b/tests/debuginfo/var-captured-in-sendable-closure.rs
@@ -22,13 +22,10 @@
 
 // lldb-command:v constant
 // lldbg-check:[...] 1
-// lldbr-check:(isize) constant = 1
 // lldb-command:v a_struct
 // lldbg-check:[...] { a = -2 b = 3.5 c = 4 }
-// lldbr-check:(var_captured_in_sendable_closure::Struct) a_struct = { a = -2 b = 3.5 c = 4 }
 // lldb-command:v *owned
 // lldbg-check:[...] 5
-// lldbr-check:(isize) *owned = 5
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/var-captured-in-stack-closure.rs b/tests/debuginfo/var-captured-in-stack-closure.rs
index 5ac804464333c..d6c4b11b5f2c8 100644
--- a/tests/debuginfo/var-captured-in-stack-closure.rs
+++ b/tests/debuginfo/var-captured-in-stack-closure.rs
@@ -35,37 +35,27 @@
 
 // lldb-command:v variable
 // lldbg-check:[...] 1
-// lldbr-check:(isize) variable = 1
 // lldb-command:v constant
 // lldbg-check:[...] 2
-// lldbr-check:(isize) constant = 2
 // lldb-command:v a_struct
 // lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
-// lldbr-check:(var_captured_in_stack_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *struct_ref
 // lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
-// lldbr-check:(var_captured_in_stack_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *owned
 // lldbg-check:[...] 6
-// lldbr-check:(isize) *owned = 6
 
 // lldb-command:continue
 
 // lldb-command:v variable
 // lldbg-check:[...] 2
-// lldbr-check:(isize) variable = 2
 // lldb-command:v constant
 // lldbg-check:[...] 2
-// lldbr-check:(isize) constant = 2
 // lldb-command:v a_struct
 // lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
-// lldbr-check:(var_captured_in_stack_closure::Struct) a_struct = { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *struct_ref
 // lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
-// lldbr-check:(var_captured_in_stack_closure::Struct) *struct_ref = { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *owned
 // lldbg-check:[...] 6
-// lldbr-check:(isize) *owned = 6
 
 
 // === CDB TESTS ===================================================================================
diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs
index a846316852800..77d7b90ca0b5a 100644
--- a/tests/debuginfo/vec-slices.rs
+++ b/tests/debuginfo/vec-slices.rs
@@ -54,27 +54,21 @@
 
 // lldb-command:v empty
 // lldbg-check:[...] size=0
-// lldbr-check:(&[i64]) empty = size=0
 
 // lldb-command:v singleton
 // lldbg-check:[...] size=1 { [0] = 1 }
-// lldbr-check:(&[i64]) singleton = &[1]
 
 // lldb-command:v multiple
 // lldbg-check:[...] size=4 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 }
-// lldbr-check:(&[i64]) multiple = size=4 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 }
 
 // lldb-command:v slice_of_slice
 // lldbg-check:[...] size=2 { [0] = 3 [1] = 4 }
-// lldbr-check:(&[i64]) slice_of_slice = size=2 { [0] = 3 [1] = 4 }
 
 // lldb-command:v padded_tuple
 // lldbg-check:[...] size=2 { [0] = { 0 = 6 1 = 7 } [1] = { 0 = 8 1 = 9 } }
-// lldbr-check:(&[(i32, i16)]) padded_tuple = size=2 { [0] = { 0 = 6 1 = 7 } [1] = { 0 = 8 1 = 9 } }
 
 // lldb-command:v padded_struct
 // lldbg-check:[...] size=2 { [0] = { x = 10 y = 11 z = 12 } [1] = { x = 13 y = 14 z = 15 } }
-// lldbr-check:(&[vec_slices::AStruct]) padded_struct = size=2 { [0] = { x = 10 y = 11 z = 12 } [1] = { x = 13 y = 14 z = 15 } }
 
 #![allow(dead_code, unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs
index 24b7ae9c39427..3bb84d485730b 100644
--- a/tests/debuginfo/vec.rs
+++ b/tests/debuginfo/vec.rs
@@ -14,7 +14,6 @@
 // lldb-command:run
 // lldb-command:v a
 // lldbg-check:[...] { [0] = 1 [1] = 2 [2] = 3 }
-// lldbr-check:([i32; 3]) a = { [0] = 1 [1] = 2 [2] = 3 }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]

From 22ed23d680fbb50c90992b03e50968e7bce6f373 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 18 Aug 2024 17:00:33 -0400
Subject: [PATCH 421/685] Convert lldbg- to lldb-

---
 tests/debuginfo/associated-types.rs           | 18 ++--
 tests/debuginfo/basic-types.rs                | 26 ++---
 tests/debuginfo/borrowed-basic.rs             | 28 +++---
 tests/debuginfo/borrowed-c-style-enum.rs      |  6 +-
 tests/debuginfo/borrowed-enum.rs              |  6 +-
 tests/debuginfo/borrowed-struct.rs            | 14 +--
 tests/debuginfo/borrowed-tuple.rs             |  6 +-
 tests/debuginfo/borrowed-unique-basic.rs      | 28 +++---
 tests/debuginfo/box.rs                        |  4 +-
 tests/debuginfo/boxed-struct.rs               |  4 +-
 .../by-value-self-argument-in-trait-impl.rs   |  6 +-
 tests/debuginfo/c-style-enum-in-composite.rs  | 14 +--
 tests/debuginfo/c-style-enum.rs               | 14 +--
 tests/debuginfo/captured-fields-1.rs          | 12 +--
 tests/debuginfo/captured-fields-2.rs          |  4 +-
 .../debuginfo/closure-in-generic-function.rs  |  8 +-
 tests/debuginfo/cross-crate-spans.rs          | 12 +--
 tests/debuginfo/destructured-fn-argument.rs   | 98 +++++++++----------
 .../destructured-for-loop-variable.rs         | 48 ++++-----
 tests/debuginfo/destructured-local.rs         | 86 ++++++++--------
 tests/debuginfo/enum-thinlto.rs               |  2 +-
 tests/debuginfo/evec-in-struct.rs             | 10 +-
 tests/debuginfo/extern-c-fn.rs                |  8 +-
 tests/debuginfo/function-arguments.rs         |  8 +-
 tests/debuginfo/generic-function.rs           | 12 +--
 tests/debuginfo/generic-functions-nested.rs   | 16 +--
 .../generic-method-on-generic-struct.rs       | 30 +++---
 tests/debuginfo/generic-struct.rs             |  8 +-
 tests/debuginfo/include_string.rs             |  6 +-
 tests/debuginfo/issue-22656.rs                |  4 +-
 tests/debuginfo/issue-57822.rs                |  4 +-
 tests/debuginfo/lexical-scope-in-for-loop.rs  | 14 +--
 tests/debuginfo/lexical-scope-in-if.rs        | 32 +++---
 tests/debuginfo/lexical-scope-in-match.rs     | 36 +++----
 .../lexical-scope-in-stack-closure.rs         | 12 +--
 .../lexical-scope-in-unconditional-loop.rs    | 26 ++---
 .../lexical-scope-in-unique-closure.rs        | 12 +--
 tests/debuginfo/lexical-scope-in-while.rs     | 26 ++---
 tests/debuginfo/lexical-scope-with-macro.rs   | 54 +++++-----
 .../lexical-scopes-in-block-expression.rs     | 96 +++++++++---------
 tests/debuginfo/method-on-generic-struct.rs   | 30 +++---
 tests/debuginfo/method-on-struct.rs           | 30 +++---
 tests/debuginfo/method-on-trait.rs            | 30 +++---
 tests/debuginfo/method-on-tuple-struct.rs     | 30 +++---
 tests/debuginfo/msvc-pretty-enums.rs          | 44 ++++-----
 tests/debuginfo/multi-cgu.rs                  |  4 +-
 .../multiple-functions-equal-var-names.rs     |  6 +-
 tests/debuginfo/multiple-functions.rs         |  6 +-
 .../name-shadowing-and-scope-nesting.rs       | 24 ++---
 .../packed-struct-with-destructor.rs          | 16 +--
 tests/debuginfo/packed-struct.rs              | 12 +--
 tests/debuginfo/pretty-std-collections.rs     |  8 +-
 tests/debuginfo/reference-debuginfo.rs        | 30 +++---
 .../regression-bad-location-list-67992.rs     |  2 +-
 tests/debuginfo/self-in-default-method.rs     | 30 +++---
 .../self-in-generic-default-method.rs         | 30 +++---
 tests/debuginfo/shadowed-argument.rs          | 12 +--
 tests/debuginfo/shadowed-variable.rs          | 20 ++--
 tests/debuginfo/simple-lexical-scope.rs       | 14 +--
 tests/debuginfo/simple-struct.rs              | 12 +--
 tests/debuginfo/simple-tuple.rs               | 14 +--
 .../static-method-on-struct-and-enum.rs       | 10 +-
 tests/debuginfo/strings-and-strs.rs           | 10 +-
 tests/debuginfo/struct-in-struct.rs           | 16 +--
 tests/debuginfo/struct-namespace.rs           |  8 +-
 tests/debuginfo/struct-style-enum.rs          |  8 +-
 tests/debuginfo/struct-with-destructor.rs     |  8 +-
 tests/debuginfo/tuple-in-tuple.rs             | 14 +--
 tests/debuginfo/tuple-struct.rs               | 12 +--
 tests/debuginfo/tuple-style-enum.rs           |  8 +-
 tests/debuginfo/union-smoke.rs                |  6 +-
 tests/debuginfo/unique-enum.rs                |  6 +-
 .../var-captured-in-nested-closure.rs         | 24 ++---
 .../var-captured-in-sendable-closure.rs       |  6 +-
 .../var-captured-in-stack-closure.rs          | 20 ++--
 tests/debuginfo/vec-slices.rs                 | 12 +--
 tests/debuginfo/vec.rs                        |  2 +-
 77 files changed, 716 insertions(+), 716 deletions(-)

diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs
index 54ea047d36c42..95e7421047292 100644
--- a/tests/debuginfo/associated-types.rs
+++ b/tests/debuginfo/associated-types.rs
@@ -37,33 +37,33 @@
 // lldb-command:run
 
 // lldb-command:v arg
-// lldbg-check:[...] { b = -1, b1 = 0 }
+// lldb-check:[...] { b = -1, b1 = 0 }
 // lldb-command:continue
 
 // lldb-command:v inferred
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v explicitly
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:continue
 
 // lldb-command:v arg
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:continue
 
 // lldb-command:v arg
-// lldbg-check:[...] (4, 5)
+// lldb-check:[...] (4, 5)
 // lldb-command:continue
 
 // lldb-command:v a
-// lldbg-check:[...] 6
+// lldb-check:[...] 6
 // lldb-command:v b
-// lldbg-check:[...] 7
+// lldb-check:[...] 7
 // lldb-command:continue
 
 // lldb-command:v a
-// lldbg-check:[...] 8
+// lldb-check:[...] 8
 // lldb-command:v b
-// lldbg-check:[...] 9
+// lldb-check:[...] 9
 // lldb-command:continue
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/basic-types.rs b/tests/debuginfo/basic-types.rs
index 656c49ee001b6..fea5262bc41da 100644
--- a/tests/debuginfo/basic-types.rs
+++ b/tests/debuginfo/basic-types.rs
@@ -46,32 +46,32 @@
 
 // lldb-command:run
 // lldb-command:v b
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:v i
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 
 // lldb-command:v i8
-// lldbg-check:[...] 'D'
+// lldb-check:[...] 'D'
 // lldb-command:v i16
-// lldbg-check:[...] -16
+// lldb-check:[...] -16
 // lldb-command:v i32
-// lldbg-check:[...] -32
+// lldb-check:[...] -32
 // lldb-command:v i64
-// lldbg-check:[...] -64
+// lldb-check:[...] -64
 // lldb-command:v u
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v u8
-// lldbg-check:[...] 'd'
+// lldb-check:[...] 'd'
 // lldb-command:v u16
-// lldbg-check:[...] 16
+// lldb-check:[...] 16
 // lldb-command:v u32
-// lldbg-check:[...] 32
+// lldb-check:[...] 32
 // lldb-command:v u64
-// lldbg-check:[...] 64
+// lldb-check:[...] 64
 // lldb-command:v f32
-// lldbg-check:[...] 2.5
+// lldb-check:[...] 2.5
 // lldb-command:v f64
-// lldbg-check:[...] 3.5
+// lldb-check:[...] 3.5
 
 // === CDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/borrowed-basic.rs b/tests/debuginfo/borrowed-basic.rs
index e51f5912fc213..91de691e78e13 100644
--- a/tests/debuginfo/borrowed-basic.rs
+++ b/tests/debuginfo/borrowed-basic.rs
@@ -53,47 +53,47 @@
 
 // lldb-command:run
 // lldb-command:v *bool_ref
-// lldbg-check:[...] true
+// lldb-check:[...] true
 
 // lldb-command:v *int_ref
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 
 
 // lldb-command:v *i8_ref
-// lldbg-check:[...] 'D'
+// lldb-check:[...] 'D'
 
 // lldb-command:v *i16_ref
-// lldbg-check:[...] -16
+// lldb-check:[...] -16
 
 // lldb-command:v *i32_ref
-// lldbg-check:[...] -32
+// lldb-check:[...] -32
 
 // lldb-command:v *i64_ref
-// lldbg-check:[...] -64
+// lldb-check:[...] -64
 
 // lldb-command:v *uint_ref
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 
 // lldb-command:v *u8_ref
-// lldbg-check:[...] 'd'
+// lldb-check:[...] 'd'
 
 // lldb-command:v *u16_ref
-// lldbg-check:[...] 16
+// lldb-check:[...] 16
 
 // lldb-command:v *u32_ref
-// lldbg-check:[...] 32
+// lldb-check:[...] 32
 
 // lldb-command:v *u64_ref
-// lldbg-check:[...] 64
+// lldb-check:[...] 64
 
 // lldb-command:v *f16_ref
-// lldbg-check:[...] 1.5
+// lldb-check:[...] 1.5
 
 // lldb-command:v *f32_ref
-// lldbg-check:[...] 2.5
+// lldb-check:[...] 2.5
 
 // lldb-command:v *f64_ref
-// lldbg-check:[...] 3.5
+// lldb-check:[...] 3.5
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/borrowed-c-style-enum.rs b/tests/debuginfo/borrowed-c-style-enum.rs
index 6d771cf679277..6a91d4f965045 100644
--- a/tests/debuginfo/borrowed-c-style-enum.rs
+++ b/tests/debuginfo/borrowed-c-style-enum.rs
@@ -19,13 +19,13 @@
 // lldb-command:run
 
 // lldb-command:v *the_a_ref
-// lldbg-check:[...] TheA
+// lldb-check:[...] TheA
 
 // lldb-command:v *the_b_ref
-// lldbg-check:[...] TheB
+// lldb-check:[...] TheB
 
 // lldb-command:v *the_c_ref
-// lldbg-check:[...] TheC
+// lldb-check:[...] TheC
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/borrowed-enum.rs b/tests/debuginfo/borrowed-enum.rs
index 8782e28e4ec10..c5a795fdede66 100644
--- a/tests/debuginfo/borrowed-enum.rs
+++ b/tests/debuginfo/borrowed-enum.rs
@@ -21,11 +21,11 @@
 // lldb-command:run
 
 // lldb-command:v *the_a_ref
-// lldbg-check:(borrowed_enum::ABC) *the_a_ref = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 }
+// lldb-check:(borrowed_enum::ABC) *the_a_ref = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 }
 // lldb-command:v *the_b_ref
-// lldbg-check:(borrowed_enum::ABC) *the_b_ref = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 }
+// lldb-check:(borrowed_enum::ABC) *the_b_ref = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 }
 // lldb-command:v *univariant_ref
-// lldbg-check:(borrowed_enum::Univariant) *univariant_ref = { value = { 0 = 4820353753753434 } }
+// lldb-check:(borrowed_enum::Univariant) *univariant_ref = { value = { 0 = 4820353753753434 } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/borrowed-struct.rs b/tests/debuginfo/borrowed-struct.rs
index e9b751465629c..245af35f50554 100644
--- a/tests/debuginfo/borrowed-struct.rs
+++ b/tests/debuginfo/borrowed-struct.rs
@@ -31,25 +31,25 @@
 // lldb-command:run
 
 // lldb-command:v *stack_val_ref
-// lldbg-check:[...] { x = 10 y = 23.5 }
+// lldb-check:[...] { x = 10 y = 23.5 }
 
 // lldb-command:v *stack_val_interior_ref_1
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 
 // lldb-command:v *stack_val_interior_ref_2
-// lldbg-check:[...] 23.5
+// lldb-check:[...] 23.5
 
 // lldb-command:v *ref_to_unnamed
-// lldbg-check:[...] { x = 11 y = 24.5 }
+// lldb-check:[...] { x = 11 y = 24.5 }
 
 // lldb-command:v *unique_val_ref
-// lldbg-check:[...] { x = 13 y = 26.5 }
+// lldb-check:[...] { x = 13 y = 26.5 }
 
 // lldb-command:v *unique_val_interior_ref_1
-// lldbg-check:[...] 13
+// lldb-check:[...] 13
 
 // lldb-command:v *unique_val_interior_ref_2
-// lldbg-check:[...] 26.5
+// lldb-check:[...] 26.5
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/borrowed-tuple.rs b/tests/debuginfo/borrowed-tuple.rs
index 720d6048f8333..9e4ceec033ec6 100644
--- a/tests/debuginfo/borrowed-tuple.rs
+++ b/tests/debuginfo/borrowed-tuple.rs
@@ -19,13 +19,13 @@
 // lldb-command:run
 
 // lldb-command:v *stack_val_ref
-// lldbg-check:[...] { 0 = -14 1 = -19 }
+// lldb-check:[...] { 0 = -14 1 = -19 }
 
 // lldb-command:v *ref_to_unnamed
-// lldbg-check:[...] { 0 = -15 1 = -20 }
+// lldb-check:[...] { 0 = -15 1 = -20 }
 
 // lldb-command:v *unique_val_ref
-// lldbg-check:[...] { 0 = -17 1 = -22 }
+// lldb-check:[...] { 0 = -17 1 = -22 }
 
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/borrowed-unique-basic.rs b/tests/debuginfo/borrowed-unique-basic.rs
index 8b2690e025b03..7a9b4d1df825b 100644
--- a/tests/debuginfo/borrowed-unique-basic.rs
+++ b/tests/debuginfo/borrowed-unique-basic.rs
@@ -57,47 +57,47 @@
 // lldb-command:run
 
 // lldb-command:v *bool_ref
-// lldbg-check:[...] true
+// lldb-check:[...] true
 
 // lldb-command:v *int_ref
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 
 
 // lldb-command:v *i8_ref
-// lldbg-check:[...] 68
+// lldb-check:[...] 68
 
 // lldb-command:v *i16_ref
-// lldbg-check:[...] -16
+// lldb-check:[...] -16
 
 // lldb-command:v *i32_ref
-// lldbg-check:[...] -32
+// lldb-check:[...] -32
 
 // lldb-command:v *i64_ref
-// lldbg-check:[...] -64
+// lldb-check:[...] -64
 
 // lldb-command:v *uint_ref
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 
 // lldb-command:v *u8_ref
-// lldbg-check:[...] 100
+// lldb-check:[...] 100
 
 // lldb-command:v *u16_ref
-// lldbg-check:[...] 16
+// lldb-check:[...] 16
 
 // lldb-command:v *u32_ref
-// lldbg-check:[...] 32
+// lldb-check:[...] 32
 
 // lldb-command:v *u64_ref
-// lldbg-check:[...] 64
+// lldb-check:[...] 64
 
 // lldb-command:v *f16_ref
-// lldbg-check:[...] 1.5
+// lldb-check:[...] 1.5
 
 // lldb-command:v *f32_ref
-// lldbg-check:[...] 2.5
+// lldb-check:[...] 2.5
 
 // lldb-command:v *f64_ref
-// lldbg-check:[...] 3.5
+// lldb-check:[...] 3.5
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/box.rs b/tests/debuginfo/box.rs
index 40f0cd524448b..d22566c0b179c 100644
--- a/tests/debuginfo/box.rs
+++ b/tests/debuginfo/box.rs
@@ -14,9 +14,9 @@
 
 // lldb-command:run
 // lldb-command:v *a
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v *b
-// lldbg-check:[...] { 0 = 2 1 = 3.5 }
+// lldb-check:[...] { 0 = 2 1 = 3.5 }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/boxed-struct.rs b/tests/debuginfo/boxed-struct.rs
index b4349122a3a88..158609fb2ed72 100644
--- a/tests/debuginfo/boxed-struct.rs
+++ b/tests/debuginfo/boxed-struct.rs
@@ -16,10 +16,10 @@
 // lldb-command:run
 
 // lldb-command:v *boxed_with_padding
-// lldbg-check:[...] { x = 99 y = 999 z = 9999 w = 99999 }
+// lldb-check:[...] { x = 99 y = 999 z = 9999 w = 99999 }
 
 // lldb-command:v *boxed_with_dtor
-// lldbg-check:[...] { x = 77 y = 777 z = 7777 w = 77777 }
+// lldb-check:[...] { x = 77 y = 777 z = 7777 w = 77777 }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
index 69a051b444df9..6981fdfc9e114 100644
--- a/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
+++ b/tests/debuginfo/by-value-self-argument-in-trait-impl.rs
@@ -22,15 +22,15 @@
 // lldb-command:run
 
 // lldb-command:v self
-// lldbg-check:[...] 1111
+// lldb-check:[...] 1111
 // lldb-command:continue
 
 // lldb-command:v self
-// lldbg-check:[...] { x = 2222 y = 3333 }
+// lldb-check:[...] { x = 2222 y = 3333 }
 // lldb-command:continue
 
 // lldb-command:v self
-// lldbg-check:[...] { 0 = 4444.5 1 = 5555 2 = 6666 3 = 7777.5 }
+// lldb-check:[...] { 0 = 4444.5 1 = 5555 2 = 6666 3 = 7777.5 }
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/c-style-enum-in-composite.rs b/tests/debuginfo/c-style-enum-in-composite.rs
index 4cd40c20cebd3..642879cf3b672 100644
--- a/tests/debuginfo/c-style-enum-in-composite.rs
+++ b/tests/debuginfo/c-style-enum-in-composite.rs
@@ -30,25 +30,25 @@
 // lldb-command:run
 
 // lldb-command:v tuple_interior_padding
-// lldbg-check:[...] { 0 = 0 1 = OneHundred }
+// lldb-check:[...] { 0 = 0 1 = OneHundred }
 
 // lldb-command:v tuple_padding_at_end
-// lldbg-check:[...] { 0 = { 0 = 1 1 = OneThousand } 1 = 2 }
+// lldb-check:[...] { 0 = { 0 = 1 1 = OneThousand } 1 = 2 }
 
 // lldb-command:v tuple_different_enums
-// lldbg-check:[...] { 0 = OneThousand 1 = MountainView 2 = OneMillion 3 = Vienna }
+// lldb-check:[...] { 0 = OneThousand 1 = MountainView 2 = OneMillion 3 = Vienna }
 
 // lldb-command:v padded_struct
-// lldbg-check:[...] { a = 3 b = OneMillion c = 4 d = Toronto e = 5 }
+// lldb-check:[...] { a = 3 b = OneMillion c = 4 d = Toronto e = 5 }
 
 // lldb-command:v packed_struct
-// lldbg-check:[...] { a = 6 b = OneHundred c = 7 d = Vienna e = 8 }
+// lldb-check:[...] { a = 6 b = OneHundred c = 7 d = Vienna e = 8 }
 
 // lldb-command:v non_padded_struct
-// lldbg-check:[...] { a = OneMillion b = MountainView c = OneThousand d = Toronto }
+// lldb-check:[...] { a = OneMillion b = MountainView c = OneThousand d = Toronto }
 
 // lldb-command:v struct_with_drop
-// lldbg-check:[...] { 0 = { a = OneHundred b = Vienna } 1 = 9 }
+// lldb-check:[...] { 0 = { a = OneHundred b = Vienna } 1 = 9 }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/c-style-enum.rs b/tests/debuginfo/c-style-enum.rs
index a148c8d384534..08378f7af181c 100644
--- a/tests/debuginfo/c-style-enum.rs
+++ b/tests/debuginfo/c-style-enum.rs
@@ -66,25 +66,25 @@
 // lldb-command:run
 
 // lldb-command:v auto_one
-// lldbg-check:[...] One
+// lldb-check:[...] One
 
 // lldb-command:v auto_two
-// lldbg-check:[...] Two
+// lldb-check:[...] Two
 
 // lldb-command:v auto_three
-// lldbg-check:[...] Three
+// lldb-check:[...] Three
 
 // lldb-command:v manual_one_hundred
-// lldbg-check:[...] OneHundred
+// lldb-check:[...] OneHundred
 
 // lldb-command:v manual_one_thousand
-// lldbg-check:[...] OneThousand
+// lldb-check:[...] OneThousand
 
 // lldb-command:v manual_one_million
-// lldbg-check:[...] OneMillion
+// lldb-check:[...] OneMillion
 
 // lldb-command:v single_variant
-// lldbg-check:[...] TheOnlyVariant
+// lldb-check:[...] TheOnlyVariant
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
diff --git a/tests/debuginfo/captured-fields-1.rs b/tests/debuginfo/captured-fields-1.rs
index 217a1f27b6783..69ca3ecd812dd 100644
--- a/tests/debuginfo/captured-fields-1.rs
+++ b/tests/debuginfo/captured-fields-1.rs
@@ -26,22 +26,22 @@
 
 // lldb-command:run
 // lldb-command:v test
-// lldbg-check:(captured_fields_1::main::{closure_env#0}) test = { _ref__my_ref__my_field1 = 0x[...] }
+// lldb-check:(captured_fields_1::main::{closure_env#0}) test = { _ref__my_ref__my_field1 = 0x[...] }
 // lldb-command:continue
 // lldb-command:v test
-// lldbg-check:(captured_fields_1::main::{closure_env#1}) test = { _ref__my_ref__my_field2 = 0x[...] }
+// lldb-check:(captured_fields_1::main::{closure_env#1}) test = { _ref__my_ref__my_field2 = 0x[...] }
 // lldb-command:continue
 // lldb-command:v test
-// lldbg-check:(captured_fields_1::main::{closure_env#2}) test = { _ref__my_ref = 0x[...] }
+// lldb-check:(captured_fields_1::main::{closure_env#2}) test = { _ref__my_ref = 0x[...] }
 // lldb-command:continue
 // lldb-command:v test
-// lldbg-check:(captured_fields_1::main::{closure_env#3}) test = { my_ref = 0x[...] }
+// lldb-check:(captured_fields_1::main::{closure_env#3}) test = { my_ref = 0x[...] }
 // lldb-command:continue
 // lldb-command:v test
-// lldbg-check:(captured_fields_1::main::{closure_env#4}) test = { my_var__my_field2 = 22 }
+// lldb-check:(captured_fields_1::main::{closure_env#4}) test = { my_var__my_field2 = 22 }
 // lldb-command:continue
 // lldb-command:v test
-// lldbg-check:(captured_fields_1::main::{closure_env#5}) test = { my_var = { my_field1 = 11 my_field2 = 22 } }
+// lldb-check:(captured_fields_1::main::{closure_env#5}) test = { my_var = { my_field1 = 11 my_field2 = 22 } }
 // lldb-command:continue
 
 #![allow(unused)]
diff --git a/tests/debuginfo/captured-fields-2.rs b/tests/debuginfo/captured-fields-2.rs
index 940f07ecacbb2..24bff1d3f35d7 100644
--- a/tests/debuginfo/captured-fields-2.rs
+++ b/tests/debuginfo/captured-fields-2.rs
@@ -14,10 +14,10 @@
 
 // lldb-command:run
 // lldb-command:v my_ref__my_field1
-// lldbg-check:(unsigned int) my_ref__my_field1 = 11
+// lldb-check:(unsigned int) my_ref__my_field1 = 11
 // lldb-command:continue
 // lldb-command:v my_var__my_field2
-// lldbg-check:(unsigned int) my_var__my_field2 = 22
+// lldb-check:(unsigned int) my_var__my_field2 = 22
 // lldb-command:continue
 
 #![allow(unused)]
diff --git a/tests/debuginfo/closure-in-generic-function.rs b/tests/debuginfo/closure-in-generic-function.rs
index 2baaf1b79e9d0..0c6a6fdfca1b2 100644
--- a/tests/debuginfo/closure-in-generic-function.rs
+++ b/tests/debuginfo/closure-in-generic-function.rs
@@ -22,15 +22,15 @@
 // lldb-command:run
 
 // lldb-command:v x
-// lldbg-check:[...] 0.5
+// lldb-check:[...] 0.5
 // lldb-command:v y
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v *x
-// lldbg-check:[...] 29
+// lldb-check:[...] 29
 // lldb-command:v *y
-// lldbg-check:[...] 110
+// lldb-check:[...] 110
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/cross-crate-spans.rs b/tests/debuginfo/cross-crate-spans.rs
index 5e8b27d4d55ec..e337aaf5a6c9c 100644
--- a/tests/debuginfo/cross-crate-spans.rs
+++ b/tests/debuginfo/cross-crate-spans.rs
@@ -36,19 +36,19 @@ extern crate cross_crate_spans;
 // lldb-command:run
 
 // lldb-command:v result
-// lldbg-check:[...] { 0 = 17 1 = 17 }
+// lldb-check:[...] { 0 = 17 1 = 17 }
 // lldb-command:v a_variable
-// lldbg-check:[...] 123456789
+// lldb-check:[...] 123456789
 // lldb-command:v another_variable
-// lldbg-check:[...] 123456789.5
+// lldb-check:[...] 123456789.5
 // lldb-command:continue
 
 // lldb-command:v result
-// lldbg-check:[...] { 0 = 1212 1 = 1212 }
+// lldb-check:[...] { 0 = 1212 1 = 1212 }
 // lldb-command:v a_variable
-// lldbg-check:[...] 123456789
+// lldb-check:[...] 123456789
 // lldb-command:v another_variable
-// lldbg-check:[...] 123456789.5
+// lldb-check:[...] 123456789.5
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/destructured-fn-argument.rs b/tests/debuginfo/destructured-fn-argument.rs
index aef4e4baae1ec..37a7bb2b77864 100644
--- a/tests/debuginfo/destructured-fn-argument.rs
+++ b/tests/debuginfo/destructured-fn-argument.rs
@@ -154,147 +154,147 @@
 // lldb-command:run
 
 // lldb-command:v a
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v b
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:continue
 
 // lldb-command:v a
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:v b
-// lldbg-check:[...] 3
+// lldb-check:[...] 3
 // lldb-command:v c
-// lldbg-check:[...] 4
+// lldb-check:[...] 4
 // lldb-command:continue
 
 // lldb-command:v a
-// lldbg-check:[...] 5
+// lldb-check:[...] 5
 // lldb-command:v b
-// lldbg-check:[...] { 0 = 6 1 = 7 }
+// lldb-check:[...] { 0 = 6 1 = 7 }
 // lldb-command:continue
 
 // lldb-command:v h
-// lldbg-check:[...] 8
+// lldb-check:[...] 8
 // lldb-command:v i
-// lldbg-check:[...] { a = 9 b = 10 }
+// lldb-check:[...] { a = 9 b = 10 }
 // lldb-command:v j
-// lldbg-check:[...] 11
+// lldb-check:[...] 11
 // lldb-command:continue
 
 // lldb-command:v k
-// lldbg-check:[...] 12
+// lldb-check:[...] 12
 // lldb-command:v l
-// lldbg-check:[...] 13
+// lldb-check:[...] 13
 // lldb-command:continue
 
 // lldb-command:v m
-// lldbg-check:[...] 14
+// lldb-check:[...] 14
 // lldb-command:v n
-// lldbg-check:[...] 16
+// lldb-check:[...] 16
 // lldb-command:continue
 
 // lldb-command:v o
-// lldbg-check:[...] 18
+// lldb-check:[...] 18
 // lldb-command:continue
 
 // lldb-command:v p
-// lldbg-check:[...] 19
+// lldb-check:[...] 19
 // lldb-command:v q
-// lldbg-check:[...] 20
+// lldb-check:[...] 20
 // lldb-command:v r
-// lldbg-check:[...] { a = 21 b = 22 }
+// lldb-check:[...] { a = 21 b = 22 }
 // lldb-command:continue
 
 // lldb-command:v s
-// lldbg-check:[...] 24
+// lldb-check:[...] 24
 // lldb-command:v t
-// lldbg-check:[...] 23
+// lldb-check:[...] 23
 // lldb-command:continue
 
 // lldb-command:v u
-// lldbg-check:[...] 25
+// lldb-check:[...] 25
 // lldb-command:v v
-// lldbg-check:[...] 26
+// lldb-check:[...] 26
 // lldb-command:v w
-// lldbg-check:[...] 27
+// lldb-check:[...] 27
 // lldb-command:v x
-// lldbg-check:[...] 28
+// lldb-check:[...] 28
 // lldb-command:v y
-// lldbg-check:[...] 29
+// lldb-check:[...] 29
 // lldb-command:v z
-// lldbg-check:[...] 30
+// lldb-check:[...] 30
 // lldb-command:v ae
-// lldbg-check:[...] 31
+// lldb-check:[...] 31
 // lldb-command:v oe
-// lldbg-check:[...] 32
+// lldb-check:[...] 32
 // lldb-command:v ue
-// lldbg-check:[...] 33
+// lldb-check:[...] 33
 // lldb-command:continue
 
 // lldb-command:v aa
-// lldbg-check:[...] { 0 = 34 1 = 35 }
+// lldb-check:[...] { 0 = 34 1 = 35 }
 // lldb-command:continue
 
 // lldb-command:v bb
-// lldbg-check:[...] { 0 = 36 1 = 37 }
+// lldb-check:[...] { 0 = 36 1 = 37 }
 // lldb-command:continue
 
 // lldb-command:v cc
-// lldbg-check:[...] 38
+// lldb-check:[...] 38
 // lldb-command:continue
 
 // lldb-command:v dd
-// lldbg-check:[...] { 0 = 40 1 = 41 2 = 42 }
+// lldb-check:[...] { 0 = 40 1 = 41 2 = 42 }
 // lldb-command:continue
 
 // lldb-command:v *ee
-// lldbg-check:[...] { 0 = 43 1 = 44 2 = 45 }
+// lldb-check:[...] { 0 = 43 1 = 44 2 = 45 }
 // lldb-command:continue
 
 // lldb-command:v *ff
-// lldbg-check:[...] 46
+// lldb-check:[...] 46
 // lldb-command:v gg
-// lldbg-check:[...] { 0 = 47 1 = 48 }
+// lldb-check:[...] { 0 = 47 1 = 48 }
 // lldb-command:continue
 
 // lldb-command:v *hh
-// lldbg-check:[...] 50
+// lldb-check:[...] 50
 // lldb-command:continue
 
 // lldb-command:v ii
-// lldbg-check:[...] 51
+// lldb-check:[...] 51
 // lldb-command:continue
 
 // lldb-command:v *jj
-// lldbg-check:[...] 52
+// lldb-check:[...] 52
 // lldb-command:continue
 
 // lldb-command:v kk
-// lldbg-check:[...] 53
+// lldb-check:[...] 53
 // lldb-command:v ll
-// lldbg-check:[...] 54
+// lldb-check:[...] 54
 // lldb-command:continue
 
 // lldb-command:v mm
-// lldbg-check:[...] 55
+// lldb-check:[...] 55
 // lldb-command:v *nn
-// lldbg-check:[...] 56
+// lldb-check:[...] 56
 // lldb-command:continue
 
 // lldb-command:v oo
-// lldbg-check:[...] 57
+// lldb-check:[...] 57
 // lldb-command:v pp
-// lldbg-check:[...] 58
+// lldb-check:[...] 58
 // lldb-command:v qq
-// lldbg-check:[...] 59
+// lldb-check:[...] 59
 // lldb-command:continue
 
 // lldb-command:v rr
-// lldbg-check:[...] 60
+// lldb-check:[...] 60
 // lldb-command:v ss
-// lldbg-check:[...] 61
+// lldb-check:[...] 61
 // lldb-command:v tt
-// lldbg-check:[...] 62
+// lldb-check:[...] 62
 // lldb-command:continue
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/destructured-for-loop-variable.rs b/tests/debuginfo/destructured-for-loop-variable.rs
index 6a43f8ca19993..cc16be1268ae7 100644
--- a/tests/debuginfo/destructured-for-loop-variable.rs
+++ b/tests/debuginfo/destructured-for-loop-variable.rs
@@ -77,66 +77,66 @@
 
 // DESTRUCTURED STRUCT
 // lldb-command:v x
-// lldbg-check:[...] 400
+// lldb-check:[...] 400
 // lldb-command:v y
-// lldbg-check:[...] 401.5
+// lldb-check:[...] 401.5
 // lldb-command:v z
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:continue
 
 // DESTRUCTURED TUPLE
 // lldb-command:v _i8
-// lldbg-check:[...] 0x6f
+// lldb-check:[...] 0x6f
 // lldb-command:v _u8
-// lldbg-check:[...] 0x70
+// lldb-check:[...] 0x70
 // lldb-command:v _i16
-// lldbg-check:[...] -113
+// lldb-check:[...] -113
 // lldb-command:v _u16
-// lldbg-check:[...] 114
+// lldb-check:[...] 114
 // lldb-command:v _i32
-// lldbg-check:[...] -115
+// lldb-check:[...] -115
 // lldb-command:v _u32
-// lldbg-check:[...] 116
+// lldb-check:[...] 116
 // lldb-command:v _i64
-// lldbg-check:[...] -117
+// lldb-check:[...] -117
 // lldb-command:v _u64
-// lldbg-check:[...] 118
+// lldb-check:[...] 118
 // lldb-command:v _f32
-// lldbg-check:[...] 119.5
+// lldb-check:[...] 119.5
 // lldb-command:v _f64
-// lldbg-check:[...] 120.5
+// lldb-check:[...] 120.5
 // lldb-command:continue
 
 // MORE COMPLEX CASE
 // lldb-command:v v1
-// lldbg-check:[...] 80000
+// lldb-check:[...] 80000
 // lldb-command:v x1
-// lldbg-check:[...] 8000
+// lldb-check:[...] 8000
 // lldb-command:v *y1
-// lldbg-check:[...] 80001.5
+// lldb-check:[...] 80001.5
 // lldb-command:v z1
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:v *x2
-// lldbg-check:[...] -30000
+// lldb-check:[...] -30000
 // lldb-command:v y2
-// lldbg-check:[...] -300001.5
+// lldb-check:[...] -300001.5
 // lldb-command:v *z2
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:v v2
-// lldbg-check:[...] 854237.5
+// lldb-check:[...] 854237.5
 // lldb-command:continue
 
 // SIMPLE IDENTIFIER
 // lldb-command:v i
-// lldbg-check:[...] 1234
+// lldb-check:[...] 1234
 // lldb-command:continue
 
 // lldb-command:v simple_struct_ident
-// lldbg-check:[...] { x = 3537 y = 35437.5 z = true }
+// lldb-check:[...] { x = 3537 y = 35437.5 z = true }
 // lldb-command:continue
 
 // lldb-command:v simple_tuple_ident
-// lldbg-check:[...] { 0 = 34903493 1 = 232323 }
+// lldb-check:[...] { 0 = 34903493 1 = 232323 }
 // lldb-command:continue
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/destructured-local.rs b/tests/debuginfo/destructured-local.rs
index b74bf8745eaac..fad96ca7d4b66 100644
--- a/tests/debuginfo/destructured-local.rs
+++ b/tests/debuginfo/destructured-local.rs
@@ -120,114 +120,114 @@
 // lldb-command:run
 
 // lldb-command:v a
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v b
-// lldbg-check:[...] false
+// lldb-check:[...] false
 
 // lldb-command:v c
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:v d
-// lldbg-check:[...] 3
+// lldb-check:[...] 3
 // lldb-command:v e
-// lldbg-check:[...] 4
+// lldb-check:[...] 4
 
 // lldb-command:v f
-// lldbg-check:[...] 5
+// lldb-check:[...] 5
 // lldb-command:v g
-// lldbg-check:[...] { 0 = 6 1 = 7 }
+// lldb-check:[...] { 0 = 6 1 = 7 }
 
 // lldb-command:v h
-// lldbg-check:[...] 8
+// lldb-check:[...] 8
 // lldb-command:v i
-// lldbg-check:[...] { a = 9 b = 10 }
+// lldb-check:[...] { a = 9 b = 10 }
 // lldb-command:v j
-// lldbg-check:[...] 11
+// lldb-check:[...] 11
 
 // lldb-command:v k
-// lldbg-check:[...] 12
+// lldb-check:[...] 12
 // lldb-command:v l
-// lldbg-check:[...] 13
+// lldb-check:[...] 13
 
 // lldb-command:v m
-// lldbg-check:[...] 14
+// lldb-check:[...] 14
 // lldb-command:v n
-// lldbg-check:[...] 16
+// lldb-check:[...] 16
 
 // lldb-command:v o
-// lldbg-check:[...] 18
+// lldb-check:[...] 18
 
 // lldb-command:v p
-// lldbg-check:[...] 19
+// lldb-check:[...] 19
 // lldb-command:v q
-// lldbg-check:[...] 20
+// lldb-check:[...] 20
 // lldb-command:v r
-// lldbg-check:[...] { a = 21 b = 22 }
+// lldb-check:[...] { a = 21 b = 22 }
 
 // lldb-command:v s
-// lldbg-check:[...] 24
+// lldb-check:[...] 24
 // lldb-command:v t
-// lldbg-check:[...] 23
+// lldb-check:[...] 23
 
 // lldb-command:v u
-// lldbg-check:[...] 25
+// lldb-check:[...] 25
 // lldb-command:v v
-// lldbg-check:[...] 26
+// lldb-check:[...] 26
 // lldb-command:v w
-// lldbg-check:[...] 27
+// lldb-check:[...] 27
 // lldb-command:v x
-// lldbg-check:[...] 28
+// lldb-check:[...] 28
 // lldb-command:v y
-// lldbg-check:[...] 29
+// lldb-check:[...] 29
 // lldb-command:v z
-// lldbg-check:[...] 30
+// lldb-check:[...] 30
 // lldb-command:v ae
-// lldbg-check:[...] 31
+// lldb-check:[...] 31
 // lldb-command:v oe
-// lldbg-check:[...] 32
+// lldb-check:[...] 32
 // lldb-command:v ue
-// lldbg-check:[...] 33
+// lldb-check:[...] 33
 
 // lldb-command:v aa
-// lldbg-check:[...] { 0 = 34 1 = 35 }
+// lldb-check:[...] { 0 = 34 1 = 35 }
 
 // lldb-command:v bb
-// lldbg-check:[...] { 0 = 36 1 = 37 }
+// lldb-check:[...] { 0 = 36 1 = 37 }
 
 // lldb-command:v cc
-// lldbg-check:[...] 38
+// lldb-check:[...] 38
 
 // lldb-command:v dd
-// lldbg-check:[...] { 0 = 40 1 = 41 2 = 42 }
+// lldb-check:[...] { 0 = 40 1 = 41 2 = 42 }
 
 // lldb-command:v *ee
-// lldbg-check:[...] { 0 = 43 1 = 44 2 = 45 }
+// lldb-check:[...] { 0 = 43 1 = 44 2 = 45 }
 
 // lldb-command:v *ff
-// lldbg-check:[...] 46
+// lldb-check:[...] 46
 
 // lldb-command:v gg
-// lldbg-check:[...] { 0 = 47 1 = 48 }
+// lldb-check:[...] { 0 = 47 1 = 48 }
 
 // lldb-command:v *hh
-// lldbg-check:[...] 50
+// lldb-check:[...] 50
 
 // lldb-command:v ii
-// lldbg-check:[...] 51
+// lldb-check:[...] 51
 
 // lldb-command:v *jj
-// lldbg-check:[...] 52
+// lldb-check:[...] 52
 
 // lldb-command:v kk
-// lldbg-check:[...] 53
+// lldb-check:[...] 53
 
 // lldb-command:v ll
-// lldbg-check:[...] 54
+// lldb-check:[...] 54
 
 // lldb-command:v mm
-// lldbg-check:[...] 55
+// lldb-check:[...] 55
 
 // lldb-command:v *nn
-// lldbg-check:[...] 56
+// lldb-check:[...] 56
 
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/enum-thinlto.rs b/tests/debuginfo/enum-thinlto.rs
index 8c3a20a2da4c0..af77145c312d7 100644
--- a/tests/debuginfo/enum-thinlto.rs
+++ b/tests/debuginfo/enum-thinlto.rs
@@ -13,7 +13,7 @@
 // lldb-command:run
 
 // lldb-command:v *abc
-// lldbg-check:(enum_thinlto::ABC) *abc = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 }
+// lldb-check:(enum_thinlto::ABC) *abc = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/evec-in-struct.rs b/tests/debuginfo/evec-in-struct.rs
index 020c6e7d15426..303669cf06cd2 100644
--- a/tests/debuginfo/evec-in-struct.rs
+++ b/tests/debuginfo/evec-in-struct.rs
@@ -24,18 +24,18 @@
 // lldb-command:run
 
 // lldb-command:v no_padding1
-// lldbg-check:[...] { x = { [0] = 0 [1] = 1 [2] = 2 } y = -3 z = { [0] = 4.5 [1] = 5.5 } }
+// lldb-check:[...] { x = { [0] = 0 [1] = 1 [2] = 2 } y = -3 z = { [0] = 4.5 [1] = 5.5 } }
 // lldb-command:v no_padding2
-// lldbg-check:[...] { x = { [0] = 6 [1] = 7 [2] = 8 } y = { [0] = { [0] = 9 [1] = 10 } [1] = { [0] = 11 [1] = 12 } } }
+// lldb-check:[...] { x = { [0] = 6 [1] = 7 [2] = 8 } y = { [0] = { [0] = 9 [1] = 10 } [1] = { [0] = 11 [1] = 12 } } }
 
 // lldb-command:v struct_internal_padding
-// lldbg-check:[...] { x = { [0] = 13 [1] = 14 } y = { [0] = 15 [1] = 16 } }
+// lldb-check:[...] { x = { [0] = 13 [1] = 14 } y = { [0] = 15 [1] = 16 } }
 
 // lldb-command:v single_vec
-// lldbg-check:[...] { x = { [0] = 17 [1] = 18 [2] = 19 [3] = 20 [4] = 21 } }
+// lldb-check:[...] { x = { [0] = 17 [1] = 18 [2] = 19 [3] = 20 [4] = 21 } }
 
 // lldb-command:v struct_padded_at_end
-// lldbg-check:[...] { x = { [0] = 22 [1] = 23 } y = { [0] = 24 [1] = 25 } }
+// lldb-check:[...] { x = { [0] = 22 [1] = 23 } y = { [0] = 24 [1] = 25 } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/extern-c-fn.rs b/tests/debuginfo/extern-c-fn.rs
index d81ab356c1e9f..4642073faabcb 100644
--- a/tests/debuginfo/extern-c-fn.rs
+++ b/tests/debuginfo/extern-c-fn.rs
@@ -20,13 +20,13 @@
 // lldb-command:run
 
 // lldb-command:v len
-// lldbg-check:[...] 20
+// lldb-check:[...] 20
 // lldb-command:v local0
-// lldbg-check:[...] 19
+// lldb-check:[...] 19
 // lldb-command:v local1
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:v local2
-// lldbg-check:[...] 20.5
+// lldb-check:[...] 20.5
 
 // lldb-command:continue
 
diff --git a/tests/debuginfo/function-arguments.rs b/tests/debuginfo/function-arguments.rs
index 9befadf5dc15c..21c0c7d859cc9 100644
--- a/tests/debuginfo/function-arguments.rs
+++ b/tests/debuginfo/function-arguments.rs
@@ -21,15 +21,15 @@
 // lldb-command:run
 
 // lldb-command:v x
-// lldbg-check:[...] 111102
+// lldb-check:[...] 111102
 // lldb-command:v y
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:continue
 
 // lldb-command:v a
-// lldbg-check:[...] 2000
+// lldb-check:[...] 2000
 // lldb-command:v b
-// lldbg-check:[...] 3000
+// lldb-check:[...] 3000
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/generic-function.rs b/tests/debuginfo/generic-function.rs
index 47f695b8fbe9a..4be8d5ad45aa5 100644
--- a/tests/debuginfo/generic-function.rs
+++ b/tests/debuginfo/generic-function.rs
@@ -27,21 +27,21 @@
 // lldb-command:run
 
 // lldb-command:v *t0
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v *t1
-// lldbg-check:[...] 2.5
+// lldb-check:[...] 2.5
 // lldb-command:continue
 
 // lldb-command:v *t0
-// lldbg-check:[...] 3.5
+// lldb-check:[...] 3.5
 // lldb-command:v *t1
-// lldbg-check:[...] 4
+// lldb-check:[...] 4
 // lldb-command:continue
 
 // lldb-command:v *t0
-// lldbg-check:[...] 5
+// lldb-check:[...] 5
 // lldb-command:v *t1
-// lldbg-check:[...] { a = 6 b = 7.5 }
+// lldb-check:[...] { a = 6 b = 7.5 }
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/generic-functions-nested.rs b/tests/debuginfo/generic-functions-nested.rs
index 500a42f3dc8c8..7e0c20f890384 100644
--- a/tests/debuginfo/generic-functions-nested.rs
+++ b/tests/debuginfo/generic-functions-nested.rs
@@ -34,27 +34,27 @@
 // lldb-command:run
 
 // lldb-command:v x
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v y
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v y
-// lldbg-check:[...] 2.5
+// lldb-check:[...] 2.5
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] -2.5
+// lldb-check:[...] -2.5
 // lldb-command:v y
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] -2.5
+// lldb-check:[...] -2.5
 // lldb-command:v y
-// lldbg-check:[...] 2.5
+// lldb-check:[...] 2.5
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/generic-method-on-generic-struct.rs b/tests/debuginfo/generic-method-on-generic-struct.rs
index 071d436b0895a..a391fbf082651 100644
--- a/tests/debuginfo/generic-method-on-generic-struct.rs
+++ b/tests/debuginfo/generic-method-on-generic-struct.rs
@@ -56,47 +56,47 @@
 
 // STACK BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { x = { 0 = 8888, 1 = -8888 } }
+// lldb-check:[...] { x = { 0 = 8888, 1 = -8888 } }
 // lldb-command:v arg1
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v arg2
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { x = { 0 = 8888, 1 = -8888 } }
+// lldb-check:[...] { x = { 0 = 8888, 1 = -8888 } }
 // lldb-command:v arg1
-// lldbg-check:[...] -3
+// lldb-check:[...] -3
 // lldb-command:v arg2
-// lldbg-check:[...] -4
+// lldb-check:[...] -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { x = 1234.5 }
+// lldb-check:[...] { x = 1234.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -5
+// lldb-check:[...] -5
 // lldb-command:v arg2
-// lldbg-check:[...] -6
+// lldb-check:[...] -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { x = 1234.5 }
+// lldb-check:[...] { x = 1234.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -7
+// lldb-check:[...] -7
 // lldb-command:v arg2
-// lldbg-check:[...] -8
+// lldb-check:[...] -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
-// lldbg-check:[...] { x = 1234.5 }
+// lldb-check:[...] { x = 1234.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -9
+// lldb-check:[...] -9
 // lldb-command:v arg2
-// lldbg-check:[...] -10.5
+// lldb-check:[...] -10.5
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs
index 49ec4ac1c177b..09160bc3ba038 100644
--- a/tests/debuginfo/generic-struct.rs
+++ b/tests/debuginfo/generic-struct.rs
@@ -18,14 +18,14 @@
 // lldb-command:run
 
 // lldb-command:v int_int
-// lldbg-check:[...] AGenericStruct<i32, i32> { key: 0, value: 1 }
+// lldb-check:[...] AGenericStruct<i32, i32> { key: 0, value: 1 }
 // lldb-command:v int_float
-// lldbg-check:[...] AGenericStruct<i32, f64> { key: 2, value: 3.5 }
+// lldb-check:[...] AGenericStruct<i32, f64> { key: 2, value: 3.5 }
 // lldb-command:v float_int
-// lldbg-check:[...] AGenericStruct<f64, i32> { key: 4.5, value: 5 }
+// lldb-check:[...] AGenericStruct<f64, i32> { key: 4.5, value: 5 }
 
 // lldb-command:v float_int_float
-// lldbg-check:[...] AGenericStruct<f64, generic_struct::AGenericStruct<i32, f64>> { key: 6.5, value: AGenericStruct<i32, f64> { key: 7, value: 8.5 } }
+// lldb-check:[...] AGenericStruct<f64, generic_struct::AGenericStruct<i32, f64>> { key: 6.5, value: AGenericStruct<i32, f64> { key: 7, value: 8.5 } }
 
 // === CDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/include_string.rs b/tests/debuginfo/include_string.rs
index 5bf7cb69cc123..704b85e1ac2d0 100644
--- a/tests/debuginfo/include_string.rs
+++ b/tests/debuginfo/include_string.rs
@@ -17,11 +17,11 @@
 // lldb-command:run
 
 // lldb-command:v string1.length
-// lldbg-check:[...] 48
+// lldb-check:[...] 48
 // lldb-command:v string2.length
-// lldbg-check:[...] 49
+// lldb-check:[...] 49
 // lldb-command:v string3.length
-// lldbg-check:[...] 50
+// lldb-check:[...] 50
 
 // lldb-command:continue
 
diff --git a/tests/debuginfo/issue-22656.rs b/tests/debuginfo/issue-22656.rs
index 5198d34c7b8be..eb0b38cfa4d6b 100644
--- a/tests/debuginfo/issue-22656.rs
+++ b/tests/debuginfo/issue-22656.rs
@@ -10,9 +10,9 @@
 // lldb-command:run
 
 // lldb-command:v v
-// lldbg-check:[...] size=3 { [0] = 1 [1] = 2 [2] = 3 }
+// lldb-check:[...] size=3 { [0] = 1 [1] = 2 [2] = 3 }
 // lldb-command:v zs
-// lldbg-check:[...] { x = y = 123 z = w = 456 }
+// lldb-check:[...] { x = y = 123 z = w = 456 }
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
diff --git a/tests/debuginfo/issue-57822.rs b/tests/debuginfo/issue-57822.rs
index 8a8cf41ab1fbe..7abac1c14d327 100644
--- a/tests/debuginfo/issue-57822.rs
+++ b/tests/debuginfo/issue-57822.rs
@@ -19,10 +19,10 @@
 // lldb-command:run
 
 // lldb-command:v g
-// lldbg-check:(issue_57822::main::{closure_env#1}) g = { f = { x = 1 } }
+// lldb-check:(issue_57822::main::{closure_env#1}) g = { f = { x = 1 } }
 
 // lldb-command:v b
-// lldbg-check:(issue_57822::main::{coroutine_env#3}) b = { value = { a = { value = { y = 2 } $discr$ = '\x02' } } $discr$ = '\x02' }
+// lldb-check:(issue_57822::main::{coroutine_env#3}) b = { value = { a = { value = { y = 2 } $discr$ = '\x02' } } $discr$ = '\x02' }
 
 #![feature(omit_gdb_pretty_printer_section, coroutines, coroutine_trait, stmt_expr_attributes)]
 #![omit_gdb_pretty_printer_section]
diff --git a/tests/debuginfo/lexical-scope-in-for-loop.rs b/tests/debuginfo/lexical-scope-in-for-loop.rs
index acfddaab89c72..08f244f89a02e 100644
--- a/tests/debuginfo/lexical-scope-in-for-loop.rs
+++ b/tests/debuginfo/lexical-scope-in-for-loop.rs
@@ -43,34 +43,34 @@
 
 // FIRST ITERATION
 // lldb-command:v x
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:continue
 
 // SECOND ITERATION
 // lldb-command:v x
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] -2
+// lldb-check:[...] -2
 // lldb-command:continue
 
 // THIRD ITERATION
 // lldb-command:v x
-// lldbg-check:[...] 3
+// lldb-check:[...] 3
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] -3
+// lldb-check:[...] -3
 // lldb-command:continue
 
 // AFTER LOOP
 // lldb-command:v x
-// lldbg-check:[...] 1000000
+// lldb-check:[...] 1000000
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-in-if.rs b/tests/debuginfo/lexical-scope-in-if.rs
index d1c5884843c4e..c0e1f2f3e05cc 100644
--- a/tests/debuginfo/lexical-scope-in-if.rs
+++ b/tests/debuginfo/lexical-scope-in-if.rs
@@ -67,58 +67,58 @@
 
 // BEFORE if
 // lldb-command:v x
-// lldbg-check:[...] 999
+// lldb-check:[...] 999
 // lldb-command:v y
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:continue
 
 // AT BEGINNING of 'then' block
 // lldb-command:v x
-// lldbg-check:[...] 999
+// lldb-check:[...] 999
 // lldb-command:v y
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:continue
 
 // AFTER 1st redeclaration of 'x'
 // lldb-command:v x
-// lldbg-check:[...] 1001
+// lldb-check:[...] 1001
 // lldb-command:v y
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:continue
 
 // AFTER 2st redeclaration of 'x'
 // lldb-command:v x
-// lldbg-check:[...] 1002
+// lldb-check:[...] 1002
 // lldb-command:v y
-// lldbg-check:[...] 1003
+// lldb-check:[...] 1003
 // lldb-command:continue
 
 // AFTER 1st if expression
 // lldb-command:v x
-// lldbg-check:[...] 999
+// lldb-check:[...] 999
 // lldb-command:v y
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:continue
 
 // BEGINNING of else branch
 // lldb-command:v x
-// lldbg-check:[...] 999
+// lldb-check:[...] 999
 // lldb-command:v y
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:continue
 
 // BEGINNING of else branch
 // lldb-command:v x
-// lldbg-check:[...] 1004
+// lldb-check:[...] 1004
 // lldb-command:v y
-// lldbg-check:[...] 1005
+// lldb-check:[...] 1005
 // lldb-command:continue
 
 // BEGINNING of else branch
 // lldb-command:v x
-// lldbg-check:[...] 999
+// lldb-check:[...] 999
 // lldb-command:v y
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-in-match.rs b/tests/debuginfo/lexical-scope-in-match.rs
index 754616b1a54b3..9169c19c6a331 100644
--- a/tests/debuginfo/lexical-scope-in-match.rs
+++ b/tests/debuginfo/lexical-scope-in-match.rs
@@ -62,55 +62,55 @@
 // lldb-command:run
 
 // lldb-command:v shadowed
-// lldbg-check:[...] 231
+// lldb-check:[...] 231
 // lldb-command:v not_shadowed
-// lldbg-check:[...] 232
+// lldb-check:[...] 232
 // lldb-command:continue
 
 // lldb-command:v shadowed
-// lldbg-check:[...] 233
+// lldb-check:[...] 233
 // lldb-command:v not_shadowed
-// lldbg-check:[...] 232
+// lldb-check:[...] 232
 // lldb-command:v local_to_arm
-// lldbg-check:[...] 234
+// lldb-check:[...] 234
 // lldb-command:continue
 
 // lldb-command:v shadowed
-// lldbg-check:[...] 236
+// lldb-check:[...] 236
 // lldb-command:v not_shadowed
-// lldbg-check:[...] 232
+// lldb-check:[...] 232
 // lldb-command:continue
 
 // lldb-command:v shadowed
-// lldbg-check:[...] 237
+// lldb-check:[...] 237
 // lldb-command:v not_shadowed
-// lldbg-check:[...] 232
+// lldb-check:[...] 232
 // lldb-command:v local_to_arm
-// lldbg-check:[...] 238
+// lldb-check:[...] 238
 // lldb-command:continue
 
 // lldb-command:v shadowed
-// lldbg-check:[...] 239
+// lldb-check:[...] 239
 // lldb-command:v not_shadowed
-// lldbg-check:[...] 232
+// lldb-check:[...] 232
 // lldb-command:continue
 
 // lldb-command:v shadowed
-// lldbg-check:[...] 241
+// lldb-check:[...] 241
 // lldb-command:v not_shadowed
-// lldbg-check:[...] 232
+// lldb-check:[...] 232
 // lldb-command:continue
 
 // lldb-command:v shadowed
-// lldbg-check:[...] 243
+// lldb-check:[...] 243
 // lldb-command:v *local_to_arm
-// lldbg-check:[...] 244
+// lldb-check:[...] 244
 // lldb-command:continue
 
 // lldb-command:v shadowed
-// lldbg-check:[...] 231
+// lldb-check:[...] 231
 // lldb-command:v not_shadowed
-// lldbg-check:[...] 232
+// lldb-check:[...] 232
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-in-stack-closure.rs b/tests/debuginfo/lexical-scope-in-stack-closure.rs
index 301423080e68f..d01162c39d69f 100644
--- a/tests/debuginfo/lexical-scope-in-stack-closure.rs
+++ b/tests/debuginfo/lexical-scope-in-stack-closure.rs
@@ -34,27 +34,27 @@
 // lldb-command:run
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 1000
+// lldb-check:[...] 1000
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 2.5
+// lldb-check:[...] 2.5
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs
index 1d111dab5c949..dfec570218f34 100644
--- a/tests/debuginfo/lexical-scope-in-unconditional-loop.rs
+++ b/tests/debuginfo/lexical-scope-in-unconditional-loop.rs
@@ -66,57 +66,57 @@
 
 // FIRST ITERATION
 // lldb-command:v x
-// lldbg-check:[...] 0
+// lldb-check:[...] 0
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 101
+// lldb-check:[...] 101
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 101
+// lldb-check:[...] 101
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] -987
+// lldb-check:[...] -987
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 101
+// lldb-check:[...] 101
 // lldb-command:continue
 
 
 // SECOND ITERATION
 // lldb-command:v x
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 102
+// lldb-check:[...] 102
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 102
+// lldb-check:[...] 102
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] -987
+// lldb-check:[...] -987
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 102
+// lldb-check:[...] 102
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-in-unique-closure.rs b/tests/debuginfo/lexical-scope-in-unique-closure.rs
index d6cf39c77ae13..db84005121aff 100644
--- a/tests/debuginfo/lexical-scope-in-unique-closure.rs
+++ b/tests/debuginfo/lexical-scope-in-unique-closure.rs
@@ -34,27 +34,27 @@
 // lldb-command:run
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 1000
+// lldb-check:[...] 1000
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 2.5
+// lldb-check:[...] 2.5
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/lexical-scope-in-while.rs b/tests/debuginfo/lexical-scope-in-while.rs
index faef8b44a2979..d6536d77545ba 100644
--- a/tests/debuginfo/lexical-scope-in-while.rs
+++ b/tests/debuginfo/lexical-scope-in-while.rs
@@ -66,57 +66,57 @@
 
 // FIRST ITERATION
 // lldb-command:v x
-// lldbg-check:[...] 0
+// lldb-check:[...] 0
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 101
+// lldb-check:[...] 101
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 101
+// lldb-check:[...] 101
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] -987
+// lldb-check:[...] -987
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 101
+// lldb-check:[...] 101
 // lldb-command:continue
 
 
 // SECOND ITERATION
 // lldb-command:v x
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 102
+// lldb-check:[...] 102
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 102
+// lldb-check:[...] 102
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] -987
+// lldb-check:[...] -987
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 102
+// lldb-check:[...] 102
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/lexical-scope-with-macro.rs b/tests/debuginfo/lexical-scope-with-macro.rs
index 5f8838c782bb5..6e8fef201eadc 100644
--- a/tests/debuginfo/lexical-scope-with-macro.rs
+++ b/tests/debuginfo/lexical-scope-with-macro.rs
@@ -54,48 +54,48 @@
 // lldb-command:run
 
 // lldb-command:v a
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:v b
-// lldbg-check:[...] 34
+// lldb-check:[...] 34
 // lldb-command:continue
 
 // lldb-command:v a
-// lldbg-check:[...] 890242
+// lldb-check:[...] 890242
 // lldb-command:v b
-// lldbg-check:[...] 34
+// lldb-check:[...] 34
 // lldb-command:continue
 
 // lldb-command:v a
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:v b
-// lldbg-check:[...] 34
+// lldb-check:[...] 34
 // lldb-command:continue
 
 // lldb-command:v a
-// lldbg-check:[...] 102
+// lldb-check:[...] 102
 // lldb-command:v b
-// lldbg-check:[...] 34
+// lldb-check:[...] 34
 // lldb-command:continue
 
-// lldbg-command:print a
-// lldbg-check:[...] 110
-// lldbg-command:print b
-// lldbg-check:[...] 34
-// lldbg-command:continue
-
-// lldbg-command:print a
-// lldbg-check:[...] 10
-// lldbg-command:print b
-// lldbg-check:[...] 34
-// lldbg-command:continue
-
-// lldbg-command:print a
-// lldbg-check:[...] 10
-// lldbg-command:print b
-// lldbg-check:[...] 34
-// lldbg-command:print c
-// lldbg-check:[...] 400
-// lldbg-command:continue
+// lldb-command:print a
+// lldb-check:[...] 110
+// lldb-command:print b
+// lldb-check:[...] 34
+// lldb-command:continue
+
+// lldb-command:print a
+// lldb-check:[...] 10
+// lldb-command:print b
+// lldb-check:[...] 34
+// lldb-command:continue
+
+// lldb-command:print a
+// lldb-check:[...] 10
+// lldb-command:print b
+// lldb-check:[...] 34
+// lldb-command:print c
+// lldb-check:[...] 400
+// lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
 #![omit_gdb_pretty_printer_section]
diff --git a/tests/debuginfo/lexical-scopes-in-block-expression.rs b/tests/debuginfo/lexical-scopes-in-block-expression.rs
index f90c3dd327bc4..cd27c88db58e9 100644
--- a/tests/debuginfo/lexical-scopes-in-block-expression.rs
+++ b/tests/debuginfo/lexical-scopes-in-block-expression.rs
@@ -183,155 +183,155 @@
 
 // STRUCT EXPRESSION
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] 11
+// lldb-check:[...] 11
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // FUNCTION CALL
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] 12
+// lldb-check:[...] 12
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // TUPLE EXPRESSION
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] 13
+// lldb-check:[...] 13
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // VEC EXPRESSION
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] 14
+// lldb-check:[...] 14
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // REPEAT VEC EXPRESSION
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] 15
+// lldb-check:[...] 15
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // ASSIGNMENT EXPRESSION
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] 16
+// lldb-check:[...] 16
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 
 // ARITHMETIC EXPRESSION
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] 17
+// lldb-check:[...] 17
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // INDEX EXPRESSION
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] 18
+// lldb-check:[...] 18
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v val
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v ten
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs
index 27e83cbbe2232..23617d46e8310 100644
--- a/tests/debuginfo/method-on-generic-struct.rs
+++ b/tests/debuginfo/method-on-generic-struct.rs
@@ -56,47 +56,47 @@
 
 // STACK BY REF
 // lldb-command:v *self
-// lldbg-check:[...] Struct<(u32, i32)> { x: (8888, -8888) }
+// lldb-check:[...] Struct<(u32, i32)> { x: (8888, -8888) }
 // lldb-command:v arg1
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v arg2
-// lldbg-check:[...] -2
+// lldb-check:[...] -2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
-// lldbg-check:[...] Struct<(u32, i32)> { x: (8888, -8888) }
+// lldb-check:[...] Struct<(u32, i32)> { x: (8888, -8888) }
 // lldb-command:v arg1
-// lldbg-check:[...] -3
+// lldb-check:[...] -3
 // lldb-command:v arg2
-// lldbg-check:[...] -4
+// lldb-check:[...] -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
-// lldbg-check:[...] Struct<f64> { x: 1234.5 }
+// lldb-check:[...] Struct<f64> { x: 1234.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -5
+// lldb-check:[...] -5
 // lldb-command:v arg2
-// lldbg-check:[...] -6
+// lldb-check:[...] -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
-// lldbg-check:[...] Struct<f64> { x: 1234.5 }
+// lldb-check:[...] Struct<f64> { x: 1234.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -7
+// lldb-check:[...] -7
 // lldb-command:v arg2
-// lldbg-check:[...] -8
+// lldb-check:[...] -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
-// lldbg-check:[...] Struct<f64> { x: 1234.5 }
+// lldb-check:[...] Struct<f64> { x: 1234.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -9
+// lldb-check:[...] -9
 // lldb-command:v arg2
-// lldbg-check:[...] -10
+// lldb-check:[...] -10
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/method-on-struct.rs b/tests/debuginfo/method-on-struct.rs
index 307c6d92d489a..91f609365e9a5 100644
--- a/tests/debuginfo/method-on-struct.rs
+++ b/tests/debuginfo/method-on-struct.rs
@@ -56,47 +56,47 @@
 
 // STACK BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { x = 100 }
+// lldb-check:[...] { x = 100 }
 // lldb-command:v arg1
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v arg2
-// lldbg-check:[...] -2
+// lldb-check:[...] -2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { x = 100 }
+// lldb-check:[...] { x = 100 }
 // lldb-command:v arg1
-// lldbg-check:[...] -3
+// lldb-check:[...] -3
 // lldb-command:v arg2
-// lldbg-check:[...] -4
+// lldb-check:[...] -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { x = 200 }
+// lldb-check:[...] { x = 200 }
 // lldb-command:v arg1
-// lldbg-check:[...] -5
+// lldb-check:[...] -5
 // lldb-command:v arg2
-// lldbg-check:[...] -6
+// lldb-check:[...] -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { x = 200 }
+// lldb-check:[...] { x = 200 }
 // lldb-command:v arg1
-// lldbg-check:[...] -7
+// lldb-check:[...] -7
 // lldb-command:v arg2
-// lldbg-check:[...] -8
+// lldb-check:[...] -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
-// lldbg-check:[...] { x = 200 }
+// lldb-check:[...] { x = 200 }
 // lldb-command:v arg1
-// lldbg-check:[...] -9
+// lldb-check:[...] -9
 // lldb-command:v arg2
-// lldbg-check:[...] -10
+// lldb-check:[...] -10
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/method-on-trait.rs b/tests/debuginfo/method-on-trait.rs
index 29087da0e6a67..7b95e1f81c701 100644
--- a/tests/debuginfo/method-on-trait.rs
+++ b/tests/debuginfo/method-on-trait.rs
@@ -56,47 +56,47 @@
 
 // STACK BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { x = 100 }
+// lldb-check:[...] { x = 100 }
 // lldb-command:v arg1
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v arg2
-// lldbg-check:[...] -2
+// lldb-check:[...] -2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { x = 100 }
+// lldb-check:[...] { x = 100 }
 // lldb-command:v arg1
-// lldbg-check:[...] -3
+// lldb-check:[...] -3
 // lldb-command:v arg2
-// lldbg-check:[...] -4
+// lldb-check:[...] -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { x = 200 }
+// lldb-check:[...] { x = 200 }
 // lldb-command:v arg1
-// lldbg-check:[...] -5
+// lldb-check:[...] -5
 // lldb-command:v arg2
-// lldbg-check:[...] -6
+// lldb-check:[...] -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { x = 200 }
+// lldb-check:[...] { x = 200 }
 // lldb-command:v arg1
-// lldbg-check:[...] -7
+// lldb-check:[...] -7
 // lldb-command:v arg2
-// lldbg-check:[...] -8
+// lldb-check:[...] -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
-// lldbg-check:[...] { x = 200 }
+// lldb-check:[...] { x = 200 }
 // lldb-command:v arg1
-// lldbg-check:[...] -9
+// lldb-check:[...] -9
 // lldb-command:v arg2
-// lldbg-check:[...] -10
+// lldb-check:[...] -10
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/method-on-tuple-struct.rs b/tests/debuginfo/method-on-tuple-struct.rs
index 7b8d30abf63c0..04c00d883025e 100644
--- a/tests/debuginfo/method-on-tuple-struct.rs
+++ b/tests/debuginfo/method-on-tuple-struct.rs
@@ -56,47 +56,47 @@
 
 // STACK BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { 0 = 100 1 = -100.5 }
+// lldb-check:[...] { 0 = 100 1 = -100.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v arg2
-// lldbg-check:[...] -2
+// lldb-check:[...] -2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { 0 = 100 1 = -100.5 }
+// lldb-check:[...] { 0 = 100 1 = -100.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -3
+// lldb-check:[...] -3
 // lldb-command:v arg2
-// lldbg-check:[...] -4
+// lldb-check:[...] -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { 0 = 200 1 = -200.5 }
+// lldb-check:[...] { 0 = 200 1 = -200.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -5
+// lldb-check:[...] -5
 // lldb-command:v arg2
-// lldbg-check:[...] -6
+// lldb-check:[...] -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { 0 = 200 1 = -200.5 }
+// lldb-check:[...] { 0 = 200 1 = -200.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -7
+// lldb-check:[...] -7
 // lldb-command:v arg2
-// lldbg-check:[...] -8
+// lldb-check:[...] -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
-// lldbg-check:[...] { 0 = 200 1 = -200.5 }
+// lldb-check:[...] { 0 = 200 1 = -200.5 }
 // lldb-command:v arg1
-// lldbg-check:[...] -9
+// lldb-check:[...] -9
 // lldb-command:v arg2
-// lldbg-check:[...] -10
+// lldb-check:[...] -10
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/msvc-pretty-enums.rs b/tests/debuginfo/msvc-pretty-enums.rs
index a2e2b32cfd116..d60a7b81944e7 100644
--- a/tests/debuginfo/msvc-pretty-enums.rs
+++ b/tests/debuginfo/msvc-pretty-enums.rs
@@ -6,72 +6,72 @@
 // lldb-command:run
 
 // lldb-command:v a
-// lldbg-check:(core::option::Option<msvc_pretty_enums::CStyleEnum>) a = { value = { 0 = Low } }
+// lldb-check:(core::option::Option<msvc_pretty_enums::CStyleEnum>) a = { value = { 0 = Low } }
 
 // lldb-command:v b
-// lldbg-check:(core::option::Option<msvc_pretty_enums::CStyleEnum>) b = { value = $discr$ = '\x01' }
+// lldb-check:(core::option::Option<msvc_pretty_enums::CStyleEnum>) b = { value = $discr$ = '\x01' }
 
 // lldb-command:v c
-// lldbg-check:(msvc_pretty_enums::NicheLayoutEnum) c = { value = $discr$ = '\x11' }
+// lldb-check:(msvc_pretty_enums::NicheLayoutEnum) c = { value = $discr$ = '\x11' }
 
 // lldb-command:v d
-// lldbg-check:(msvc_pretty_enums::NicheLayoutEnum) d = { value = { my_data = High } }
+// lldb-check:(msvc_pretty_enums::NicheLayoutEnum) d = { value = { my_data = High } }
 
 // lldb-command:v e
-// lldbg-check:(msvc_pretty_enums::NicheLayoutEnum) e = { value = $discr$ = '\x13' }
+// lldb-check:(msvc_pretty_enums::NicheLayoutEnum) e = { value = $discr$ = '\x13' }
 
 // lldb-command:v h
-// lldbg-check:(core::option::Option<u32>) h = { value = { 0 = 12 } $discr$ = 1 }
+// lldb-check:(core::option::Option<u32>) h = { value = { 0 = 12 } $discr$ = 1 }
 
 // lldb-command:v i
-// lldbg-check:(core::option::Option<u32>) i = { value = $discr$ = 0 }
+// lldb-check:(core::option::Option<u32>) i = { value = $discr$ = 0 }
 
 // lldb-command:v j
-// lldbg-check:(msvc_pretty_enums::CStyleEnum) j = High
+// lldb-check:(msvc_pretty_enums::CStyleEnum) j = High
 
 // lldb-command:v k
-// lldbg-check:(core::option::Option<alloc::string::String>) k = { value = { 0 = "IAMA optional string!" { vec = size=21 { [0] = 'I' [1] = 'A' [2] = 'M' [3] = 'A' [4] = ' ' [5] = 'o' [6] = 'p' [7] = 't' [8] = 'i' [9] = 'o' [10] = 'n' [11] = 'a' [12] = 'l' [13] = ' ' [14] = 's' [15] = 't' [16] = 'r' [17] = 'i' [18] = 'n' [19] = 'g' [20] = '!' } } } }
+// lldb-check:(core::option::Option<alloc::string::String>) k = { value = { 0 = "IAMA optional string!" { vec = size=21 { [0] = 'I' [1] = 'A' [2] = 'M' [3] = 'A' [4] = ' ' [5] = 'o' [6] = 'p' [7] = 't' [8] = 'i' [9] = 'o' [10] = 'n' [11] = 'a' [12] = 'l' [13] = ' ' [14] = 's' [15] = 't' [16] = 'r' [17] = 'i' [18] = 'n' [19] = 'g' [20] = '!' } } } }
 
 // lldb-command:v l
-// lldbg-check:(core::result::Result<u32, msvc_pretty_enums::Empty>) l = { value = { 0 = {} } }
+// lldb-check:(core::result::Result<u32, msvc_pretty_enums::Empty>) l = { value = { 0 = {} } }
 
 // lldb-command:v niche128_some
-// lldbg-check:(core::option::Option<core::num::nonzero::NonZero<i128>>) niche128_some = { value = $discr$ = 123456 }
+// lldb-check:(core::option::Option<core::num::nonzero::NonZero<i128>>) niche128_some = { value = $discr$ = 123456 }
 
 // lldb-command:v niche128_none
-// lldbg-check:(core::option::Option<core::num::nonzero::NonZero<i128>>) niche128_none = { value = $discr$ = 0 }
+// lldb-check:(core::option::Option<core::num::nonzero::NonZero<i128>>) niche128_none = { value = $discr$ = 0 }
 
 // lldb-command:v wrapping_niche128_untagged
-// lldbg-check:(msvc_pretty_enums::Wrapping128Niche) wrapping_niche128_untagged = { value = { 0 = { 0 = 340282366920938463463374607431768211454 } } }
+// lldb-check:(msvc_pretty_enums::Wrapping128Niche) wrapping_niche128_untagged = { value = { 0 = { 0 = 340282366920938463463374607431768211454 } } }
 
 // lldb-command:v wrapping_niche128_none1
-// lldbg-check:(msvc_pretty_enums::Wrapping128Niche) wrapping_niche128_none1 = { value = { 0 = { 0 = 2 } } }
+// lldb-check:(msvc_pretty_enums::Wrapping128Niche) wrapping_niche128_none1 = { value = { 0 = { 0 = 2 } } }
 
 // lldb-command:v direct_tag_128_a
-// lldbg-check:(msvc_pretty_enums::DirectTag128) direct_tag_128_a = { value = { 0 = 42 } $discr$ = 0 }
+// lldb-check:(msvc_pretty_enums::DirectTag128) direct_tag_128_a = { value = { 0 = 42 } $discr$ = 0 }
 
 // lldb-command:v direct_tag_128_b
-// lldbg-check:(msvc_pretty_enums::DirectTag128) direct_tag_128_b = { value = { 0 = 137 } $discr$ = 1 }
+// lldb-check:(msvc_pretty_enums::DirectTag128) direct_tag_128_b = { value = { 0 = 137 } $discr$ = 1 }
 
 // &u32 is incorrectly formatted and LLDB thinks it's a char* so skipping niche_w_fields_1_some
 
 // lldb-command:v niche_w_fields_1_none
-// lldbg-check:(msvc_pretty_enums::NicheLayoutWithFields1) niche_w_fields_1_none = { value = { 0 = 99 } $discr$ = 1 }
+// lldb-check:(msvc_pretty_enums::NicheLayoutWithFields1) niche_w_fields_1_none = { value = { 0 = 99 } $discr$ = 1 }
 
 // lldb-command:v niche_w_fields_2_some
-// lldbg-check:(msvc_pretty_enums::NicheLayoutWithFields2) niche_w_fields_2_some = { value = { 0 = 800 { __0 = { 0 = 800 } } 1 = 900 } $discr$ = 0 }
+// lldb-check:(msvc_pretty_enums::NicheLayoutWithFields2) niche_w_fields_2_some = { value = { 0 = 800 { __0 = { 0 = 800 } } 1 = 900 } $discr$ = 0 }
 
 // lldb-command:v niche_w_fields_3_some
-// lldbg-check:(msvc_pretty_enums::NicheLayoutWithFields3) niche_w_fields_3_some = { value = { 0 = '\x89' 1 = true } }
+// lldb-check:(msvc_pretty_enums::NicheLayoutWithFields3) niche_w_fields_3_some = { value = { 0 = '\x89' 1 = true } }
 
 // lldb-command:v niche_w_fields_3_niche3
-// lldbg-check:(msvc_pretty_enums::NicheLayoutWithFields3) niche_w_fields_3_niche3 = { value = { 0 = '"' } $discr$ = '\x04' }
+// lldb-check:(msvc_pretty_enums::NicheLayoutWithFields3) niche_w_fields_3_niche3 = { value = { 0 = '"' } $discr$ = '\x04' }
 
 // lldb-command:v arbitrary_discr1
-// lldbg-check:(msvc_pretty_enums::ArbitraryDiscr) arbitrary_discr1 = { value = { 0 = 1234 } $discr$ = 1000 }
+// lldb-check:(msvc_pretty_enums::ArbitraryDiscr) arbitrary_discr1 = { value = { 0 = 1234 } $discr$ = 1000 }
 
 // lldb-command:v arbitrary_discr2
-// lldbg-check:(msvc_pretty_enums::ArbitraryDiscr) arbitrary_discr2 = { value = { 0 = 5678 } $discr$ = 5000000 }
+// lldb-check:(msvc_pretty_enums::ArbitraryDiscr) arbitrary_discr2 = { value = { 0 = 5678 } $discr$ = 5000000 }
 
 // === CDB TESTS ==================================================================================
 
diff --git a/tests/debuginfo/multi-cgu.rs b/tests/debuginfo/multi-cgu.rs
index 81735f2bc09a3..3bb5269adeadd 100644
--- a/tests/debuginfo/multi-cgu.rs
+++ b/tests/debuginfo/multi-cgu.rs
@@ -21,11 +21,11 @@
 // lldb-command:run
 
 // lldb-command:v xxx
-// lldbg-check:[...] 12345
+// lldb-check:[...] 12345
 // lldb-command:continue
 
 // lldb-command:v yyy
-// lldbg-check:[...] 67890
+// lldb-check:[...] 67890
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/multiple-functions-equal-var-names.rs b/tests/debuginfo/multiple-functions-equal-var-names.rs
index cbf513ad0f71c..6ae9225d55c38 100644
--- a/tests/debuginfo/multiple-functions-equal-var-names.rs
+++ b/tests/debuginfo/multiple-functions-equal-var-names.rs
@@ -21,15 +21,15 @@
 // lldb-command:run
 
 // lldb-command:v abc
-// lldbg-check:[...] 10101
+// lldb-check:[...] 10101
 // lldb-command:continue
 
 // lldb-command:v abc
-// lldbg-check:[...] 20202
+// lldb-check:[...] 20202
 // lldb-command:continue
 
 // lldb-command:v abc
-// lldbg-check:[...] 30303
+// lldb-check:[...] 30303
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/multiple-functions.rs b/tests/debuginfo/multiple-functions.rs
index a113ce17855cf..3f7a0ded91b0b 100644
--- a/tests/debuginfo/multiple-functions.rs
+++ b/tests/debuginfo/multiple-functions.rs
@@ -21,15 +21,15 @@
 // lldb-command:run
 
 // lldb-command:v a
-// lldbg-check:[...] 10101
+// lldb-check:[...] 10101
 // lldb-command:continue
 
 // lldb-command:v b
-// lldbg-check:[...] 20202
+// lldb-check:[...] 20202
 // lldb-command:continue
 
 // lldb-command:v c
-// lldbg-check:[...] 30303
+// lldb-check:[...] 30303
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/name-shadowing-and-scope-nesting.rs b/tests/debuginfo/name-shadowing-and-scope-nesting.rs
index 9d1accd963be1..d3829b60713d7 100644
--- a/tests/debuginfo/name-shadowing-and-scope-nesting.rs
+++ b/tests/debuginfo/name-shadowing-and-scope-nesting.rs
@@ -46,39 +46,39 @@
 // lldb-command:run
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:v y
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:v y
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10.5
+// lldb-check:[...] 10.5
 // lldb-command:v y
-// lldbg-check:[...] 20
+// lldb-check:[...] 20
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:v y
-// lldbg-check:[...] 2220
+// lldb-check:[...] 2220
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 203203.5
+// lldb-check:[...] 203203.5
 // lldb-command:v y
-// lldbg-check:[...] 2220
+// lldb-check:[...] 2220
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10.5
+// lldb-check:[...] 10.5
 // lldb-command:v y
-// lldbg-check:[...] 20
+// lldb-check:[...] 20
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/packed-struct-with-destructor.rs b/tests/debuginfo/packed-struct-with-destructor.rs
index f715fdaea6fe5..f923d36953c7a 100644
--- a/tests/debuginfo/packed-struct-with-destructor.rs
+++ b/tests/debuginfo/packed-struct-with-destructor.rs
@@ -35,28 +35,28 @@
 // lldb-command:run
 
 // lldb-command:v packed
-// lldbg-check:[...] { x = 123 y = 234 z = 345 }
+// lldb-check:[...] { x = 123 y = 234 z = 345 }
 
 // lldb-command:v packedInPacked
-// lldbg-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } }
+// lldb-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } }
 
 // lldb-command:v packedInUnpacked
-// lldbg-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } }
+// lldb-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } }
 
 // lldb-command:v unpackedInPacked
-// lldbg-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 } c = { x = 543 y = 432 z = 321 } d = 210 }
+// lldb-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 } c = { x = 543 y = 432 z = 321 } d = 210 }
 
 // lldb-command:v packedInPackedWithDrop
-// lldbg-check:[...] { a = 11 b = { x = 22 y = 33 z = 44 } c = 55 d = { x = 66 y = 77 z = 88 } }
+// lldb-check:[...] { a = 11 b = { x = 22 y = 33 z = 44 } c = 55 d = { x = 66 y = 77 z = 88 } }
 
 // lldb-command:v packedInUnpackedWithDrop
-// lldbg-check:[...] { a = -11 b = { x = -22 y = -33 z = -44 } c = -55 d = { x = -66 y = -77 z = -88 } }
+// lldb-check:[...] { a = -11 b = { x = -22 y = -33 z = -44 } c = -55 d = { x = -66 y = -77 z = -88 } }
 
 // lldb-command:v unpackedInPackedWithDrop
-// lldbg-check:[...] { a = 98 b = { x = 87 y = 76 z = 65 } c = { x = 54 y = 43 z = 32 } d = 21 }
+// lldb-check:[...] { a = 98 b = { x = 87 y = 76 z = 65 } c = { x = 54 y = 43 z = 32 } d = 21 }
 
 // lldb-command:v deeplyNested
-// lldbg-check:[...] { a = { a = 1 b = { x = 2 y = 3 z = 4 } c = 5 d = { x = 6 y = 7 z = 8 } } b = { a = 9 b = { x = 10 y = 11 z = 12 } c = { x = 13 y = 14 z = 15 } d = 16 } c = { a = 17 b = { x = 18 y = 19 z = 20 } c = 21 d = { x = 22 y = 23 z = 24 } } d = { a = 25 b = { x = 26 y = 27 z = 28 } c = 29 d = { x = 30 y = 31 z = 32 } } e = { a = 33 b = { x = 34 y = 35 z = 36 } c = { x = 37 y = 38 z = 39 } d = 40 } f = { a = 41 b = { x = 42 y = 43 z = 44 } c = 45 d = { x = 46 y = 47 z = 48 } } }
+// lldb-check:[...] { a = { a = 1 b = { x = 2 y = 3 z = 4 } c = 5 d = { x = 6 y = 7 z = 8 } } b = { a = 9 b = { x = 10 y = 11 z = 12 } c = { x = 13 y = 14 z = 15 } d = 16 } c = { a = 17 b = { x = 18 y = 19 z = 20 } c = 21 d = { x = 22 y = 23 z = 24 } } d = { a = 25 b = { x = 26 y = 27 z = 28 } c = 29 d = { x = 30 y = 31 z = 32 } } e = { a = 33 b = { x = 34 y = 35 z = 36 } c = { x = 37 y = 38 z = 39 } d = 40 } f = { a = 41 b = { x = 42 y = 43 z = 44 } c = 45 d = { x = 46 y = 47 z = 48 } } }
 
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/packed-struct.rs b/tests/debuginfo/packed-struct.rs
index 5f5233e3732de..2b3652fe86113 100644
--- a/tests/debuginfo/packed-struct.rs
+++ b/tests/debuginfo/packed-struct.rs
@@ -28,22 +28,22 @@
 // lldb-command:run
 
 // lldb-command:v packed
-// lldbg-check:[...] { x = 123 y = 234 z = 345 }
+// lldb-check:[...] { x = 123 y = 234 z = 345 }
 
 // lldb-command:v packedInPacked
-// lldbg-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } }
+// lldb-check:[...] { a = 1111 b = { x = 2222 y = 3333 z = 4444 } c = 5555 d = { x = 6666 y = 7777 z = 8888 } }
 
 // lldb-command:v packedInUnpacked
-// lldbg-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } }
+// lldb-check:[...] { a = -1111 b = { x = -2222 y = -3333 z = -4444 } c = -5555 d = { x = -6666 y = -7777 z = -8888 } }
 
 // lldb-command:v unpackedInPacked
-// lldbg-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 w = 543 } c = { x = 432 y = 321 z = 210 w = 109 } d = -98 }
+// lldb-check:[...] { a = 987 b = { x = 876 y = 765 z = 654 w = 543 } c = { x = 432 y = 321 z = 210 w = 109 } d = -98 }
 
 // lldb-command:expr sizeof(packed)
-// lldbg-check:[...] 14
+// lldb-check:[...] 14
 
 // lldb-command:expr sizeof(packedInPacked)
-// lldbg-check:[...] 40
+// lldb-check:[...] 40
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/pretty-std-collections.rs b/tests/debuginfo/pretty-std-collections.rs
index 2489d6d413621..5e133ee718e2e 100644
--- a/tests/debuginfo/pretty-std-collections.rs
+++ b/tests/debuginfo/pretty-std-collections.rs
@@ -52,16 +52,16 @@
 // lldb-command:run
 
 // lldb-command:v vec_deque
-// lldbg-check:[...] size=3 { [0] = 5 [1] = 3 [2] = 7 }
+// lldb-check:[...] size=3 { [0] = 5 [1] = 3 [2] = 7 }
 
 // lldb-command:v vec_deque2
-// lldbg-check:[...] size=7 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 [4] = 6 [5] = 7 [6] = 8 }
+// lldb-check:[...] size=7 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 [4] = 6 [5] = 7 [6] = 8 }
 
 // lldb-command:v hash_map
-// lldbg-check:[...] size=4 { [0] = { 0 = 1 1 = 10 } [1] = { 0 = 2 1 = 20 } [2] = { 0 = 3 1 = 30 } [3] = { 0 = 4 1 = 40 } }
+// lldb-check:[...] size=4 { [0] = { 0 = 1 1 = 10 } [1] = { 0 = 2 1 = 20 } [2] = { 0 = 3 1 = 30 } [3] = { 0 = 4 1 = 40 } }
 
 // lldb-command:v hash_set
-// lldbg-check:[...] size=4 { [0] = 1 [1] = 2 [2] = 3 [3] = 4 }
+// lldb-check:[...] size=4 { [0] = 1 [1] = 2 [2] = 3 [3] = 4 }
 
 #![allow(unused_variables)]
 use std::collections::BTreeMap;
diff --git a/tests/debuginfo/reference-debuginfo.rs b/tests/debuginfo/reference-debuginfo.rs
index 3889c1f5ba8f4..773c3ae4bc366 100644
--- a/tests/debuginfo/reference-debuginfo.rs
+++ b/tests/debuginfo/reference-debuginfo.rs
@@ -60,50 +60,50 @@
 
 // lldb-command:run
 // lldb-command:v *bool_ref
-// lldbg-check:[...] true
+// lldb-check:[...] true
 
 // lldb-command:v *int_ref
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 
 
 // lldb-command:v *i8_ref
-// lldbg-check:[...] 'D'
+// lldb-check:[...] 'D'
 
 // lldb-command:v *i16_ref
-// lldbg-check:[...] -16
+// lldb-check:[...] -16
 
 // lldb-command:v *i32_ref
-// lldbg-check:[...] -32
+// lldb-check:[...] -32
 
 // lldb-command:v *i64_ref
-// lldbg-check:[...] -64
+// lldb-check:[...] -64
 
 // lldb-command:v *uint_ref
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 
 // lldb-command:v *u8_ref
-// lldbg-check:[...] 'd'
+// lldb-check:[...] 'd'
 
 // lldb-command:v *u16_ref
-// lldbg-check:[...] 16
+// lldb-check:[...] 16
 
 // lldb-command:v *u32_ref
-// lldbg-check:[...] 32
+// lldb-check:[...] 32
 
 // lldb-command:v *u64_ref
-// lldbg-check:[...] 64
+// lldb-check:[...] 64
 
 // lldb-command:v *f16_ref
-// lldbg-check:[...] 1.5
+// lldb-check:[...] 1.5
 
 // lldb-command:v *f32_ref
-// lldbg-check:[...] 2.5
+// lldb-check:[...] 2.5
 
 // lldb-command:v *f64_ref
-// lldbg-check:[...] 3.5
+// lldb-check:[...] 3.5
 
 // lldb-command:v *f64_double_ref
-// lldbg-check:[...] 3.5
+// lldb-check:[...] 3.5
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/regression-bad-location-list-67992.rs b/tests/debuginfo/regression-bad-location-list-67992.rs
index 6502cce3700f9..0ec474b5b5af9 100644
--- a/tests/debuginfo/regression-bad-location-list-67992.rs
+++ b/tests/debuginfo/regression-bad-location-list-67992.rs
@@ -11,7 +11,7 @@
 
 // lldb-command:run
 // lldb-command:v a
-// lldbg-check:(regression_bad_location_list_67992::Foo) [...]
+// lldb-check:(regression_bad_location_list_67992::Foo) [...]
 
 const ARRAY_SIZE: usize = 1024;
 
diff --git a/tests/debuginfo/self-in-default-method.rs b/tests/debuginfo/self-in-default-method.rs
index 8c607d0121059..02fc01d96eb3c 100644
--- a/tests/debuginfo/self-in-default-method.rs
+++ b/tests/debuginfo/self-in-default-method.rs
@@ -56,47 +56,47 @@
 
 // STACK BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { x = 100 }
+// lldb-check:[...] { x = 100 }
 // lldb-command:v arg1
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v arg2
-// lldbg-check:[...] -2
+// lldb-check:[...] -2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { x = 100 }
+// lldb-check:[...] { x = 100 }
 // lldb-command:v arg1
-// lldbg-check:[...] -3
+// lldb-check:[...] -3
 // lldb-command:v arg2
-// lldbg-check:[...] -4
+// lldb-check:[...] -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { x = 200 }
+// lldb-check:[...] { x = 200 }
 // lldb-command:v arg1
-// lldbg-check:[...] -5
+// lldb-check:[...] -5
 // lldb-command:v arg2
-// lldbg-check:[...] -6
+// lldb-check:[...] -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { x = 200 }
+// lldb-check:[...] { x = 200 }
 // lldb-command:v arg1
-// lldbg-check:[...] -7
+// lldb-check:[...] -7
 // lldb-command:v arg2
-// lldbg-check:[...] -8
+// lldb-check:[...] -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
-// lldbg-check:[...] { x = 200 }
+// lldb-check:[...] { x = 200 }
 // lldb-command:v arg1
-// lldbg-check:[...] -9
+// lldb-check:[...] -9
 // lldb-command:v arg2
-// lldbg-check:[...] -10
+// lldb-check:[...] -10
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/self-in-generic-default-method.rs b/tests/debuginfo/self-in-generic-default-method.rs
index 71d1f2d52d265..65018e549ee04 100644
--- a/tests/debuginfo/self-in-generic-default-method.rs
+++ b/tests/debuginfo/self-in-generic-default-method.rs
@@ -56,47 +56,47 @@
 
 // STACK BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { x = 987 }
+// lldb-check:[...] { x = 987 }
 // lldb-command:v arg1
-// lldbg-check:[...] -1
+// lldb-check:[...] -1
 // lldb-command:v arg2
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:continue
 
 // STACK BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { x = 987 }
+// lldb-check:[...] { x = 987 }
 // lldb-command:v arg1
-// lldbg-check:[...] -3
+// lldb-check:[...] -3
 // lldb-command:v arg2
-// lldbg-check:[...] -4
+// lldb-check:[...] -4
 // lldb-command:continue
 
 // OWNED BY REF
 // lldb-command:v *self
-// lldbg-check:[...] { x = 879 }
+// lldb-check:[...] { x = 879 }
 // lldb-command:v arg1
-// lldbg-check:[...] -5
+// lldb-check:[...] -5
 // lldb-command:v arg2
-// lldbg-check:[...] -6
+// lldb-check:[...] -6
 // lldb-command:continue
 
 // OWNED BY VAL
 // lldb-command:v self
-// lldbg-check:[...] { x = 879 }
+// lldb-check:[...] { x = 879 }
 // lldb-command:v arg1
-// lldbg-check:[...] -7
+// lldb-check:[...] -7
 // lldb-command:v arg2
-// lldbg-check:[...] -8
+// lldb-check:[...] -8
 // lldb-command:continue
 
 // OWNED MOVED
 // lldb-command:v *self
-// lldbg-check:[...] { x = 879 }
+// lldb-check:[...] { x = 879 }
 // lldb-command:v arg1
-// lldbg-check:[...] -9
+// lldb-check:[...] -9
 // lldb-command:v arg2
-// lldbg-check:[...] -10.5
+// lldb-check:[...] -10.5
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/shadowed-argument.rs b/tests/debuginfo/shadowed-argument.rs
index b4da794ef9557..3a575b4addfd5 100644
--- a/tests/debuginfo/shadowed-argument.rs
+++ b/tests/debuginfo/shadowed-argument.rs
@@ -28,21 +28,21 @@
 // lldb-command:run
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:v y
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:v y
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10.5
+// lldb-check:[...] 10.5
 // lldb-command:v y
-// lldbg-check:[...] 20
+// lldb-check:[...] 20
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/shadowed-variable.rs b/tests/debuginfo/shadowed-variable.rs
index cbbad4c2b7cb6..752e4c233f12e 100644
--- a/tests/debuginfo/shadowed-variable.rs
+++ b/tests/debuginfo/shadowed-variable.rs
@@ -39,33 +39,33 @@
 // lldb-command:run
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:v y
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:v y
-// lldbg-check:[...] true
+// lldb-check:[...] true
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10.5
+// lldb-check:[...] 10.5
 // lldb-command:v y
-// lldbg-check:[...] 20
+// lldb-check:[...] 20
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10.5
+// lldb-check:[...] 10.5
 // lldb-command:v y
-// lldbg-check:[...] 20
+// lldb-check:[...] 20
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 11.5
+// lldb-check:[...] 11.5
 // lldb-command:v y
-// lldbg-check:[...] 20
+// lldb-check:[...] 20
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/simple-lexical-scope.rs b/tests/debuginfo/simple-lexical-scope.rs
index 82737b04b6447..6008489bd65db 100644
--- a/tests/debuginfo/simple-lexical-scope.rs
+++ b/tests/debuginfo/simple-lexical-scope.rs
@@ -38,31 +38,31 @@
 // lldb-command:run
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10.5
+// lldb-check:[...] 10.5
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] 10
+// lldb-check:[...] 10
 // lldb-command:continue
 
 // lldb-command:v x
-// lldbg-check:[...] false
+// lldb-check:[...] false
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/simple-struct.rs b/tests/debuginfo/simple-struct.rs
index 9fe4d3c8d3fac..bb6b2b798102c 100644
--- a/tests/debuginfo/simple-struct.rs
+++ b/tests/debuginfo/simple-struct.rs
@@ -65,22 +65,22 @@
 // lldb-command:run
 
 // lldb-command:v no_padding16
-// lldbg-check:[...] { x = 10000 y = -10001 }
+// lldb-check:[...] { x = 10000 y = -10001 }
 
 // lldb-command:v no_padding32
-// lldbg-check:[...] { x = -10002 y = -10003.5 z = 10004 }
+// lldb-check:[...] { x = -10002 y = -10003.5 z = 10004 }
 
 // lldb-command:v no_padding64
-// lldbg-check:[...] { x = -10005.5 y = 10006 z = 10007 }
+// lldb-check:[...] { x = -10005.5 y = 10006 z = 10007 }
 
 // lldb-command:v no_padding163264
-// lldbg-check:[...] { a = -10008 b = 10009 c = 10010 d = 10011 }
+// lldb-check:[...] { a = -10008 b = 10009 c = 10010 d = 10011 }
 
 // lldb-command:v internal_padding
-// lldbg-check:[...] { x = 10012 y = -10013 }
+// lldb-check:[...] { x = 10012 y = -10013 }
 
 // lldb-command:v padding_at_end
-// lldbg-check:[...] { x = -10014 y = 10015 }
+// lldb-check:[...] { x = -10014 y = 10015 }
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
diff --git a/tests/debuginfo/simple-tuple.rs b/tests/debuginfo/simple-tuple.rs
index f267fc7d8d94c..82467ef3bcf20 100644
--- a/tests/debuginfo/simple-tuple.rs
+++ b/tests/debuginfo/simple-tuple.rs
@@ -61,21 +61,21 @@
 // lldb-command:run
 
 // lldb-command:v/d noPadding8
-// lldbg-check:[...] { 0 = -100 1 = 100 }
+// lldb-check:[...] { 0 = -100 1 = 100 }
 // lldb-command:v noPadding16
-// lldbg-check:[...] { 0 = 0 1 = 1 2 = 2 }
+// lldb-check:[...] { 0 = 0 1 = 1 2 = 2 }
 // lldb-command:v noPadding32
-// lldbg-check:[...] { 0 = 3 1 = 4.5 2 = 5 }
+// lldb-check:[...] { 0 = 3 1 = 4.5 2 = 5 }
 // lldb-command:v noPadding64
-// lldbg-check:[...] { 0 = 6 1 = 7.5 2 = 8 }
+// lldb-check:[...] { 0 = 6 1 = 7.5 2 = 8 }
 
 // lldb-command:v internalPadding1
-// lldbg-check:[...] { 0 = 9 1 = 10 }
+// lldb-check:[...] { 0 = 9 1 = 10 }
 // lldb-command:v internalPadding2
-// lldbg-check:[...] { 0 = 11 1 = 12 2 = 13 3 = 14 }
+// lldb-check:[...] { 0 = 11 1 = 12 2 = 13 3 = 14 }
 
 // lldb-command:v paddingAtEnd
-// lldbg-check:[...] { 0 = 15 1 = 16 }
+// lldb-check:[...] { 0 = 15 1 = 16 }
 
 
 // === CDB TESTS ==================================================================================
diff --git a/tests/debuginfo/static-method-on-struct-and-enum.rs b/tests/debuginfo/static-method-on-struct-and-enum.rs
index 5d2932e378dfd..b487512a52f13 100644
--- a/tests/debuginfo/static-method-on-struct-and-enum.rs
+++ b/tests/debuginfo/static-method-on-struct-and-enum.rs
@@ -27,18 +27,18 @@
 
 // STRUCT
 // lldb-command:v arg1
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v arg2
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:continue
 
 // ENUM
 // lldb-command:v arg1
-// lldbg-check:[...] -3
+// lldb-check:[...] -3
 // lldb-command:v arg2
-// lldbg-check:[...] 4.5
+// lldb-check:[...] 4.5
 // lldb-command:v arg3
-// lldbg-check:[...] 5
+// lldb-check:[...] 5
 // lldb-command:continue
 
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/strings-and-strs.rs b/tests/debuginfo/strings-and-strs.rs
index c109b40230097..b7ee3312d1311 100644
--- a/tests/debuginfo/strings-and-strs.rs
+++ b/tests/debuginfo/strings-and-strs.rs
@@ -25,19 +25,19 @@
 // === LLDB TESTS ==================================================================================
 // lldb-command:run
 // lldb-command:v plain_string
-// lldbg-check:(alloc::string::String) plain_string = "Hello" { vec = size=5 { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } }
+// lldb-check:(alloc::string::String) plain_string = "Hello" { vec = size=5 { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } }
 
 // lldb-command:v plain_str
-// lldbg-check:(&str) plain_str = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' }
+// lldb-check:(&str) plain_str = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' }
 
 // lldb-command:v str_in_struct
-// lldbg-check:((&str, &str)) str_in_tuple = { 0 = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } 1 = "World" { [0] = 'W' [1] = 'o' [2] = 'r' [3] = 'l' [4] = 'd' } }
+// lldb-check:((&str, &str)) str_in_tuple = { 0 = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } 1 = "World" { [0] = 'W' [1] = 'o' [2] = 'r' [3] = 'l' [4] = 'd' } }
 
 // lldb-command:v str_in_tuple
-// lldbg-check:((&str, &str)) str_in_tuple = { 0 = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } 1 = "World" { [0] = 'W' [1] = 'o' [2] = 'r' [3] = 'l' [4] = 'd' } }
+// lldb-check:((&str, &str)) str_in_tuple = { 0 = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } 1 = "World" { [0] = 'W' [1] = 'o' [2] = 'r' [3] = 'l' [4] = 'd' } }
 
 // lldb-command:v str_in_rc
-// lldbg-check:(alloc::rc::Rc<&str, alloc::alloc::Global>) str_in_rc = strong=1, weak=0 { value = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } }
+// lldb-check:(alloc::rc::Rc<&str, alloc::alloc::Global>) str_in_rc = strong=1, weak=0 { value = "Hello" { [0] = 'H' [1] = 'e' [2] = 'l' [3] = 'l' [4] = 'o' } }
 
 
 #![allow(unused_variables)]
diff --git a/tests/debuginfo/struct-in-struct.rs b/tests/debuginfo/struct-in-struct.rs
index 5dde8079f9aa2..3cf48470391b8 100644
--- a/tests/debuginfo/struct-in-struct.rs
+++ b/tests/debuginfo/struct-in-struct.rs
@@ -19,28 +19,28 @@
 // lldb-command:run
 
 // lldb-command:v three_simple_structs
-// lldbg-check:[...] { x = { x = 1 } y = { x = 2 } z = { x = 3 } }
+// lldb-check:[...] { x = { x = 1 } y = { x = 2 } z = { x = 3 } }
 
 // lldb-command:v internal_padding_parent
-// lldbg-check:[...] { x = { x = 4 y = 5 } y = { x = 6 y = 7 } z = { x = 8 y = 9 } }
+// lldb-check:[...] { x = { x = 4 y = 5 } y = { x = 6 y = 7 } z = { x = 8 y = 9 } }
 
 // lldb-command:v padding_at_end_parent
-// lldbg-check:[...] { x = { x = 10 y = 11 } y = { x = 12 y = 13 } z = { x = 14 y = 15 } }
+// lldb-check:[...] { x = { x = 10 y = 11 } y = { x = 12 y = 13 } z = { x = 14 y = 15 } }
 
 // lldb-command:v mixed
-// lldbg-check:[...] { x = { x = 16 y = 17 } y = { x = 18 y = 19 } z = { x = 20 } w = 21 }
+// lldb-check:[...] { x = { x = 16 y = 17 } y = { x = 18 y = 19 } z = { x = 20 } w = 21 }
 
 // lldb-command:v bag
-// lldbg-check:[...] { x = { x = 22 } }
+// lldb-check:[...] { x = { x = 22 } }
 
 // lldb-command:v bag_in_bag
-// lldbg-check:[...] { x = { x = { x = 23 } } }
+// lldb-check:[...] { x = { x = { x = 23 } } }
 
 // lldb-command:v tjo
-// lldbg-check:[...] { x = { x = { x = { x = 24 } } } }
+// lldb-check:[...] { x = { x = { x = { x = 24 } } } }
 
 // lldb-command:v tree
-// lldbg-check:[...] { x = { x = 25 } y = { x = { x = 26 y = 27 } y = { x = 28 y = 29 } z = { x = 30 y = 31 } } z = { x = { x = { x = 32 } } } }
+// lldb-check:[...] { x = { x = 25 } y = { x = { x = 26 y = 27 } y = { x = 28 y = 29 } z = { x = 30 y = 31 } } z = { x = { x = { x = 32 } } } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/struct-namespace.rs b/tests/debuginfo/struct-namespace.rs
index aacc1d3825d74..9578841910034 100644
--- a/tests/debuginfo/struct-namespace.rs
+++ b/tests/debuginfo/struct-namespace.rs
@@ -5,14 +5,14 @@
 
 // lldb-command:run
 // lldb-command:v struct1
-// lldbg-check:(struct_namespace::Struct1)[...]
+// lldb-check:(struct_namespace::Struct1)[...]
 // lldb-command:v struct2
-// lldbg-check:(struct_namespace::Struct2)[...]
+// lldb-check:(struct_namespace::Struct2)[...]
 
 // lldb-command:v mod1_struct1
-// lldbg-check:(struct_namespace::mod1::Struct1)[...]
+// lldb-check:(struct_namespace::mod1::Struct1)[...]
 // lldb-command:v mod1_struct2
-// lldbg-check:(struct_namespace::mod1::Struct2)[...]
+// lldb-check:(struct_namespace::mod1::Struct2)[...]
 
 #![allow(unused_variables)]
 #![allow(dead_code)]
diff --git a/tests/debuginfo/struct-style-enum.rs b/tests/debuginfo/struct-style-enum.rs
index c2f7fb688ed21..cea9f3def8bc3 100644
--- a/tests/debuginfo/struct-style-enum.rs
+++ b/tests/debuginfo/struct-style-enum.rs
@@ -24,16 +24,16 @@
 // lldb-command:run
 
 // lldb-command:v case1
-// lldbg-check:(struct_style_enum::Regular) case1 = { value = { a = 0 b = 31868 c = 31868 d = 31868 e = 31868 } $discr$ = 0 }
+// lldb-check:(struct_style_enum::Regular) case1 = { value = { a = 0 b = 31868 c = 31868 d = 31868 e = 31868 } $discr$ = 0 }
 
 // lldb-command:v case2
-// lldbg-check:(struct_style_enum::Regular) case2 = { value = { a = 0 b = 286331153 c = 286331153 } $discr$ = 1 }
+// lldb-check:(struct_style_enum::Regular) case2 = { value = { a = 0 b = 286331153 c = 286331153 } $discr$ = 1 }
 
 // lldb-command:v case3
-// lldbg-check:(struct_style_enum::Regular) case3 = { value = { a = 0 b = 6438275382588823897 } $discr$ = 2 }
+// lldb-check:(struct_style_enum::Regular) case3 = { value = { a = 0 b = 6438275382588823897 } $discr$ = 2 }
 
 // lldb-command:v univariant
-// lldbg-check:(struct_style_enum::Univariant) univariant = { value = { a = -1 } }
+// lldb-check:(struct_style_enum::Univariant) univariant = { value = { a = -1 } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/struct-with-destructor.rs b/tests/debuginfo/struct-with-destructor.rs
index 654a574ebb5e5..c159824980a20 100644
--- a/tests/debuginfo/struct-with-destructor.rs
+++ b/tests/debuginfo/struct-with-destructor.rs
@@ -20,16 +20,16 @@
 
 // lldb-command:run
 // lldb-command:v simple
-// lldbg-check:[...] { x = 10 y = 20 }
+// lldb-check:[...] { x = 10 y = 20 }
 
 // lldb-command:v noDestructor
-// lldbg-check:[...] { a = { x = 10 y = 20 } guard = -1 }
+// lldb-check:[...] { a = { x = 10 y = 20 } guard = -1 }
 
 // lldb-command:v withDestructor
-// lldbg-check:[...] { a = { x = 10 y = 20 } guard = -1 }
+// lldb-check:[...] { a = { x = 10 y = 20 } guard = -1 }
 
 // lldb-command:v nested
-// lldbg-check:[...] { a = { a = { x = 7890 y = 9870 } } }
+// lldb-check:[...] { a = { a = { x = 7890 y = 9870 } } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/tuple-in-tuple.rs b/tests/debuginfo/tuple-in-tuple.rs
index 74ccaf14d00b1..d4388095ad721 100644
--- a/tests/debuginfo/tuple-in-tuple.rs
+++ b/tests/debuginfo/tuple-in-tuple.rs
@@ -27,21 +27,21 @@
 // lldb-command:run
 
 // lldb-command:v no_padding1
-// lldbg-check:[...] { 0 = { 0 = 0 1 = 1 } 1 = 2 2 = 3 }
+// lldb-check:[...] { 0 = { 0 = 0 1 = 1 } 1 = 2 2 = 3 }
 // lldb-command:v no_padding2
-// lldbg-check:[...] { 0 = 4 1 = { 0 = 5 1 = 6 } 2 = 7 }
+// lldb-check:[...] { 0 = 4 1 = { 0 = 5 1 = 6 } 2 = 7 }
 // lldb-command:v no_padding3
-// lldbg-check:[...] { 0 = 8 1 = 9 2 = { 0 = 10 1 = 11 } }
+// lldb-check:[...] { 0 = 8 1 = 9 2 = { 0 = 10 1 = 11 } }
 
 // lldb-command:v internal_padding1
-// lldbg-check:[...] { 0 = 12 1 = { 0 = 13 1 = 14 } }
+// lldb-check:[...] { 0 = 12 1 = { 0 = 13 1 = 14 } }
 // lldb-command:v internal_padding2
-// lldbg-check:[...] { 0 = 15 1 = { 0 = 16 1 = 17 } }
+// lldb-check:[...] { 0 = 15 1 = { 0 = 16 1 = 17 } }
 
 // lldb-command:v padding_at_end1
-// lldbg-check:[...] { 0 = 18 1 = { 0 = 19 1 = 20 } }
+// lldb-check:[...] { 0 = 18 1 = { 0 = 19 1 = 20 } }
 // lldb-command:v padding_at_end2
-// lldbg-check:[...] { 0 = { 0 = 21 1 = 22 } 1 = 23 }
+// lldb-check:[...] { 0 = { 0 = 21 1 = 22 } 1 = 23 }
 
 
 // === CDB TESTS ==================================================================================
diff --git a/tests/debuginfo/tuple-struct.rs b/tests/debuginfo/tuple-struct.rs
index f9755a8a0d5bd..0110203a7c79e 100644
--- a/tests/debuginfo/tuple-struct.rs
+++ b/tests/debuginfo/tuple-struct.rs
@@ -28,22 +28,22 @@
 // lldb-command:run
 
 // lldb-command:v no_padding16
-// lldbg-check:[...] { 0 = 10000 1 = -10001 }
+// lldb-check:[...] { 0 = 10000 1 = -10001 }
 
 // lldb-command:v no_padding32
-// lldbg-check:[...] { 0 = -10002 1 = -10003.5 2 = 10004 }
+// lldb-check:[...] { 0 = -10002 1 = -10003.5 2 = 10004 }
 
 // lldb-command:v no_padding64
-// lldbg-check:[...] { 0 = -10005.5 1 = 10006 2 = 10007 }
+// lldb-check:[...] { 0 = -10005.5 1 = 10006 2 = 10007 }
 
 // lldb-command:v no_padding163264
-// lldbg-check:[...] { 0 = -10008 1 = 10009 2 = 10010 3 = 10011 }
+// lldb-check:[...] { 0 = -10008 1 = 10009 2 = 10010 3 = 10011 }
 
 // lldb-command:v internal_padding
-// lldbg-check:[...] { 0 = 10012 1 = -10013 }
+// lldb-check:[...] { 0 = 10012 1 = -10013 }
 
 // lldb-command:v padding_at_end
-// lldbg-check:[...] { 0 = -10014 1 = 10015 }
+// lldb-check:[...] { 0 = -10014 1 = 10015 }
 
 // This test case mainly makes sure that no field names are generated for tuple structs (as opposed
 // to all fields having the name "<unnamed_field>"). Otherwise they are handled the same a normal
diff --git a/tests/debuginfo/tuple-style-enum.rs b/tests/debuginfo/tuple-style-enum.rs
index efdf8c6970e25..a759ad61c056c 100644
--- a/tests/debuginfo/tuple-style-enum.rs
+++ b/tests/debuginfo/tuple-style-enum.rs
@@ -25,16 +25,16 @@
 // lldb-command:run
 
 // lldb-command:v case1
-// lldbg-check:(tuple_style_enum::Regular) case1 = { value = { 0 = 0 1 = 31868 2 = 31868 3 = 31868 4 = 31868 } $discr$ = 0 }
+// lldb-check:(tuple_style_enum::Regular) case1 = { value = { 0 = 0 1 = 31868 2 = 31868 3 = 31868 4 = 31868 } $discr$ = 0 }
 
 // lldb-command:v case2
-// lldbg-check:(tuple_style_enum::Regular) case2 = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 }
+// lldb-check:(tuple_style_enum::Regular) case2 = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 }
 
 // lldb-command:v case3
-// lldbg-check:(tuple_style_enum::Regular) case3 = { value = { 0 = 0 1 = 6438275382588823897 } $discr$ = 2 }
+// lldb-check:(tuple_style_enum::Regular) case3 = { value = { 0 = 0 1 = 6438275382588823897 } $discr$ = 2 }
 
 // lldb-command:v univariant
-// lldbg-check:(tuple_style_enum::Univariant) univariant = { value = { 0 = -1 } }
+// lldb-check:(tuple_style_enum::Univariant) univariant = { value = { 0 = -1 } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/union-smoke.rs b/tests/debuginfo/union-smoke.rs
index 73617df10b137..6043240069e39 100644
--- a/tests/debuginfo/union-smoke.rs
+++ b/tests/debuginfo/union-smoke.rs
@@ -12,10 +12,10 @@
 
 // lldb-command:run
 // lldb-command:v u
-// lldbg-check:[...] { a = { 0 = '\x02' 1 = '\x02' } b = 514 }
+// lldb-check:[...] { a = { 0 = '\x02' 1 = '\x02' } b = 514 }
 
-// lldbg-command:print union_smoke::SU
-// lldbg-check:[...] { a = { 0 = '\x01' 1 = '\x01' } b = 257 }
+// lldb-command:print union_smoke::SU
+// lldb-check:[...] { a = { 0 = '\x01' 1 = '\x01' } b = 257 }
 
 #![allow(unused)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/unique-enum.rs b/tests/debuginfo/unique-enum.rs
index b9ee480c851a5..230429278aa59 100644
--- a/tests/debuginfo/unique-enum.rs
+++ b/tests/debuginfo/unique-enum.rs
@@ -21,13 +21,13 @@
 // lldb-command:run
 
 // lldb-command:v *the_a
-// lldbg-check:(unique_enum::ABC) *the_a = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 }
+// lldb-check:(unique_enum::ABC) *the_a = { value = { x = 0 y = 8970181431921507452 } $discr$ = 0 }
 
 // lldb-command:v *the_b
-// lldbg-check:(unique_enum::ABC) *the_b = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 }
+// lldb-check:(unique_enum::ABC) *the_b = { value = { 0 = 0 1 = 286331153 2 = 286331153 } $discr$ = 1 }
 
 // lldb-command:v *univariant
-// lldbg-check:(unique_enum::Univariant) *univariant = { value = { 0 = 123234 } }
+// lldb-check:(unique_enum::Univariant) *univariant = { value = { 0 = 123234 } }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/var-captured-in-nested-closure.rs b/tests/debuginfo/var-captured-in-nested-closure.rs
index 0f544c24b5bcf..4e8700015ba6c 100644
--- a/tests/debuginfo/var-captured-in-nested-closure.rs
+++ b/tests/debuginfo/var-captured-in-nested-closure.rs
@@ -38,31 +38,31 @@
 // lldb-command:run
 
 // lldb-command:v variable
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v constant
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:v a_struct
-// lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
+// lldb-check:[...] { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *struct_ref
-// lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
+// lldb-check:[...] { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *owned
-// lldbg-check:[...] 6
+// lldb-check:[...] 6
 // lldb-command:v closure_local
-// lldbg-check:[...] 8
+// lldb-check:[...] 8
 // lldb-command:continue
 
 // lldb-command:v variable
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v constant
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:v a_struct
-// lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
+// lldb-check:[...] { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *struct_ref
-// lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
+// lldb-check:[...] { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *owned
-// lldbg-check:[...] 6
+// lldb-check:[...] 6
 // lldb-command:v closure_local
-// lldbg-check:[...] 8
+// lldb-check:[...] 8
 // lldb-command:continue
 
 
diff --git a/tests/debuginfo/var-captured-in-sendable-closure.rs b/tests/debuginfo/var-captured-in-sendable-closure.rs
index 2d9e60744739b..cbb09daeb5f79 100644
--- a/tests/debuginfo/var-captured-in-sendable-closure.rs
+++ b/tests/debuginfo/var-captured-in-sendable-closure.rs
@@ -21,11 +21,11 @@
 // lldb-command:run
 
 // lldb-command:v constant
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v a_struct
-// lldbg-check:[...] { a = -2 b = 3.5 c = 4 }
+// lldb-check:[...] { a = -2 b = 3.5 c = 4 }
 // lldb-command:v *owned
-// lldbg-check:[...] 5
+// lldb-check:[...] 5
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/var-captured-in-stack-closure.rs b/tests/debuginfo/var-captured-in-stack-closure.rs
index d6c4b11b5f2c8..0f84ea57b0076 100644
--- a/tests/debuginfo/var-captured-in-stack-closure.rs
+++ b/tests/debuginfo/var-captured-in-stack-closure.rs
@@ -34,28 +34,28 @@
 // lldb-command:run
 
 // lldb-command:v variable
-// lldbg-check:[...] 1
+// lldb-check:[...] 1
 // lldb-command:v constant
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:v a_struct
-// lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
+// lldb-check:[...] { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *struct_ref
-// lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
+// lldb-check:[...] { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *owned
-// lldbg-check:[...] 6
+// lldb-check:[...] 6
 
 // lldb-command:continue
 
 // lldb-command:v variable
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:v constant
-// lldbg-check:[...] 2
+// lldb-check:[...] 2
 // lldb-command:v a_struct
-// lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
+// lldb-check:[...] { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *struct_ref
-// lldbg-check:[...] { a = -3 b = 4.5 c = 5 }
+// lldb-check:[...] { a = -3 b = 4.5 c = 5 }
 // lldb-command:v *owned
-// lldbg-check:[...] 6
+// lldb-check:[...] 6
 
 
 // === CDB TESTS ===================================================================================
diff --git a/tests/debuginfo/vec-slices.rs b/tests/debuginfo/vec-slices.rs
index 77d7b90ca0b5a..2b4d624976ab5 100644
--- a/tests/debuginfo/vec-slices.rs
+++ b/tests/debuginfo/vec-slices.rs
@@ -53,22 +53,22 @@
 // lldb-command:run
 
 // lldb-command:v empty
-// lldbg-check:[...] size=0
+// lldb-check:[...] size=0
 
 // lldb-command:v singleton
-// lldbg-check:[...] size=1 { [0] = 1 }
+// lldb-check:[...] size=1 { [0] = 1 }
 
 // lldb-command:v multiple
-// lldbg-check:[...] size=4 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 }
+// lldb-check:[...] size=4 { [0] = 2 [1] = 3 [2] = 4 [3] = 5 }
 
 // lldb-command:v slice_of_slice
-// lldbg-check:[...] size=2 { [0] = 3 [1] = 4 }
+// lldb-check:[...] size=2 { [0] = 3 [1] = 4 }
 
 // lldb-command:v padded_tuple
-// lldbg-check:[...] size=2 { [0] = { 0 = 6 1 = 7 } [1] = { 0 = 8 1 = 9 } }
+// lldb-check:[...] size=2 { [0] = { 0 = 6 1 = 7 } [1] = { 0 = 8 1 = 9 } }
 
 // lldb-command:v padded_struct
-// lldbg-check:[...] size=2 { [0] = { x = 10 y = 11 z = 12 } [1] = { x = 13 y = 14 z = 15 } }
+// lldb-check:[...] size=2 { [0] = { x = 10 y = 11 z = 12 } [1] = { x = 13 y = 14 z = 15 } }
 
 #![allow(dead_code, unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]
diff --git a/tests/debuginfo/vec.rs b/tests/debuginfo/vec.rs
index 3bb84d485730b..1093e38d87805 100644
--- a/tests/debuginfo/vec.rs
+++ b/tests/debuginfo/vec.rs
@@ -13,7 +13,7 @@
 
 // lldb-command:run
 // lldb-command:v a
-// lldbg-check:[...] { [0] = 1 [1] = 2 [2] = 3 }
+// lldb-check:[...] { [0] = 1 [1] = 2 [2] = 3 }
 
 #![allow(unused_variables)]
 #![feature(omit_gdb_pretty_printer_section)]

From 32185decd6875d5a86374043c7cfa77682b98ba3 Mon Sep 17 00:00:00 2001
From: RayMuir <rachelmuir0313@gmail.com>
Date: Fri, 15 Mar 2024 14:21:29 +0000
Subject: [PATCH 422/685] Added "copy" to Debug fmt for copy operands

---
 compiler/rustc_middle/src/mir/pretty.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 5dd0e69cf1fe6..76a25e45cdedc 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1159,7 +1159,7 @@ impl<'tcx> Debug for Operand<'tcx> {
         use self::Operand::*;
         match *self {
             Constant(ref a) => write!(fmt, "{a:?}"),
-            Copy(ref place) => write!(fmt, "{place:?}"),
+            Copy(ref place) => write!(fmt, "copy {place:?}"),
             Move(ref place) => write!(fmt, "move {place:?}"),
         }
     }

From b2dae987f8d0118be944434f0504f5fefd8737c4 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 18 Aug 2024 17:41:01 -0400
Subject: [PATCH 423/685] Fixup tests

---
 tests/debuginfo/associated-types.rs                 |  4 ++--
 tests/debuginfo/generic-method-on-generic-struct.rs |  4 ++--
 tests/debuginfo/generic-struct.rs                   |  8 ++++----
 tests/debuginfo/method-on-generic-struct.rs         | 10 +++++-----
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/tests/debuginfo/associated-types.rs b/tests/debuginfo/associated-types.rs
index 95e7421047292..b20bd5209368e 100644
--- a/tests/debuginfo/associated-types.rs
+++ b/tests/debuginfo/associated-types.rs
@@ -37,7 +37,7 @@
 // lldb-command:run
 
 // lldb-command:v arg
-// lldb-check:[...] { b = -1, b1 = 0 }
+// lldb-check:[...] { b = -1 b1 = 0 }
 // lldb-command:continue
 
 // lldb-command:v inferred
@@ -51,7 +51,7 @@
 // lldb-command:continue
 
 // lldb-command:v arg
-// lldb-check:[...] (4, 5)
+// lldb-check:[...] { 0 = 4 1 = 5 }
 // lldb-command:continue
 
 // lldb-command:v a
diff --git a/tests/debuginfo/generic-method-on-generic-struct.rs b/tests/debuginfo/generic-method-on-generic-struct.rs
index a391fbf082651..9c587ca2839bd 100644
--- a/tests/debuginfo/generic-method-on-generic-struct.rs
+++ b/tests/debuginfo/generic-method-on-generic-struct.rs
@@ -56,7 +56,7 @@
 
 // STACK BY REF
 // lldb-command:v *self
-// lldb-check:[...] { x = { 0 = 8888, 1 = -8888 } }
+// lldb-check:[...] { x = { 0 = 8888 1 = -8888 } }
 // lldb-command:v arg1
 // lldb-check:[...] -1
 // lldb-command:v arg2
@@ -65,7 +65,7 @@
 
 // STACK BY VAL
 // lldb-command:v self
-// lldb-check:[...] { x = { 0 = 8888, 1 = -8888 } }
+// lldb-check:[...] { x = { 0 = 8888 1 = -8888 } }
 // lldb-command:v arg1
 // lldb-check:[...] -3
 // lldb-command:v arg2
diff --git a/tests/debuginfo/generic-struct.rs b/tests/debuginfo/generic-struct.rs
index 09160bc3ba038..f26d823d4f2e7 100644
--- a/tests/debuginfo/generic-struct.rs
+++ b/tests/debuginfo/generic-struct.rs
@@ -18,14 +18,14 @@
 // lldb-command:run
 
 // lldb-command:v int_int
-// lldb-check:[...] AGenericStruct<i32, i32> { key: 0, value: 1 }
+// lldb-check:[...]AGenericStruct<int, int>) int_int = { key = 0 value = 1 }
 // lldb-command:v int_float
-// lldb-check:[...] AGenericStruct<i32, f64> { key: 2, value: 3.5 }
+// lldb-check:[...]AGenericStruct<int, double>) int_float = { key = 2 value = 3.5 }
 // lldb-command:v float_int
-// lldb-check:[...] AGenericStruct<f64, i32> { key: 4.5, value: 5 }
+// lldb-check:[...]AGenericStruct<double, int>) float_int = { key = 4.5 value = 5 }
 
 // lldb-command:v float_int_float
-// lldb-check:[...] AGenericStruct<f64, generic_struct::AGenericStruct<i32, f64>> { key: 6.5, value: AGenericStruct<i32, f64> { key: 7, value: 8.5 } }
+// lldb-check:[...]AGenericStruct<double, generic_struct::AGenericStruct<int, double> >) float_int_float = { key = 6.5 value = { key = 7 value = 8.5 } }
 
 // === CDB TESTS ===================================================================================
 
diff --git a/tests/debuginfo/method-on-generic-struct.rs b/tests/debuginfo/method-on-generic-struct.rs
index 23617d46e8310..1e6c9d66178aa 100644
--- a/tests/debuginfo/method-on-generic-struct.rs
+++ b/tests/debuginfo/method-on-generic-struct.rs
@@ -56,7 +56,7 @@
 
 // STACK BY REF
 // lldb-command:v *self
-// lldb-check:[...] Struct<(u32, i32)> { x: (8888, -8888) }
+// lldb-check:[...]Struct<(u32, i32)>) *self = { x = { 0 = 8888 1 = -8888 } }
 // lldb-command:v arg1
 // lldb-check:[...] -1
 // lldb-command:v arg2
@@ -65,7 +65,7 @@
 
 // STACK BY VAL
 // lldb-command:v self
-// lldb-check:[...] Struct<(u32, i32)> { x: (8888, -8888) }
+// lldb-check:[...]Struct<(u32, i32)>) self = { x = { 0 = 8888 1 = -8888 } }
 // lldb-command:v arg1
 // lldb-check:[...] -3
 // lldb-command:v arg2
@@ -74,7 +74,7 @@
 
 // OWNED BY REF
 // lldb-command:v *self
-// lldb-check:[...] Struct<f64> { x: 1234.5 }
+// lldb-check:[...]Struct<double>) *self = { x = 1234.5 }
 // lldb-command:v arg1
 // lldb-check:[...] -5
 // lldb-command:v arg2
@@ -83,7 +83,7 @@
 
 // OWNED BY VAL
 // lldb-command:v self
-// lldb-check:[...] Struct<f64> { x: 1234.5 }
+// lldb-check:[...]Struct<double>) self = { x = 1234.5 }
 // lldb-command:v arg1
 // lldb-check:[...] -7
 // lldb-command:v arg2
@@ -92,7 +92,7 @@
 
 // OWNED MOVED
 // lldb-command:v *self
-// lldb-check:[...] Struct<f64> { x: 1234.5 }
+// lldb-check:[...]Struct<double>) *self = { x = 1234.5 }
 // lldb-command:v arg1
 // lldb-check:[...] -9
 // lldb-command:v arg2

From 4508800d20006375fbd0b8f5b5fd41a6ad8d7ae4 Mon Sep 17 00:00:00 2001
From: DianQK <dianqk@dianqk.net>
Date: Mon, 19 Aug 2024 06:26:52 +0800
Subject: [PATCH 424/685] Don't generate functions with the
 `rustc_intrinsic_must_be_overridden` attribute

---
 compiler/rustc_monomorphize/src/collector.rs       |  4 +++-
 .../rustc_intrinsic_must_be_overridden.rs          | 14 ++++++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)
 create mode 100644 tests/codegen/intrinsics/rustc_intrinsic_must_be_overridden.rs

diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 0ae635f9b73e5..9f449868f0316 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -888,7 +888,9 @@ fn visit_instance_use<'tcx>(
             if tcx.should_codegen_locally(panic_instance) {
                 output.push(create_fn_mono_item(tcx, panic_instance, source));
             }
-        } else if tcx.has_attr(def_id, sym::rustc_intrinsic) {
+        } else if tcx.has_attr(def_id, sym::rustc_intrinsic)
+            && !tcx.has_attr(def_id, sym::rustc_intrinsic_must_be_overridden)
+        {
             // Codegen the fallback body of intrinsics with fallback bodies
             let instance = ty::Instance::new(def_id, instance.args);
             if tcx.should_codegen_locally(instance) {
diff --git a/tests/codegen/intrinsics/rustc_intrinsic_must_be_overridden.rs b/tests/codegen/intrinsics/rustc_intrinsic_must_be_overridden.rs
new file mode 100644
index 0000000000000..b41e441d309da
--- /dev/null
+++ b/tests/codegen/intrinsics/rustc_intrinsic_must_be_overridden.rs
@@ -0,0 +1,14 @@
+//@ revisions: OPT0 OPT1
+//@ [OPT0] compile-flags: -Copt-level=0
+//@ [OPT1] compile-flags: -Copt-level=1
+//@ compile-flags: -Cno-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(core_intrinsics)]
+
+// CHECK-NOT: core::intrinsics::size_of_val
+
+#[no_mangle]
+pub unsafe fn size_of_val(ptr: *const i32) -> usize {
+    core::intrinsics::size_of_val(ptr)
+}

From 5fe70afc8c6372018da586f3a9068ac593eb80b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Kr=C3=BCger?= <matthias.krueger@famsik.de>
Date: Sun, 18 Aug 2024 12:50:01 +0200
Subject: [PATCH 425/685] crashes: more tests

---
 tests/crashes/129150.rs |  7 +++++++
 tests/crashes/129166.rs |  7 +++++++
 tests/crashes/129205.rs |  5 +++++
 tests/crashes/129209.rs | 11 +++++++++++
 tests/crashes/129214.rs | 30 ++++++++++++++++++++++++++++++
 tests/crashes/129216.rs | 12 ++++++++++++
 tests/crashes/129219.rs | 26 ++++++++++++++++++++++++++
 7 files changed, 98 insertions(+)
 create mode 100644 tests/crashes/129150.rs
 create mode 100644 tests/crashes/129166.rs
 create mode 100644 tests/crashes/129205.rs
 create mode 100644 tests/crashes/129209.rs
 create mode 100644 tests/crashes/129214.rs
 create mode 100644 tests/crashes/129216.rs
 create mode 100644 tests/crashes/129219.rs

diff --git a/tests/crashes/129150.rs b/tests/crashes/129150.rs
new file mode 100644
index 0000000000000..9f8c2ba173939
--- /dev/null
+++ b/tests/crashes/129150.rs
@@ -0,0 +1,7 @@
+//@ known-bug: rust-lang/rust#129150
+//@ only-x86_64
+use std::arch::x86_64::_mm_blend_ps;
+
+pub fn main() {
+     _mm_blend_ps(1, 2, &const {} );
+}
diff --git a/tests/crashes/129166.rs b/tests/crashes/129166.rs
new file mode 100644
index 0000000000000..d3635d410db5e
--- /dev/null
+++ b/tests/crashes/129166.rs
@@ -0,0 +1,7 @@
+//@ known-bug: rust-lang/rust#129166
+
+fn main() {
+    #[cfg_eval]
+    #[cfg]
+    0
+}
diff --git a/tests/crashes/129205.rs b/tests/crashes/129205.rs
new file mode 100644
index 0000000000000..f328fca247ac5
--- /dev/null
+++ b/tests/crashes/129205.rs
@@ -0,0 +1,5 @@
+//@ known-bug: rust-lang/rust#129205
+
+fn x<T: Copy>() {
+    T::try_from();
+}
diff --git a/tests/crashes/129209.rs b/tests/crashes/129209.rs
new file mode 100644
index 0000000000000..249fa41552ebf
--- /dev/null
+++ b/tests/crashes/129209.rs
@@ -0,0 +1,11 @@
+//@ known-bug: rust-lang/rust#129209
+
+impl<
+        const N: usize = {
+            static || {
+                Foo([0; X]);
+            }
+        },
+    > PartialEq for True
+{
+}
diff --git a/tests/crashes/129214.rs b/tests/crashes/129214.rs
new file mode 100644
index 0000000000000..e14b9f379d62a
--- /dev/null
+++ b/tests/crashes/129214.rs
@@ -0,0 +1,30 @@
+//@ known-bug: rust-lang/rust#129214
+//@ compile-flags: -Zvalidate-mir -Copt-level=3 --crate-type=lib
+
+trait to_str {}
+
+trait map<T> {
+    fn map<U, F>(&self, f: F) -> Vec<U>
+    where
+        F: FnMut(&Box<usize>) -> U;
+}
+impl<T> map<T> for Vec<T> {
+    fn map<U, F>(&self, mut f: F) -> Vec<U>
+    where
+        F: FnMut(&T) -> U,
+    {
+        let mut r = Vec::new();
+        for i in self {
+            r.push(f(i));
+        }
+        r
+    }
+}
+
+fn foo<U, T: map<U>>(x: T) -> Vec<String> {
+    x.map(|_e| "hi".to_string())
+}
+
+pub fn main() {
+    assert_eq!(foo(vec![1]), ["hi".to_string()]);
+}
diff --git a/tests/crashes/129216.rs b/tests/crashes/129216.rs
new file mode 100644
index 0000000000000..0ad6bc5c71baf
--- /dev/null
+++ b/tests/crashes/129216.rs
@@ -0,0 +1,12 @@
+//@ known-bug: rust-lang/rust#129216
+//@ only-linux
+
+trait Mirror {
+    type Assoc;
+}
+
+struct Foo;
+
+fn main() {
+    <Foo as Mirror>::Assoc::new();
+}
diff --git a/tests/crashes/129219.rs b/tests/crashes/129219.rs
new file mode 100644
index 0000000000000..effbfcd8b8e45
--- /dev/null
+++ b/tests/crashes/129219.rs
@@ -0,0 +1,26 @@
+//@ known-bug: rust-lang/rust#129219
+//@ compile-flags: -Zmir-opt-level=5 -Zvalidate-mir --edition=2018
+
+use core::marker::Unsize;
+
+pub trait CastTo<T: ?Sized>: Unsize<T> {}
+
+impl<T: ?Sized, U: ?Sized> CastTo<T> for U {}
+
+impl<T: ?Sized> Cast for T {}
+pub trait Cast {
+    fn cast<T: ?Sized>(&self) -> &T
+    where
+        Self: CastTo<T>,
+    {
+        self
+    }
+}
+
+pub trait Foo {}
+impl Foo for [i32; 0] {}
+
+fn main() {
+    let x: &dyn Foo = &[];
+    let x = x.cast::<[i32]>();
+}

From 249a36ffbd577fc76153b7ad4cafd33607ee4ddc Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Sun, 18 Aug 2024 15:51:53 -0700
Subject: [PATCH 426/685] Update mir-opt filechecks

---
 tests/mir-opt/array_index_is_temporary.rs     |   2 +-
 tests/mir-opt/box_expr.rs                     |   2 +-
 .../mir-opt/building/match/sort_candidates.rs |   2 +-
 tests/mir-opt/building/while_storage.rs       |   4 +-
 tests/mir-opt/const_prop/address_of_pair.rs   |   4 +-
 .../bad_op_unsafe_oob_for_slices.rs           |   2 +-
 tests/mir-opt/const_prop/boxes.rs             |   4 +-
 tests/mir-opt/const_prop/indirect_mutation.rs |   4 +-
 tests/mir-opt/const_prop/mutable_variable.rs  |   2 +-
 .../const_prop/mutable_variable_aggregate.rs  |   2 +-
 .../mutable_variable_aggregate_mut_ref.rs     |   2 +-
 ...mutable_variable_aggregate_partial_read.rs |   2 +-
 .../const_prop/mutable_variable_no_prop.rs    |   4 +-
 .../mutable_variable_unprop_assign.rs         |   6 +-
 .../overwrite_with_const_with_params.rs       |   2 +-
 .../const_prop/pointer_expose_provenance.rs   |   2 +-
 tests/mir-opt/const_prop/slice_len.rs         |   2 +-
 tests/mir-opt/copy-prop/borrowed_local.rs     |  16 +-
 .../dataflow-const-prop/array_index.rs        |   2 +-
 tests/mir-opt/dataflow-const-prop/enum.rs     |  10 +-
 .../dataflow-const-prop/large_array_index.rs  |   2 +-
 .../dataflow-const-prop/ref_without_sb.rs     |   2 +-
 tests/mir-opt/dataflow-const-prop/repeat.rs   |   4 +-
 .../dataflow-const-prop/sibling_ptr.rs        |   2 +-
 .../mir-opt/dataflow-const-prop/slice_len.rs  |   6 +-
 tests/mir-opt/dataflow-const-prop/struct.rs   |  16 +-
 .../dead-store-elimination/call_arg_copy.rs   |   4 +-
 .../mir-opt/dest-prop/copy_propagation_arg.rs |   4 +-
 tests/mir-opt/dest-prop/dead_stores_79191.rs  |   2 +-
 tests/mir-opt/dest-prop/dead_stores_better.rs |   2 +-
 tests/mir-opt/dest-prop/simple.rs             |   4 +-
 tests/mir-opt/early_otherwise_branch.rs       |   4 +-
 .../early_otherwise_branch_3_element_tuple.rs |   2 +-
 tests/mir-opt/gvn.rs                          | 366 +++++++++---------
 tests/mir-opt/gvn_copy_moves.rs               |   6 +-
 tests/mir-opt/instsimplify/casts.rs           |   4 +-
 tests/mir-opt/instsimplify/ref_of_deref.rs    |   8 +-
 tests/mir-opt/instsimplify/ub_check.rs        |   2 +-
 tests/mir-opt/jump_threading.rs               |  24 +-
 tests/mir-opt/lower_array_len.rs              |   4 +-
 tests/mir-opt/lower_intrinsics.rs             |   4 +-
 tests/mir-opt/pre-codegen/slice_index.rs      |  20 +-
 tests/mir-opt/reference_prop.rs               | 114 +++---
 tests/mir-opt/simplify_dead_blocks.rs         |   4 +-
 tests/mir-opt/sroa/structs.rs                 |  26 +-
 45 files changed, 356 insertions(+), 356 deletions(-)

diff --git a/tests/mir-opt/array_index_is_temporary.rs b/tests/mir-opt/array_index_is_temporary.rs
index 771fb3771b5c0..cda9e86b3e664 100644
--- a/tests/mir-opt/array_index_is_temporary.rs
+++ b/tests/mir-opt/array_index_is_temporary.rs
@@ -15,7 +15,7 @@ fn main() {
     // CHECK: debug x => [[x:_.*]];
     // CHECK: debug y => [[y:_.*]];
     // CHECK: [[y]] = const 1_usize;
-    // CHECK: [[tmp:_.*]] = [[y]];
+    // CHECK: [[tmp:_.*]] = copy [[y]];
     // CHECK: [[x]][[[tmp]]] =
     let mut x = [42, 43, 44];
     let mut y = 1;
diff --git a/tests/mir-opt/box_expr.rs b/tests/mir-opt/box_expr.rs
index a2d3ab94db65e..41cd4ca57bfee 100644
--- a/tests/mir-opt/box_expr.rs
+++ b/tests/mir-opt/box_expr.rs
@@ -7,7 +7,7 @@
 fn main() {
     // CHECK-LABEL: fn main(
     // CHECK:   [[box:_.*]] = ShallowInitBox(
-    // CHECK:   [[ptr:_.*]] = ((([[box]].0: std::ptr::Unique<S>).0: std::ptr::NonNull<S>).0: *const S);
+    // CHECK:   [[ptr:_.*]] = copy ((([[box]].0: std::ptr::Unique<S>).0: std::ptr::NonNull<S>).0: *const S);
     // CHECK:   (*[[ptr]]) = S::new() -> [return: [[ret:bb.*]], unwind: [[unwind:bb.*]]];
     // CHECK: [[ret]]: {
     // CHECK:   [[box2:_.*]] = move [[box]];
diff --git a/tests/mir-opt/building/match/sort_candidates.rs b/tests/mir-opt/building/match/sort_candidates.rs
index 593a975a7a474..d7dd82791ffa1 100644
--- a/tests/mir-opt/building/match/sort_candidates.rs
+++ b/tests/mir-opt/building/match/sort_candidates.rs
@@ -25,7 +25,7 @@ fn disjoint_ranges(x: i32, b: bool) -> u32 {
     // CHECK-LABEL: fn disjoint_ranges(
     // CHECK: debug b => _2;
     // CHECK: bb0: {
-    // CHECK: switchInt(_2) -> [0: [[jump:bb.*]], otherwise: {{bb.*}}];
+    // CHECK: switchInt(copy _2) -> [0: [[jump:bb.*]], otherwise: {{bb.*}}];
     // CHECK: [[jump]]: {
     // CHECK-NEXT: _0 = const 3_u32;
     // CHECK-NEXT: return;
diff --git a/tests/mir-opt/building/while_storage.rs b/tests/mir-opt/building/while_storage.rs
index 83095316f0054..cd226eb0c1e21 100644
--- a/tests/mir-opt/building/while_storage.rs
+++ b/tests/mir-opt/building/while_storage.rs
@@ -15,7 +15,7 @@ fn while_loop(c: bool) {
     // CHECK: bb1: {
     // CHECK-NEXT:     StorageLive(_3);
     // CHECK-NEXT:     StorageLive(_2);
-    // CHECK-NEXT:     _2 = _1;
+    // CHECK-NEXT:     _2 = copy _1;
     // CHECK-NEXT:     _3 = get_bool(move _2) -> [return: bb2, unwind
     // CHECK: bb2: {
     // CHECK-NEXT:     switchInt(move _3) -> [0: bb3, otherwise: bb4];
@@ -29,7 +29,7 @@ fn while_loop(c: bool) {
     // CHECK-NEXT:     StorageDead(_2);
     // CHECK-NEXT:     StorageLive(_5);
     // CHECK-NEXT:     StorageLive(_4);
-    // CHECK-NEXT:     _4 = _1;
+    // CHECK-NEXT:     _4 = copy _1;
     // CHECK-NEXT:     _5 = get_bool(move _4) -> [return: bb5, unwind
     // CHECK: bb5: {
     // CHECK-NEXT:     switchInt(move _5) -> [0: bb6, otherwise: bb7];
diff --git a/tests/mir-opt/const_prop/address_of_pair.rs b/tests/mir-opt/const_prop/address_of_pair.rs
index 9acaaa0ccaf9d..df1ab229d6e39 100644
--- a/tests/mir-opt/const_prop/address_of_pair.rs
+++ b/tests/mir-opt/const_prop/address_of_pair.rs
@@ -10,13 +10,13 @@ pub fn fn0() -> bool {
     // CHECK: (*[[ptr]]) = const true;
     // CHECK-NOT: = const false;
     // CHECK-NOT: = const true;
-    // CHECK: [[tmp:_.*]] = ([[pair]].1: bool);
+    // CHECK: [[tmp:_.*]] = copy ([[pair]].1: bool);
     // CHECK-NOT: = const false;
     // CHECK-NOT: = const true;
     // CHECK: [[ret]] = Not(move [[tmp]]);
     // CHECK-NOT: = const false;
     // CHECK-NOT: = const true;
-    // CHECK: _0 = [[ret]];
+    // CHECK: _0 = copy [[ret]];
     let mut pair = (1, false);
     let ptr = core::ptr::addr_of_mut!(pair.1);
     pair = (1, false);
diff --git a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs
index 0f8d278535dc7..139d0fa2e0f1c 100644
--- a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs
+++ b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.rs
@@ -8,7 +8,7 @@ fn main() {
     // CHECK-LABEL: fn main(
     // CHECK: debug a => [[a:_.*]];
     // CHECK: debug _b => [[b:_.*]];
-    // CHECK: [[b]] = (*[[a]])[3 of 4];
+    // CHECK: [[b]] = copy (*[[a]])[3 of 4];
     let a: *const [_] = &[1, 2, 3];
     unsafe {
         let _b = (*a)[3];
diff --git a/tests/mir-opt/const_prop/boxes.rs b/tests/mir-opt/const_prop/boxes.rs
index 7813352261e53..f04db260e27f9 100644
--- a/tests/mir-opt/const_prop/boxes.rs
+++ b/tests/mir-opt/const_prop/boxes.rs
@@ -11,8 +11,8 @@ fn main() {
     // CHECK-LABEL: fn main(
     // CHECK: debug x => [[x:_.*]];
     // CHECK: (*{{_.*}}) = const 42_i32;
-    // CHECK: [[tmp:_.*]] = (*{{_.*}});
-    // CHECK: [[x]] = [[tmp]];
+    // CHECK: [[tmp:_.*]] = copy (*{{_.*}});
+    // CHECK: [[x]] = copy [[tmp]];
     let x = *(#[rustc_box]
     Box::new(42))
         + 0;
diff --git a/tests/mir-opt/const_prop/indirect_mutation.rs b/tests/mir-opt/const_prop/indirect_mutation.rs
index 32ff8f142b1e7..0a4c455c76ef2 100644
--- a/tests/mir-opt/const_prop/indirect_mutation.rs
+++ b/tests/mir-opt/const_prop/indirect_mutation.rs
@@ -10,7 +10,7 @@ fn foo() {
     // CHECK: _1 = const (1_i32,);
     // CHECK: _2 = &mut (_1.0: i32);
     // CHECK: (*_2) = const 5_i32;
-    // CHECK: _4 = (_1.0: i32);
+    // CHECK: _4 = copy (_1.0: i32);
     // CHECK: _3 = Eq(move _4, const 5_i32);
 
     let mut u = (1,);
@@ -25,7 +25,7 @@ fn bar() {
     // CHECK: debug y => _4;
     // CHECK: _3 = &raw mut (_1.0: i32);
     // CHECK: (*_3) = const 5_i32;
-    // CHECK: _5 = (_1.0: i32);
+    // CHECK: _5 = copy (_1.0: i32);
     // CHECK: _4 = Eq(move _5, const 5_i32);
 
     let mut v = (1,);
diff --git a/tests/mir-opt/const_prop/mutable_variable.rs b/tests/mir-opt/const_prop/mutable_variable.rs
index 9698fba6a11ac..3aa1b1bcd2181 100644
--- a/tests/mir-opt/const_prop/mutable_variable.rs
+++ b/tests/mir-opt/const_prop/mutable_variable.rs
@@ -7,7 +7,7 @@ fn main() {
     // CHECK: debug y => [[y:_.*]];
     // CHECK: [[x]] = const 42_i32;
     // CHECK: [[x]] = const 99_i32;
-    // CHECK: [[y]] = [[x]];
+    // CHECK: [[y]] = copy [[x]];
     let mut x = 42;
     x = 99;
     let y = x;
diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate.rs b/tests/mir-opt/const_prop/mutable_variable_aggregate.rs
index 80cd75215c1b7..bb8bf7f71646e 100644
--- a/tests/mir-opt/const_prop/mutable_variable_aggregate.rs
+++ b/tests/mir-opt/const_prop/mutable_variable_aggregate.rs
@@ -8,7 +8,7 @@ fn main() {
     // CHECK: debug y => [[y:_.*]];
     // CHECK: [[x]] = const (42_i32, 43_i32);
     // CHECK: ([[x]].1: i32) = const 99_i32;
-    // CHECK: [[y]] = [[x]];
+    // CHECK: [[y]] = copy [[x]];
     let mut x = (42, 43);
     x.1 = 99;
     let y = x;
diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.rs b/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.rs
index 856afd53ab46b..332cac96f75d0 100644
--- a/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.rs
+++ b/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.rs
@@ -10,7 +10,7 @@ fn main() {
     // CHECK: [[x]] = const (42_i32, 43_i32);
     // CHECK: [[z]] = &mut [[x]];
     // CHECK: ((*[[z]]).1: i32) = const 99_i32;
-    // CHECK: [[y]] = [[x]];
+    // CHECK: [[y]] = copy [[x]];
     let mut x = (42, 43);
     let z = &mut x;
     z.1 = 99;
diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs
index 6f99e6be246fa..e27437a1c7541 100644
--- a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs
+++ b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.rs
@@ -9,7 +9,7 @@ fn main() {
     // CHECK: [[x]] = foo()
     // CHECK: ([[x]].1: i32) = const 99_i32;
     // CHECK: ([[x]].0: i32) = const 42_i32;
-    // CHECK: [[y]] = ([[x]].1: i32);
+    // CHECK: [[y]] = copy ([[x]].1: i32);
     let mut x: (i32, i32) = foo();
     x.1 = 99;
     x.0 = 42;
diff --git a/tests/mir-opt/const_prop/mutable_variable_no_prop.rs b/tests/mir-opt/const_prop/mutable_variable_no_prop.rs
index 8289832f81ea3..66af5bf1d5d40 100644
--- a/tests/mir-opt/const_prop/mutable_variable_no_prop.rs
+++ b/tests/mir-opt/const_prop/mutable_variable_no_prop.rs
@@ -9,9 +9,9 @@ fn main() {
     // CHECK: debug x => [[x:_.*]];
     // CHECK: debug y => [[y:_.*]];
     // CHECK: [[x]] = const 42_u32;
-    // CHECK: [[tmp:_.*]] = (*{{_.*}});
+    // CHECK: [[tmp:_.*]] = copy (*{{_.*}});
     // CHECK: [[x]] = move [[tmp]];
-    // CHECK: [[y]] = [[x]];
+    // CHECK: [[y]] = copy [[x]];
     let mut x = 42;
     unsafe {
         x = STATIC;
diff --git a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs
index 2c6cc0db6b211..1f4421331bccd 100644
--- a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs
+++ b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.rs
@@ -11,9 +11,9 @@ fn main() {
     // CHECK: debug z => [[z:_.*]];
     // CHECK: [[a]] = foo()
     // CHECK: [[x]] = const (1_i32, 2_i32);
-    // CHECK: ([[x]].1: i32) = [[a]];
-    // CHECK: [[y]] = ([[x]].1: i32);
-    // CHECK: [[z]] = ([[x]].0: i32);
+    // CHECK: ([[x]].1: i32) = copy [[a]];
+    // CHECK: [[y]] = copy ([[x]].1: i32);
+    // CHECK: [[z]] = copy ([[x]].0: i32);
     let a = foo();
     let mut x: (i32, i32) = (1, 2);
     x.1 = a;
diff --git a/tests/mir-opt/const_prop/overwrite_with_const_with_params.rs b/tests/mir-opt/const_prop/overwrite_with_const_with_params.rs
index a43558223fe1a..1d8890bf3692f 100644
--- a/tests/mir-opt/const_prop/overwrite_with_const_with_params.rs
+++ b/tests/mir-opt/const_prop/overwrite_with_const_with_params.rs
@@ -15,7 +15,7 @@ fn size_of<T>() -> usize {
     // CHECK-LABEL: fn size_of(
     // CHECK: _1 = const 0_usize;
     // CHECK-NEXT: _1 = const SizeOfConst::<T>::SIZE;
-    // CHECK-NEXT: _0 = _1;
+    // CHECK-NEXT: _0 = copy _1;
     let mut a = 0;
     a = SizeOfConst::<T>::SIZE;
     a
diff --git a/tests/mir-opt/const_prop/pointer_expose_provenance.rs b/tests/mir-opt/const_prop/pointer_expose_provenance.rs
index a76fead985948..bee8a985f8f9b 100644
--- a/tests/mir-opt/const_prop/pointer_expose_provenance.rs
+++ b/tests/mir-opt/const_prop/pointer_expose_provenance.rs
@@ -10,7 +10,7 @@ fn main() {
     // CHECK: [[ptr:_.*]] = const main::FOO;
     // CHECK: [[ref:_.*]] = &raw const (*[[ptr]]);
     // CHECK: [[x:_.*]] = move [[ref]] as usize (PointerExposeProvenance);
-    // CHECK: = read([[x]])
+    // CHECK: = read(copy [[x]])
     const FOO: &i32 = &1;
     let x = FOO as *const i32 as usize;
     read(x);
diff --git a/tests/mir-opt/const_prop/slice_len.rs b/tests/mir-opt/const_prop/slice_len.rs
index 3d1b58965ac4e..46604cfe1e091 100644
--- a/tests/mir-opt/const_prop/slice_len.rs
+++ b/tests/mir-opt/const_prop/slice_len.rs
@@ -7,7 +7,7 @@
 fn main() {
     // CHECK-LABEL: fn main(
     // CHECK: debug a => [[a:_.*]];
-    // CHECK: [[slice:_.*]] = {{.*}} as &[u32] (PointerCoercion(Unsize));
+    // CHECK: [[slice:_.*]] = copy {{.*}} as &[u32] (PointerCoercion(Unsize));
     // CHECK: assert(const true,
     // CHECK: [[a]] = const 2_u32;
     let a = (&[1u32, 2, 3] as &[u32])[1];
diff --git a/tests/mir-opt/copy-prop/borrowed_local.rs b/tests/mir-opt/copy-prop/borrowed_local.rs
index dd1679513f6c9..8db19fbd37755 100644
--- a/tests/mir-opt/copy-prop/borrowed_local.rs
+++ b/tests/mir-opt/copy-prop/borrowed_local.rs
@@ -21,11 +21,11 @@ fn compare_address() -> bool {
     // CHECK: bb0: {
     // CHECK-NEXT: _1 = const 5_u8;
     // CHECK-NEXT: _2 = &_1;
-    // CHECK-NEXT: _3 = _1;
+    // CHECK-NEXT: _3 = copy _1;
     // CHECK-NEXT: _4 = &_3;
-    // CHECK-NEXT: _0 = cmp_ref(_2, _4)
+    // CHECK-NEXT: _0 = cmp_ref(copy _2, copy _4)
     // CHECK: bb1: {
-    // CHECK-NEXT: _0 = opaque::<u8>(_3)
+    // CHECK-NEXT: _0 = opaque::<u8>(copy _3)
     mir! {
         {
             let a = 5_u8;
@@ -51,9 +51,9 @@ fn borrowed<T: Copy + Freeze>(x: T) -> bool {
     // CHECK-LABEL: fn borrowed(
     // CHECK: bb0: {
     // CHECK-NEXT: _3 = &_1;
-    // CHECK-NEXT: _0 = opaque::<&T>(_3)
+    // CHECK-NEXT: _0 = opaque::<&T>(copy _3)
     // CHECK: bb1: {
-    // CHECK-NEXT: _0 = opaque::<T>(_1)
+    // CHECK-NEXT: _0 = opaque::<T>(copy _1)
     mir! {
         {
             let a = x;
@@ -74,11 +74,11 @@ fn borrowed<T: Copy + Freeze>(x: T) -> bool {
 fn non_freeze<T: Copy>(x: T) -> bool {
     // CHECK-LABEL: fn non_freeze(
     // CHECK: bb0: {
-    // CHECK-NEXT: _2 = _1;
+    // CHECK-NEXT: _2 = copy _1;
     // CHECK-NEXT: _3 = &_1;
-    // CHECK-NEXT: _0 = opaque::<&T>(_3)
+    // CHECK-NEXT: _0 = opaque::<&T>(copy _3)
     // CHECK: bb1: {
-    // CHECK-NEXT: _0 = opaque::<T>(_2)
+    // CHECK-NEXT: _0 = opaque::<T>(copy _2)
     mir! {
         {
             let a = x;
diff --git a/tests/mir-opt/dataflow-const-prop/array_index.rs b/tests/mir-opt/dataflow-const-prop/array_index.rs
index daf9c7729c604..e442ef99f79e6 100644
--- a/tests/mir-opt/dataflow-const-prop/array_index.rs
+++ b/tests/mir-opt/dataflow-const-prop/array_index.rs
@@ -16,6 +16,6 @@ fn main() {
     // CHECK:       {{_.*}} = const 4_usize;
     // CHECK:       {{_.*}} = const true;
     // CHECK:       assert(const true
-    // CHECK:       [[x]] = [[array_lit]][2 of 3];
+    // CHECK:       [[x]] = copy [[array_lit]][2 of 3];
     let x: u32 = [0, 1, 2, 3][2];
 }
diff --git a/tests/mir-opt/dataflow-const-prop/enum.rs b/tests/mir-opt/dataflow-const-prop/enum.rs
index 37304e3a270e9..207e29e63df9e 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.rs
+++ b/tests/mir-opt/dataflow-const-prop/enum.rs
@@ -73,7 +73,7 @@ fn statics() {
     static RC: &E = &E::V2(4);
 
     // CHECK: [[t:_.*]] = const {alloc5: &&E};
-    // CHECK: [[e2]] = (*[[t]]);
+    // CHECK: [[e2]] = copy (*[[t]]);
     let e2 = RC;
 
     // CHECK: switchInt({{move _.*}}) -> {{.*}}
@@ -108,7 +108,7 @@ fn mutate_discriminant() -> u8 {
             // CHECK: [[a:_.*]] = discriminant({{_.*}});
             let a = Discriminant(x);
 
-            // CHECK: switchInt([[a]]) -> [0: {{bb.*}}, otherwise: {{bb.*}}];
+            // CHECK: switchInt(copy [[a]]) -> [0: {{bb.*}}, otherwise: {{bb.*}}];
             match a {
                 0 => bb1,
                 _ => bad,
@@ -143,8 +143,8 @@ fn multiple(x: bool, i: u8) {
     //   discriminant(e) => Top
     //   (e as Some).0 => Top
     // CHECK: [[x2]] = const 0_u8;
-    // CHECK: [[some:_.*]] = (({{_.*}} as Some).0: u8)
-    // CHECK: [[x2]] = [[some]];
+    // CHECK: [[some:_.*]] = copy (({{_.*}} as Some).0: u8)
+    // CHECK: [[x2]] = copy [[some]];
     let x2 = match e {
         Some(i) => i,
         None => 0,
@@ -153,7 +153,7 @@ fn multiple(x: bool, i: u8) {
     // Therefore, `x2` should be `Top` here, and no replacement shall happen.
 
     // CHECK-NOT: [[y]] = const
-    // CHECK: [[y]] = [[x2]];
+    // CHECK: [[y]] = copy [[x2]];
     // CHECK-NOT: [[y]] = const
     let y = x2;
 }
diff --git a/tests/mir-opt/dataflow-const-prop/large_array_index.rs b/tests/mir-opt/dataflow-const-prop/large_array_index.rs
index e74fd88d002cc..e9f2fa2badf95 100644
--- a/tests/mir-opt/dataflow-const-prop/large_array_index.rs
+++ b/tests/mir-opt/dataflow-const-prop/large_array_index.rs
@@ -13,6 +13,6 @@ fn main() {
     // CHECK: {{_.*}} = const 5000_usize;
     // CHECK: {{_.*}} = const true;
     // CHECK: assert(const true
-    // CHECK: [[x]] = [[array_lit]][2 of 3];
+    // CHECK: [[x]] = copy [[array_lit]][2 of 3];
     let x: u8 = [0_u8; 5000][2];
 }
diff --git a/tests/mir-opt/dataflow-const-prop/ref_without_sb.rs b/tests/mir-opt/dataflow-const-prop/ref_without_sb.rs
index 399de921a590f..1c4eb41f35ec6 100644
--- a/tests/mir-opt/dataflow-const-prop/ref_without_sb.rs
+++ b/tests/mir-opt/dataflow-const-prop/ref_without_sb.rs
@@ -24,7 +24,7 @@ fn main() {
     // This should currently not be propagated.
 
     // CHECK-NOT: [[b]] = const
-    // CHECK: [[b]] = [[a]];
+    // CHECK: [[b]] = copy [[a]];
     // CHECK-NOT: [[b]] = const
     let b = a;
 }
diff --git a/tests/mir-opt/dataflow-const-prop/repeat.rs b/tests/mir-opt/dataflow-const-prop/repeat.rs
index e32c0d0877dec..2067aa3d709e2 100644
--- a/tests/mir-opt/dataflow-const-prop/repeat.rs
+++ b/tests/mir-opt/dataflow-const-prop/repeat.rs
@@ -14,8 +14,8 @@ fn main() {
     // CHECK: {{_.*}} = const true;
     // CHECK: assert(const true
 
-    // CHECK-NOT: [[t:_.*]] = [[array_lit]][_
-    // CHECK: [[t:_.*]] = [[array_lit]][2 of 3];
+    // CHECK-NOT: [[t:_.*]] = {{copy|move}} [[array_lit]][_
+    // CHECK: [[t:_.*]] = copy [[array_lit]][2 of 3];
     // CHECK: [[x]] = Add(move [[t]], const 0_u32);
     let x: u32 = [42; 8][2] + 0;
 }
diff --git a/tests/mir-opt/dataflow-const-prop/sibling_ptr.rs b/tests/mir-opt/dataflow-const-prop/sibling_ptr.rs
index be7f311cdc10d..b123f06807d60 100644
--- a/tests/mir-opt/dataflow-const-prop/sibling_ptr.rs
+++ b/tests/mir-opt/dataflow-const-prop/sibling_ptr.rs
@@ -20,6 +20,6 @@ fn main() {
         *p.add(1) = 1;
     }
 
-    // CHECK: [[x1]] = ({{_.*}}.1: u8);
+    // CHECK: [[x1]] = copy ({{_.*}}.1: u8);
     let x1 = x.1; // should not be propagated
 }
diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.rs b/tests/mir-opt/dataflow-const-prop/slice_len.rs
index 64c043cca795b..e0e68f9fde54a 100644
--- a/tests/mir-opt/dataflow-const-prop/slice_len.rs
+++ b/tests/mir-opt/dataflow-const-prop/slice_len.rs
@@ -17,7 +17,7 @@ fn main() {
     // CHECK: {{_.*}} = const true;
     // CHECK: assert(const true,
 
-    // CHECK: [[local]] = (*{{_.*}})[1 of 2];
+    // CHECK: [[local]] = copy (*{{_.*}})[1 of 2];
     let local = (&[1u32, 2, 3] as &[u32])[1];
 
     // CHECK-NOT: {{_.*}} = Len(
@@ -28,7 +28,7 @@ fn main() {
     // CHECK: {{_.*}} = const true;
     // CHECK: assert(const true,
 
-    // CHECK-NOT: [[constant]] = (*{{_.*}})[_
-    // CHECK: [[constant]] = (*{{_.*}})[1 of 2];
+    // CHECK-NOT: [[constant]] = {{copy|move}} (*{{_.*}})[_
+    // CHECK: [[constant]] = copy (*{{_.*}})[1 of 2];
     let constant = SLICE[1];
 }
diff --git a/tests/mir-opt/dataflow-const-prop/struct.rs b/tests/mir-opt/dataflow-const-prop/struct.rs
index 89ad1b870294e..44591ffb6de2e 100644
--- a/tests/mir-opt/dataflow-const-prop/struct.rs
+++ b/tests/mir-opt/dataflow-const-prop/struct.rs
@@ -46,15 +46,15 @@ fn main() {
     const SMALL_VAL: SmallStruct = SmallStruct(4., Some(S(1)), &[]);
 
     // CHECK: [[a1]] = const 4f32;
-    // CHECK: [[b1]] = ({{_.*}}.1: std::option::Option<S>);
-    // CHECK: [[c1]] = ({{_.*}}.2: &[f32]);
+    // CHECK: [[b1]] = copy ({{_.*}}.1: std::option::Option<S>);
+    // CHECK: [[c1]] = copy ({{_.*}}.2: &[f32]);
     let SmallStruct(a1, b1, c1) = SMALL_VAL;
 
     static SMALL_STAT: &SmallStruct = &SmallStruct(9., None, &[13.]);
 
     // CHECK: [[a2]] = const 9f32;
-    // CHECK: [[b2]] = ((*{{_.*}}).1: std::option::Option<S>);
-    // CHECK: [[c2]] = ((*{{_.*}}).2: &[f32]);
+    // CHECK: [[b2]] = copy ((*{{_.*}}).1: std::option::Option<S>);
+    // CHECK: [[c2]] = copy ((*{{_.*}}).2: &[f32]);
     let SmallStruct(a2, b2, c2) = *SMALL_STAT;
 
     // CHECK: [[ss]] = SmallStruct(const 9f32, move {{_.*}}, move {{_.*}});
@@ -63,14 +63,14 @@ fn main() {
     const BIG_VAL: BigStruct = BigStruct(25., None, &[]);
 
     // CHECK: [[a3]] = const 25f32;
-    // CHECK: [[b3]] = ({{_.*}}.1: std::option::Option<S>);
-    // CHECK: [[c3]] = ({{_.*}}.2: &[f32]);
+    // CHECK: [[b3]] = copy ({{_.*}}.1: std::option::Option<S>);
+    // CHECK: [[c3]] = copy ({{_.*}}.2: &[f32]);
     let BigStruct(a3, b3, c3) = BIG_VAL;
 
     static BIG_STAT: &BigStruct = &BigStruct(82., Some(S(35)), &[45., 72.]);
     // CHECK: [[a4]] = const 82f32;
-    // CHECK: [[b4]] = ((*{{_.*}}).1: std::option::Option<S>);
-    // CHECK: [[c4]] = ((*{{_.*}}).2: &[f32]);
+    // CHECK: [[b4]] = copy ((*{{_.*}}).1: std::option::Option<S>);
+    // CHECK: [[c4]] = copy ((*{{_.*}}).2: &[f32]);
     let BigStruct(a4, b4, c4) = *BIG_STAT;
 
     // We arbitrarily limit the size of synthetized values to 4 pointers.
diff --git a/tests/mir-opt/dead-store-elimination/call_arg_copy.rs b/tests/mir-opt/dead-store-elimination/call_arg_copy.rs
index 2556848ec4629..27b5ccdb936db 100644
--- a/tests/mir-opt/dead-store-elimination/call_arg_copy.rs
+++ b/tests/mir-opt/dead-store-elimination/call_arg_copy.rs
@@ -14,7 +14,7 @@ fn use_both(_: i32, _: i32) {}
 // EMIT_MIR call_arg_copy.move_simple.DeadStoreElimination-final.diff
 fn move_simple(x: i32) {
     // CHECK-LABEL: fn move_simple(
-    // CHECK: = use_both(_1, move _1)
+    // CHECK: = use_both(copy _1, move _1)
     use_both(x, x);
 }
 
@@ -28,7 +28,7 @@ struct Packed {
 #[custom_mir(dialect = "analysis")]
 fn move_packed(packed: Packed) {
     // CHECK-LABEL: fn move_packed(
-    // CHECK: = use_both(const 0_i32, (_1.1: i32))
+    // CHECK: = use_both(const 0_i32, copy (_1.1: i32))
     mir! {
         {
             // We have a packed struct, verify that the copy is not turned into a move.
diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.rs b/tests/mir-opt/dest-prop/copy_propagation_arg.rs
index 084bd0544c175..ef531f4afa2b7 100644
--- a/tests/mir-opt/dest-prop/copy_propagation_arg.rs
+++ b/tests/mir-opt/dest-prop/copy_propagation_arg.rs
@@ -41,9 +41,9 @@ fn arg_src(mut x: i32) -> i32 {
     // CHECK-LABEL: fn arg_src(
     // CHECK: debug x => [[x:_.*]];
     // CHECK: debug y => [[y:_.*]];
-    // CHECK: [[y]] = [[x]]
+    // CHECK: [[y]] = copy [[x]]
     // CHECK: [[x]] = const 123_i32;
-    // CHECK-NOT: {{_.*}} = [[y]];
+    // CHECK-NOT: {{_.*}} = copy [[y]];
     let y = x;
     x = 123; // Don't propagate this assignment to `y`
     y
diff --git a/tests/mir-opt/dest-prop/dead_stores_79191.rs b/tests/mir-opt/dest-prop/dead_stores_79191.rs
index 61060e4f8506b..d035de5ce0765 100644
--- a/tests/mir-opt/dest-prop/dead_stores_79191.rs
+++ b/tests/mir-opt/dest-prop/dead_stores_79191.rs
@@ -10,7 +10,7 @@ fn f(mut a: usize) -> usize {
     // CHECK-LABEL: fn f(
     // CHECK: debug a => [[a:_.*]];
     // CHECK: debug b => [[b:_.*]];
-    // CHECK: [[b]] = [[a]];
+    // CHECK: [[b]] = copy [[a]];
     // CHECK: [[a]] = const 5_usize;
     // CHECK: [[a]] = move [[b]];
     // CHECK: id::<usize>(move [[a]])
diff --git a/tests/mir-opt/dest-prop/dead_stores_better.rs b/tests/mir-opt/dest-prop/dead_stores_better.rs
index d2b9fe0571234..d4c297fd97a38 100644
--- a/tests/mir-opt/dest-prop/dead_stores_better.rs
+++ b/tests/mir-opt/dest-prop/dead_stores_better.rs
@@ -14,7 +14,7 @@ pub fn f(mut a: usize) -> usize {
     // CHECK-LABEL: fn f(
     // CHECK: debug a => [[a:_.*]];
     // CHECK: debug b => [[b:_.*]];
-    // CHECK: [[b]] = [[a]];
+    // CHECK: [[b]] = copy [[a]];
     // CHECK: [[a]] = const 5_usize;
     // CHECK: [[a]] = move [[b]];
     // CHECK: id::<usize>(move [[a]])
diff --git a/tests/mir-opt/dest-prop/simple.rs b/tests/mir-opt/dest-prop/simple.rs
index 833d49b8c4665..927a9c5b24cdb 100644
--- a/tests/mir-opt/dest-prop/simple.rs
+++ b/tests/mir-opt/dest-prop/simple.rs
@@ -7,9 +7,9 @@ fn nrvo(init: fn(&mut [u8; 1024])) -> [u8; 1024] {
     // CHECK: debug init => [[init:_.*]];
     // CHECK: debug buf => [[buf:_.*]];
     // CHECK: [[buf]] = [const 0_u8; 1024];
-    // CHECK-NOT: {{_.*}} = [[init]];
+    // CHECK-NOT: {{_.*}} = copy [[init]];
     // CHECK: move [[init]](move {{_.*}})
-    // CHECK: {{_.*}} = [[buf]]
+    // CHECK: {{_.*}} = copy [[buf]]
     let mut buf = [0; 1024];
     init(&mut buf);
     buf
diff --git a/tests/mir-opt/early_otherwise_branch.rs b/tests/mir-opt/early_otherwise_branch.rs
index b047c50df97fa..47bd4be295b04 100644
--- a/tests/mir-opt/early_otherwise_branch.rs
+++ b/tests/mir-opt/early_otherwise_branch.rs
@@ -49,7 +49,7 @@ fn opt3(x: Option2<u32>, y: Option2<bool>) -> u32 {
     // CHECK: bb0: {
     // CHECK: [[LOCAL1:_.*]] = discriminant({{.*}});
     // CHECK: [[LOCAL2:_.*]] = discriminant({{.*}});
-    // CHECK: [[CMP_LOCAL]] = Ne([[LOCAL1]], move [[LOCAL2]]);
+    // CHECK: [[CMP_LOCAL]] = Ne(copy [[LOCAL1]], move [[LOCAL2]]);
     // CHECK: switchInt(move [[CMP_LOCAL]]) -> [
     // CHECK-NEXT: }
     match (x, y) {
@@ -67,7 +67,7 @@ fn opt4(x: Option2<u32>, y: Option2<u32>) -> u32 {
     // CHECK: bb0: {
     // CHECK: [[LOCAL1:_.*]] = discriminant({{.*}});
     // CHECK: [[LOCAL2:_.*]] = discriminant({{.*}});
-    // CHECK: [[CMP_LOCAL]] = Ne([[LOCAL1]], move [[LOCAL2]]);
+    // CHECK: [[CMP_LOCAL]] = Ne(copy [[LOCAL1]], move [[LOCAL2]]);
     // CHECK: switchInt(move [[CMP_LOCAL]]) -> [
     // CHECK-NEXT: }
     match (x, y) {
diff --git a/tests/mir-opt/early_otherwise_branch_3_element_tuple.rs b/tests/mir-opt/early_otherwise_branch_3_element_tuple.rs
index d2a3e1f59ff6e..d6b27fbce4844 100644
--- a/tests/mir-opt/early_otherwise_branch_3_element_tuple.rs
+++ b/tests/mir-opt/early_otherwise_branch_3_element_tuple.rs
@@ -32,7 +32,7 @@ fn opt2(x: Option2<u32>, y: Option2<u32>, z: Option2<u32>) -> u32 {
     // CHECK: bb0: {
     // CHECK: [[LOCAL1:_.*]] = discriminant({{.*}});
     // CHECK: [[LOCAL2:_.*]] = discriminant({{.*}});
-    // CHECK: [[CMP_LOCAL]] = Ne([[LOCAL1]], move [[LOCAL2]]);
+    // CHECK: [[CMP_LOCAL]] = Ne(copy [[LOCAL1]], move [[LOCAL2]]);
     // CHECK: switchInt(move [[CMP_LOCAL]]) -> [
     // CHECK-NEXT: }
     match (x, y, z) {
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
index 430f979fec716..ab1253eadeec3 100644
--- a/tests/mir-opt/gvn.rs
+++ b/tests/mir-opt/gvn.rs
@@ -21,91 +21,91 @@ struct S<T>(T);
 fn subexpression_elimination(x: u64, y: u64, mut z: u64) {
     // CHECK-LABEL: fn subexpression_elimination(
 
-    // CHECK: [[add:_.*]] = Add(_1, _2);
-    // CHECK: opaque::<u64>([[add]])
+    // CHECK: [[add:_.*]] = Add(copy _1, copy _2);
+    // CHECK: opaque::<u64>(copy [[add]])
     opaque(x + y);
-    // CHECK: [[mul:_.*]] = Mul(_1, _2);
-    // CHECK: opaque::<u64>([[mul]])
+    // CHECK: [[mul:_.*]] = Mul(copy _1, copy _2);
+    // CHECK: opaque::<u64>(copy [[mul]])
     opaque(x * y);
-    // CHECK: [[sub:_.*]] = Sub(_1, _2);
-    // CHECK: opaque::<u64>([[sub]])
+    // CHECK: [[sub:_.*]] = Sub(copy _1, copy _2);
+    // CHECK: opaque::<u64>(copy [[sub]])
     opaque(x - y);
-    // CHECK: [[div:_.*]] = Div(_1, _2);
-    // CHECK: opaque::<u64>([[div]])
+    // CHECK: [[div:_.*]] = Div(copy _1, copy _2);
+    // CHECK: opaque::<u64>(copy [[div]])
     opaque(x / y);
-    // CHECK: [[rem:_.*]] = Rem(_1, _2);
-    // CHECK: opaque::<u64>([[rem]])
+    // CHECK: [[rem:_.*]] = Rem(copy _1, copy _2);
+    // CHECK: opaque::<u64>(copy [[rem]])
     opaque(x % y);
-    // CHECK: [[and:_.*]] = BitAnd(_1, _2);
-    // CHECK: opaque::<u64>([[and]])
+    // CHECK: [[and:_.*]] = BitAnd(copy _1, copy _2);
+    // CHECK: opaque::<u64>(copy [[and]])
     opaque(x & y);
-    // CHECK: [[or:_.*]] = BitOr(_1, _2);
-    // CHECK: opaque::<u64>([[or]])
+    // CHECK: [[or:_.*]] = BitOr(copy _1, copy _2);
+    // CHECK: opaque::<u64>(copy [[or]])
     opaque(x | y);
-    // CHECK: [[xor:_.*]] = BitXor(_1, _2);
-    // CHECK: opaque::<u64>([[xor]])
+    // CHECK: [[xor:_.*]] = BitXor(copy _1, copy _2);
+    // CHECK: opaque::<u64>(copy [[xor]])
     opaque(x ^ y);
-    // CHECK: [[shl:_.*]] = Shl(_1, _2);
-    // CHECK: opaque::<u64>([[shl]])
+    // CHECK: [[shl:_.*]] = Shl(copy _1, copy _2);
+    // CHECK: opaque::<u64>(copy [[shl]])
     opaque(x << y);
-    // CHECK: [[shr:_.*]] = Shr(_1, _2);
-    // CHECK: opaque::<u64>([[shr]])
+    // CHECK: [[shr:_.*]] = Shr(copy _1, copy _2);
+    // CHECK: opaque::<u64>(copy [[shr]])
     opaque(x >> y);
-    // CHECK: [[int:_.*]] = _1 as u32 (IntToInt);
-    // CHECK: opaque::<u32>([[int]])
+    // CHECK: [[int:_.*]] = copy _1 as u32 (IntToInt);
+    // CHECK: opaque::<u32>(copy [[int]])
     opaque(x as u32);
-    // CHECK: [[float:_.*]] = _1 as f32 (IntToFloat);
-    // CHECK: opaque::<f32>([[float]])
+    // CHECK: [[float:_.*]] = copy _1 as f32 (IntToFloat);
+    // CHECK: opaque::<f32>(copy [[float]])
     opaque(x as f32);
-    // CHECK: [[wrap:_.*]] = S::<u64>(_1);
-    // CHECK: opaque::<S<u64>>([[wrap]])
+    // CHECK: [[wrap:_.*]] = S::<u64>(copy _1);
+    // CHECK: opaque::<S<u64>>(copy [[wrap]])
     opaque(S(x));
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(S(x).0);
 
     // Those are duplicates to substitute somehow.
-    // CHECK: opaque::<u64>([[add]])
+    // CHECK: opaque::<u64>(copy [[add]])
     opaque(x + y);
-    // CHECK: opaque::<u64>([[mul]])
+    // CHECK: opaque::<u64>(copy [[mul]])
     opaque(x * y);
-    // CHECK: opaque::<u64>([[sub]])
+    // CHECK: opaque::<u64>(copy [[sub]])
     opaque(x - y);
-    // CHECK: opaque::<u64>([[div]])
+    // CHECK: opaque::<u64>(copy [[div]])
     opaque(x / y);
-    // CHECK: opaque::<u64>([[rem]])
+    // CHECK: opaque::<u64>(copy [[rem]])
     opaque(x % y);
-    // CHECK: opaque::<u64>([[and]])
+    // CHECK: opaque::<u64>(copy [[and]])
     opaque(x & y);
-    // CHECK: opaque::<u64>([[or]])
+    // CHECK: opaque::<u64>(copy [[or]])
     opaque(x | y);
-    // CHECK: opaque::<u64>([[xor]])
+    // CHECK: opaque::<u64>(copy [[xor]])
     opaque(x ^ y);
-    // CHECK: opaque::<u64>([[shl]])
+    // CHECK: opaque::<u64>(copy [[shl]])
     opaque(x << y);
-    // CHECK: opaque::<u64>([[shr]])
+    // CHECK: opaque::<u64>(copy [[shr]])
     opaque(x >> y);
-    // CHECK: opaque::<u32>([[int]])
+    // CHECK: opaque::<u32>(copy [[int]])
     opaque(x as u32);
-    // CHECK: opaque::<f32>([[float]])
+    // CHECK: opaque::<f32>(copy [[float]])
     opaque(x as f32);
-    // CHECK: opaque::<S<u64>>([[wrap]])
+    // CHECK: opaque::<S<u64>>(copy [[wrap]])
     opaque(S(x));
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(S(x).0);
 
     // We can substitute through a complex expression.
-    // CHECK: [[compound:_.*]] = Sub([[mul]], _2);
-    // CHECK: opaque::<u64>([[compound]])
-    // CHECK: opaque::<u64>([[compound]])
+    // CHECK: [[compound:_.*]] = Sub(copy [[mul]], copy _2);
+    // CHECK: opaque::<u64>(copy [[compound]])
+    // CHECK: opaque::<u64>(copy [[compound]])
     opaque((x * y) - y);
     opaque((x * y) - y);
 
     // We can substitute through an immutable reference too.
     // CHECK: [[ref:_.*]] = &_3;
-    // CHECK: [[deref:_.*]] = (*[[ref]]);
-    // CHECK: [[addref:_.*]] = Add([[deref]], _1);
-    // CHECK: opaque::<u64>([[addref]])
-    // CHECK: opaque::<u64>([[addref]])
+    // CHECK: [[deref:_.*]] = copy (*[[ref]]);
+    // CHECK: [[addref:_.*]] = Add(copy [[deref]], copy _1);
+    // CHECK: opaque::<u64>(copy [[addref]])
+    // CHECK: opaque::<u64>(copy [[addref]])
     let a = &z;
     opaque(*a + x);
     opaque(*a + x);
@@ -141,10 +141,10 @@ fn subexpression_elimination(x: u64, y: u64, mut z: u64) {
     // We can substitute again, but not with the earlier computations.
     // Important: `e` is not `a`!
     // CHECK: [[ref2:_.*]] = &_3;
-    // CHECK: [[deref2:_.*]] = (*[[ref2]]);
-    // CHECK: [[addref2:_.*]] = Add([[deref2]], _1);
-    // CHECK: opaque::<u64>([[addref2]])
-    // CHECK: opaque::<u64>([[addref2]])
+    // CHECK: [[deref2:_.*]] = copy (*[[ref2]]);
+    // CHECK: [[addref2:_.*]] = Add(copy [[deref2]], copy _1);
+    // CHECK: opaque::<u64>(copy [[addref2]])
+    // CHECK: opaque::<u64>(copy [[addref2]])
     let e = &z;
     opaque(*e + x);
     opaque(*e + x);
@@ -152,9 +152,9 @@ fn subexpression_elimination(x: u64, y: u64, mut z: u64) {
 
 fn wrap_unwrap<T: Copy>(x: T) -> T {
     // CHECK-LABEL: fn wrap_unwrap(
-    // CHECK: [[some:_.*]] = Option::<T>::Some(_1);
+    // CHECK: [[some:_.*]] = Option::<T>::Some(copy _1);
     // CHECK: switchInt(const 1_isize)
-    // CHECK: _0 = _1;
+    // CHECK: _0 = copy _1;
     match Some(x) {
         Some(y) => y,
         None => panic!(),
@@ -163,35 +163,35 @@ fn wrap_unwrap<T: Copy>(x: T) -> T {
 
 fn repeated_index<T: Copy, const N: usize>(x: T, idx: usize) {
     // CHECK-LABEL: fn repeated_index(
-    // CHECK: [[a:_.*]] = [_1; N];
+    // CHECK: [[a:_.*]] = [copy _1; N];
     let a = [x; N];
-    // CHECK: opaque::<T>(_1)
+    // CHECK: opaque::<T>(copy _1)
     opaque(a[0]);
-    // CHECK: opaque::<T>(_1)
+    // CHECK: opaque::<T>(copy _1)
     opaque(a[idx]);
 }
 
 fn unary(x: i64) {
     // CHECK-LABEL: fn unary(
-    // CHECK: opaque::<i64>(_1)
+    // CHECK: opaque::<i64>(copy _1)
     opaque(--x); // This is `x`.
 
-    // CHECK: [[b:_.*]] = Lt(_1, const 13_i64);
-    // CHECK: opaque::<bool>([[b]])
+    // CHECK: [[b:_.*]] = Lt(copy _1, const 13_i64);
+    // CHECK: opaque::<bool>(copy [[b]])
     let b = x < 13;
     opaque(!!b); // This is `b`.
 
     // Both lines should test the same thing.
-    // CHECK: [[c:_.*]] = Ne(_1, const 15_i64);
-    // CHECK: opaque::<bool>([[c]])
-    // CHECK: opaque::<bool>([[c]])
+    // CHECK: [[c:_.*]] = Ne(copy _1, const 15_i64);
+    // CHECK: opaque::<bool>(copy [[c]])
+    // CHECK: opaque::<bool>(copy [[c]])
     opaque(x != 15);
     opaque(!(x == 15));
 
     // Both lines should test the same thing.
-    // CHECK: [[d:_.*]] = Eq(_1, const 35_i64);
-    // CHECK: opaque::<bool>([[d]])
-    // CHECK: opaque::<bool>([[d]])
+    // CHECK: [[d:_.*]] = Eq(copy _1, const 35_i64);
+    // CHECK: opaque::<bool>(copy [[d]])
+    // CHECK: opaque::<bool>(copy [[d]])
     opaque(x == 35);
     opaque(!(x != 35));
 }
@@ -199,53 +199,53 @@ fn unary(x: i64) {
 /// Verify symbolic integer arithmetic simplifications.
 fn arithmetic(x: u64) {
     // CHECK-LABEL: fn arithmetic(
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x + 0);
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x - 0);
     // CHECK: opaque::<u64>(const 0_u64)
     opaque(x - x);
     // CHECK: opaque::<u64>(const 0_u64)
     opaque(x * 0);
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x * 1);
     // CHECK: assert(!const true, "attempt to divide `{}` by zero",
-    // CHECK: [[div0:_.*]] = Div(_1, const 0_u64);
+    // CHECK: [[div0:_.*]] = Div(copy _1, const 0_u64);
     // CHECK: opaque::<u64>(move [[div0]])
     opaque(x / 0);
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x / 1);
     // CHECK: opaque::<u64>(const 0_u64)
     opaque(0 / x);
-    // CHECK: [[odiv:_.*]] = Div(const 1_u64, _1);
+    // CHECK: [[odiv:_.*]] = Div(const 1_u64, copy _1);
     // CHECK: opaque::<u64>(move [[odiv]])
     opaque(1 / x);
     // CHECK: assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero"
-    // CHECK: [[rem0:_.*]] = Rem(_1, const 0_u64);
+    // CHECK: [[rem0:_.*]] = Rem(copy _1, const 0_u64);
     // CHECK: opaque::<u64>(move [[rem0]])
     opaque(x % 0);
     // CHECK: opaque::<u64>(const 0_u64)
     opaque(x % 1);
     // CHECK: opaque::<u64>(const 0_u64)
     opaque(0 % x);
-    // CHECK: [[orem:_.*]] = Rem(const 1_u64, _1);
+    // CHECK: [[orem:_.*]] = Rem(const 1_u64, copy _1);
     // CHECK: opaque::<u64>(move [[orem]])
     opaque(1 % x);
     // CHECK: opaque::<u64>(const 0_u64)
     opaque(x & 0);
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x & u64::MAX);
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x | 0);
     // CHECK: opaque::<u64>(const u64::MAX)
     opaque(x | u64::MAX);
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x ^ 0);
     // CHECK: opaque::<u64>(const 0_u64)
     opaque(x ^ x);
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x >> 0);
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x << 0);
 }
 
@@ -255,10 +255,10 @@ fn comparison(x: u64, y: u64) {
     opaque(x == x);
     // CHECK: opaque::<bool>(const false)
     opaque(x != x);
-    // CHECK: [[eqxy:_.*]] = Eq(_1, _2);
+    // CHECK: [[eqxy:_.*]] = Eq(copy _1, copy _2);
     // CHECK: opaque::<bool>(move [[eqxy]])
     opaque(x == y);
-    // CHECK: [[nexy:_.*]] = Ne(_1, _2);
+    // CHECK: [[nexy:_.*]] = Ne(copy _1, copy _2);
     // CHECK: opaque::<bool>(move [[nexy]])
     opaque(x != y);
 }
@@ -268,10 +268,10 @@ fn comparison(x: u64, y: u64) {
 fn arithmetic_checked(x: u64) {
     // CHECK-LABEL: fn arithmetic_checked(
     // CHECK: assert(!const false,
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x + 0);
     // CHECK: assert(!const false,
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x - 0);
     // CHECK: assert(!const false,
     // CHECK: opaque::<u64>(const 0_u64)
@@ -280,39 +280,39 @@ fn arithmetic_checked(x: u64) {
     // CHECK: opaque::<u64>(const 0_u64)
     opaque(x * 0);
     // CHECK: assert(!const false,
-    // CHECK: opaque::<u64>(_1)
+    // CHECK: opaque::<u64>(copy _1)
     opaque(x * 1);
 }
 
 /// Verify that we do not apply arithmetic simplifications on floats.
 fn arithmetic_float(x: f64) {
     // CHECK-LABEL: fn arithmetic_float(
-    // CHECK: [[add:_.*]] = Add(_1, const 0f64);
+    // CHECK: [[add:_.*]] = Add(copy _1, const 0f64);
     // CHECK: opaque::<f64>(move [[add]])
     opaque(x + 0.);
-    // CHECK: [[sub:_.*]] = Sub(_1, const 0f64);
+    // CHECK: [[sub:_.*]] = Sub(copy _1, const 0f64);
     // CHECK: opaque::<f64>(move [[sub]])
     opaque(x - 0.);
-    // CHECK: [[mul:_.*]] = Mul(_1, const 0f64);
+    // CHECK: [[mul:_.*]] = Mul(copy _1, const 0f64);
     // CHECK: opaque::<f64>(move [[mul]])
     opaque(x * 0.);
-    // CHECK: [[div0:_.*]] = Div(_1, const 0f64);
+    // CHECK: [[div0:_.*]] = Div(copy _1, const 0f64);
     // CHECK: opaque::<f64>(move [[div0]])
     opaque(x / 0.);
-    // CHECK: [[zdiv:_.*]] = Div(const 0f64, _1);
+    // CHECK: [[zdiv:_.*]] = Div(const 0f64, copy _1);
     // CHECK: opaque::<f64>(move [[zdiv]])
     opaque(0. / x);
-    // CHECK: [[rem0:_.*]] = Rem(_1, const 0f64);
+    // CHECK: [[rem0:_.*]] = Rem(copy _1, const 0f64);
     // CHECK: opaque::<f64>(move [[rem0]])
     opaque(x % 0.);
-    // CHECK: [[zrem:_.*]] = Rem(const 0f64, _1);
+    // CHECK: [[zrem:_.*]] = Rem(const 0f64, copy _1);
     // CHECK: opaque::<f64>(move [[zrem]])
     opaque(0. % x);
     // Those are not simplifiable to `true`/`false`, thanks to NaNs.
-    // CHECK: [[eq:_.*]] = Eq(_1, _1);
+    // CHECK: [[eq:_.*]] = Eq(copy _1, copy _1);
     // CHECK: opaque::<bool>(move [[eq]])
     opaque(x == x);
-    // CHECK: [[ne:_.*]] = Ne(_1, _1);
+    // CHECK: [[ne:_.*]] = Ne(copy _1, copy _1);
     // CHECK: opaque::<bool>(move [[ne]])
     opaque(x != x);
 }
@@ -386,36 +386,36 @@ fn cast() {
 
 fn multiple_branches(t: bool, x: u8, y: u8) {
     // CHECK-LABEL: fn multiple_branches(
-    // CHECK: switchInt(_1) -> [0: [[bbf:bb.*]], otherwise: [[bbt:bb.*]]];
+    // CHECK: switchInt(copy _1) -> [0: [[bbf:bb.*]], otherwise: [[bbt:bb.*]]];
     if t {
         // CHECK: [[bbt]]: {
-        // CHECK: [[a:_.*]] = Add(_2, _3);
-        // CHECK: opaque::<u8>([[a]])
-        // CHECK: opaque::<u8>([[a]])
+        // CHECK: [[a:_.*]] = Add(copy _2, copy _3);
+        // CHECK: opaque::<u8>(copy [[a]])
+        // CHECK: opaque::<u8>(copy [[a]])
         // CHECK: goto -> [[bbc:bb.*]];
         opaque(x + y);
         opaque(x + y);
     } else {
         // CHECK: [[bbf]]: {
-        // CHECK: [[b:_.*]] = Add(_2, _3);
-        // CHECK: opaque::<u8>([[b]])
-        // CHECK: opaque::<u8>([[b]])
+        // CHECK: [[b:_.*]] = Add(copy _2, copy _3);
+        // CHECK: opaque::<u8>(copy [[b]])
+        // CHECK: opaque::<u8>(copy [[b]])
         // CHECK: goto -> [[bbc:bb.*]];
         opaque(x + y);
         opaque(x + y);
     }
     // Neither `a` nor `b` dominate `c`, so we cannot reuse any of them.
     // CHECK: [[bbc]]: {
-    // CHECK: [[c:_.*]] = Add(_2, _3);
-    // CHECK: opaque::<u8>([[c]])
+    // CHECK: [[c:_.*]] = Add(copy _2, copy _3);
+    // CHECK: opaque::<u8>(copy [[c]])
     opaque(x + y);
 
     // `c` dominates both calls, so we can reuse it.
     if t {
-        // CHECK: opaque::<u8>([[c]])
+        // CHECK: opaque::<u8>(copy [[c]])
         opaque(x + y);
     } else {
-        // CHECK: opaque::<u8>([[c]])
+        // CHECK: opaque::<u8>(copy [[c]])
         opaque(x + y);
     }
 }
@@ -469,18 +469,18 @@ fn dereferences(t: &mut u32, u: &impl Copy, s: &S<u32>) {
     // CHECK-LABEL: fn dereferences(
 
     // Do not reuse dereferences of `&mut`.
-    // CHECK: [[st1:_.*]] = (*_1);
+    // CHECK: [[st1:_.*]] = copy (*_1);
     // CHECK: opaque::<u32>(move [[st1]])
-    // CHECK: [[st2:_.*]] = (*_1);
+    // CHECK: [[st2:_.*]] = copy (*_1);
     // CHECK: opaque::<u32>(move [[st2]])
     opaque(*t);
     opaque(*t);
 
     // Do not reuse dereferences of `*const`.
     // CHECK: [[raw:_.*]] = &raw const (*_1);
-    // CHECK: [[st3:_.*]] = (*[[raw]]);
+    // CHECK: [[st3:_.*]] = copy (*[[raw]]);
     // CHECK: opaque::<u32>(move [[st3]])
-    // CHECK: [[st4:_.*]] = (*[[raw]]);
+    // CHECK: [[st4:_.*]] = copy (*[[raw]]);
     // CHECK: opaque::<u32>(move [[st4]])
     let z = &raw const *t;
     unsafe { opaque(*z) };
@@ -488,9 +488,9 @@ fn dereferences(t: &mut u32, u: &impl Copy, s: &S<u32>) {
 
     // Do not reuse dereferences of `*mut`.
     // CHECK: [[ptr:_.*]] = &raw mut (*_1);
-    // CHECK: [[st5:_.*]] = (*[[ptr]]);
+    // CHECK: [[st5:_.*]] = copy (*[[ptr]]);
     // CHECK: opaque::<u32>(move [[st5]])
-    // CHECK: [[st6:_.*]] = (*[[ptr]]);
+    // CHECK: [[st6:_.*]] = copy (*[[ptr]]);
     // CHECK: opaque::<u32>(move [[st6]])
     let z = &raw mut *t;
     unsafe { opaque(*z) };
@@ -498,9 +498,9 @@ fn dereferences(t: &mut u32, u: &impl Copy, s: &S<u32>) {
 
     // We can reuse dereferences of `&Freeze`.
     // CHECK: [[ref:_.*]] = &(*_1);
-    // CHECK: [[st7:_.*]] = (*[[ref]]);
-    // CHECK: opaque::<u32>([[st7]])
-    // CHECK: opaque::<u32>([[st7]])
+    // CHECK: [[st7:_.*]] = copy (*[[ref]]);
+    // CHECK: opaque::<u32>(copy [[st7]])
+    // CHECK: opaque::<u32>(copy [[st7]])
     let z = &*t;
     opaque(*z);
     opaque(*z);
@@ -510,17 +510,17 @@ fn dereferences(t: &mut u32, u: &impl Copy, s: &S<u32>) {
     opaque(&*z);
 
     // `*u` is not Freeze, so we cannot reuse.
-    // CHECK: [[st8:_.*]] = (*_2);
+    // CHECK: [[st8:_.*]] = copy (*_2);
     // CHECK: opaque::<impl Copy>(move [[st8]])
-    // CHECK: [[st9:_.*]] = (*_2);
+    // CHECK: [[st9:_.*]] = copy (*_2);
     // CHECK: opaque::<impl Copy>(move [[st9]])
     opaque(*u);
     opaque(*u);
 
-    // `*s` is not Copy, by `(*s).0` is, so we can reuse.
-    // CHECK: [[st10:_.*]] = ((*_3).0: u32);
-    // CHECK: opaque::<u32>([[st10]])
-    // CHECK: opaque::<u32>([[st10]])
+    // `*s` is not Copy, but `(*s).0` is, so we can reuse.
+    // CHECK: [[st10:_.*]] = copy ((*_3).0: u32);
+    // CHECK: opaque::<u32>(copy [[st10]])
+    // CHECK: opaque::<u32>(copy [[st10]])
     opaque(s.0);
     opaque(s.0);
 }
@@ -551,38 +551,38 @@ fn duplicate_slice() -> (bool, bool) {
         let d: &str;
         {
             // CHECK: [[a:_.*]] = (const "a",);
-            // CHECK: [[au:_.*]] = ([[a]].0: &str) as u128 (Transmute);
+            // CHECK: [[au:_.*]] = copy ([[a]].0: &str) as u128 (Transmute);
             let a = ("a",);
             Call(au = transmute::<_, u128>(a.0), ReturnTo(bb1), UnwindContinue())
         }
         bb1 = {
-            // CHECK: [[c:_.*]] = identity::<&str>(([[a]].0: &str))
+            // CHECK: [[c:_.*]] = identity::<&str>(copy ([[a]].0: &str))
             Call(c = identity(a.0), ReturnTo(bb2), UnwindContinue())
         }
         bb2 = {
-            // CHECK: [[cu:_.*]] = [[c]] as u128 (Transmute);
+            // CHECK: [[cu:_.*]] = copy [[c]] as u128 (Transmute);
             Call(cu = transmute::<_, u128>(c), ReturnTo(bb3), UnwindContinue())
         }
         bb3 = {
             // This slice is different from `a.0`. Hence `bu` is not `au`.
             // CHECK: [[b:_.*]] = const "a";
-            // CHECK: [[bu:_.*]] = [[b]] as u128 (Transmute);
+            // CHECK: [[bu:_.*]] = copy [[b]] as u128 (Transmute);
             let b = "a";
             Call(bu = transmute::<_, u128>(b), ReturnTo(bb4), UnwindContinue())
         }
         bb4 = {
             // This returns a copy of `b`, which is not `a`.
-            // CHECK: [[d:_.*]] = identity::<&str>([[b]])
+            // CHECK: [[d:_.*]] = identity::<&str>(copy [[b]])
             Call(d = identity(b), ReturnTo(bb5), UnwindContinue())
         }
         bb5 = {
-            // CHECK: [[du:_.*]] = [[d]] as u128 (Transmute);
+            // CHECK: [[du:_.*]] = copy [[d]] as u128 (Transmute);
             Call(du = transmute::<_, u128>(d), ReturnTo(bb6), UnwindContinue())
         }
         bb6 = {
             // `direct` must not fold to `true`, as `indirect` will not.
-            // CHECK: = Eq([[au]], [[bu]]);
-            // CHECK: = Eq([[cu]], [[du]]);
+            // CHECK: = Eq(copy [[au]], copy [[bu]]);
+            // CHECK: = Eq(copy [[cu]], copy [[du]]);
             let direct = au == bu;
             let indirect = cu == du;
             RET = (direct, indirect);
@@ -602,21 +602,21 @@ fn repeat() {
 fn fn_pointers() {
     // CHECK-LABEL: fn fn_pointers(
     // CHECK: [[f:_.*]] = identity::<u8> as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer
-    // CHECK: opaque::<fn(u8) -> u8>([[f]])
+    // CHECK: opaque::<fn(u8) -> u8>(copy [[f]])
     let f = identity as fn(u8) -> u8;
     opaque(f);
     // CHECK: [[g:_.*]] = identity::<u8> as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer
-    // CHECK: opaque::<fn(u8) -> u8>([[g]])
+    // CHECK: opaque::<fn(u8) -> u8>(copy [[g]])
     let g = identity as fn(u8) -> u8;
     opaque(g);
 
     // CHECK: [[cf:_.*]] = const {{.*}} as fn() (PointerCoercion(ClosureFnPointer
-    // CHECK: opaque::<fn()>([[cf]])
+    // CHECK: opaque::<fn()>(copy [[cf]])
     let closure = || {};
     let cf = closure as fn();
     opaque(cf);
     // CHECK: [[cg:_.*]] = const {{.*}} as fn() (PointerCoercion(ClosureFnPointer
-    // CHECK: opaque::<fn()>([[cg]])
+    // CHECK: opaque::<fn()>(copy [[cg]])
     let cg = closure as fn();
     opaque(cg);
 }
@@ -642,9 +642,9 @@ fn constant_index_overflow<T: Copy>(x: &[T]) {
     // CHECK: debug b => [[b:_.*]];
     // CHECK: [[a]] = const usize::MAX;
     // CHECK-NOT: = (*_1)[{{.*}} of 0];
-    // CHECK: [[b]] = (*_1)[[[a]]];
+    // CHECK: [[b]] = copy (*_1)[[[a]]];
     // CHECK-NOT: = (*_1)[{{.*}} of 0];
-    // CHECK: [[b]] = (*_1)[0 of 1];
+    // CHECK: [[b]] = copy (*_1)[0 of 1];
     // CHECK-NOT: = (*_1)[{{.*}} of 0];
     let a = u64::MAX as usize;
     let b = if a < x.len() { x[a] } else { x[0] };
@@ -657,22 +657,22 @@ fn wide_ptr_provenance() {
     let a: *const dyn Send = &1 as &dyn Send;
     let b: *const dyn Send = &1 as &dyn Send;
 
-    // CHECK: [[eqp:_.*]] = Eq([[a:_.*]], [[b:_.*]]);
+    // CHECK: [[eqp:_.*]] = Eq(copy [[a:_.*]], copy [[b:_.*]]);
     // CHECK: opaque::<bool>(move [[eqp]])
     opaque(a == b);
-    // CHECK: [[nep:_.*]] = Ne([[a]], [[b]]);
+    // CHECK: [[nep:_.*]] = Ne(copy [[a]], copy [[b]]);
     // CHECK: opaque::<bool>(move [[nep]])
     opaque(a != b);
-    // CHECK: [[ltp:_.*]] = Lt([[a]], [[b]]);
+    // CHECK: [[ltp:_.*]] = Lt(copy [[a]], copy [[b]]);
     // CHECK: opaque::<bool>(move [[ltp]])
     opaque(a < b);
-    // CHECK: [[lep:_.*]] = Le([[a]], [[b]]);
+    // CHECK: [[lep:_.*]] = Le(copy [[a]], copy [[b]]);
     // CHECK: opaque::<bool>(move [[lep]])
     opaque(a <= b);
-    // CHECK: [[gtp:_.*]] = Gt([[a]], [[b]]);
+    // CHECK: [[gtp:_.*]] = Gt(copy [[a]], copy [[b]]);
     // CHECK: opaque::<bool>(move [[gtp]])
     opaque(a > b);
-    // CHECK: [[gep:_.*]] = Ge([[a]], [[b]]);
+    // CHECK: [[gep:_.*]] = Ge(copy [[a]], copy [[b]]);
     // CHECK: opaque::<bool>(move [[gep]])
     opaque(a >= b);
 }
@@ -684,22 +684,22 @@ fn wide_ptr_same_provenance() {
     let a: *const dyn Send = &slice[0] as &dyn Send;
     let b: *const dyn Send = &slice[1] as &dyn Send;
 
-    // CHECK: [[eqp:_.*]] = Eq([[a:_.*]], [[b:_.*]]);
+    // CHECK: [[eqp:_.*]] = Eq(copy [[a:_.*]], copy [[b:_.*]]);
     // CHECK: opaque::<bool>(move [[eqp]])
     opaque(a == b);
-    // CHECK: [[nep:_.*]] = Ne([[a]], [[b]]);
+    // CHECK: [[nep:_.*]] = Ne(copy [[a]], copy [[b]]);
     // CHECK: opaque::<bool>(move [[nep]])
     opaque(a != b);
-    // CHECK: [[ltp:_.*]] = Lt([[a]], [[b]]);
+    // CHECK: [[ltp:_.*]] = Lt(copy [[a]], copy [[b]]);
     // CHECK: opaque::<bool>(move [[ltp]])
     opaque(a < b);
-    // CHECK: [[lep:_.*]] = Le([[a]], [[b]]);
+    // CHECK: [[lep:_.*]] = Le(copy [[a]], copy [[b]]);
     // CHECK: opaque::<bool>(move [[lep]])
     opaque(a <= b);
-    // CHECK: [[gtp:_.*]] = Gt([[a]], [[b]]);
+    // CHECK: [[gtp:_.*]] = Gt(copy [[a]], copy [[b]]);
     // CHECK: opaque::<bool>(move [[gtp]])
     opaque(a > b);
-    // CHECK: [[gep:_.*]] = Ge([[a]], [[b]]);
+    // CHECK: [[gep:_.*]] = Ge(copy [[a]], copy [[b]]);
     // CHECK: opaque::<bool>(move [[gep]])
     opaque(a >= b);
 }
@@ -731,13 +731,13 @@ fn wide_ptr_integer() {
 fn borrowed<T: Copy + Freeze>(x: T) {
     // CHECK-LABEL: fn borrowed(
     // CHECK: bb0: {
-    // CHECK-NEXT: _2 = _1;
+    // CHECK-NEXT: _2 = copy _1;
     // CHECK-NEXT: _3 = &_1;
-    // CHECK-NEXT: _0 = opaque::<&T>(_3)
+    // CHECK-NEXT: _0 = opaque::<&T>(copy _3)
     // CHECK: bb1: {
-    // CHECK-NEXT: _0 = opaque::<T>(_1)
+    // CHECK-NEXT: _0 = opaque::<T>(copy _1)
     // CHECK: bb2: {
-    // CHECK-NEXT: _0 = opaque::<T>(_1)
+    // CHECK-NEXT: _0 = opaque::<T>(copy _1)
     mir! {
         {
             let a = x;
@@ -761,13 +761,13 @@ fn borrowed<T: Copy + Freeze>(x: T) {
 fn non_freeze<T: Copy>(x: T) {
     // CHECK-LABEL: fn non_freeze(
     // CHECK: bb0: {
-    // CHECK-NEXT: _2 = _1;
+    // CHECK-NEXT: _2 = copy _1;
     // CHECK-NEXT: _3 = &_1;
-    // CHECK-NEXT: _0 = opaque::<&T>(_3)
+    // CHECK-NEXT: _0 = opaque::<&T>(copy _3)
     // CHECK: bb1: {
-    // CHECK-NEXT: _0 = opaque::<T>(_2)
+    // CHECK-NEXT: _0 = opaque::<T>(copy _2)
     // CHECK: bb2: {
-    // CHECK-NEXT: _0 = opaque::<T>((*_3))
+    // CHECK-NEXT: _0 = opaque::<T>(copy (*_3))
     mir! {
         {
             let a = x;
@@ -789,7 +789,7 @@ fn non_freeze<T: Copy>(x: T) {
 // Check that we can const-prop into `from_raw_parts`
 fn slice_const_length(x: &[i32]) -> *const [i32] {
     // CHECK-LABEL: fn slice_const_length(
-    // CHECK: _0 = *const [i32] from ({{_[0-9]+}}, const 123_usize);
+    // CHECK: _0 = *const [i32] from (copy {{_[0-9]+}}, const 123_usize);
     let ptr = x.as_ptr();
     let len = 123;
     std::intrinsics::aggregate_raw_ptr(ptr, len)
@@ -804,15 +804,15 @@ fn meta_of_ref_to_slice(x: *const i32) -> usize {
 
 fn slice_from_raw_parts_as_ptr(x: *const u16, n: usize) -> (*const u16, *const f32) {
     // CHECK-LABEL: fn slice_from_raw_parts_as_ptr
-    // CHECK: _8 = _1 as *const f32 (PtrToPtr);
-    // CHECK: _0 = (_1, move _8);
+    // CHECK: _8 = copy _1 as *const f32 (PtrToPtr);
+    // CHECK: _0 = (copy _1, move _8);
     let ptr: *const [u16] = std::intrinsics::aggregate_raw_ptr(x, n);
     (ptr as *const u16, ptr as *const f32)
 }
 
 fn casts_before_aggregate_raw_ptr(x: *const u32) -> *const [u8] {
     // CHECK-LABEL: fn casts_before_aggregate_raw_ptr
-    // CHECK: _0 = *const [u8] from (_1, const 4_usize);
+    // CHECK: _0 = *const [u8] from (copy _1, const 4_usize);
     let x = x as *const [u8; 4];
     let x = x as *const u8;
     let x = x as *const ();
@@ -821,7 +821,7 @@ fn casts_before_aggregate_raw_ptr(x: *const u32) -> *const [u8] {
 
 fn manual_slice_mut_len(x: &mut [i32]) -> usize {
     // CHECK-LABEL: fn manual_slice_mut_len
-    // CHECK: _0 = PtrMetadata(_1);
+    // CHECK: _0 = PtrMetadata(copy _1);
     let x: *mut [i32] = x;
     let x: *const [i32] = x;
     std::intrinsics::ptr_metadata(x)
@@ -844,38 +844,38 @@ fn generic_cast_metadata<T, A: ?Sized, B: ?Sized>(ps: *const [T], pa: *const A,
             // when the pointee metadata do or don't match, respectively.
 
             // Metadata usize -> (), do not optimize.
-            // CHECK: [[T:_.+]] = _1 as
-            // CHECK-NEXT: PtrMetadata([[T]])
+            // CHECK: [[T:_.+]] = copy _1 as
+            // CHECK-NEXT: PtrMetadata(copy [[T]])
             let t1 = CastPtrToPtr::<_, *const T>(ps);
             let m1 = PtrMetadata(t1);
 
             // `(&A, [T])` has `usize` metadata, same as `[T]`, yes optimize.
-            // CHECK: [[T:_.+]] = _1 as
-            // CHECK-NEXT: PtrMetadata(_1)
+            // CHECK: [[T:_.+]] = copy _1 as
+            // CHECK-NEXT: PtrMetadata(copy _1)
             let t2 = CastPtrToPtr::<_, *const (&A, [T])>(ps);
             let m2 = PtrMetadata(t2);
 
             // Tail `A` and tail `B`, do not optimize.
-            // CHECK: [[T:_.+]] = _2 as
-            // CHECK-NEXT: PtrMetadata([[T]])
+            // CHECK: [[T:_.+]] = copy _2 as
+            // CHECK-NEXT: PtrMetadata(copy [[T]])
             let t3 = CastPtrToPtr::<_, *const (T, B)>(pa);
             let m3 = PtrMetadata(t3);
 
             // Both have tail `A`, yes optimize.
-            // CHECK: [[T:_.+]] = _2 as
-            // CHECK-NEXT: PtrMetadata(_2)
+            // CHECK: [[T:_.+]] = copy _2 as
+            // CHECK-NEXT: PtrMetadata(copy _2)
             let t4 = CastPtrToPtr::<_, *const (T, A)>(pa);
             let m4 = PtrMetadata(t4);
 
             // Tail `B` and tail `A`, do not optimize.
-            // CHECK: [[T:_.+]] = _3 as
-            // CHECK-NEXT: PtrMetadata([[T]])
+            // CHECK: [[T:_.+]] = copy _3 as
+            // CHECK-NEXT: PtrMetadata(copy [[T]])
             let t5 = CastPtrToPtr::<_, *mut A>(pb);
             let m5 = PtrMetadata(t5);
 
             // Both have tail `B`, yes optimize.
-            // CHECK: [[T:_.+]] = _3 as
-            // CHECK-NEXT: PtrMetadata(_3)
+            // CHECK: [[T:_.+]] = copy _3 as
+            // CHECK-NEXT: PtrMetadata(copy _3)
             let t6 = CastPtrToPtr::<_, *mut B>(pb);
             let m6 = PtrMetadata(t6);
 
@@ -891,21 +891,21 @@ fn cast_pointer_eq(p1: *mut u8, p2: *mut u32, p3: *mut u32, p4: *mut [u32]) {
     // CHECK: debug p3 => [[P3:_3]];
     // CHECK: debug p4 => [[P4:_4]];
 
-    // CHECK: [[M1:_.+]] = [[P1]] as *const u32 (PtrToPtr);
-    // CHECK: [[M2:_.+]] = [[P2]] as *const u32 (PtrToPtr);
-    // CHECK: [[M3:_.+]] = [[P3]] as *const u32 (PtrToPtr);
-    // CHECK: [[M4:_.+]] = [[P4]] as *const u32 (PtrToPtr);
+    // CHECK: [[M1:_.+]] = copy [[P1]] as *const u32 (PtrToPtr);
+    // CHECK: [[M2:_.+]] = copy [[P2]] as *const u32 (PtrToPtr);
+    // CHECK: [[M3:_.+]] = copy [[P3]] as *const u32 (PtrToPtr);
+    // CHECK: [[M4:_.+]] = copy [[P4]] as *const u32 (PtrToPtr);
     let m1 = p1 as *const u32;
     let m2 = p2 as *const u32;
     let m3 = p3 as *const u32;
     let m4 = p4 as *const u32;
 
     // CHECK-NOT: Eq
-    // CHECK: Eq([[M1]], [[M2]])
+    // CHECK: Eq(copy [[M1]], copy [[M2]])
     // CHECK-NOT: Eq
-    // CHECK: Eq([[P2]], [[P3]])
+    // CHECK: Eq(copy [[P2]], copy [[P3]])
     // CHECK-NOT: Eq
-    // CHECK: Eq([[M3]], [[M4]])
+    // CHECK: Eq(copy [[M3]], copy [[M4]])
     // CHECK-NOT: Eq
     let eq_different_thing = m1 == m2;
     let eq_optimize = m2 == m3;
@@ -918,11 +918,11 @@ fn cast_pointer_eq(p1: *mut u8, p2: *mut u32, p3: *mut u32, p4: *mut [u32]) {
 unsafe fn cast_pointer_then_transmute(thin: *mut u32, fat: *mut [u8]) {
     // CHECK-LABEL: fn cast_pointer_then_transmute
 
-    // CHECK: [[UNUSED:_.+]] = _1 as *const () (PtrToPtr);
-    // CHECK: = _1 as usize (Transmute);
+    // CHECK: [[UNUSED:_.+]] = copy _1 as *const () (PtrToPtr);
+    // CHECK: = copy _1 as usize (Transmute);
     let thin_addr: usize = std::intrinsics::transmute(thin as *const ());
 
-    // CHECK: [[TEMP2:_.+]] = _2 as *const () (PtrToPtr);
+    // CHECK: [[TEMP2:_.+]] = copy _2 as *const () (PtrToPtr);
     // CHECK: = move [[TEMP2]] as usize (Transmute);
     let fat_addr: usize = std::intrinsics::transmute(fat as *const ());
 }
@@ -935,11 +935,11 @@ fn remove_casts_must_change_both_sides(mut_a: &*mut u8, mut_b: *mut u8) -> bool
         // to be locals, so make sure we don't change one without the other, as
         // that would be a type error.
         {
-            // CHECK: [[A:_.+]] = (*_1) as *const u8 (PtrToPtr);
+            // CHECK: [[A:_.+]] = copy (*_1) as *const u8 (PtrToPtr);
             let a = *mut_a as *const u8;
-            // CHECK: [[B:_.+]] = _2 as *const u8 (PtrToPtr);
+            // CHECK: [[B:_.+]] = copy _2 as *const u8 (PtrToPtr);
             let b = mut_b as *const u8;
-            // CHECK: _0 = Eq([[A]], [[B]]);
+            // CHECK: _0 = Eq(copy [[A]], copy [[B]]);
             RET = a == b;
             Return()
         }
diff --git a/tests/mir-opt/gvn_copy_moves.rs b/tests/mir-opt/gvn_copy_moves.rs
index 1812de16d69fd..b1fe2caf3a143 100644
--- a/tests/mir-opt/gvn_copy_moves.rs
+++ b/tests/mir-opt/gvn_copy_moves.rs
@@ -18,9 +18,9 @@ fn fn0() {
             // CHECK-NEXT: _1 = const 1_usize;
             // CHECK-NEXT: _2 = [const 42_u128; 6];
             // CHECK-NEXT: _2[1 of 2] = const 1_u128;
-            // CHECK-NEXT: _3 = (_2,);
-            // CHECK-NEXT: _4 = _3;
-            // CHECK-NEXT: _5 = fn1((_3.0: [u128; 6]), _3)
+            // CHECK-NEXT: _3 = (copy _2,);
+            // CHECK-NEXT: _4 = copy _3;
+            // CHECK-NEXT: _5 = fn1(copy (_3.0: [u128; 6]), copy _3)
             a = 1_usize;
             b = [42; 6];
             b[a] = 1;
diff --git a/tests/mir-opt/instsimplify/casts.rs b/tests/mir-opt/instsimplify/casts.rs
index 24dbb67b42d1a..27308ee52bc2c 100644
--- a/tests/mir-opt/instsimplify/casts.rs
+++ b/tests/mir-opt/instsimplify/casts.rs
@@ -19,7 +19,7 @@ pub fn redundant<'a, 'b: 'a>(x: *const &'a u8) -> *const &'a u8 {
 // EMIT_MIR casts.roundtrip.InstSimplify-after-simplifycfg.diff
 pub fn roundtrip(x: *const u8) -> *const u8 {
     // CHECK-LABEL: fn roundtrip(
-    // CHECK: _4 = _1;
+    // CHECK: _4 = copy _1;
     // CHECK: _3 = move _4 as *mut u8 (PtrToPtr);
     // CHECK: _2 = move _3 as *const u8 (PtrToPtr);
     x as *mut u8 as *const u8
@@ -28,7 +28,7 @@ pub fn roundtrip(x: *const u8) -> *const u8 {
 // EMIT_MIR casts.roundtrip.InstSimplify-after-simplifycfg.diff
 pub fn cast_thin_via_aggregate(x: *const u8) -> *const () {
     // CHECK-LABEL: fn cast_thin_via_aggregate(
-    // CHECK: _2 = _1;
+    // CHECK: _2 = copy _1;
     // CHECK: _0 = move _2 as *const () (PtrToPtr);
     std::intrinsics::aggregate_raw_ptr(x, ())
 }
diff --git a/tests/mir-opt/instsimplify/ref_of_deref.rs b/tests/mir-opt/instsimplify/ref_of_deref.rs
index dc0f5f8198bc7..5ba9bafaea2a4 100644
--- a/tests/mir-opt/instsimplify/ref_of_deref.rs
+++ b/tests/mir-opt/instsimplify/ref_of_deref.rs
@@ -8,11 +8,11 @@
 // EMIT_MIR ref_of_deref.references.InstSimplify-after-simplifycfg.diff
 // CHECK-LABEL: references
 pub fn references(const_ref: &i32, mut_ref: &mut [i32]) {
-    // CHECK: _3 = _1;
+    // CHECK: _3 = copy _1;
     let _a = &*const_ref;
     // CHECK: _4 = &(*_2);
     let _b = &*mut_ref;
-    // CHECK: _5 = _2;
+    // CHECK: _5 = copy _2;
     let _c = &mut *mut_ref;
     // CHECK: _6 = &raw const (*_1);
     let _d = &raw const *const_ref;
@@ -31,10 +31,10 @@ pub unsafe fn pointers(const_ptr: *const [i32], mut_ptr: *mut i32) {
     let _b = &*mut_ptr;
     // CHECK: _5 = &mut (*_2);
     let _c = &mut *mut_ptr;
-    // CHECK: _6 = _1;
+    // CHECK: _6 = copy _1;
     let _d = &raw const *const_ptr;
     // CHECK: _7 = &raw const (*_2);
     let _e = &raw const *mut_ptr;
-    // CHECK: _8 = _2;
+    // CHECK: _8 = copy _2;
     let _f = &raw mut *mut_ptr;
 }
diff --git a/tests/mir-opt/instsimplify/ub_check.rs b/tests/mir-opt/instsimplify/ub_check.rs
index ee72511c132de..b513f60dc7b94 100644
--- a/tests/mir-opt/instsimplify/ub_check.rs
+++ b/tests/mir-opt/instsimplify/ub_check.rs
@@ -6,7 +6,7 @@ pub fn unwrap_unchecked(x: Option<i32>) -> i32 {
     // CHECK-LABEL: fn unwrap_unchecked(
     // CHECK-NOT: UbChecks()
     // CHECK: [[assume:_.*]] = const false;
-    // CHECK-NEXT: assume([[assume]]);
+    // CHECK-NEXT: assume(copy [[assume]]);
     // CHECK-NEXT: unreachable_unchecked::precondition_check
     unsafe { x.unwrap_unchecked() }
 }
diff --git a/tests/mir-opt/jump_threading.rs b/tests/mir-opt/jump_threading.rs
index 6486a321e693e..9487a4e7e5ffe 100644
--- a/tests/mir-opt/jump_threading.rs
+++ b/tests/mir-opt/jump_threading.rs
@@ -24,11 +24,11 @@ fn too_complex(x: Result<i32, usize>) -> Option<i32> {
     // CHECK: bb4: {
     // CHECK:     goto -> bb6;
     // CHECK: bb5: {
-    // CHECK:     {{_.*}} = (([[controlflow]] as Break).0: usize);
+    // CHECK:     {{_.*}} = copy (([[controlflow]] as Break).0: usize);
     // CHECK:     _0 = Option::<i32>::None;
     // CHECK:     goto -> bb7;
     // CHECK: bb6: {
-    // CHECK:     {{_.*}} = (([[controlflow]] as Continue).0: i32);
+    // CHECK:     {{_.*}} = copy (([[controlflow]] as Continue).0: i32);
     // CHECK:     _0 = Option::<i32>::Some(
     // CHECK:     goto -> bb7;
     // CHECK: bb7: {
@@ -49,16 +49,16 @@ fn too_complex(x: Result<i32, usize>) -> Option<i32> {
 fn identity(x: Result<i32, i32>) -> Result<i32, i32> {
     // CHECK-LABEL: fn identity(
     // CHECK: bb0: {
-    // CHECK:     [[x:_.*]] = _1;
+    // CHECK:     [[x:_.*]] = copy _1;
     // CHECK:     switchInt(move {{_.*}}) -> [0: bb7, 1: bb6, otherwise: bb1];
     // CHECK: bb1: {
     // CHECK:     unreachable;
     // CHECK: bb2: {
-    // CHECK:     {{_.*}} = (([[controlflow:_.*]] as Continue).0: i32);
+    // CHECK:     {{_.*}} = copy (([[controlflow:_.*]] as Continue).0: i32);
     // CHECK:     _0 = Result::<i32, i32>::Ok(
     // CHECK:     goto -> bb4;
     // CHECK: bb3: {
-    // CHECK:     {{_.*}} = (([[controlflow]] as Break).0: std::result::Result<std::convert::Infallible, i32>);
+    // CHECK:     {{_.*}} = copy (([[controlflow]] as Break).0: std::result::Result<std::convert::Infallible, i32>);
     // CHECK:     _0 = Result::<i32, i32>::Err(
     // CHECK:     goto -> bb4;
     // CHECK: bb4: {
@@ -160,13 +160,13 @@ fn multiple_match(x: u8) -> u8 {
     mir! {
         {
             // CHECK: bb0: {
-            // CHECK:     switchInt([[x:_.*]]) -> [3: bb1, otherwise: bb2];
+            // CHECK:     switchInt(copy [[x:_.*]]) -> [3: bb1, otherwise: bb2];
             match x { 3 => bb1, _ => bb2 }
         }
         bb1 = {
             // We know `x == 3`, so we can take `bb3`.
             // CHECK: bb1: {
-            // CHECK:     {{_.*}} = [[x]];
+            // CHECK:     {{_.*}} = copy [[x]];
             // CHECK:     goto -> bb3;
             let y = x;
             match y { 3 => bb3, _ => bb4 }
@@ -174,7 +174,7 @@ fn multiple_match(x: u8) -> u8 {
         bb2 = {
             // We know `x != 3`, so we can take `bb6`.
             // CHECK: bb2: {
-            // CHECK:     [[z:_.*]] = [[x]];
+            // CHECK:     [[z:_.*]] = copy [[x]];
             // CHECK:     goto -> bb6;
             let z = x;
             match z { 3 => bb5, _ => bb6 }
@@ -203,7 +203,7 @@ fn multiple_match(x: u8) -> u8 {
         bb6 = {
             // We know `z != 3`, so we CANNOT take `bb7`.
             // CHECK: bb6: {
-            // CHECK:     switchInt([[z]]) -> [1: bb7, otherwise: bb8];
+            // CHECK:     switchInt(copy [[z]]) -> [1: bb7, otherwise: bb8];
             match z { 1 => bb7, _ => bb8 }
         }
         bb7 = {
@@ -467,12 +467,12 @@ fn assume(a: u8, b: bool) -> u8 {
     mir! {
         {
             // CHECK: bb0: {
-            // CHECK-NEXT: switchInt(_1) -> [7: bb1, otherwise: bb2]
+            // CHECK-NEXT: switchInt(copy _1) -> [7: bb1, otherwise: bb2]
             match a { 7 => bb1, _ => bb2 }
         }
         bb1 = {
             // CHECK: bb1: {
-            // CHECK-NEXT: assume(_2);
+            // CHECK-NEXT: assume(copy _2);
             // CHECK-NEXT: goto -> bb6;
             Assume(b);
             Goto(bb3)
@@ -484,7 +484,7 @@ fn assume(a: u8, b: bool) -> u8 {
         }
         bb3 = {
             // CHECK: bb3: {
-            // CHECK-NEXT: switchInt(_2) -> [0: bb4, otherwise: bb5];
+            // CHECK-NEXT: switchInt(copy _2) -> [0: bb4, otherwise: bb5];
             match b { false => bb4, _ => bb5 }
         }
         bb4 = {
diff --git a/tests/mir-opt/lower_array_len.rs b/tests/mir-opt/lower_array_len.rs
index f7ed376726c8f..6553343cbf031 100644
--- a/tests/mir-opt/lower_array_len.rs
+++ b/tests/mir-opt/lower_array_len.rs
@@ -6,7 +6,7 @@
 pub fn array_bound<const N: usize>(index: usize, slice: &[u8; N]) -> u8 {
     // CHECK-LABEL: fn array_bound(
     // CHECK-NOT: Lt
-    // CHECK: Lt(_1, const N);
+    // CHECK: Lt(copy _1, const N);
     // CHECK-NOT: Lt
     if index < slice.len() { slice[index] } else { 42 }
 }
@@ -15,7 +15,7 @@ pub fn array_bound<const N: usize>(index: usize, slice: &[u8; N]) -> u8 {
 pub fn array_bound_mut<const N: usize>(index: usize, slice: &mut [u8; N]) -> u8 {
     // CHECK-LABEL: fn array_bound_mut(
     // CHECK-NOT: Lt
-    // CHECK: Lt(_1, const N);
+    // CHECK: Lt(copy _1, const N);
     // CHECK-NOT: Lt
     // CHECK: Lt(const 0_usize, const N)
     // CHECK-NOT: Lt
diff --git a/tests/mir-opt/lower_intrinsics.rs b/tests/mir-opt/lower_intrinsics.rs
index 2569f4f4de5df..4859d93546196 100644
--- a/tests/mir-opt/lower_intrinsics.rs
+++ b/tests/mir-opt/lower_intrinsics.rs
@@ -197,7 +197,7 @@ pub fn with_overflow(a: i32, b: i32) {
 pub fn read_via_copy_primitive(r: &i32) -> i32 {
     // CHECK-LABEL: fn read_via_copy_primitive(
     // CHECK: [[tmp:_.*]] = &raw const (*_1);
-    // CHECK: _0 = (*[[tmp]]);
+    // CHECK: _0 = copy (*[[tmp]]);
     // CHECK: return;
 
     unsafe { core::intrinsics::read_via_copy(r) }
@@ -207,7 +207,7 @@ pub fn read_via_copy_primitive(r: &i32) -> i32 {
 pub fn read_via_copy_uninhabited(r: &Never) -> Never {
     // CHECK-LABEL: fn read_via_copy_uninhabited(
     // CHECK: [[tmp:_.*]] = &raw const (*_1);
-    // CHECK: _0 = (*[[tmp]]);
+    // CHECK: _0 = copy (*[[tmp]]);
     // CHECK: unreachable;
 
     unsafe { core::intrinsics::read_via_copy(r) }
diff --git a/tests/mir-opt/pre-codegen/slice_index.rs b/tests/mir-opt/pre-codegen/slice_index.rs
index 6ddc4ad022075..574062d6c3569 100644
--- a/tests/mir-opt/pre-codegen/slice_index.rs
+++ b/tests/mir-opt/pre-codegen/slice_index.rs
@@ -10,17 +10,17 @@ use std::ops::Range;
 pub fn slice_index_usize(slice: &[u32], index: usize) -> u32 {
     // CHECK-LABEL: slice_index_usize
     // CHECK: [[LEN:_[0-9]+]] = Len((*_1))
-    // CHECK: Lt(_2, [[LEN]])
+    // CHECK: Lt(copy _2, copy [[LEN]])
     // CHECK-NOT: precondition_check
-    // CHECK: _0 = (*_1)[_2];
+    // CHECK: _0 = copy (*_1)[_2];
     slice[index]
 }
 
 // EMIT_MIR slice_index.slice_get_mut_usize.PreCodegen.after.mir
 pub fn slice_get_mut_usize(slice: &mut [u32], index: usize) -> Option<&mut u32> {
     // CHECK-LABEL: slice_get_mut_usize
-    // CHECK: [[LEN:_[0-9]+]] = PtrMetadata(_1)
-    // CHECK: Lt(_2, move [[LEN]])
+    // CHECK: [[LEN:_[0-9]+]] = PtrMetadata(copy _1)
+    // CHECK: Lt(copy _2, move [[LEN]])
     // CHECK-NOT: precondition_check
     slice.get_mut(index)
 }
@@ -37,9 +37,9 @@ pub unsafe fn slice_get_unchecked_mut_range(slice: &mut [u32], index: Range<usiz
     // CHECK: [[START:_[0-9]+]] = move (_2.0: usize);
     // CHECK: [[END:_[0-9]+]] = move (_2.1: usize);
     // CHECK: precondition_check
-    // CHECK: [[LEN:_[0-9]+]] = SubUnchecked([[END]], [[START]]);
-    // CHECK: [[PTR:_[0-9]+]] = Offset({{_[0-9]+}}, [[START]]);
-    // CHECK: [[SLICE:_[0-9]+]] = *mut [u32] from ([[PTR]], [[LEN]])
+    // CHECK: [[LEN:_[0-9]+]] = SubUnchecked(copy [[END]], copy [[START]]);
+    // CHECK: [[PTR:_[0-9]+]] = Offset(copy {{_[0-9]+}}, copy [[START]]);
+    // CHECK: [[SLICE:_[0-9]+]] = *mut [u32] from (copy [[PTR]], copy [[LEN]])
     // CHECK: _0 = &mut (*[[SLICE]]);
     slice.get_unchecked_mut(index)
 }
@@ -53,8 +53,8 @@ pub unsafe fn slice_ptr_get_unchecked_range(
     // CHECK: [[START:_[0-9]+]] = move (_2.0: usize);
     // CHECK: [[END:_[0-9]+]] = move (_2.1: usize);
     // CHECK: precondition_check
-    // CHECK: [[LEN:_[0-9]+]] = SubUnchecked([[END]], [[START]]);
-    // CHECK: [[PTR:_[0-9]+]] = Offset({{_[0-9]+}}, [[START]]);
-    // CHECK: _0 = *const [u32] from ([[PTR]], [[LEN]])
+    // CHECK: [[LEN:_[0-9]+]] = SubUnchecked(copy [[END]], copy [[START]]);
+    // CHECK: [[PTR:_[0-9]+]] = Offset(copy {{_[0-9]+}}, copy [[START]]);
+    // CHECK: _0 = *const [u32] from (copy [[PTR]], copy [[LEN]])
     slice.get_unchecked(index)
 }
diff --git a/tests/mir-opt/reference_prop.rs b/tests/mir-opt/reference_prop.rs
index 58d8b524ad642..1846d2f7c2419 100644
--- a/tests/mir-opt/reference_prop.rs
+++ b/tests/mir-opt/reference_prop.rs
@@ -16,7 +16,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
         // CHECK: bb0: {
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &[[a]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let a = 5_usize;
         let b = &a; // This borrow is only used once.
@@ -32,7 +32,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
         // CHECK: [[b:_.*]] = &[[a]];
         // CHECK: [[btmp:_.*]] = &[[a2]];
         // CHECK: [[b]] = move [[btmp]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let a = 5_usize;
         let a2 = 7_usize;
@@ -49,7 +49,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &[[a]];
         // CHECK: [[d:_.*]] = &[[b]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let a = 5_usize;
         let b = &a;
@@ -64,7 +64,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &[[a]];
         // CHECK: [[d:_.*]] = &raw mut [[b]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let a = 5_usize;
         let mut b = &a;
@@ -78,7 +78,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
         // CHECK: bb4: {
         // CHECK: [[a:_.*]] = const 7_usize;
         // CHECK: [[b:_.*]] = &[[a]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let a = 7_usize;
         let b = &a;
@@ -91,10 +91,10 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
         // CHECK: bb5: {
         // CHECK: [[a:_.*]] = const 7_usize;
         // CHECK: [[b1:_.*]] = &[[a]];
-        // CHECK: [[c:_.*]] = [[a]];
-        // CHECK: [[b2:_.*]] = [[b1]];
-        // CHECK: [[c2:_.*]] = [[a]];
-        // CHECK: [[b3:_.*]] = [[b2]];
+        // CHECK: [[c:_.*]] = copy [[a]];
+        // CHECK: [[b2:_.*]] = copy [[b1]];
+        // CHECK: [[c2:_.*]] = copy [[a]];
+        // CHECK: [[b3:_.*]] = copy [[b2]];
 
         let a = 7_usize;
         let b1 = &a;
@@ -111,7 +111,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
     {
         // CHECK: bb6: {
         // CHECK-NOT: {{_.*}} = &(*_1);
-        // CHECK: [[b:_.*]] = (*_1);
+        // CHECK: [[b:_.*]] = copy (*_1);
 
         let a = &*single;
         let b = *a; // This should be optimized as `*single`.
@@ -124,7 +124,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
         // CHECK: [[a:_.*]] = &(*_2);
         // CHECK: [[tmp:_.*]] = &(*_1);
         // CHECK: _2 = move [[tmp]];
-        // CHECK: [[b:_.*]] = (*[[a]]);
+        // CHECK: [[b:_.*]] = copy (*[[a]]);
 
         let a = &*multiple;
         multiple = &*single;
@@ -138,7 +138,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &[[a]];
         // CHECK: [[d:_.*]] = &[[b]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let a = 5_usize;
         let b = &a;
@@ -154,7 +154,7 @@ fn reference_propagation<'a, T: Copy>(single: &'a T, mut multiple: &'a T) {
         // CHECK: [[b:_.*]] = &[[a]];
         // CHECK: [[d:_.*]] = &mut [[b]];
         // FIXME this could be [[a]]
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let a = 5_usize;
         let mut b = &a;
@@ -172,7 +172,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
         // CHECK: bb0: {
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &mut [[a]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let mut a = 5_usize;
         let b = &mut a; // This borrow is only used once.
@@ -188,7 +188,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
         // CHECK: [[b:_.*]] = &mut [[a]];
         // CHECK: [[btmp:_.*]] = &mut [[a2]];
         // CHECK: [[b]] = move [[btmp]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 5_usize;
         let mut a2 = 7_usize;
@@ -205,7 +205,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &mut [[a]];
         // CHECK: [[d:_.*]] = &[[b]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 5_usize;
         let b = &mut a;
@@ -220,7 +220,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &mut [[a]];
         // CHECK: [[d:_.*]] = &raw mut [[b]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 5_usize;
         let mut b = &mut a;
@@ -234,7 +234,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
         // CHECK: bb4: {
         // CHECK: [[a:_.*]] = const 7_usize;
         // CHECK: [[b:_.*]] = &mut [[a]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 7_usize;
         let b = &mut a;
@@ -247,9 +247,9 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
         // CHECK: bb5: {
         // CHECK: [[a:_.*]] = const 7_usize;
         // CHECK: [[b1:_.*]] = &mut [[a]];
-        // CHECK: [[c:_.*]] = (*[[b1]]);
+        // CHECK: [[c:_.*]] = copy (*[[b1]]);
         // CHECK: [[b2:_.*]] = move [[b1]];
-        // CHECK: [[c2:_.*]] = (*[[b2]]);
+        // CHECK: [[c2:_.*]] = copy (*[[b2]]);
         // CHECK: [[b3:_.*]] = move [[b2]];
 
         let mut a = 7_usize;
@@ -267,7 +267,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
     {
         // CHECK: bb6: {
         // CHECK-NOT: {{_.*}} = &(*_1);
-        // CHECK: [[b:_.*]] = (*_1);
+        // CHECK: [[b:_.*]] = copy (*_1);
 
         let a = &mut *single;
         let b = *a; // This should be optimized as `*single`.
@@ -280,7 +280,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
         // CHECK: [[a:_.*]] = &mut (*_2);
         // CHECK: [[tmp:_.*]] = &mut (*_1);
         // CHECK: _2 = move [[tmp]];
-        // CHECK: [[b:_.*]] = (*[[a]]);
+        // CHECK: [[b:_.*]] = copy (*[[a]]);
 
         let a = &mut *multiple;
         multiple = &mut *single;
@@ -295,7 +295,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
         // CHECK: [[b:_.*]] = &mut [[a]];
         // CHECK: [[d:_.*]] = &[[b]];
         // FIXME this could be [[a]]
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 5_usize;
         let b = &mut a;
@@ -311,7 +311,7 @@ fn reference_propagation_mut<'a, T: Copy>(single: &'a mut T, mut multiple: &'a m
         // CHECK: [[b:_.*]] = &mut [[a]];
         // CHECK: [[d:_.*]] = &mut [[b]];
         // FIXME this could be [[a]]
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 5_usize;
         let mut b = &mut a;
@@ -329,7 +329,7 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
         // CHECK: bb0: {
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &raw const [[a]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let a = 5_usize;
         let b = &raw const a; // This borrow is only used once.
@@ -345,7 +345,7 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
         // CHECK: [[b:_.*]] = &raw const [[a]];
         // CHECK: [[btmp:_.*]] = &raw const [[a2]];
         // CHECK: [[b]] = move [[btmp]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let a = 5_usize;
         let a2 = 7_usize;
@@ -362,7 +362,7 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &raw const [[a]];
         // CHECK: [[d:_.*]] = &[[b]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let a = 5_usize;
         let b = &raw const a;
@@ -377,7 +377,7 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &raw const [[a]];
         // CHECK: [[d:_.*]] = &raw mut [[b]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let a = 5_usize;
         let mut b = &raw const a;
@@ -391,7 +391,7 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
         // CHECK: bb4: {
         // CHECK: [[a:_.*]] = const 7_usize;
         // CHECK: [[b:_.*]] = &raw const [[a]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let a = 7_usize;
         let b = &raw const a;
@@ -404,10 +404,10 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
         // CHECK: bb5: {
         // CHECK: [[a:_.*]] = const 7_usize;
         // CHECK: [[b1:_.*]] = &raw const [[a]];
-        // CHECK: [[c:_.*]] = [[a]];
-        // CHECK: [[b2:_.*]] = [[b1]];
-        // CHECK: [[c2:_.*]] = [[a]];
-        // CHECK: [[b3:_.*]] = [[b2]];
+        // CHECK: [[c:_.*]] = copy [[a]];
+        // CHECK: [[b2:_.*]] = copy [[b1]];
+        // CHECK: [[c2:_.*]] = copy [[a]];
+        // CHECK: [[b3:_.*]] = copy [[b2]];
 
         let a = 7_usize;
         let b1 = &raw const a;
@@ -424,7 +424,7 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
     unsafe {
         // CHECK: bb6: {
         // CHECK-NOT: {{_.*}} = &(*_1);
-        // CHECK: [[b:_.*]] = (*_1);
+        // CHECK: [[b:_.*]] = copy (*_1);
 
         let a = &raw const *single;
         let b = *a; // This should be optimized as `*single`.
@@ -437,7 +437,7 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
         // CHECK: [[a:_.*]] = &raw const (*_2);
         // CHECK: [[tmp:_.*]] = &raw const (*_1);
         // CHECK: _2 = move [[tmp]];
-        // CHECK: [[b:_.*]] = (*[[a]]);
+        // CHECK: [[b:_.*]] = copy (*[[a]]);
 
         let a = &raw const *multiple;
         multiple = &raw const *single;
@@ -451,7 +451,7 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
         // CHECK: [[a:_.*]] = const 13_usize;
         // CHECK: [[b:_.*]] = &raw const [[a]];
         // CHECK: [[d:_.*]] = &raw const [[a]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let a = 13_usize;
         let b = &raw const a;
@@ -466,7 +466,7 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &raw const [[a]];
         // CHECK: [[d:_.*]] = &[[b]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let a = 5_usize;
         let b = &raw const a;
@@ -482,7 +482,7 @@ fn reference_propagation_const_ptr<T: Copy>(single: *const T, mut multiple: *con
         // CHECK: [[b:_.*]] = &raw const [[a]];
         // CHECK: [[d:_.*]] = &mut [[b]];
         // FIXME this could be [[a]]
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let a = 5_usize;
         let mut b = &raw const a;
@@ -500,7 +500,7 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
         // CHECK: bb0: {
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &raw mut [[a]];
-        // CHECK: [[c:_.*]] = [[a]];
+        // CHECK: [[c:_.*]] = copy [[a]];
 
         let mut a = 5_usize;
         let b = &raw mut a; // This borrow is only used once.
@@ -516,7 +516,7 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
         // CHECK: [[b:_.*]] = &raw mut [[a]];
         // CHECK: [[btmp:_.*]] = &raw mut [[a2]];
         // CHECK: [[b]] = move [[btmp]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 5_usize;
         let mut a2 = 7_usize;
@@ -533,7 +533,7 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &raw mut [[a]];
         // CHECK: [[d:_.*]] = &[[b]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 5_usize;
         let b = &raw mut a;
@@ -548,7 +548,7 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
         // CHECK: [[a:_.*]] = const 5_usize;
         // CHECK: [[b:_.*]] = &raw mut [[a]];
         // CHECK: [[d:_.*]] = &raw mut [[b]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 5_usize;
         let mut b = &raw mut a;
@@ -562,7 +562,7 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
         // CHECK: bb4: {
         // CHECK: [[a:_.*]] = const 7_usize;
         // CHECK: [[b:_.*]] = &raw mut [[a]];
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 7_usize;
         let b = &raw mut a;
@@ -575,10 +575,10 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
         // CHECK: bb5: {
         // CHECK: [[a:_.*]] = const 7_usize;
         // CHECK: [[b1:_.*]] = &raw mut [[a]];
-        // CHECK: [[c:_.*]] = (*[[b1]]);
-        // CHECK: [[b2:_.*]] = [[b1]];
-        // CHECK: [[c2:_.*]] = (*[[b2]]);
-        // CHECK: [[b3:_.*]] = [[b2]];
+        // CHECK: [[c:_.*]] = copy (*[[b1]]);
+        // CHECK: [[b2:_.*]] = copy [[b1]];
+        // CHECK: [[c2:_.*]] = copy (*[[b2]]);
+        // CHECK: [[b3:_.*]] = copy [[b2]];
 
         let mut a = 7_usize;
         let b1 = &raw mut a;
@@ -595,7 +595,7 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
     unsafe {
         // CHECK: bb6: {
         // CHECK-NOT: {{_.*}} = &(*_1);
-        // CHECK: [[b:_.*]] = (*_1);
+        // CHECK: [[b:_.*]] = copy (*_1);
 
         let a = &raw mut *single;
         let b = *a; // This should be optimized as `*single`.
@@ -608,7 +608,7 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
         // CHECK: [[a:_.*]] = &raw mut (*_2);
         // CHECK: [[tmp:_.*]] = &raw mut (*_1);
         // CHECK: _2 = move [[tmp]];
-        // CHECK: [[b:_.*]] = (*[[a]]);
+        // CHECK: [[b:_.*]] = copy (*[[a]]);
 
         let a = &raw mut *multiple;
         multiple = &raw mut *single;
@@ -623,7 +623,7 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
         // CHECK: [[b:_.*]] = &raw mut [[a]];
         // CHECK: [[d:_.*]] = &[[b]];
         // FIXME this could be [[a]]
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 5_usize;
         let b = &raw mut a;
@@ -639,7 +639,7 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
         // CHECK: [[b:_.*]] = &raw mut [[a]];
         // CHECK: [[d:_.*]] = &mut [[b]];
         // FIXME this could be [[a]]
-        // CHECK: [[c:_.*]] = (*[[b]]);
+        // CHECK: [[c:_.*]] = copy (*[[b]]);
 
         let mut a = 5_usize;
         let mut b = &raw mut a;
@@ -653,8 +653,8 @@ fn reference_propagation_mut_ptr<T: Copy>(single: *mut T, mut multiple: *mut T)
 fn read_through_raw(x: &mut usize) -> usize {
     // CHECK-LABEL: read_through_raw
     // CHECK: bb0: {
-    // CHECK-NEXT: _0 = (*_1);
-    // CHECK-NEXT: _0 = (*_1);
+    // CHECK-NEXT: _0 = copy (*_1);
+    // CHECK-NEXT: _0 = copy (*_1);
     // CHECK-NEXT: return;
 
     use std::intrinsics::mir::*;
@@ -680,7 +680,7 @@ fn read_through_raw(x: &mut usize) -> usize {
 #[custom_mir(dialect = "runtime", phase = "post-cleanup")]
 fn multiple_storage() {
     // CHECK-LABEL: multiple_storage
-    // CHECK: _3 = (*_2);
+    // CHECK: _3 = copy (*_2);
 
     use std::intrinsics::mir::*;
     mir! {
@@ -706,7 +706,7 @@ fn multiple_storage() {
 #[custom_mir(dialect = "runtime", phase = "post-cleanup")]
 fn dominate_storage() {
     // CHECK-LABEL: dominate_storage
-    // CHECK: _5 = (*_2);
+    // CHECK: _5 = copy (*_2);
 
     use std::intrinsics::mir::*;
     mir! {
@@ -798,12 +798,12 @@ fn unique_with_copies() {
     // CHECK: [[a:_.*]] = const 0_i32;
     // CHECK: [[x:_.*]] = &raw mut [[a]];
     // CHECK-NOT: [[a]]
-    // CHECK: [[tmp:_.*]] = (*[[x]]);
+    // CHECK: [[tmp:_.*]] = copy (*[[x]]);
     // CHECK-NEXT: opaque::<i32>(move [[tmp]])
     // CHECK-NOT: [[a]]
     // CHECK: StorageDead([[a]]);
     // CHECK-NOT: [[a]]
-    // CHECK: [[tmp:_.*]] = (*[[x]]);
+    // CHECK: [[tmp:_.*]] = copy (*[[x]]);
     // CHECK-NEXT: opaque::<i32>(move [[tmp]])
 
     let y = {
diff --git a/tests/mir-opt/simplify_dead_blocks.rs b/tests/mir-opt/simplify_dead_blocks.rs
index b9a404fd35c86..7f2134c61218b 100644
--- a/tests/mir-opt/simplify_dead_blocks.rs
+++ b/tests/mir-opt/simplify_dead_blocks.rs
@@ -10,7 +10,7 @@ use std::intrinsics::mir::*;
 pub unsafe fn assert_nonzero_nonmax(x: u8) -> u8 {
     // CHECK-LABEL: fn assert_nonzero_nonmax(
     // CHECK: bb0: {
-    // CHECK-NEXT: switchInt({{.*}}) -> [0: [[unreachable:bb.*]], 1: [[retblock2:bb.*]], 255: [[unreachable:bb.*]], otherwise: [[retblock:bb.*]]];
+    // CHECK-NEXT: switchInt(copy {{_[0-9]+}}) -> [0: [[unreachable:bb.*]], 1: [[retblock2:bb.*]], 255: [[unreachable:bb.*]], otherwise: [[retblock:bb.*]]];
     // CHECK-NEXT: }
     // CHECK-NOT: _0 = const 1_u8;
     // CHECK: [[retblock2]]: {
@@ -21,7 +21,7 @@ pub unsafe fn assert_nonzero_nonmax(x: u8) -> u8 {
     // CHECK-NEXT: unreachable;
     // CHECK-NEXT: }
     // CHECK: [[retblock]]: {
-    // CHECK-NEXT: _0 = _1;
+    // CHECK-NEXT: _0 = copy _1;
     // CHECK-NEXT: return;
     // CHECK-NEXT: }
     mir! {
diff --git a/tests/mir-opt/sroa/structs.rs b/tests/mir-opt/sroa/structs.rs
index a177dbf71cf1c..d5f13f8b00908 100644
--- a/tests/mir-opt/sroa/structs.rs
+++ b/tests/mir-opt/sroa/structs.rs
@@ -31,8 +31,8 @@ pub fn enums(a: usize) -> usize {
 
     // CHECK: bb0: {
     // CHECK: [[enum]] = Option::<usize>::Some
-    // CHECK: _5 = (([[enum]] as Some).0: usize)
-    // CHECK: _0 = _5
+    // CHECK: _5 = copy (([[enum]] as Some).0: usize)
+    // CHECK: _0 = copy _5
     if let Some(a) = Some(a) { a } else { 0 }
 }
 
@@ -51,13 +51,13 @@ pub fn structs(a: f32) -> f32 {
 
     // CHECK: bb0: {
     // CHECK-NOT: [[struct]]
-    // CHECK: [[a_tmp]] = _1;
+    // CHECK: [[a_tmp]] = copy _1;
     // CHECK-NOT: [[struct]]
     // CHECK: [[foo]] = const 0_usize;
     // CHECK-NOT: [[struct]]
     // CHECK: [[a_ret]] = move [[a_tmp]];
     // CHECK-NOT: [[struct]]
-    // CHECK: _0 = [[a_ret]];
+    // CHECK: _0 = copy [[a_ret]];
     // CHECK-NOT: [[struct]]
     U { _foo: 0, a }.a
 }
@@ -73,7 +73,7 @@ pub fn unions(a: f32) -> u32 {
 
     // CHECK: bb0: {
     // CHECK: [[union]] = Repr {
-    // CHECK: _0 = ([[union]].1: u32)
+    // CHECK: _0 = copy ([[union]].1: u32)
     unsafe { Repr { f: a }.u }
 }
 
@@ -156,10 +156,10 @@ fn copies(x: Foo) {
     // CHECK: [[opt_isize:_[0-9]+]]: std::option::Option<isize>;
 
     // CHECK: bb0: {
-    // CHECK: [[byte]] = ([[external]].0
-    // CHECK: [[unit]] = ([[external]].1
-    // CHECK: [[str]] = ([[external]].2
-    // CHECK: [[opt_isize]] = ([[external]].3
+    // CHECK: [[byte]] = copy ([[external]].0
+    // CHECK: [[unit]] = copy ([[external]].1
+    // CHECK: [[str]] = copy ([[external]].2
+    // CHECK: [[opt_isize]] = copy ([[external]].3
 
     let y = x;
     let t = y.a;
@@ -181,10 +181,10 @@ fn ref_copies(x: &Foo) {
     // CHECK: [[opt_isize:_[0-9]+]]: std::option::Option<isize>;
 
     // CHECK: bb0: {
-    // CHECK: [[byte]] = ((*[[external]]).0
-    // CHECK: [[unit]] = ((*[[external]]).1
-    // CHECK: [[str]] = ((*[[external]]).2
-    // CHECK: [[opt_isize]] = ((*[[external]]).3
+    // CHECK: [[byte]] = copy ((*[[external]]).0
+    // CHECK: [[unit]] = copy ((*[[external]]).1
+    // CHECK: [[str]] = copy ((*[[external]]).2
+    // CHECK: [[opt_isize]] = copy ((*[[external]]).3
 
     let y = *x;
     let t = y.a;

From 99cb0c6bc399fb94a0ddde7e9b38e9c00d523bad Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Sun, 18 Aug 2024 14:26:34 -0700
Subject: [PATCH 427/685] Bless *all* the mir-opt tests

---
 ..._of_reborrow.SimplifyCfg-initial.after.mir |  12 +-
 ...fg-pre-optimizations.after.panic-abort.mir |   8 +-
 ...g-pre-optimizations.after.panic-unwind.mir |   8 +-
 ...ure#0}.coroutine_by_move.0.panic-abort.mir |   2 +-
 ...re#0}.coroutine_by_move.0.panic-unwind.mir |   2 +-
 ...ure#0}.coroutine_by_move.0.panic-abort.mir |   2 +-
 ...re#0}.coroutine_by_move.0.panic-unwind.mir |   2 +-
 ...coroutine_closure_by_ref.0.panic-abort.mir |   2 +-
 ...oroutine_closure_by_ref.0.panic-unwind.mir |   2 +-
 .../basic_assignment.main.ElaborateDrops.diff |   2 +-
 ...ignment.main.SimplifyCfg-initial.after.mir |   2 +-
 ...await.b-{closure#0}.coroutine_resume.0.mir |  12 +-
 .../aggregate_exprs.adt.built.after.mir       |   4 +-
 .../aggregate_exprs.array.built.after.mir     |   2 +-
 ...rbitrary_let.arbitrary_let.built.after.mir |   6 +-
 .../custom/arrays.arrays.built.after.mir      |   2 +-
 .../as_cast.float_to_int.built.after.mir      |   2 +-
 .../custom/as_cast.int_to_int.built.after.mir |   2 +-
 .../custom/as_cast.int_to_ptr.built.after.mir |   2 +-
 .../assume.assume_local.built.after.mir       |   2 +-
 .../assume.assume_place.built.after.mir       |   2 +-
 .../custom/enums.switch_bool.built.after.mir  |   2 +-
 .../enums.switch_option.built.after.mir       |   2 +-
 .../enums.switch_option_repr.built.after.mir  |   2 +-
 .../custom/operators.f.built.after.mir        |  40 +-
 .../custom/operators.g.runtime.after.mir      |   4 +-
 ...projections.copy_for_deref.built.after.mir |   2 +-
 .../projections.simple_index.built.after.mir  |   4 +-
 .../custom/projections.tuples.built.after.mir |   4 +-
 .../custom/projections.unions.built.after.mir |   2 +-
 .../custom/projections.unwrap.built.after.mir |   2 +-
 .../projections.unwrap_deref.built.after.mir  |   2 +-
 ...erences.raw_pointer_offset.built.after.mir |   2 +-
 .../simple_assign.simple.built.after.mir      |   4 +-
 ...terminators.assert_nonzero.built.after.mir |   2 +-
 .../terminators.direct_call.built.after.mir   |   2 +-
 .../terminators.indirect_call.built.after.mir |   2 +-
 .../terminators.tail_call.built.after.mir     |   4 +-
 .../building/enum_cast.bar.built.after.mir    |   4 +-
 .../building/enum_cast.boo.built.after.mir    |   4 +-
 .../building/enum_cast.droppy.built.after.mir |   4 +-
 .../building/enum_cast.far.built.after.mir    |   4 +-
 .../enum_cast.offsetty.built.after.mir        |   6 +-
 .../building/enum_cast.signy.built.after.mir  |   6 +-
 .../building/eq_never_type._f.built.after.mir |   4 +-
 .../issue_101867.main.built.after.mir         |   2 +-
 .../building/issue_49232.main.built.after.mir |   2 +-
 ...n_conditional.test_complex.built.after.mir |   4 +-
 ..._or_in_conditional.test_or.built.after.mir |   4 +-
 .../string.foo.PreCodegen.after.mir           |   4 +-
 ....match_tuple.SimplifyCfg-initial.after.mir |  20 +-
 ...se_edges.full_tested_match.built.after.mir |   8 +-
 ...e_edges.full_tested_match2.built.after.mir |   8 +-
 .../match_false_edges.main.built.after.mir    |  10 +-
 .../simple_match.match_bool.built.after.mir   |   2 +-
 ....constant_eq.SimplifyCfg-initial.after.mir |  14 +-
 ...joint_ranges.SimplifyCfg-initial.after.mir |  12 +-
 ...ceiver_ptr_mutability.main.built.after.mir |   4 +-
 .../shifts.shift_signed.built.after.mir       |  48 +--
 .../shifts.shift_unsigned.built.after.mir     |  48 +--
 ...hile_loop.PreCodegen.after.panic-abort.mir |   4 +-
 ...ile_loop.PreCodegen.after.panic-unwind.mir |   4 +-
 .../const_allocation.main.GVN.after.32bit.mir |   2 +-
 .../const_allocation.main.GVN.after.64bit.mir |   2 +-
 ...const_allocation2.main.GVN.after.32bit.mir |   2 +-
 ...const_allocation2.main.GVN.after.64bit.mir |   2 +-
 ...const_allocation3.main.GVN.after.32bit.mir |   2 +-
 ...const_allocation3.main.GVN.after.64bit.mir |   2 +-
 ..._goto_const_eval_fail.f.JumpThreading.diff |   2 +-
 .../const_prop/address_of_pair.fn0.GVN.diff   |   4 +-
 .../aggregate.foo.GVN.panic-abort.diff        |  12 +-
 .../aggregate.foo.GVN.panic-unwind.diff       |  12 +-
 .../aggregate.main.GVN.panic-abort.diff       |   4 +-
 .../aggregate.main.GVN.panic-unwind.diff      |   4 +-
 ...rray_index.main.GVN.32bit.panic-abort.diff |   6 +-
 ...ray_index.main.GVN.32bit.panic-unwind.diff |   6 +-
 ...rray_index.main.GVN.64bit.panic-abort.diff |   6 +-
 ...ray_index.main.GVN.64bit.panic-unwind.diff |   6 +-
 ...d_op_div_by_zero.main.GVN.panic-abort.diff |   8 +-
 ..._op_div_by_zero.main.GVN.panic-unwind.diff |   8 +-
 ...d_op_mod_by_zero.main.GVN.panic-abort.diff |   8 +-
 ..._op_mod_by_zero.main.GVN.panic-unwind.diff |   8 +-
 ...for_slices.main.GVN.32bit.panic-abort.diff |  10 +-
 ...or_slices.main.GVN.32bit.panic-unwind.diff |  10 +-
 ...for_slices.main.GVN.64bit.panic-abort.diff |  10 +-
 ...or_slices.main.GVN.64bit.panic-unwind.diff |  10 +-
 .../boolean_identities.test.GVN.diff          |   8 +-
 .../boxes.main.GVN.panic-abort.diff           |   8 +-
 .../boxes.main.GVN.panic-unwind.diff          |   8 +-
 .../discriminant.main.GVN.32bit.diff          |   2 +-
 .../discriminant.main.GVN.64bit.diff          |   2 +-
 .../indirect.main.GVN.panic-abort.diff        |   2 +-
 .../indirect.main.GVN.panic-unwind.diff       |   2 +-
 .../const_prop/indirect_mutation.bar.GVN.diff |   2 +-
 .../const_prop/indirect_mutation.foo.GVN.diff |   2 +-
 ...inherit_overflow.main.GVN.panic-abort.diff |   4 +-
 ...nherit_overflow.main.GVN.panic-unwind.diff |   4 +-
 .../const_prop/invalid_constant.main.GVN.diff |   4 +-
 .../invalid_constant.main.RemoveZsts.diff     |   6 +-
 ...rray_index.main.GVN.32bit.panic-abort.diff |   6 +-
 ...ray_index.main.GVN.32bit.panic-unwind.diff |   6 +-
 ...rray_index.main.GVN.64bit.panic-abort.diff |   6 +-
 ...ray_index.main.GVN.64bit.panic-unwind.diff |   6 +-
 .../const_prop/mult_by_zero.test.GVN.diff     |   2 +-
 .../const_prop/mutable_variable.main.GVN.diff |   2 +-
 .../mutable_variable_aggregate.main.GVN.diff  |   2 +-
 ...e_variable_aggregate_mut_ref.main.GVN.diff |   2 +-
 ...ate_partial_read.main.GVN.panic-abort.diff |   2 +-
 ...te_partial_read.main.GVN.panic-unwind.diff |   2 +-
 .../mutable_variable_no_prop.main.GVN.diff    |   4 +-
 ...le_unprop_assign.main.GVN.panic-abort.diff |   8 +-
 ...e_unprop_assign.main.GVN.panic-unwind.diff |   8 +-
 ...te_with_const_with_params.size_of.GVN.diff |   2 +-
 ...xpose_provenance.main.GVN.panic-abort.diff |   4 +-
 ...pose_provenance.main.GVN.panic-unwind.diff |   4 +-
 .../read_immutable_static.main.GVN.diff       |   4 +-
 .../const_prop/ref_deref.main.GVN.diff        |   2 +-
 .../ref_deref_project.main.GVN.diff           |   2 +-
 .../repeat.main.GVN.32bit.panic-abort.diff    |   6 +-
 .../repeat.main.GVN.32bit.panic-unwind.diff   |   6 +-
 .../repeat.main.GVN.64bit.panic-abort.diff    |   6 +-
 .../repeat.main.GVN.64bit.panic-unwind.diff   |   6 +-
 ...eral_propagation.main.GVN.panic-abort.diff |   2 +-
 ...ral_propagation.main.GVN.panic-unwind.diff |   2 +-
 .../slice_len.main.GVN.32bit.panic-abort.diff |  14 +-
 ...slice_len.main.GVN.32bit.panic-unwind.diff |  14 +-
 .../slice_len.main.GVN.64bit.panic-abort.diff |  14 +-
 ...slice_len.main.GVN.64bit.panic-unwind.diff |  14 +-
 .../switch_int.main.GVN.panic-abort.diff      |   2 +-
 .../switch_int.main.GVN.panic-unwind.diff     |   2 +-
 .../transmute.unreachable_box.GVN.32bit.diff  |   2 +-
 .../transmute.unreachable_box.GVN.64bit.diff  |   2 +-
 ...eral_propagation.main.GVN.panic-abort.diff |   2 +-
 ...ral_propagation.main.GVN.panic-unwind.diff |   2 +-
 .../while_let_loops.change_loop_body.GVN.diff |   2 +-
 ...d_local.borrowed.CopyProp.panic-abort.diff |   8 +-
 ..._local.borrowed.CopyProp.panic-unwind.diff |   8 +-
 ....compare_address.CopyProp.panic-abort.diff |   6 +-
 ...compare_address.CopyProp.panic-unwind.diff |   6 +-
 ...local.non_freeze.CopyProp.panic-abort.diff |   6 +-
 ...ocal.non_freeze.CopyProp.panic-unwind.diff |   6 +-
 .../branch.foo.CopyProp.panic-abort.diff      |   6 +-
 .../branch.foo.CopyProp.panic-unwind.diff     |   6 +-
 .../calls.multiple_edges.CopyProp.diff        |   4 +-
 .../copy-prop/calls.nrvo.CopyProp.diff        |   2 +-
 ...tion_arg.arg_src.CopyProp.panic-abort.diff |   6 +-
 ...ion_arg.arg_src.CopyProp.panic-unwind.diff |   6 +-
 ...pagation_arg.bar.CopyProp.panic-abort.diff |   2 +-
 ...agation_arg.bar.CopyProp.panic-unwind.diff |   2 +-
 ...pagation_arg.baz.CopyProp.panic-abort.diff |   4 +-
 ...agation_arg.baz.CopyProp.panic-unwind.diff |   4 +-
 ...pagation_arg.foo.CopyProp.panic-abort.diff |   2 +-
 ...agation_arg.foo.CopyProp.panic-unwind.diff |   2 +-
 ...ustom_move_arg.f.CopyProp.panic-abort.diff |   8 +-
 ...stom_move_arg.f.CopyProp.panic-unwind.diff |   8 +-
 .../cycle.main.CopyProp.panic-abort.diff      |  10 +-
 .../cycle.main.CopyProp.panic-unwind.diff     |  10 +-
 ...res_79191.f.CopyProp.after.panic-abort.mir |   6 +-
 ...es_79191.f.CopyProp.after.panic-unwind.mir |   6 +-
 ...es_better.f.CopyProp.after.panic-abort.mir |   6 +-
 ...s_better.f.CopyProp.after.panic-unwind.mir |   6 +-
 ...ssue_107511.main.CopyProp.panic-abort.diff |  18 +-
 ...sue_107511.main.CopyProp.panic-unwind.diff |  18 +-
 .../move_arg.f.CopyProp.panic-abort.diff      |   8 +-
 .../move_arg.f.CopyProp.panic-unwind.diff     |   8 +-
 ...ove_projection.f.CopyProp.panic-abort.diff |   6 +-
 ...ve_projection.f.CopyProp.panic-unwind.diff |   6 +-
 .../mutate_through_pointer.f.CopyProp.diff    |   4 +-
 .../copy-prop/non_dominate.f.CopyProp.diff    |   8 +-
 ...reborrow.demiraw.CopyProp.panic-abort.diff |   6 +-
 ...eborrow.demiraw.CopyProp.panic-unwind.diff |   6 +-
 .../reborrow.miraw.CopyProp.panic-abort.diff  |   6 +-
 .../reborrow.miraw.CopyProp.panic-unwind.diff |   6 +-
 ...ch_match_arms.main.InstrumentCoverage.diff |  16 +-
 .../aggregate_copy.foo.DataflowConstProp.diff |   8 +-
 ...n.DataflowConstProp.32bit.panic-abort.diff |   8 +-
 ....DataflowConstProp.32bit.panic-unwind.diff |   8 +-
 ...n.DataflowConstProp.64bit.panic-abort.diff |   8 +-
 ....DataflowConstProp.64bit.panic-unwind.diff |   8 +-
 ...ean_identities.test.DataflowConstProp.diff |   4 +-
 .../cast.main.DataflowConstProp.diff          |   2 +-
 ...ed.main.DataflowConstProp.panic-abort.diff |  10 +-
 ...d.main.DataflowConstProp.panic-unwind.diff |  10 +-
 ...oxed_slice.main.GVN.32bit.panic-abort.diff |  10 +-
 ...xed_slice.main.GVN.32bit.panic-unwind.diff |  10 +-
 ...oxed_slice.main.GVN.64bit.panic-abort.diff |  10 +-
 ...xed_slice.main.GVN.64bit.panic-unwind.diff |  10 +-
 ...enum.constant.DataflowConstProp.32bit.diff |   8 +-
 ...enum.constant.DataflowConstProp.64bit.diff |   8 +-
 ...enum.multiple.DataflowConstProp.32bit.diff |  10 +-
 ...enum.multiple.DataflowConstProp.64bit.diff |  10 +-
 ..._discriminant.DataflowConstProp.32bit.diff |   2 +-
 ..._discriminant.DataflowConstProp.64bit.diff |   2 +-
 .../enum.simple.DataflowConstProp.32bit.diff  |   8 +-
 .../enum.simple.DataflowConstProp.64bit.diff  |   8 +-
 .../enum.statics.DataflowConstProp.32bit.diff |  14 +-
 .../enum.statics.DataflowConstProp.64bit.diff |  14 +-
 .../if.main.DataflowConstProp.diff            |  12 +-
 ...ow.main.DataflowConstProp.panic-abort.diff |   4 +-
 ...w.main.DataflowConstProp.panic-unwind.diff |   4 +-
 ...n.DataflowConstProp.32bit.panic-abort.diff |   8 +-
 ....DataflowConstProp.32bit.panic-unwind.diff |   8 +-
 ...n.DataflowConstProp.64bit.panic-abort.diff |   8 +-
 ....DataflowConstProp.64bit.panic-unwind.diff |   8 +-
 .../mult_by_zero.test.DataflowConstProp.diff  |   2 +-
 ...sb.main.DataflowConstProp.panic-abort.diff |   2 +-
 ...b.main.DataflowConstProp.panic-unwind.diff |   2 +-
 ...n.DataflowConstProp.32bit.panic-abort.diff |   8 +-
 ....DataflowConstProp.32bit.panic-unwind.diff |   8 +-
 ...n.DataflowConstProp.64bit.panic-abort.diff |   8 +-
 ....DataflowConstProp.64bit.panic-unwind.diff |   8 +-
 ...pr_transparent.main.DataflowConstProp.diff |   4 +-
 .../self_assign.main.DataflowConstProp.diff   |   8 +-
 ...elf_assign_add.main.DataflowConstProp.diff |   4 +-
 ...tr.main.DataflowConstProp.panic-abort.diff |   4 +-
 ...r.main.DataflowConstProp.panic-unwind.diff |   4 +-
 ...n.DataflowConstProp.32bit.panic-abort.diff |  20 +-
 ....DataflowConstProp.32bit.panic-unwind.diff |  20 +-
 ...n.DataflowConstProp.64bit.panic-abort.diff |  20 +-
 ....DataflowConstProp.64bit.panic-unwind.diff |  20 +-
 .../struct.main.DataflowConstProp.32bit.diff  |  42 +--
 .../struct.main.DataflowConstProp.64bit.diff  |  42 +--
 ...or.main.DataflowConstProp.panic-abort.diff |   2 +-
 ...r.main.DataflowConstProp.panic-unwind.diff |   2 +-
 ...reachable_box.DataflowConstProp.32bit.diff |   2 +-
 ...reachable_box.DataflowConstProp.64bit.diff |   2 +-
 .../tuple.main.DataflowConstProp.32bit.diff   |  16 +-
 .../tuple.main.DataflowConstProp.64bit.diff   |  16 +-
 ...eadStoreElimination-final.panic-abort.diff |   2 +-
 ...adStoreElimination-final.panic-unwind.diff |   2 +-
 ...eadStoreElimination-final.panic-abort.diff |   4 +-
 ...adStoreElimination-final.panic-unwind.diff |   4 +-
 ...le.cycle.DeadStoreElimination-initial.diff |  10 +-
 ...r_to_int.DeadStoreElimination-initial.diff |   4 +-
 ...mment_2.DeduplicateBlocks.panic-abort.diff |  22 +-
 ...ment_2.DeduplicateBlocks.panic-unwind.diff |  22 +-
 ...complex_case.main.Derefer.panic-abort.diff |   6 +-
 ...omplex_case.main.Derefer.panic-unwind.diff |   6 +-
 ...minator_test.main.Derefer.panic-abort.diff |   4 +-
 ...inator_test.main.Derefer.panic-unwind.diff |   4 +-
 ...oo.DestinationPropagation.panic-abort.diff |   6 +-
 ...o.DestinationPropagation.panic-unwind.diff |   6 +-
 ...rc.DestinationPropagation.panic-abort.diff |   6 +-
 ...c.DestinationPropagation.panic-unwind.diff |   6 +-
 ...ar.DestinationPropagation.panic-abort.diff |   2 +-
 ...r.DestinationPropagation.panic-unwind.diff |   2 +-
 ...az.DestinationPropagation.panic-abort.diff |   4 +-
 ...z.DestinationPropagation.panic-unwind.diff |   4 +-
 ...oo.DestinationPropagation.panic-abort.diff |   2 +-
 ...o.DestinationPropagation.panic-unwind.diff |   2 +-
 ...in.DestinationPropagation.panic-abort.diff |   8 +-
 ...n.DestinationPropagation.panic-unwind.diff |   8 +-
 ...stinationPropagation.after.panic-abort.mir |   2 +-
 ...tinationPropagation.after.panic-unwind.mir |   2 +-
 ...stinationPropagation.after.panic-abort.mir |   2 +-
 ...tinationPropagation.after.panic-unwind.mir |   2 +-
 ...vo.DestinationPropagation.panic-abort.diff |   4 +-
 ...o.DestinationPropagation.panic-unwind.diff |   4 +-
 ...in.DestinationPropagation.panic-abort.diff |   2 +-
 ...n.DestinationPropagation.panic-unwind.diff |   2 +-
 ...wise_branch.opt1.EarlyOtherwiseBranch.diff |   8 +-
 ...wise_branch.opt2.EarlyOtherwiseBranch.diff |   8 +-
 ...wise_branch.opt3.EarlyOtherwiseBranch.diff |   8 +-
 ...wise_branch.opt4.EarlyOtherwiseBranch.diff |   8 +-
 ...ement_tuple.opt1.EarlyOtherwiseBranch.diff |  12 +-
 ...ement_tuple.opt2.EarlyOtherwiseBranch.diff |  10 +-
 ...ch_68867.try_sum.EarlyOtherwiseBranch.diff |  36 +-
 ...nch_noopt.noopt1.EarlyOtherwiseBranch.diff |  12 +-
 ...ess.no_deref_ptr.EarlyOtherwiseBranch.diff |   4 +-
 .../enum_opt.cand.EnumSizeOpt.32bit.diff      |  20 +-
 .../enum_opt.cand.EnumSizeOpt.64bit.diff      |  20 +-
 .../enum_opt.unin.EnumSizeOpt.32bit.diff      |  20 +-
 .../enum_opt.unin.EnumSizeOpt.64bit.diff      |  20 +-
 ...to_exponential_common.GVN.panic-abort.diff |  32 +-
 ...o_exponential_common.GVN.panic-unwind.diff |  32 +-
 .../gvn.arithmetic.GVN.panic-abort.diff       | 130 +++----
 .../gvn.arithmetic.GVN.panic-unwind.diff      | 130 +++----
 ...vn.arithmetic_checked.GVN.panic-abort.diff |  50 +--
 ...n.arithmetic_checked.GVN.panic-unwind.diff |  50 +--
 .../gvn.arithmetic_float.GVN.panic-abort.diff |  40 +-
 ...gvn.arithmetic_float.GVN.panic-unwind.diff |  40 +-
 .../mir-opt/gvn.borrowed.GVN.panic-abort.diff |  12 +-
 .../gvn.borrowed.GVN.panic-unwind.diff        |  12 +-
 tests/mir-opt/gvn.cast.GVN.panic-abort.diff   |  60 +--
 tests/mir-opt/gvn.cast.GVN.panic-unwind.diff  |  60 +--
 .../gvn.cast_pointer_eq.GVN.panic-abort.diff  |  46 +--
 .../gvn.cast_pointer_eq.GVN.panic-unwind.diff |  46 +--
 ...ointer_then_transmute.GVN.panic-abort.diff |  10 +-
 ...inter_then_transmute.GVN.panic-unwind.diff |  10 +-
 ...ore_aggregate_raw_ptr.GVN.panic-abort.diff |  16 +-
 ...re_aggregate_raw_ptr.GVN.panic-unwind.diff |  16 +-
 .../gvn.comparison.GVN.panic-abort.diff       |  20 +-
 .../gvn.comparison.GVN.panic-unwind.diff      |  20 +-
 ...nstant_index_overflow.GVN.panic-abort.diff |  26 +-
 ...stant_index_overflow.GVN.panic-unwind.diff |  26 +-
 .../gvn.dereferences.GVN.panic-abort.diff     |  36 +-
 .../gvn.dereferences.GVN.panic-unwind.diff    |  36 +-
 .../gvn.duplicate_slice.GVN.panic-abort.diff  |  18 +-
 .../gvn.duplicate_slice.GVN.panic-unwind.diff |  18 +-
 .../gvn.fn_pointers.GVN.panic-abort.diff      |  20 +-
 .../gvn.fn_pointers.GVN.panic-unwind.diff     |  20 +-
 ...generic_cast_metadata.GVN.panic-abort.diff |  30 +-
 ...eneric_cast_metadata.GVN.panic-unwind.diff |  30 +-
 .../gvn.indirect_static.GVN.panic-abort.diff  |   2 +-
 .../gvn.indirect_static.GVN.panic-unwind.diff |   2 +-
 ....manual_slice_mut_len.GVN.panic-abort.diff |   8 +-
 ...manual_slice_mut_len.GVN.panic-unwind.diff |   8 +-
 ....meta_of_ref_to_slice.GVN.panic-abort.diff |   6 +-
 ...meta_of_ref_to_slice.GVN.panic-unwind.diff |   6 +-
 ...gvn.multiple_branches.GVN.panic-abort.diff |  64 ++--
 ...vn.multiple_branches.GVN.panic-unwind.diff |  64 ++--
 .../gvn.non_freeze.GVN.panic-abort.diff       |   8 +-
 .../gvn.non_freeze.GVN.panic-unwind.diff      |   8 +-
 .../gvn.references.GVN.panic-abort.diff       |   6 +-
 .../gvn.references.GVN.panic-unwind.diff      |   6 +-
 ...ust_change_both_sides.GVN.panic-abort.diff |   6 +-
 ...st_change_both_sides.GVN.panic-unwind.diff |   6 +-
 tests/mir-opt/gvn.repeat.GVN.panic-abort.diff |  20 +-
 .../mir-opt/gvn.repeat.GVN.panic-unwind.diff  |  20 +-
 .../gvn.repeated_index.GVN.panic-abort.diff   |  30 +-
 .../gvn.repeated_index.GVN.panic-unwind.diff  |  30 +-
 ...vn.slice_const_length.GVN.panic-abort.diff |   6 +-
 ...n.slice_const_length.GVN.panic-unwind.diff |   6 +-
 ...from_raw_parts_as_ptr.GVN.panic-abort.diff |  16 +-
 ...rom_raw_parts_as_ptr.GVN.panic-unwind.diff |  16 +-
 tests/mir-opt/gvn.slices.GVN.panic-abort.diff |  56 +--
 .../mir-opt/gvn.slices.GVN.panic-unwind.diff  |  56 +--
 ...xpression_elimination.GVN.panic-abort.diff | 344 +++++++++---------
 ...pression_elimination.GVN.panic-unwind.diff | 344 +++++++++---------
 tests/mir-opt/gvn.unary.GVN.panic-abort.diff  |  48 +--
 tests/mir-opt/gvn.unary.GVN.panic-unwind.diff |  48 +--
 .../gvn.wide_ptr_integer.GVN.panic-abort.diff |  24 +-
 ...gvn.wide_ptr_integer.GVN.panic-unwind.diff |  24 +-
 ...n.wide_ptr_provenance.GVN.panic-abort.diff |  76 ++--
 ....wide_ptr_provenance.GVN.panic-unwind.diff |  76 ++--
 ...e_ptr_same_provenance.GVN.panic-abort.diff |  84 ++---
 ..._ptr_same_provenance.GVN.panic-unwind.diff |  84 ++---
 .../gvn.wrap_unwrap.GVN.panic-abort.diff      |  12 +-
 .../gvn.wrap_unwrap.GVN.panic-unwind.diff     |  12 +-
 tests/mir-opt/gvn_copy_moves.fn0.GVN.diff     |   8 +-
 .../gvn_ptr_eq_with_constant.main.GVN.diff    |   8 +-
 .../gvn_uninhabited.f.GVN.panic-abort.diff    |   8 +-
 .../gvn_uninhabited.f.GVN.panic-unwind.diff   |   8 +-
 ...t_opt_bool.SimplifyComparisonIntegral.diff |   2 +-
 ...opt_floats.SimplifyComparisonIntegral.diff |   2 +-
 ...comparison.SimplifyComparisonIntegral.diff |  10 +-
 ...t.opt_char.SimplifyComparisonIntegral.diff |   2 +-
 ...int.opt_i8.SimplifyComparisonIntegral.diff |   2 +-
 ...ltiple_ifs.SimplifyComparisonIntegral.diff |   4 +-
 ...t_negative.SimplifyComparisonIntegral.diff |   2 +-
 ...nt.opt_u32.SimplifyComparisonIntegral.diff |   2 +-
 ...yn_trait.get_query.Inline.panic-abort.diff |   6 +-
 ...n_trait.get_query.Inline.panic-unwind.diff |   6 +-
 ...dyn_trait.mk_cycle.Inline.panic-abort.diff |   2 +-
 ...yn_trait.mk_cycle.Inline.panic-unwind.diff |   2 +-
 ....try_execute_query.Inline.panic-abort.diff |   2 +-
 ...try_execute_query.Inline.panic-unwind.diff |   2 +-
 .../inline_any_operand.bar.Inline.after.mir   |   4 +-
 .../inline_closure.foo.Inline.after.mir       |   6 +-
 ...e_closure_borrows_arg.foo.Inline.after.mir |   6 +-
 ...line_closure_captures.foo.Inline.after.mir |  10 +-
 ...ine_coroutine.main.Inline.panic-abort.diff |   8 +-
 ...ne_coroutine.main.Inline.panic-unwind.diff |   8 +-
 ...inline_diverging.g.Inline.panic-abort.diff |   4 +-
 ...nline_diverging.g.Inline.panic-unwind.diff |   4 +-
 ...inline_diverging.h.Inline.panic-abort.diff |   2 +-
 ...nline_diverging.h.Inline.panic-unwind.diff |   2 +-
 ...inline_direct.Inline.after.panic-abort.mir |   2 +-
 ...nline_direct.Inline.after.panic-unwind.mir |   2 +-
 ...line_indirect.Inline.after.panic-abort.mir |   2 +-
 ...ine_indirect.Inline.after.panic-unwind.mir |   2 +-
 ...ic_not_inline.Inline.after.panic-abort.mir |   4 +-
 ...c_not_inline.Inline.after.panic-unwind.mir |   4 +-
 .../inline/inline_retag.bar.Inline.after.mir  |  14 +-
 ...inline_shims.clone.Inline.panic-abort.diff |   2 +-
 ...nline_shims.clone.Inline.panic-unwind.diff |   2 +-
 .../inline_shims.drop.Inline.panic-abort.diff |   4 +-
 ...inline_shims.drop.Inline.panic-unwind.diff |   4 +-
 ...t_method.test.Inline.after.panic-abort.mir |   2 +-
 ..._method.test.Inline.after.panic-unwind.mir |   2 +-
 ...ethod_2.test2.Inline.after.panic-abort.mir |   2 +-
 ...thod_2.test2.Inline.after.panic-unwind.mir |   2 +-
 ...issue_106141.outer.Inline.panic-abort.diff |   6 +-
 ...ssue_106141.outer.Inline.panic-unwind.diff |   6 +-
 ...67_inline_as_ref_as_mut.a.Inline.after.mir |   8 +-
 ...67_inline_as_ref_as_mut.b.Inline.after.mir |  10 +-
 ...67_inline_as_ref_as_mut.c.Inline.after.mir |   6 +-
 ...67_inline_as_ref_as_mut.d.Inline.after.mir |   8 +-
 ...l_unsigned_smaller.Inline.panic-abort.diff |   8 +-
 ..._unsigned_smaller.Inline.panic-unwind.diff |   8 +-
 ...d_smaller.PreCodegen.after.panic-abort.mir |   2 +-
 ..._smaller.PreCodegen.after.panic-unwind.mir |   2 +-
 ..._shr_signed_bigger.Inline.panic-abort.diff |   8 +-
 ...shr_signed_bigger.Inline.panic-unwind.diff |   8 +-
 ...ed_bigger.PreCodegen.after.panic-abort.mir |   2 +-
 ...d_bigger.PreCodegen.after.panic-unwind.mir |   2 +-
 .../unsized_argument.caller.Inline.diff       |   2 +-
 ...d.unwrap_unchecked.Inline.panic-abort.diff |   2 +-
 ....unwrap_unchecked.Inline.panic-unwind.diff |   2 +-
 ...unchecked.PreCodegen.after.panic-abort.mir |   2 +-
 ...nchecked.PreCodegen.after.panic-unwind.mir |   2 +-
 ...y.run2-{closure#0}.Inline.panic-abort.diff |  10 +-
 ....run2-{closure#0}.Inline.panic-unwind.diff |  10 +-
 ..._false.InstSimplify-after-simplifycfg.diff |   2 +-
 ...q_true.InstSimplify-after-simplifycfg.diff |   2 +-
 ...lse_eq.InstSimplify-after-simplifycfg.diff |   2 +-
 ...lse_ne.InstSimplify-after-simplifycfg.diff |   2 +-
 ..._false.InstSimplify-after-simplifycfg.diff |   2 +-
 ...e_true.InstSimplify-after-simplifycfg.diff |   2 +-
 ...rue_eq.InstSimplify-after-simplifycfg.diff |   2 +-
 ...rue_ne.InstSimplify-after-simplifycfg.diff |   2 +-
 ...undant.InstSimplify-after-simplifycfg.diff |   6 +-
 ...ndtrip.InstSimplify-after-simplifycfg.diff |   2 +-
 ...implify-after-simplifycfg.panic-abort.diff |  20 +-
 ...mplify-after-simplifycfg.panic-unwind.diff |  20 +-
 ...implify-after-simplifycfg.panic-abort.diff |  10 +-
 ...mplify-after-simplifycfg.panic-unwind.diff |  10 +-
 ...t_zero.InstSimplify-after-simplifycfg.diff |   6 +-
 ...inters.InstSimplify-after-simplifycfg.diff |   4 +-
 ...rences.InstSimplify-after-simplifycfg.diff |   4 +-
 ...hecked.InstSimplify-after-simplifycfg.diff |   4 +-
 .../issue_101973.inner.GVN.panic-abort.diff   |  14 +-
 .../issue_101973.inner.GVN.panic-unwind.diff  |  14 +-
 ...e_38669.main.SimplifyCfg-initial.after.mir |   2 +-
 ...41110.main.ElaborateDrops.panic-abort.diff |   2 +-
 ...1110.main.ElaborateDrops.panic-unwind.diff |   2 +-
 ...41110.test.ElaborateDrops.panic-abort.diff |   2 +-
 ...1110.test.ElaborateDrops.panic-unwind.diff |   2 +-
 ...41888.main.ElaborateDrops.panic-abort.diff |   6 +-
 ...1888.main.ElaborateDrops.panic-unwind.diff |   6 +-
 ...test.ElaborateDrops.before.panic-abort.mir |   8 +-
 ...est.ElaborateDrops.before.panic-unwind.mir |   8 +-
 tests/mir-opt/issue_72181.bar.built.after.mir |   4 +-
 tests/mir-opt/issue_72181.foo.built.after.mir |   6 +-
 .../mir-opt/issue_72181.main.built.after.mir  |   6 +-
 ...implifyComparisonIntegral.panic-abort.diff |   4 +-
 ...mplifyComparisonIntegral.panic-unwind.diff |   4 +-
 ...8192.f.InstSimplify-after-simplifycfg.diff |   4 +-
 tests/mir-opt/issue_91633.foo.built.after.mir |   4 +-
 tests/mir-opt/issue_91633.fun.built.after.mir |   4 +-
 .../issue_99325.main.built.after.32bit.mir    |   8 +-
 .../issue_99325.main.built.after.64bit.mir    |   8 +-
 ..._to_digit.PreCodegen.after.panic-abort.mir |   2 +-
 ...to_digit.PreCodegen.after.panic-unwind.mir |   2 +-
 ...e_75439.foo.MatchBranchSimplification.diff |  12 +-
 ...g.aggregate.JumpThreading.panic-abort.diff |  10 +-
 ....aggregate.JumpThreading.panic-unwind.diff |  10 +-
 ...regate_copy.JumpThreading.panic-abort.diff |   8 +-
 ...egate_copy.JumpThreading.panic-unwind.diff |   8 +-
 ...ding.assume.JumpThreading.panic-abort.diff |   6 +-
 ...ing.assume.JumpThreading.panic-unwind.diff |   6 +-
 ...ustom_discr.JumpThreading.panic-abort.diff |   2 +-
 ...stom_discr.JumpThreading.panic-unwind.diff |   2 +-
 ...ppearing_bb.JumpThreading.panic-abort.diff |   6 +-
 ...pearing_bb.JumpThreading.panic-unwind.diff |   6 +-
 ...icate_chain.JumpThreading.panic-abort.diff |   4 +-
 ...cate_chain.JumpThreading.panic-unwind.diff |   4 +-
 ...ding.floats.JumpThreading.panic-abort.diff |   2 +-
 ...ing.floats.JumpThreading.panic-unwind.diff |   2 +-
 ...ng.identity.JumpThreading.panic-abort.diff |  14 +-
 ...g.identity.JumpThreading.panic-unwind.diff |  14 +-
 ...tiple_match.JumpThreading.panic-abort.diff |  12 +-
 ...iple_match.JumpThreading.panic-unwind.diff |  12 +-
 ...mutable_ref.JumpThreading.panic-abort.diff |   2 +-
 ...utable_ref.JumpThreading.panic-unwind.diff |   2 +-
 ...iscriminant.JumpThreading.panic-abort.diff |   2 +-
 ...scriminant.JumpThreading.panic-unwind.diff |   2 +-
 ...numbered_bb.JumpThreading.panic-abort.diff |  10 +-
 ...umbered_bb.JumpThreading.panic-unwind.diff |  10 +-
 ...too_complex.JumpThreading.panic-abort.diff |  14 +-
 ...oo_complex.JumpThreading.panic-unwind.diff |  14 +-
 ...array_len.array_bound.GVN.panic-abort.diff |  20 +-
 ...rray_len.array_bound.GVN.panic-unwind.diff |  20 +-
 ...y_len.array_bound_mut.GVN.panic-abort.diff |  24 +-
 ..._len.array_bound_mut.GVN.panic-unwind.diff |  24 +-
 ...erlapping.LowerIntrinsics.panic-abort.diff |   4 +-
 ...rlapping.LowerIntrinsics.panic-unwind.diff |   4 +-
 ..._metadata.LowerIntrinsics.panic-abort.diff |   6 +-
 ...metadata.LowerIntrinsics.panic-unwind.diff |   6 +-
 ..._pointers.LowerIntrinsics.panic-abort.diff |  12 +-
 ...pointers.LowerIntrinsics.panic-unwind.diff |  12 +-
 ...non_const.LowerIntrinsics.panic-abort.diff |   2 +-
 ...on_const.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...tr_offset.LowerIntrinsics.panic-abort.diff |   4 +-
 ...r_offset.LowerIntrinsics.panic-unwind.diff |   4 +-
 ...primitive.LowerIntrinsics.panic-abort.diff |   2 +-
 ...rimitive.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...inhabited.LowerIntrinsics.panic-abort.diff |   2 +-
 ...nhabited.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...pare_char.LowerIntrinsics.panic-abort.diff |   4 +-
 ...are_char.LowerIntrinsics.panic-unwind.diff |   4 +-
 ...re_signed.LowerIntrinsics.panic-abort.diff |   4 +-
 ...e_signed.LowerIntrinsics.panic-unwind.diff |   4 +-
 ..._unsigned.LowerIntrinsics.panic-abort.diff |   4 +-
 ...unsigned.LowerIntrinsics.panic-unwind.diff |   4 +-
 ...inhabited.LowerIntrinsics.panic-abort.diff |   2 +-
 ...nhabited.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...e_ref_dst.LowerIntrinsics.panic-abort.diff |   2 +-
 ..._ref_dst.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...inhabited.LowerIntrinsics.panic-abort.diff |   2 +-
 ...nhabited.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...inhabited.LowerIntrinsics.panic-abort.diff |   2 +-
 ...nhabited.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...unchecked.LowerIntrinsics.panic-abort.diff |  36 +-
 ...nchecked.LowerIntrinsics.panic-unwind.diff |  36 +-
 ..._overflow.LowerIntrinsics.panic-abort.diff |  12 +-
 ...overflow.LowerIntrinsics.panic-unwind.diff |  12 +-
 ....wrapping.LowerIntrinsics.panic-abort.diff |  12 +-
 ...wrapping.LowerIntrinsics.panic-unwind.diff |  12 +-
 ....bound.LowerSliceLenCalls.panic-abort.diff |  10 +-
 ...bound.LowerSliceLenCalls.panic-unwind.diff |  10 +-
 ...fg-initial.after-ElaborateDrops.after.diff |  28 +-
 ...fg-initial.after-ElaborateDrops.after.diff |  28 +-
 ...ranches.bar.MatchBranchSimplification.diff |  16 +-
 ...ranches.foo.MatchBranchSimplification.diff |   2 +-
 ...h_i128_u128.MatchBranchSimplification.diff |   2 +-
 ...h_nested_if.MatchBranchSimplification.diff |  10 +-
 ...sext_i8_i16.MatchBranchSimplification.diff |   2 +-
 ...sext_i8_u16.MatchBranchSimplification.diff |   2 +-
 ...runc_i16_i8.MatchBranchSimplification.diff |   2 +-
 ...runc_i16_u8.MatchBranchSimplification.diff |   2 +-
 ...runc_u16_i8.MatchBranchSimplification.diff |   2 +-
 ...runc_u16_u8.MatchBranchSimplification.diff |   2 +-
 ...match_u8_i8.MatchBranchSimplification.diff |   2 +-
 ...tch_u8_i8_2.MatchBranchSimplification.diff |   8 +-
 ...i8_2_failed.MatchBranchSimplification.diff |   4 +-
 ...ailed_len_1.MatchBranchSimplification.diff |   2 +-
 ...ailed_len_2.MatchBranchSimplification.diff |   2 +-
 ...zext_u8_i16.MatchBranchSimplification.diff |   2 +-
 ...zext_u8_u16.MatchBranchSimplification.diff |   2 +-
 ...stive_match.MatchBranchSimplification.diff |   2 +-
 ...ve_match_i8.MatchBranchSimplification.diff |   2 +-
 ...egion_subtyping_basic.main.nll.0.32bit.mir |   8 +-
 ...egion_subtyping_basic.main.nll.0.64bit.mir |   8 +-
 ...ompile_111005.wrong.RenameReturnPlace.diff |   6 +-
 ...le.nrvo.RenameReturnPlace.panic-abort.diff |   4 +-
 ...e.nrvo.RenameReturnPlace.panic-unwind.diff |   4 +-
 ...ut_second_or.SimplifyCfg-initial.after.mir |  24 +-
 ...le_switchint.SimplifyCfg-initial.after.mir |   8 +-
 ...ned_comparison.bitand.PreCodegen.after.mir |  20 +-
 ...ined_comparison.naive.PreCodegen.after.mir |  20 +-
 ..._comparison.returning.PreCodegen.after.mir |  20 +-
 ...ecked_shl.PreCodegen.after.panic-abort.mir |   4 +-
 ...cked_shl.PreCodegen.after.panic-unwind.mir |   4 +-
 ...p_forward.PreCodegen.after.panic-abort.mir |  12 +-
 ..._forward.PreCodegen.after.panic-unwind.mir |  12 +-
 ....{impl#0}-partial_cmp.PreCodegen.after.mir |  12 +-
 ...d_constant.main.GVN.32bit.panic-abort.diff |  14 +-
 ..._constant.main.GVN.32bit.panic-unwind.diff |  12 +-
 ...d_constant.main.GVN.64bit.panic-abort.diff |  14 +-
 ..._constant.main.GVN.64bit.panic-unwind.diff |  12 +-
 .../loops.filter_mapped.PreCodegen.after.mir  |   2 +-
 .../loops.int_range.PreCodegen.after.mir      |  16 +-
 .../loops.mapped.PreCodegen.after.mir         |   4 +-
 ...l_replace.PreCodegen.after.panic-abort.mir |   4 +-
 ..._replace.PreCodegen.after.panic-unwind.mir |   4 +-
 ...m_replace.PreCodegen.after.panic-abort.mir |   4 +-
 ..._replace.PreCodegen.after.panic-unwind.mir |   4 +-
 ..._clone.{impl#0}-clone.PreCodegen.after.mir |   2 +-
 ...o_variable.main.GVN.32bit.panic-abort.diff |   8 +-
 ..._variable.main.GVN.32bit.panic-unwind.diff |   8 +-
 ...o_variable.main.GVN.64bit.panic-abort.diff |   8 +-
 ..._variable.main.GVN.64bit.panic-unwind.diff |   8 +-
 ...acementOfAggregates.32bit.panic-abort.diff |  10 +-
 ...cementOfAggregates.32bit.panic-unwind.diff |  10 +-
 ...acementOfAggregates.64bit.panic-abort.diff |  10 +-
 ...cementOfAggregates.64bit.panic-unwind.diff |  10 +-
 ...e_add_fat.PreCodegen.after.panic-abort.mir |   8 +-
 ..._add_fat.PreCodegen.after.panic-unwind.mir |   8 +-
 ..._add_thin.PreCodegen.after.panic-abort.mir |   6 +-
 ...add_thin.PreCodegen.after.panic-unwind.mir |   6 +-
 ...ward_loop.PreCodegen.after.panic-abort.mir |  16 +-
 ...ard_loop.PreCodegen.after.panic-unwind.mir |  16 +-
 ...sive_loop.PreCodegen.after.panic-abort.mir |   8 +-
 ...ive_loop.PreCodegen.after.panic-unwind.mir |   8 +-
 ...iter_next.PreCodegen.after.panic-abort.mir |  10 +-
 ...ter_next.PreCodegen.after.panic-unwind.mir |  10 +-
 ...mple_option_map.ezmap.PreCodegen.after.mir |   4 +-
 ...variant_a-{closure#0}.PreCodegen.after.mir |  26 +-
 ...variant_b-{closure#0}.PreCodegen.after.mir |  18 +-
 ...mut_usize.PreCodegen.after.panic-abort.mir |  10 +-
 ...ut_usize.PreCodegen.after.panic-unwind.mir |  10 +-
 ...mut_range.PreCodegen.after.panic-abort.mir |  12 +-
 ...ut_range.PreCodegen.after.panic-unwind.mir |  12 +-
 ...dex_usize.PreCodegen.after.panic-abort.mir |   6 +-
 ...ex_usize.PreCodegen.after.panic-unwind.mir |   6 +-
 ...ked_range.PreCodegen.after.panic-abort.mir |  12 +-
 ...ed_range.PreCodegen.after.panic-unwind.mir |  12 +-
 ...ated_loop.PreCodegen.after.panic-abort.mir |  36 +-
 ...ted_loop.PreCodegen.after.panic-unwind.mir |  26 +-
 ...ward_loop.PreCodegen.after.panic-abort.mir |  22 +-
 ...ard_loop.PreCodegen.after.panic-unwind.mir |  22 +-
 ...ange_loop.PreCodegen.after.panic-abort.mir |  20 +-
 ...nge_loop.PreCodegen.after.panic-unwind.mir |  20 +-
 ...erse_loop.PreCodegen.after.panic-abort.mir |  24 +-
 ...rse_loop.PreCodegen.after.panic-unwind.mir |  24 +-
 ..._is_empty.PreCodegen.after.panic-abort.mir |  18 +-
 ...is_empty.PreCodegen.after.panic-unwind.mir |  18 +-
 ...ans.outer.PreCodegen.after.panic-abort.mir |   2 +-
 ...ns.outer.PreCodegen.after.panic-unwind.mir |   2 +-
 .../try_identity.new.PreCodegen.after.mir     |   8 +-
 .../try_identity.old.PreCodegen.after.mir     |   4 +-
 ..._to_slice.PreCodegen.after.panic-abort.mir |  10 +-
 ...to_slice.PreCodegen.after.panic-unwind.mir |  10 +-
 ...dominate_storage.ReferencePropagation.diff |   6 +-
 ..._prop.maybe_dead.ReferencePropagation.diff |  16 +-
 ...multiple_storage.ReferencePropagation.diff |   4 +-
 ...raw_then_mut_shr.ReferencePropagation.diff |  10 +-
 ...read_through_raw.ReferencePropagation.diff |   8 +-
 ...ence_propagation.ReferencePropagation.diff |  48 +--
 ...gation_const_ptr.ReferencePropagation.diff |  52 +--
 ..._propagation_mut.ReferencePropagation.diff |  30 +-
 ...pagation_mut_ptr.ReferencePropagation.diff |  38 +-
 ...ique_with_copies.ReferencePropagation.diff |   8 +-
 ...guard.CleanupPostBorrowck.panic-abort.diff |   4 +-
 ...uard.CleanupPostBorrowck.panic-unwind.diff |   4 +-
 ...main.RemoveStorageMarkers.panic-abort.diff |   6 +-
 ...ain.RemoveStorageMarkers.panic-unwind.diff |   6 +-
 ...s.opt.RemoveUnneededDrops.panic-abort.diff |   2 +-
 ....opt.RemoveUnneededDrops.panic-unwind.diff |   2 +-
 ..._copy.RemoveUnneededDrops.panic-abort.diff |   2 +-
 ...copy.RemoveUnneededDrops.panic-unwind.diff |   2 +-
 ...fg-pre-optimizations.after.panic-abort.mir |  14 +-
 ...g-pre-optimizations.after.panic-unwind.mir |  14 +-
 ...fg-pre-optimizations.after.panic-abort.mir |   2 +-
 ...g-pre-optimizations.after.panic-unwind.mir |   2 +-
 ...fg-pre-optimizations.after.panic-abort.mir |   2 +-
 ...g-pre-optimizations.after.panic-unwind.mir |   2 +-
 ...fg-pre-optimizations.after.panic-abort.mir |   6 +-
 ...g-pre-optimizations.after.panic-unwind.mir |   6 +-
 ...fg-pre-optimizations.after.panic-abort.mir |   2 +-
 ...g-pre-optimizations.after.panic-unwind.mir |   2 +-
 ...e_const_switch.identity.JumpThreading.diff |  18 +-
 ...onst_switch.too_complex.JumpThreading.diff |  14 +-
 .../set_no_discriminant.f.JumpThreading.diff  |   2 +-
 ...no_discriminant.generic.JumpThreading.diff |   2 +-
 ...yCfg-after-unreachable-enum-branching.diff |   6 +-
 ...ance.SimplifyLocals-before-const-prop.diff |   2 +-
 ...s.t1.SimplifyLocals-before-const-prop.diff |   2 +-
 ...s.t3.SimplifyLocals-before-const-prop.diff |   2 +-
 ...s.t4.SimplifyLocals-before-const-prop.diff |   2 +-
 ....foo.SimplifyLocals-final.panic-abort.diff |   2 +-
 ...foo.SimplifyLocals-final.panic-unwind.diff |   2 +-
 ...yLocals-before-const-prop.panic-abort.diff |   4 +-
 ...Locals-before-const-prop.panic-unwind.diff |   4 +-
 .../simplify_match.main.GVN.panic-abort.diff  |   4 +-
 .../simplify_match.main.GVN.panic-unwind.diff |   4 +-
 ...nst_debug.SingleUseConsts.panic-abort.diff |   2 +-
 ...st_debug.SingleUseConsts.panic-unwind.diff |   2 +-
 ...tch_const.SingleUseConsts.panic-abort.diff |   2 +-
 ...ch_const.SingleUseConsts.panic-unwind.diff |   2 +-
 ...nst_debug.SingleUseConsts.panic-abort.diff |   2 +-
 ...st_debug.SingleUseConsts.panic-unwind.diff |   2 +-
 ...[String].AddMovesForPackedDrops.before.mir |   4 +-
 ...mes.foo.ScalarReplacementOfAggregates.diff |   6 +-
 ...onstant.ScalarReplacementOfAggregates.diff |   8 +-
 ....copies.ScalarReplacementOfAggregates.diff |  32 +-
 ...s.enums.ScalarReplacementOfAggregates.diff |   6 +-
 ...ts.flat.ScalarReplacementOfAggregates.diff |  16 +-
 ..._copies.ScalarReplacementOfAggregates.diff |  18 +-
 ...structs.ScalarReplacementOfAggregates.diff |   6 +-
 ....unions.ScalarReplacementOfAggregates.diff |   4 +-
 tests/mir-opt/storage_ranges.main.nll.0.mir   |   2 +-
 ...o_self.test.MatchBranchSimplification.diff |   4 +-
 ...ll_drops.f.ElaborateDrops.panic-abort.diff |   2 +-
 ...l_drops.f.ElaborateDrops.panic-unwind.diff |   2 +-
 ...f_with_arg.ElaborateDrops.panic-abort.diff |   2 +-
 ..._with_arg.ElaborateDrops.panic-unwind.diff |   2 +-
 ...d_access.bar.SimplifyCfg-initial.after.mir |   8 +-
 ...d_access.foo.SimplifyCfg-initial.after.mir |   8 +-
 ...ch.UnreachablePropagation.panic-abort.diff |   2 +-
 ...h.UnreachablePropagation.panic-unwind.diff |   2 +-
 ...et.UnreachablePropagation.panic-abort.diff |   2 +-
 ...t.UnreachablePropagation.panic-unwind.diff |   2 +-
 ...in.UnreachablePropagation.panic-abort.diff |   4 +-
 ...n.UnreachablePropagation.panic-unwind.diff |   4 +-
 ....UnreachableEnumBranching.panic-abort.diff |   2 +-
 ...UnreachableEnumBranching.panic-unwind.diff |   2 +-
 678 files changed, 3567 insertions(+), 3567 deletions(-)

diff --git a/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir b/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir
index cb72ad3d2531d..be636da4517ca 100644
--- a/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/address_of.address_of_reborrow.SimplifyCfg-initial.after.mir
@@ -140,7 +140,7 @@ fn address_of_reborrow() -> () {
         StorageLive(_6);
         _6 = &raw const (*_1);
         AscribeUserType(_6, o, UserTypeProjection { base: UserType(0), projs: [] });
-        _5 = _6;
+        _5 = copy _6;
         StorageDead(_6);
         StorageDead(_5);
         StorageLive(_7);
@@ -153,7 +153,7 @@ fn address_of_reborrow() -> () {
         _9 = move _10 as *const dyn std::marker::Send (PointerCoercion(Unsize));
         StorageDead(_10);
         AscribeUserType(_9, o, UserTypeProjection { base: UserType(1), projs: [] });
-        _8 = _9;
+        _8 = copy _9;
         StorageDead(_9);
         StorageDead(_8);
         StorageLive(_11);
@@ -194,7 +194,7 @@ fn address_of_reborrow() -> () {
         StorageLive(_22);
         _22 = &raw const (*_3);
         AscribeUserType(_22, o, UserTypeProjection { base: UserType(10), projs: [] });
-        _21 = _22;
+        _21 = copy _22;
         StorageDead(_22);
         StorageDead(_21);
         StorageLive(_23);
@@ -207,7 +207,7 @@ fn address_of_reborrow() -> () {
         _25 = move _26 as *const dyn std::marker::Send (PointerCoercion(Unsize));
         StorageDead(_26);
         AscribeUserType(_25, o, UserTypeProjection { base: UserType(11), projs: [] });
-        _24 = _25;
+        _24 = copy _25;
         StorageDead(_25);
         StorageDead(_24);
         StorageLive(_27);
@@ -242,7 +242,7 @@ fn address_of_reborrow() -> () {
         StorageLive(_36);
         _36 = &raw mut (*_3);
         AscribeUserType(_36, o, UserTypeProjection { base: UserType(20), projs: [] });
-        _35 = _36;
+        _35 = copy _36;
         StorageDead(_36);
         StorageDead(_35);
         StorageLive(_37);
@@ -255,7 +255,7 @@ fn address_of_reborrow() -> () {
         _39 = move _40 as *mut dyn std::marker::Send (PointerCoercion(Unsize));
         StorageDead(_40);
         AscribeUserType(_39, o, UserTypeProjection { base: UserType(21), projs: [] });
-        _38 = _39;
+        _38 = copy _39;
         StorageDead(_39);
         StorageDead(_38);
         StorageLive(_41);
diff --git a/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir
index ef51b07827fb4..a467987e88612 100644
--- a/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir
+++ b/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir
@@ -33,17 +33,17 @@ fn main() -> () {
         StorageDead(_4);
         StorageLive(_5);
         StorageLive(_6);
-        _6 = _3;
+        _6 = copy _3;
         _5 = foo(move _6) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
         StorageDead(_6);
         StorageLive(_7);
-        _7 = _2;
+        _7 = copy _2;
         _8 = Len(_1);
-        _9 = Lt(_7, _8);
-        assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb2, unwind unreachable];
+        _9 = Lt(copy _7, copy _8);
+        assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb2, unwind unreachable];
     }
 
     bb2: {
diff --git a/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
index d1aa9382a2c5d..bd7365543bdce 100644
--- a/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
+++ b/tests/mir-opt/array_index_is_temporary.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
@@ -33,17 +33,17 @@ fn main() -> () {
         StorageDead(_4);
         StorageLive(_5);
         StorageLive(_6);
-        _6 = _3;
+        _6 = copy _3;
         _5 = foo(move _6) -> [return: bb1, unwind continue];
     }
 
     bb1: {
         StorageDead(_6);
         StorageLive(_7);
-        _7 = _2;
+        _7 = copy _2;
         _8 = Len(_1);
-        _9 = Lt(_7, _8);
-        assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb2, unwind continue];
+        _9 = Lt(copy _7, copy _8);
+        assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb2, unwind continue];
     }
 
     bb2: {
diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-abort.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-abort.mir
index 1c34955a8d9da..1f5bb551b8e01 100644
--- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-abort.mir
+++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-abort.mir
@@ -22,7 +22,7 @@ yields ()
 
     bb0: {
         StorageLive(_3);
-        _3 = (_1.0: i32);
+        _3 = copy (_1.0: i32);
         FakeRead(ForLet(None), _3);
         StorageLive(_4);
         _4 = &_3;
diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-unwind.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-unwind.mir
index 1c34955a8d9da..1f5bb551b8e01 100644
--- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-unwind.mir
+++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.coroutine_by_move.0.panic-unwind.mir
@@ -22,7 +22,7 @@ yields ()
 
     bb0: {
         StorageLive(_3);
-        _3 = (_1.0: i32);
+        _3 = copy (_1.0: i32);
         FakeRead(ForLet(None), _3);
         StorageLive(_4);
         _4 = &_3;
diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-abort.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-abort.mir
index 516908144a641..17fa93148064f 100644
--- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-abort.mir
+++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-abort.mir
@@ -22,7 +22,7 @@ yields ()
 
     bb0: {
         StorageLive(_3);
-        _3 = (_1.0: i32);
+        _3 = copy (_1.0: i32);
         FakeRead(ForLet(None), _3);
         StorageLive(_4);
         _4 = &_3;
diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-unwind.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-unwind.mir
index 516908144a641..17fa93148064f 100644
--- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-unwind.mir
+++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.coroutine_by_move.0.panic-unwind.mir
@@ -22,7 +22,7 @@ yields ()
 
     bb0: {
         StorageLive(_3);
-        _3 = (_1.0: i32);
+        _3 = copy (_1.0: i32);
         FakeRead(ForLet(None), _3);
         StorageLive(_4);
         _4 = &_3;
diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-abort.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-abort.mir
index ba20c28cd0147..3fdc81791deef 100644
--- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-abort.mir
+++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-abort.mir
@@ -4,7 +4,7 @@ fn main::{closure#0}::{closure#1}(_1: &{async closure@$DIR/async_closure_shims.r
     let mut _0: {async closure body@$DIR/async_closure_shims.rs:62:48: 65:10};
 
     bb0: {
-        _0 = {coroutine@$DIR/async_closure_shims.rs:62:48: 65:10 (#0)} { a: move _2, b: ((*_1).0: &i32) };
+        _0 = {coroutine@$DIR/async_closure_shims.rs:62:48: 65:10 (#0)} { a: move _2, b: copy ((*_1).0: &i32) };
         return;
     }
 }
diff --git a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-unwind.mir b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-unwind.mir
index ba20c28cd0147..3fdc81791deef 100644
--- a/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-unwind.mir
+++ b/tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.panic-unwind.mir
@@ -4,7 +4,7 @@ fn main::{closure#0}::{closure#1}(_1: &{async closure@$DIR/async_closure_shims.r
     let mut _0: {async closure body@$DIR/async_closure_shims.rs:62:48: 65:10};
 
     bb0: {
-        _0 = {coroutine@$DIR/async_closure_shims.rs:62:48: 65:10 (#0)} { a: move _2, b: ((*_1).0: &i32) };
+        _0 = {coroutine@$DIR/async_closure_shims.rs:62:48: 65:10 (#0)} { a: move _2, b: copy ((*_1).0: &i32) };
         return;
     }
 }
diff --git a/tests/mir-opt/basic_assignment.main.ElaborateDrops.diff b/tests/mir-opt/basic_assignment.main.ElaborateDrops.diff
index f187f95972795..2d6adaca19e61 100644
--- a/tests/mir-opt/basic_assignment.main.ElaborateDrops.diff
+++ b/tests/mir-opt/basic_assignment.main.ElaborateDrops.diff
@@ -27,7 +27,7 @@
           _1 = const false;
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = move _3;
           StorageDead(_3);
           StorageLive(_4);
diff --git a/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir b/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir
index 5c0d1e9b93ffa..d4f0363e44314 100644
--- a/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/basic_assignment.main.SimplifyCfg-initial.after.mir
@@ -31,7 +31,7 @@ fn main() -> () {
         FakeRead(ForLet(None), _1);
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
+        _3 = copy _1;
         _2 = move _3;
         StorageDead(_3);
         StorageLive(_4);
diff --git a/tests/mir-opt/building/async_await.b-{closure#0}.coroutine_resume.0.mir b/tests/mir-opt/building/async_await.b-{closure#0}.coroutine_resume.0.mir
index c0f16ee7ec0b4..c1c2fdcfa949e 100644
--- a/tests/mir-opt/building/async_await.b-{closure#0}.coroutine_resume.0.mir
+++ b/tests/mir-opt/building/async_await.b-{closure#0}.coroutine_resume.0.mir
@@ -151,7 +151,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
         StorageLive(_13);
         StorageLive(_14);
         StorageLive(_15);
-        _15 = _38;
+        _15 = copy _38;
         _14 = move _15;
         goto -> bb6;
     }
@@ -194,8 +194,8 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
 
     bb10: {
         StorageLive(_17);
-        _17 = ((_9 as Ready).0: ());
-        _3 = _17;
+        _17 = copy ((_9 as Ready).0: ());
+        _3 = copy _17;
         StorageDead(_17);
         StorageDead(_14);
         StorageDead(_12);
@@ -253,7 +253,7 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
         StorageLive(_29);
         StorageLive(_30);
         StorageLive(_31);
-        _31 = _38;
+        _31 = copy _38;
         _30 = move _31;
         goto -> bb18;
     }
@@ -291,8 +291,8 @@ fn b::{closure#0}(_1: Pin<&mut {async fn body of b()}>, _2: &mut Context<'_>) ->
 
     bb21: {
         StorageLive(_33);
-        _33 = ((_25 as Ready).0: ());
-        _37 = _33;
+        _33 = copy ((_25 as Ready).0: ());
+        _37 = copy _33;
         StorageDead(_33);
         StorageDead(_30);
         StorageDead(_28);
diff --git a/tests/mir-opt/building/custom/aggregate_exprs.adt.built.after.mir b/tests/mir-opt/building/custom/aggregate_exprs.adt.built.after.mir
index c14882142f56f..6d4d261b895a3 100644
--- a/tests/mir-opt/building/custom/aggregate_exprs.adt.built.after.mir
+++ b/tests/mir-opt/building/custom/aggregate_exprs.adt.built.after.mir
@@ -9,8 +9,8 @@ fn adt() -> Onion {
     bb0: {
         _1 = const 1_i32;
         _2 = Foo { a: const 1_i32, b: const 2_i32 };
-        _3 = Bar::Foo(move _2, _1);
-        _0 = Onion { neon: ((_3 as variant#0).1: i32) };
+        _3 = Bar::Foo(move _2, copy _1);
+        _0 = Onion { neon: copy ((_3 as variant#0).1: i32) };
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/aggregate_exprs.array.built.after.mir b/tests/mir-opt/building/custom/aggregate_exprs.array.built.after.mir
index fde007abab0ac..2c14258956a98 100644
--- a/tests/mir-opt/building/custom/aggregate_exprs.array.built.after.mir
+++ b/tests/mir-opt/building/custom/aggregate_exprs.array.built.after.mir
@@ -8,7 +8,7 @@ fn array() -> [i32; 2] {
     bb0: {
         _1 = [const 42_i32, const 43_i32];
         _2 = const 1_i32;
-        _1 = [_2, const 2_i32];
+        _1 = [copy _2, const 2_i32];
         _0 = move _1;
         return;
     }
diff --git a/tests/mir-opt/building/custom/arbitrary_let.arbitrary_let.built.after.mir b/tests/mir-opt/building/custom/arbitrary_let.arbitrary_let.built.after.mir
index 189996f117982..72a16b3588524 100644
--- a/tests/mir-opt/building/custom/arbitrary_let.arbitrary_let.built.after.mir
+++ b/tests/mir-opt/building/custom/arbitrary_let.arbitrary_let.built.after.mir
@@ -6,17 +6,17 @@ fn arbitrary_let(_1: i32) -> i32 {
     let mut _3: i32;
 
     bb0: {
-        _2 = _1;
+        _2 = copy _1;
         goto -> bb2;
     }
 
     bb1: {
-        _0 = _3;
+        _0 = copy _3;
         return;
     }
 
     bb2: {
-        _3 = _2;
+        _3 = copy _2;
         goto -> bb1;
     }
 }
diff --git a/tests/mir-opt/building/custom/arrays.arrays.built.after.mir b/tests/mir-opt/building/custom/arrays.arrays.built.after.mir
index eaeba302f1510..30d11e31e4d4e 100644
--- a/tests/mir-opt/building/custom/arrays.arrays.built.after.mir
+++ b/tests/mir-opt/building/custom/arrays.arrays.built.after.mir
@@ -8,7 +8,7 @@ fn arrays() -> usize {
     bb0: {
         _1 = [const 5_i32; C];
         _2 = Len(_1);
-        _0 = _2;
+        _0 = copy _2;
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/as_cast.float_to_int.built.after.mir b/tests/mir-opt/building/custom/as_cast.float_to_int.built.after.mir
index e3334bc7dbee4..93750719d2704 100644
--- a/tests/mir-opt/building/custom/as_cast.float_to_int.built.after.mir
+++ b/tests/mir-opt/building/custom/as_cast.float_to_int.built.after.mir
@@ -4,7 +4,7 @@ fn float_to_int(_1: f32) -> i32 {
     let mut _0: i32;
 
     bb0: {
-        _0 = _1 as i32 (FloatToInt);
+        _0 = copy _1 as i32 (FloatToInt);
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/as_cast.int_to_int.built.after.mir b/tests/mir-opt/building/custom/as_cast.int_to_int.built.after.mir
index d71cb9d78d338..9adec45d64b15 100644
--- a/tests/mir-opt/building/custom/as_cast.int_to_int.built.after.mir
+++ b/tests/mir-opt/building/custom/as_cast.int_to_int.built.after.mir
@@ -4,7 +4,7 @@ fn int_to_int(_1: u32) -> i32 {
     let mut _0: i32;
 
     bb0: {
-        _0 = _1 as i32 (IntToInt);
+        _0 = copy _1 as i32 (IntToInt);
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/as_cast.int_to_ptr.built.after.mir b/tests/mir-opt/building/custom/as_cast.int_to_ptr.built.after.mir
index faff79e8c5786..aa64225809566 100644
--- a/tests/mir-opt/building/custom/as_cast.int_to_ptr.built.after.mir
+++ b/tests/mir-opt/building/custom/as_cast.int_to_ptr.built.after.mir
@@ -4,7 +4,7 @@ fn int_to_ptr(_1: usize) -> *const i32 {
     let mut _0: *const i32;
 
     bb0: {
-        _0 = _1 as *const i32 (PointerWithExposedProvenance);
+        _0 = copy _1 as *const i32 (PointerWithExposedProvenance);
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/assume.assume_local.built.after.mir b/tests/mir-opt/building/custom/assume.assume_local.built.after.mir
index 7ea1fcd30c2ec..36e2859ce16dc 100644
--- a/tests/mir-opt/building/custom/assume.assume_local.built.after.mir
+++ b/tests/mir-opt/building/custom/assume.assume_local.built.after.mir
@@ -4,7 +4,7 @@ fn assume_local(_1: bool) -> () {
     let mut _0: ();
 
     bb0: {
-        assume(_1);
+        assume(copy _1);
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/assume.assume_place.built.after.mir b/tests/mir-opt/building/custom/assume.assume_place.built.after.mir
index ce914618d3dce..074af333d63a8 100644
--- a/tests/mir-opt/building/custom/assume.assume_place.built.after.mir
+++ b/tests/mir-opt/building/custom/assume.assume_place.built.after.mir
@@ -4,7 +4,7 @@ fn assume_place(_1: (bool, u8)) -> () {
     let mut _0: ();
 
     bb0: {
-        assume((_1.0: bool));
+        assume(copy (_1.0: bool));
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/enums.switch_bool.built.after.mir b/tests/mir-opt/building/custom/enums.switch_bool.built.after.mir
index f82e5f1c6fd0a..beefef331df84 100644
--- a/tests/mir-opt/building/custom/enums.switch_bool.built.after.mir
+++ b/tests/mir-opt/building/custom/enums.switch_bool.built.after.mir
@@ -4,7 +4,7 @@ fn switch_bool(_1: bool) -> u32 {
     let mut _0: u32;
 
     bb0: {
-        switchInt(_1) -> [1: bb1, 0: bb2, otherwise: bb2];
+        switchInt(copy _1) -> [1: bb1, 0: bb2, otherwise: bb2];
     }
 
     bb1: {
diff --git a/tests/mir-opt/building/custom/enums.switch_option.built.after.mir b/tests/mir-opt/building/custom/enums.switch_option.built.after.mir
index fa03f274be340..a854df878668d 100644
--- a/tests/mir-opt/building/custom/enums.switch_option.built.after.mir
+++ b/tests/mir-opt/building/custom/enums.switch_option.built.after.mir
@@ -6,7 +6,7 @@ fn switch_option(_1: Option<()>) -> bool {
 
     bb0: {
         _2 = discriminant(_1);
-        switchInt(_2) -> [0: bb1, 1: bb2, otherwise: bb2];
+        switchInt(copy _2) -> [0: bb1, 1: bb2, otherwise: bb2];
     }
 
     bb1: {
diff --git a/tests/mir-opt/building/custom/enums.switch_option_repr.built.after.mir b/tests/mir-opt/building/custom/enums.switch_option_repr.built.after.mir
index eec2197a8bd3a..4ffc08772a844 100644
--- a/tests/mir-opt/building/custom/enums.switch_option_repr.built.after.mir
+++ b/tests/mir-opt/building/custom/enums.switch_option_repr.built.after.mir
@@ -6,7 +6,7 @@ fn switch_option_repr(_1: Bool) -> bool {
 
     bb0: {
         _2 = discriminant(_1);
-        switchInt(_2) -> [0: bb2, otherwise: bb1];
+        switchInt(copy _2) -> [0: bb2, otherwise: bb1];
     }
 
     bb1: {
diff --git a/tests/mir-opt/building/custom/operators.f.built.after.mir b/tests/mir-opt/building/custom/operators.f.built.after.mir
index cac82f7b3ea3b..ed6cddd548fb2 100644
--- a/tests/mir-opt/building/custom/operators.f.built.after.mir
+++ b/tests/mir-opt/building/custom/operators.f.built.after.mir
@@ -5,26 +5,26 @@ fn f(_1: i32, _2: bool) -> i32 {
     let mut _3: (i32, bool);
 
     bb0: {
-        _1 = Neg(_1);
-        _2 = Not(_2);
-        _1 = Add(_1, _1);
-        _1 = Sub(_1, _1);
-        _1 = Mul(_1, _1);
-        _1 = Div(_1, _1);
-        _1 = Rem(_1, _1);
-        _1 = BitXor(_1, _1);
-        _1 = BitAnd(_1, _1);
-        _1 = Shl(_1, _1);
-        _1 = Shr(_1, _1);
-        _2 = Eq(_1, _1);
-        _2 = Lt(_1, _1);
-        _2 = Le(_1, _1);
-        _2 = Ge(_1, _1);
-        _2 = Gt(_1, _1);
-        _3 = AddWithOverflow(_1, _1);
-        _2 = (_3.1: bool);
-        _1 = (_3.0: i32);
-        _0 = _1;
+        _1 = Neg(copy _1);
+        _2 = Not(copy _2);
+        _1 = Add(copy _1, copy _1);
+        _1 = Sub(copy _1, copy _1);
+        _1 = Mul(copy _1, copy _1);
+        _1 = Div(copy _1, copy _1);
+        _1 = Rem(copy _1, copy _1);
+        _1 = BitXor(copy _1, copy _1);
+        _1 = BitAnd(copy _1, copy _1);
+        _1 = Shl(copy _1, copy _1);
+        _1 = Shr(copy _1, copy _1);
+        _2 = Eq(copy _1, copy _1);
+        _2 = Lt(copy _1, copy _1);
+        _2 = Le(copy _1, copy _1);
+        _2 = Ge(copy _1, copy _1);
+        _2 = Gt(copy _1, copy _1);
+        _3 = AddWithOverflow(copy _1, copy _1);
+        _2 = copy (_3.1: bool);
+        _1 = copy (_3.0: i32);
+        _0 = copy _1;
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/operators.g.runtime.after.mir b/tests/mir-opt/building/custom/operators.g.runtime.after.mir
index a0ad7d0f93f4e..7d87fd9327838 100644
--- a/tests/mir-opt/building/custom/operators.g.runtime.after.mir
+++ b/tests/mir-opt/building/custom/operators.g.runtime.after.mir
@@ -6,8 +6,8 @@ fn g(_1: *const i32, _2: *const [i32]) -> () {
     let mut _4: usize;
 
     bb0: {
-        _3 = PtrMetadata(_1);
-        _4 = PtrMetadata(_2);
+        _3 = PtrMetadata(copy _1);
+        _4 = PtrMetadata(copy _2);
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/projections.copy_for_deref.built.after.mir b/tests/mir-opt/building/custom/projections.copy_for_deref.built.after.mir
index b1ba5f9314d51..b28e96f10eae7 100644
--- a/tests/mir-opt/building/custom/projections.copy_for_deref.built.after.mir
+++ b/tests/mir-opt/building/custom/projections.copy_for_deref.built.after.mir
@@ -6,7 +6,7 @@ fn copy_for_deref(_1: (&i32, i32)) -> i32 {
 
     bb0: {
         _2 = deref_copy (_1.0: &i32);
-        _0 = (*_2);
+        _0 = copy (*_2);
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/projections.simple_index.built.after.mir b/tests/mir-opt/building/custom/projections.simple_index.built.after.mir
index f74c61009d341..2cd781696da7c 100644
--- a/tests/mir-opt/building/custom/projections.simple_index.built.after.mir
+++ b/tests/mir-opt/building/custom/projections.simple_index.built.after.mir
@@ -6,8 +6,8 @@ fn simple_index(_1: [i32; 10], _2: &[i32]) -> i32 {
 
     bb0: {
         _3 = const 3_usize;
-        _0 = _1[_3];
-        _0 = (*_2)[_3];
+        _0 = copy _1[_3];
+        _0 = copy (*_2)[_3];
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/projections.tuples.built.after.mir b/tests/mir-opt/building/custom/projections.tuples.built.after.mir
index a370de2ed8439..d07269cd0d30d 100644
--- a/tests/mir-opt/building/custom/projections.tuples.built.after.mir
+++ b/tests/mir-opt/building/custom/projections.tuples.built.after.mir
@@ -4,8 +4,8 @@ fn tuples(_1: (u32, i32)) -> (u32, i32) {
     let mut _0: (u32, i32);
 
     bb0: {
-        (_0.0: u32) = (_1.0: u32);
-        (_0.1: i32) = (_1.1: i32);
+        (_0.0: u32) = copy (_1.0: u32);
+        (_0.1: i32) = copy (_1.1: i32);
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/projections.unions.built.after.mir b/tests/mir-opt/building/custom/projections.unions.built.after.mir
index 4189b329e8cc5..fe4f7acebb52b 100644
--- a/tests/mir-opt/building/custom/projections.unions.built.after.mir
+++ b/tests/mir-opt/building/custom/projections.unions.built.after.mir
@@ -4,7 +4,7 @@ fn unions(_1: U) -> i32 {
     let mut _0: i32;
 
     bb0: {
-        _0 = (_1.0: i32);
+        _0 = copy (_1.0: i32);
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/projections.unwrap.built.after.mir b/tests/mir-opt/building/custom/projections.unwrap.built.after.mir
index 0c43bdc9d24d0..ea706e0a97d20 100644
--- a/tests/mir-opt/building/custom/projections.unwrap.built.after.mir
+++ b/tests/mir-opt/building/custom/projections.unwrap.built.after.mir
@@ -4,7 +4,7 @@ fn unwrap(_1: Option<i32>) -> i32 {
     let mut _0: i32;
 
     bb0: {
-        _0 = ((_1 as variant#1).0: i32);
+        _0 = copy ((_1 as variant#1).0: i32);
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/projections.unwrap_deref.built.after.mir b/tests/mir-opt/building/custom/projections.unwrap_deref.built.after.mir
index 39e9785134380..eb83dcece3e82 100644
--- a/tests/mir-opt/building/custom/projections.unwrap_deref.built.after.mir
+++ b/tests/mir-opt/building/custom/projections.unwrap_deref.built.after.mir
@@ -4,7 +4,7 @@ fn unwrap_deref(_1: Option<&i32>) -> i32 {
     let mut _0: i32;
 
     bb0: {
-        _0 = (*((_1 as variant#1).0: &i32));
+        _0 = copy (*((_1 as variant#1).0: &i32));
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/references.raw_pointer_offset.built.after.mir b/tests/mir-opt/building/custom/references.raw_pointer_offset.built.after.mir
index 8046b543eefc9..3893613bff9f4 100644
--- a/tests/mir-opt/building/custom/references.raw_pointer_offset.built.after.mir
+++ b/tests/mir-opt/building/custom/references.raw_pointer_offset.built.after.mir
@@ -4,7 +4,7 @@ fn raw_pointer_offset(_1: *const i32) -> *const i32 {
     let mut _0: *const i32;
 
     bb0: {
-        _0 = Offset(_1, const 1_isize);
+        _0 = Offset(copy _1, const 1_isize);
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/simple_assign.simple.built.after.mir b/tests/mir-opt/building/custom/simple_assign.simple.built.after.mir
index 6f7aaeed97990..10ad840f98c50 100644
--- a/tests/mir-opt/building/custom/simple_assign.simple.built.after.mir
+++ b/tests/mir-opt/building/custom/simple_assign.simple.built.after.mir
@@ -7,14 +7,14 @@ fn simple(_1: i32) -> i32 {
 
     bb0: {
         StorageLive(_2);
-        _2 = _1;
+        _2 = copy _1;
         goto -> bb1;
     }
 
     bb1: {
         _3 = move _2;
         StorageDead(_2);
-        _0 = _3;
+        _0 = copy _3;
         return;
     }
 }
diff --git a/tests/mir-opt/building/custom/terminators.assert_nonzero.built.after.mir b/tests/mir-opt/building/custom/terminators.assert_nonzero.built.after.mir
index 9cf26dff35033..44030abc79747 100644
--- a/tests/mir-opt/building/custom/terminators.assert_nonzero.built.after.mir
+++ b/tests/mir-opt/building/custom/terminators.assert_nonzero.built.after.mir
@@ -4,7 +4,7 @@ fn assert_nonzero(_1: i32) -> () {
     let mut _0: ();
 
     bb0: {
-        switchInt(_1) -> [0: bb1, otherwise: bb2];
+        switchInt(copy _1) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
diff --git a/tests/mir-opt/building/custom/terminators.direct_call.built.after.mir b/tests/mir-opt/building/custom/terminators.direct_call.built.after.mir
index 07044ceaef440..b29d4ec70957b 100644
--- a/tests/mir-opt/building/custom/terminators.direct_call.built.after.mir
+++ b/tests/mir-opt/building/custom/terminators.direct_call.built.after.mir
@@ -4,7 +4,7 @@ fn direct_call(_1: i32) -> i32 {
     let mut _0: i32;
 
     bb0: {
-        _0 = ident::<i32>(_1) -> [return: bb1, unwind continue];
+        _0 = ident::<i32>(copy _1) -> [return: bb1, unwind continue];
     }
 
     bb1: {
diff --git a/tests/mir-opt/building/custom/terminators.indirect_call.built.after.mir b/tests/mir-opt/building/custom/terminators.indirect_call.built.after.mir
index 3b849354dcd8e..b88f660302693 100644
--- a/tests/mir-opt/building/custom/terminators.indirect_call.built.after.mir
+++ b/tests/mir-opt/building/custom/terminators.indirect_call.built.after.mir
@@ -4,7 +4,7 @@ fn indirect_call(_1: i32, _2: fn(i32) -> i32) -> i32 {
     let mut _0: i32;
 
     bb0: {
-        _0 = _2(_1) -> [return: bb1, unwind continue];
+        _0 = copy _2(copy _1) -> [return: bb1, unwind continue];
     }
 
     bb1: {
diff --git a/tests/mir-opt/building/custom/terminators.tail_call.built.after.mir b/tests/mir-opt/building/custom/terminators.tail_call.built.after.mir
index 4cf6e459aa820..ab3925dae1c3a 100644
--- a/tests/mir-opt/building/custom/terminators.tail_call.built.after.mir
+++ b/tests/mir-opt/building/custom/terminators.tail_call.built.after.mir
@@ -5,7 +5,7 @@ fn tail_call(_1: i32) -> i32 {
     let mut _2: i32;
 
     bb0: {
-        _2 = Add(_1, const 42_i32);
-        tailcall ident::<i32>(Spanned { node: _2, span: $DIR/terminators.rs:32:28: 32:29 (#0) });
+        _2 = Add(copy _1, const 42_i32);
+        tailcall ident::<i32>(Spanned { node: copy _2, span: $DIR/terminators.rs:32:28: 32:29 (#0) });
     }
 }
diff --git a/tests/mir-opt/building/enum_cast.bar.built.after.mir b/tests/mir-opt/building/enum_cast.bar.built.after.mir
index 512c73216198e..72d0cf5d1e823 100644
--- a/tests/mir-opt/building/enum_cast.bar.built.after.mir
+++ b/tests/mir-opt/building/enum_cast.bar.built.after.mir
@@ -12,8 +12,8 @@ fn bar(_1: Bar) -> usize {
         StorageLive(_2);
         _2 = move _1;
         _3 = discriminant(_2);
-        _4 = _3 as u8 (IntToInt);
-        _5 = Le(_4, const 1_u8);
+        _4 = copy _3 as u8 (IntToInt);
+        _5 = Le(copy _4, const 1_u8);
         assume(move _5);
         _0 = move _3 as usize (IntToInt);
         StorageDead(_2);
diff --git a/tests/mir-opt/building/enum_cast.boo.built.after.mir b/tests/mir-opt/building/enum_cast.boo.built.after.mir
index ad0adf14e4ac8..91e06dc886299 100644
--- a/tests/mir-opt/building/enum_cast.boo.built.after.mir
+++ b/tests/mir-opt/building/enum_cast.boo.built.after.mir
@@ -12,8 +12,8 @@ fn boo(_1: Boo) -> usize {
         StorageLive(_2);
         _2 = move _1;
         _3 = discriminant(_2);
-        _4 = _3 as u8 (IntToInt);
-        _5 = Le(_4, const 1_u8);
+        _4 = copy _3 as u8 (IntToInt);
+        _5 = Le(copy _4, const 1_u8);
         assume(move _5);
         _0 = move _3 as usize (IntToInt);
         StorageDead(_2);
diff --git a/tests/mir-opt/building/enum_cast.droppy.built.after.mir b/tests/mir-opt/building/enum_cast.droppy.built.after.mir
index ea0edb610f5cc..f53c9199a4949 100644
--- a/tests/mir-opt/building/enum_cast.droppy.built.after.mir
+++ b/tests/mir-opt/building/enum_cast.droppy.built.after.mir
@@ -31,8 +31,8 @@ fn droppy() -> () {
         StorageLive(_4);
         _4 = move _2;
         _5 = discriminant(_4);
-        _6 = _5 as u8 (IntToInt);
-        _7 = Le(_6, const 2_u8);
+        _6 = copy _5 as u8 (IntToInt);
+        _7 = Le(copy _6, const 2_u8);
         assume(move _7);
         _3 = move _5 as usize (IntToInt);
         drop(_4) -> [return: bb1, unwind: bb4];
diff --git a/tests/mir-opt/building/enum_cast.far.built.after.mir b/tests/mir-opt/building/enum_cast.far.built.after.mir
index e75803c706daf..14eaf34419034 100644
--- a/tests/mir-opt/building/enum_cast.far.built.after.mir
+++ b/tests/mir-opt/building/enum_cast.far.built.after.mir
@@ -12,8 +12,8 @@ fn far(_1: Far) -> isize {
         StorageLive(_2);
         _2 = move _1;
         _3 = discriminant(_2);
-        _4 = _3 as u16 (IntToInt);
-        _5 = Le(_4, const 1_u16);
+        _4 = copy _3 as u16 (IntToInt);
+        _5 = Le(copy _4, const 1_u16);
         assume(move _5);
         _0 = move _3 as isize (IntToInt);
         StorageDead(_2);
diff --git a/tests/mir-opt/building/enum_cast.offsetty.built.after.mir b/tests/mir-opt/building/enum_cast.offsetty.built.after.mir
index 282859d7cd014..1c2acbe3023fe 100644
--- a/tests/mir-opt/building/enum_cast.offsetty.built.after.mir
+++ b/tests/mir-opt/building/enum_cast.offsetty.built.after.mir
@@ -14,9 +14,9 @@ fn offsetty(_1: NotStartingAtZero) -> u32 {
         StorageLive(_2);
         _2 = move _1;
         _3 = discriminant(_2);
-        _4 = _3 as u8 (IntToInt);
-        _5 = Ge(_4, const 4_u8);
-        _6 = Le(_4, const 8_u8);
+        _4 = copy _3 as u8 (IntToInt);
+        _5 = Ge(copy _4, const 4_u8);
+        _6 = Le(copy _4, const 8_u8);
         _7 = BitAnd(move _5, move _6);
         assume(move _7);
         _0 = move _3 as u32 (IntToInt);
diff --git a/tests/mir-opt/building/enum_cast.signy.built.after.mir b/tests/mir-opt/building/enum_cast.signy.built.after.mir
index a9f7d6c78007a..39b6dfaf005e3 100644
--- a/tests/mir-opt/building/enum_cast.signy.built.after.mir
+++ b/tests/mir-opt/building/enum_cast.signy.built.after.mir
@@ -14,9 +14,9 @@ fn signy(_1: SignedAroundZero) -> i16 {
         StorageLive(_2);
         _2 = move _1;
         _3 = discriminant(_2);
-        _4 = _3 as u16 (IntToInt);
-        _5 = Ge(_4, const 65534_u16);
-        _6 = Le(_4, const 2_u16);
+        _4 = copy _3 as u16 (IntToInt);
+        _5 = Ge(copy _4, const 65534_u16);
+        _6 = Le(copy _4, const 2_u16);
         _7 = BitOr(move _5, move _6);
         assume(move _7);
         _0 = move _3 as i16 (IntToInt);
diff --git a/tests/mir-opt/building/eq_never_type._f.built.after.mir b/tests/mir-opt/building/eq_never_type._f.built.after.mir
index 39438258c2ebb..4711af46f1c8c 100644
--- a/tests/mir-opt/building/eq_never_type._f.built.after.mir
+++ b/tests/mir-opt/building/eq_never_type._f.built.after.mir
@@ -16,7 +16,7 @@ fn _f(_1: !, _2: !) -> () {
         StorageLive(_4);
         StorageLive(_5);
         StorageLive(_6);
-        _6 = _1;
+        _6 = copy _1;
         unreachable;
     }
 
@@ -25,7 +25,7 @@ fn _f(_1: !, _2: !) -> () {
         StorageLive(_7);
         StorageLive(_8);
         StorageLive(_9);
-        _9 = _2;
+        _9 = copy _2;
         unreachable;
     }
 
diff --git a/tests/mir-opt/building/issue_101867.main.built.after.mir b/tests/mir-opt/building/issue_101867.main.built.after.mir
index 5c50b3db5cad6..34e5bedf4ce9c 100644
--- a/tests/mir-opt/building/issue_101867.main.built.after.mir
+++ b/tests/mir-opt/building/issue_101867.main.built.after.mir
@@ -55,7 +55,7 @@ fn main() -> () {
     }
 
     bb6: {
-        _5 = ((_1 as Some).0: u8);
+        _5 = copy ((_1 as Some).0: u8);
         _0 = const ();
         StorageDead(_5);
         StorageDead(_1);
diff --git a/tests/mir-opt/building/issue_49232.main.built.after.mir b/tests/mir-opt/building/issue_49232.main.built.after.mir
index d09a1748a8b36..b78f6691d54c0 100644
--- a/tests/mir-opt/building/issue_49232.main.built.after.mir
+++ b/tests/mir-opt/building/issue_49232.main.built.after.mir
@@ -25,7 +25,7 @@ fn main() -> () {
         StorageLive(_3);
         _3 = const true;
         PlaceMention(_3);
-        switchInt(_3) -> [0: bb4, otherwise: bb6];
+        switchInt(copy _3) -> [0: bb4, otherwise: bb6];
     }
 
     bb3: {
diff --git a/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir b/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir
index 3e16efe6980d9..72bd4605b2641 100644
--- a/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir
+++ b/tests/mir-opt/building/logical_or_in_conditional.test_complex.built.after.mir
@@ -54,7 +54,7 @@ fn test_complex() -> () {
         StorageLive(_6);
         StorageLive(_7);
         _7 = Droppy(const 0_u8);
-        _6 = (_7.0: u8);
+        _6 = copy (_7.0: u8);
         _5 = Gt(move _6, const 0_u8);
         switchInt(move _5) -> [0: bb10, otherwise: bb9];
     }
@@ -92,7 +92,7 @@ fn test_complex() -> () {
         StorageLive(_9);
         StorageLive(_10);
         _10 = Droppy(const 1_u8);
-        _9 = (_10.0: u8);
+        _9 = copy (_10.0: u8);
         _8 = Gt(move _9, const 1_u8);
         switchInt(move _8) -> [0: bb16, otherwise: bb15];
     }
diff --git a/tests/mir-opt/building/logical_or_in_conditional.test_or.built.after.mir b/tests/mir-opt/building/logical_or_in_conditional.test_or.built.after.mir
index 3e7c116016cc1..2fc19e7e0fdcd 100644
--- a/tests/mir-opt/building/logical_or_in_conditional.test_or.built.after.mir
+++ b/tests/mir-opt/building/logical_or_in_conditional.test_or.built.after.mir
@@ -14,7 +14,7 @@ fn test_or() -> () {
         StorageLive(_2);
         StorageLive(_3);
         _3 = Droppy(const 0_u8);
-        _2 = (_3.0: u8);
+        _2 = copy (_3.0: u8);
         _1 = Gt(move _2, const 0_u8);
         switchInt(move _1) -> [0: bb2, otherwise: bb1];
     }
@@ -44,7 +44,7 @@ fn test_or() -> () {
         StorageLive(_5);
         StorageLive(_6);
         _6 = Droppy(const 1_u8);
-        _5 = (_6.0: u8);
+        _5 = copy (_6.0: u8);
         _4 = Gt(move _5, const 1_u8);
         switchInt(move _4) -> [0: bb7, otherwise: bb6];
     }
diff --git a/tests/mir-opt/building/match/deref-patterns/string.foo.PreCodegen.after.mir b/tests/mir-opt/building/match/deref-patterns/string.foo.PreCodegen.after.mir
index 1e4f7485089ec..9f52a8cd1e55e 100644
--- a/tests/mir-opt/building/match/deref-patterns/string.foo.PreCodegen.after.mir
+++ b/tests/mir-opt/building/match/deref-patterns/string.foo.PreCodegen.after.mir
@@ -26,7 +26,7 @@ fn foo(_1: Option<String>) -> i32 {
     }
 
     bb2: {
-        _6 = <str as PartialEq>::eq(_5, const "a") -> [return: bb3, unwind unreachable];
+        _6 = <str as PartialEq>::eq(copy _5, const "a") -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
@@ -52,7 +52,7 @@ fn foo(_1: Option<String>) -> i32 {
     }
 
     bb7: {
-        switchInt(_2) -> [0: bb9, otherwise: bb8];
+        switchInt(copy _2) -> [0: bb9, otherwise: bb8];
     }
 
     bb8: {
diff --git a/tests/mir-opt/building/match/exponential_or.match_tuple.SimplifyCfg-initial.after.mir b/tests/mir-opt/building/match/exponential_or.match_tuple.SimplifyCfg-initial.after.mir
index 596dcef85fd21..d52241b459ebd 100644
--- a/tests/mir-opt/building/match/exponential_or.match_tuple.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/building/match/exponential_or.match_tuple.SimplifyCfg-initial.after.mir
@@ -19,7 +19,7 @@ fn match_tuple(_1: (u32, bool, Option<i32>, u32)) -> u32 {
 
     bb0: {
         PlaceMention(_1);
-        switchInt((_1.0: u32)) -> [1: bb2, 4: bb2, otherwise: bb1];
+        switchInt(copy (_1.0: u32)) -> [1: bb2, 4: bb2, otherwise: bb1];
     }
 
     bb1: {
@@ -33,26 +33,26 @@ fn match_tuple(_1: (u32, bool, Option<i32>, u32)) -> u32 {
     }
 
     bb3: {
-        switchInt((((_1.2: std::option::Option<i32>) as Some).0: i32)) -> [1: bb4, 8: bb4, otherwise: bb1];
+        switchInt(copy (((_1.2: std::option::Option<i32>) as Some).0: i32)) -> [1: bb4, 8: bb4, otherwise: bb1];
     }
 
     bb4: {
-        _5 = Le(const 6_u32, (_1.3: u32));
+        _5 = Le(const 6_u32, copy (_1.3: u32));
         switchInt(move _5) -> [0: bb5, otherwise: bb7];
     }
 
     bb5: {
-        _3 = Le(const 13_u32, (_1.3: u32));
+        _3 = Le(const 13_u32, copy (_1.3: u32));
         switchInt(move _3) -> [0: bb1, otherwise: bb6];
     }
 
     bb6: {
-        _4 = Le((_1.3: u32), const 16_u32);
+        _4 = Le(copy (_1.3: u32), const 16_u32);
         switchInt(move _4) -> [0: bb1, otherwise: bb8];
     }
 
     bb7: {
-        _6 = Le((_1.3: u32), const 9_u32);
+        _6 = Le(copy (_1.3: u32), const 9_u32);
         switchInt(move _6) -> [0: bb5, otherwise: bb8];
     }
 
@@ -62,13 +62,13 @@ fn match_tuple(_1: (u32, bool, Option<i32>, u32)) -> u32 {
 
     bb9: {
         StorageLive(_7);
-        _7 = (_1.0: u32);
+        _7 = copy (_1.0: u32);
         StorageLive(_8);
-        _8 = (_1.3: u32);
+        _8 = copy (_1.3: u32);
         StorageLive(_9);
-        _9 = _7;
+        _9 = copy _7;
         StorageLive(_10);
-        _10 = _8;
+        _10 = copy _8;
         _0 = BitXor(move _9, move _10);
         StorageDead(_10);
         StorageDead(_9);
diff --git a/tests/mir-opt/building/match/match_false_edges.full_tested_match.built.after.mir b/tests/mir-opt/building/match/match_false_edges.full_tested_match.built.after.mir
index a93743edfac73..4b0cdcfbb8662 100644
--- a/tests/mir-opt/building/match/match_false_edges.full_tested_match.built.after.mir
+++ b/tests/mir-opt/building/match/match_false_edges.full_tested_match.built.after.mir
@@ -59,9 +59,9 @@ fn full_tested_match() -> () {
 
     bb7: {
         StorageLive(_9);
-        _9 = ((_2 as Some).0: i32);
+        _9 = copy ((_2 as Some).0: i32);
         StorageLive(_10);
-        _10 = _9;
+        _10 = copy _9;
         _1 = (const 2_i32, move _10);
         StorageDead(_10);
         StorageDead(_9);
@@ -89,9 +89,9 @@ fn full_tested_match() -> () {
         FakeRead(ForMatchGuard, _3);
         FakeRead(ForGuardBinding, _6);
         StorageLive(_5);
-        _5 = ((_2 as Some).0: i32);
+        _5 = copy ((_2 as Some).0: i32);
         StorageLive(_8);
-        _8 = _5;
+        _8 = copy _5;
         _1 = (const 1_i32, move _8);
         StorageDead(_8);
         StorageDead(_5);
diff --git a/tests/mir-opt/building/match/match_false_edges.full_tested_match2.built.after.mir b/tests/mir-opt/building/match/match_false_edges.full_tested_match2.built.after.mir
index 0d0ea2be1b005..63ec71fdf5133 100644
--- a/tests/mir-opt/building/match/match_false_edges.full_tested_match2.built.after.mir
+++ b/tests/mir-opt/building/match/match_false_edges.full_tested_match2.built.after.mir
@@ -42,9 +42,9 @@ fn full_tested_match2() -> () {
 
     bb3: {
         StorageLive(_9);
-        _9 = ((_2 as Some).0: i32);
+        _9 = copy ((_2 as Some).0: i32);
         StorageLive(_10);
-        _10 = _9;
+        _10 = copy _9;
         _1 = (const 2_i32, move _10);
         StorageDead(_10);
         StorageDead(_9);
@@ -89,9 +89,9 @@ fn full_tested_match2() -> () {
         FakeRead(ForMatchGuard, _3);
         FakeRead(ForGuardBinding, _6);
         StorageLive(_5);
-        _5 = ((_2 as Some).0: i32);
+        _5 = copy ((_2 as Some).0: i32);
         StorageLive(_8);
-        _8 = _5;
+        _8 = copy _5;
         _1 = (const 1_i32, move _8);
         StorageDead(_8);
         StorageDead(_5);
diff --git a/tests/mir-opt/building/match/match_false_edges.main.built.after.mir b/tests/mir-opt/building/match/match_false_edges.main.built.after.mir
index 87b7e29848f74..3b10adb499cd5 100644
--- a/tests/mir-opt/building/match/match_false_edges.main.built.after.mir
+++ b/tests/mir-opt/building/match/match_false_edges.main.built.after.mir
@@ -61,7 +61,7 @@ fn main() -> () {
 
     bb5: {
         StorageLive(_14);
-        _14 = _2;
+        _14 = copy _2;
         _1 = const 4_i32;
         StorageDead(_14);
         goto -> bb22;
@@ -86,7 +86,7 @@ fn main() -> () {
         _3 = &fake shallow _2;
         StorageLive(_12);
         StorageLive(_13);
-        _13 = (*_11);
+        _13 = copy (*_11);
         _12 = guard2(move _13) -> [return: bb18, unwind: bb24];
     }
 
@@ -96,7 +96,7 @@ fn main() -> () {
 
     bb11: {
         StorageLive(_9);
-        _9 = _2;
+        _9 = copy _2;
         _1 = const 2_i32;
         StorageDead(_9);
         goto -> bb22;
@@ -123,7 +123,7 @@ fn main() -> () {
         FakeRead(ForMatchGuard, _3);
         FakeRead(ForGuardBinding, _7);
         StorageLive(_6);
-        _6 = ((_2 as Some).0: i32);
+        _6 = copy ((_2 as Some).0: i32);
         _1 = const 1_i32;
         StorageDead(_6);
         StorageDead(_7);
@@ -150,7 +150,7 @@ fn main() -> () {
         FakeRead(ForMatchGuard, _3);
         FakeRead(ForGuardBinding, _11);
         StorageLive(_10);
-        _10 = ((_2 as Some).0: i32);
+        _10 = copy ((_2 as Some).0: i32);
         _1 = const 3_i32;
         StorageDead(_10);
         StorageDead(_11);
diff --git a/tests/mir-opt/building/match/simple_match.match_bool.built.after.mir b/tests/mir-opt/building/match/simple_match.match_bool.built.after.mir
index b0ebdc37b067d..0e82d9591a691 100644
--- a/tests/mir-opt/building/match/simple_match.match_bool.built.after.mir
+++ b/tests/mir-opt/building/match/simple_match.match_bool.built.after.mir
@@ -6,7 +6,7 @@ fn match_bool(_1: bool) -> usize {
 
     bb0: {
         PlaceMention(_1);
-        switchInt(_1) -> [0: bb1, otherwise: bb2];
+        switchInt(copy _1) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
diff --git a/tests/mir-opt/building/match/sort_candidates.constant_eq.SimplifyCfg-initial.after.mir b/tests/mir-opt/building/match/sort_candidates.constant_eq.SimplifyCfg-initial.after.mir
index 2bce79a3ae799..b8f54fef0fafc 100644
--- a/tests/mir-opt/building/match/sort_candidates.constant_eq.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/building/match/sort_candidates.constant_eq.SimplifyCfg-initial.after.mir
@@ -16,18 +16,18 @@ fn constant_eq(_1: &str, _2: bool) -> u32 {
     bb0: {
         StorageLive(_3);
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         StorageLive(_5);
-        _5 = _2;
+        _5 = copy _2;
         _3 = (move _4, move _5);
         StorageDead(_5);
         StorageDead(_4);
         PlaceMention(_3);
-        _9 = <str as PartialEq>::eq((_3.0: &str), const "a") -> [return: bb9, unwind: bb19];
+        _9 = <str as PartialEq>::eq(copy (_3.0: &str), const "a") -> [return: bb9, unwind: bb19];
     }
 
     bb1: {
-        switchInt((_3.1: bool)) -> [0: bb10, otherwise: bb11];
+        switchInt(copy (_3.1: bool)) -> [0: bb10, otherwise: bb11];
     }
 
     bb2: {
@@ -35,7 +35,7 @@ fn constant_eq(_1: &str, _2: bool) -> u32 {
     }
 
     bb3: {
-        switchInt((_3.1: bool)) -> [0: bb1, otherwise: bb4];
+        switchInt(copy (_3.1: bool)) -> [0: bb1, otherwise: bb4];
     }
 
     bb4: {
@@ -43,11 +43,11 @@ fn constant_eq(_1: &str, _2: bool) -> u32 {
     }
 
     bb5: {
-        _8 = <str as PartialEq>::eq((_3.0: &str), const "b") -> [return: bb8, unwind: bb19];
+        _8 = <str as PartialEq>::eq(copy (_3.0: &str), const "b") -> [return: bb8, unwind: bb19];
     }
 
     bb6: {
-        switchInt((_3.1: bool)) -> [0: bb1, otherwise: bb7];
+        switchInt(copy (_3.1: bool)) -> [0: bb1, otherwise: bb7];
     }
 
     bb7: {
diff --git a/tests/mir-opt/building/match/sort_candidates.disjoint_ranges.SimplifyCfg-initial.after.mir b/tests/mir-opt/building/match/sort_candidates.disjoint_ranges.SimplifyCfg-initial.after.mir
index e521fb4509aa1..d625168081435 100644
--- a/tests/mir-opt/building/match/sort_candidates.disjoint_ranges.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/building/match/sort_candidates.disjoint_ranges.SimplifyCfg-initial.after.mir
@@ -13,7 +13,7 @@ fn disjoint_ranges(_1: i32, _2: bool) -> u32 {
 
     bb0: {
         PlaceMention(_1);
-        _6 = Le(const 0_i32, _1);
+        _6 = Le(const 0_i32, copy _1);
         switchInt(move _6) -> [0: bb3, otherwise: bb8];
     }
 
@@ -27,7 +27,7 @@ fn disjoint_ranges(_1: i32, _2: bool) -> u32 {
     }
 
     bb3: {
-        _4 = Le(const 10_i32, _1);
+        _4 = Le(const 10_i32, copy _1);
         switchInt(move _4) -> [0: bb5, otherwise: bb7];
     }
 
@@ -36,7 +36,7 @@ fn disjoint_ranges(_1: i32, _2: bool) -> u32 {
     }
 
     bb5: {
-        switchInt(_1) -> [4294967295: bb6, otherwise: bb1];
+        switchInt(copy _1) -> [4294967295: bb6, otherwise: bb1];
     }
 
     bb6: {
@@ -44,12 +44,12 @@ fn disjoint_ranges(_1: i32, _2: bool) -> u32 {
     }
 
     bb7: {
-        _5 = Le(_1, const 20_i32);
+        _5 = Le(copy _1, const 20_i32);
         switchInt(move _5) -> [0: bb5, otherwise: bb4];
     }
 
     bb8: {
-        _7 = Lt(_1, const 10_i32);
+        _7 = Lt(copy _1, const 10_i32);
         switchInt(move _7) -> [0: bb3, otherwise: bb2];
     }
 
@@ -66,7 +66,7 @@ fn disjoint_ranges(_1: i32, _2: bool) -> u32 {
     bb11: {
         _3 = &fake shallow _1;
         StorageLive(_8);
-        _8 = _2;
+        _8 = copy _2;
         switchInt(move _8) -> [0: bb13, otherwise: bb12];
     }
 
diff --git a/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir b/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir
index 1855bb0787d2a..296d71a319d1b 100644
--- a/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir
+++ b/tests/mir-opt/building/receiver_ptr_mutability.main.built.after.mir
@@ -38,7 +38,7 @@ fn main() -> () {
         StorageLive(_2);
         StorageLive(_3);
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         _3 = move _4 as *const Test (PointerCoercion(MutToConstPointer));
         StorageDead(_4);
         _2 = Test::x(move _3) -> [return: bb2, unwind: bb4];
@@ -63,7 +63,7 @@ fn main() -> () {
         StorageLive(_10);
         StorageLive(_11);
         StorageLive(_12);
-        _12 = (*(*(*(*_5))));
+        _12 = copy (*(*(*(*_5))));
         _11 = move _12 as *const Test (PointerCoercion(MutToConstPointer));
         StorageDead(_12);
         _10 = Test::x(move _11) -> [return: bb3, unwind: bb4];
diff --git a/tests/mir-opt/building/shifts.shift_signed.built.after.mir b/tests/mir-opt/building/shifts.shift_signed.built.after.mir
index 8706ee9d44636..65e2db300cdea 100644
--- a/tests/mir-opt/building/shifts.shift_signed.built.after.mir
+++ b/tests/mir-opt/building/shifts.shift_signed.built.after.mir
@@ -44,12 +44,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128;
         StorageLive(_6);
         StorageLive(_7);
         StorageLive(_8);
-        _8 = _1;
+        _8 = copy _1;
         StorageLive(_9);
-        _9 = _3;
-        _10 = _9 as u8 (IntToInt);
+        _9 = copy _3;
+        _10 = copy _9 as u8 (IntToInt);
         _11 = Lt(move _10, const 8_u8);
-        assert(move _11, "attempt to shift right by `{}`, which would overflow", _9) -> [success: bb1, unwind: bb7];
+        assert(move _11, "attempt to shift right by `{}`, which would overflow", copy _9) -> [success: bb1, unwind: bb7];
     }
 
     bb1: {
@@ -58,12 +58,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128;
         StorageDead(_8);
         StorageLive(_12);
         StorageLive(_13);
-        _13 = _1;
+        _13 = copy _1;
         StorageLive(_14);
-        _14 = _4;
-        _15 = _14 as u32 (IntToInt);
+        _14 = copy _4;
+        _15 = copy _14 as u32 (IntToInt);
         _16 = Lt(move _15, const 8_u32);
-        assert(move _16, "attempt to shift right by `{}`, which would overflow", _14) -> [success: bb2, unwind: bb7];
+        assert(move _16, "attempt to shift right by `{}`, which would overflow", copy _14) -> [success: bb2, unwind: bb7];
     }
 
     bb2: {
@@ -72,12 +72,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128;
         StorageDead(_13);
         StorageLive(_17);
         StorageLive(_18);
-        _18 = _1;
+        _18 = copy _1;
         StorageLive(_19);
-        _19 = _5;
-        _20 = _19 as u128 (IntToInt);
+        _19 = copy _5;
+        _20 = copy _19 as u128 (IntToInt);
         _21 = Lt(move _20, const 8_u128);
-        assert(move _21, "attempt to shift right by `{}`, which would overflow", _19) -> [success: bb3, unwind: bb7];
+        assert(move _21, "attempt to shift right by `{}`, which would overflow", copy _19) -> [success: bb3, unwind: bb7];
     }
 
     bb3: {
@@ -91,12 +91,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128;
         StorageLive(_22);
         StorageLive(_23);
         StorageLive(_24);
-        _24 = _2;
+        _24 = copy _2;
         StorageLive(_25);
-        _25 = _3;
-        _26 = _25 as u8 (IntToInt);
+        _25 = copy _3;
+        _26 = copy _25 as u8 (IntToInt);
         _27 = Lt(move _26, const 128_u8);
-        assert(move _27, "attempt to shift left by `{}`, which would overflow", _25) -> [success: bb4, unwind: bb7];
+        assert(move _27, "attempt to shift left by `{}`, which would overflow", copy _25) -> [success: bb4, unwind: bb7];
     }
 
     bb4: {
@@ -105,12 +105,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128;
         StorageDead(_24);
         StorageLive(_28);
         StorageLive(_29);
-        _29 = _2;
+        _29 = copy _2;
         StorageLive(_30);
-        _30 = _4;
-        _31 = _30 as u32 (IntToInt);
+        _30 = copy _4;
+        _31 = copy _30 as u32 (IntToInt);
         _32 = Lt(move _31, const 128_u32);
-        assert(move _32, "attempt to shift left by `{}`, which would overflow", _30) -> [success: bb5, unwind: bb7];
+        assert(move _32, "attempt to shift left by `{}`, which would overflow", copy _30) -> [success: bb5, unwind: bb7];
     }
 
     bb5: {
@@ -119,12 +119,12 @@ fn shift_signed(_1: i8, _2: u128, _3: i8, _4: i32, _5: i128) -> ([i8; 3], [u128;
         StorageDead(_29);
         StorageLive(_33);
         StorageLive(_34);
-        _34 = _2;
+        _34 = copy _2;
         StorageLive(_35);
-        _35 = _5;
-        _36 = _35 as u128 (IntToInt);
+        _35 = copy _5;
+        _36 = copy _35 as u128 (IntToInt);
         _37 = Lt(move _36, const 128_u128);
-        assert(move _37, "attempt to shift left by `{}`, which would overflow", _35) -> [success: bb6, unwind: bb7];
+        assert(move _37, "attempt to shift left by `{}`, which would overflow", copy _35) -> [success: bb6, unwind: bb7];
     }
 
     bb6: {
diff --git a/tests/mir-opt/building/shifts.shift_unsigned.built.after.mir b/tests/mir-opt/building/shifts.shift_unsigned.built.after.mir
index dfd3b5b35ad59..62536833e4914 100644
--- a/tests/mir-opt/building/shifts.shift_unsigned.built.after.mir
+++ b/tests/mir-opt/building/shifts.shift_unsigned.built.after.mir
@@ -38,11 +38,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12
         StorageLive(_6);
         StorageLive(_7);
         StorageLive(_8);
-        _8 = _1;
+        _8 = copy _1;
         StorageLive(_9);
-        _9 = _3;
-        _10 = Lt(_9, const 8_u8);
-        assert(move _10, "attempt to shift right by `{}`, which would overflow", _9) -> [success: bb1, unwind: bb7];
+        _9 = copy _3;
+        _10 = Lt(copy _9, const 8_u8);
+        assert(move _10, "attempt to shift right by `{}`, which would overflow", copy _9) -> [success: bb1, unwind: bb7];
     }
 
     bb1: {
@@ -51,11 +51,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12
         StorageDead(_8);
         StorageLive(_11);
         StorageLive(_12);
-        _12 = _1;
+        _12 = copy _1;
         StorageLive(_13);
-        _13 = _4;
-        _14 = Lt(_13, const 8_u32);
-        assert(move _14, "attempt to shift right by `{}`, which would overflow", _13) -> [success: bb2, unwind: bb7];
+        _13 = copy _4;
+        _14 = Lt(copy _13, const 8_u32);
+        assert(move _14, "attempt to shift right by `{}`, which would overflow", copy _13) -> [success: bb2, unwind: bb7];
     }
 
     bb2: {
@@ -64,11 +64,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12
         StorageDead(_12);
         StorageLive(_15);
         StorageLive(_16);
-        _16 = _1;
+        _16 = copy _1;
         StorageLive(_17);
-        _17 = _5;
-        _18 = Lt(_17, const 8_u128);
-        assert(move _18, "attempt to shift right by `{}`, which would overflow", _17) -> [success: bb3, unwind: bb7];
+        _17 = copy _5;
+        _18 = Lt(copy _17, const 8_u128);
+        assert(move _18, "attempt to shift right by `{}`, which would overflow", copy _17) -> [success: bb3, unwind: bb7];
     }
 
     bb3: {
@@ -82,11 +82,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12
         StorageLive(_19);
         StorageLive(_20);
         StorageLive(_21);
-        _21 = _2;
+        _21 = copy _2;
         StorageLive(_22);
-        _22 = _3;
-        _23 = Lt(_22, const 128_u8);
-        assert(move _23, "attempt to shift left by `{}`, which would overflow", _22) -> [success: bb4, unwind: bb7];
+        _22 = copy _3;
+        _23 = Lt(copy _22, const 128_u8);
+        assert(move _23, "attempt to shift left by `{}`, which would overflow", copy _22) -> [success: bb4, unwind: bb7];
     }
 
     bb4: {
@@ -95,11 +95,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12
         StorageDead(_21);
         StorageLive(_24);
         StorageLive(_25);
-        _25 = _2;
+        _25 = copy _2;
         StorageLive(_26);
-        _26 = _4;
-        _27 = Lt(_26, const 128_u32);
-        assert(move _27, "attempt to shift left by `{}`, which would overflow", _26) -> [success: bb5, unwind: bb7];
+        _26 = copy _4;
+        _27 = Lt(copy _26, const 128_u32);
+        assert(move _27, "attempt to shift left by `{}`, which would overflow", copy _26) -> [success: bb5, unwind: bb7];
     }
 
     bb5: {
@@ -108,11 +108,11 @@ fn shift_unsigned(_1: u8, _2: i128, _3: u8, _4: u32, _5: u128) -> ([u8; 3], [i12
         StorageDead(_25);
         StorageLive(_28);
         StorageLive(_29);
-        _29 = _2;
+        _29 = copy _2;
         StorageLive(_30);
-        _30 = _5;
-        _31 = Lt(_30, const 128_u128);
-        assert(move _31, "attempt to shift left by `{}`, which would overflow", _30) -> [success: bb6, unwind: bb7];
+        _30 = copy _5;
+        _31 = Lt(copy _30, const 128_u128);
+        assert(move _31, "attempt to shift left by `{}`, which would overflow", copy _30) -> [success: bb6, unwind: bb7];
     }
 
     bb6: {
diff --git a/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-abort.mir
index 26c82edf2d5fd..44a8b7342b2e4 100644
--- a/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-abort.mir
@@ -20,7 +20,7 @@ fn while_loop(_1: bool) -> () {
     bb1: {
         StorageLive(_3);
         StorageLive(_2);
-        _2 = _1;
+        _2 = copy _1;
         _3 = get_bool(move _2) -> [return: bb2, unwind unreachable];
     }
 
@@ -40,7 +40,7 @@ fn while_loop(_1: bool) -> () {
         StorageDead(_2);
         StorageLive(_5);
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         _5 = get_bool(move _4) -> [return: bb5, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-unwind.mir
index 1bb72074846e7..9a6403006744d 100644
--- a/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/building/while_storage.while_loop.PreCodegen.after.panic-unwind.mir
@@ -20,7 +20,7 @@ fn while_loop(_1: bool) -> () {
     bb1: {
         StorageLive(_3);
         StorageLive(_2);
-        _2 = _1;
+        _2 = copy _1;
         _3 = get_bool(move _2) -> [return: bb2, unwind continue];
     }
 
@@ -40,7 +40,7 @@ fn while_loop(_1: bool) -> () {
         StorageDead(_2);
         StorageLive(_5);
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         _5 = get_bool(move _4) -> [return: bb5, unwind continue];
     }
 
diff --git a/tests/mir-opt/const_allocation.main.GVN.after.32bit.mir b/tests/mir-opt/const_allocation.main.GVN.after.32bit.mir
index 10d99a1346332..a2bd2bc0d92ab 100644
--- a/tests/mir-opt/const_allocation.main.GVN.after.32bit.mir
+++ b/tests/mir-opt/const_allocation.main.GVN.after.32bit.mir
@@ -9,7 +9,7 @@ fn main() -> () {
         StorageLive(_1);
         StorageLive(_2);
         _2 = const {ALLOC9: &&[(Option<i32>, &[&str])]};
-        _1 = (*_2);
+        _1 = copy (*_2);
         StorageDead(_2);
         StorageDead(_1);
         _0 = const ();
diff --git a/tests/mir-opt/const_allocation.main.GVN.after.64bit.mir b/tests/mir-opt/const_allocation.main.GVN.after.64bit.mir
index 2f23dbe9ee4fb..a431104d08bec 100644
--- a/tests/mir-opt/const_allocation.main.GVN.after.64bit.mir
+++ b/tests/mir-opt/const_allocation.main.GVN.after.64bit.mir
@@ -9,7 +9,7 @@ fn main() -> () {
         StorageLive(_1);
         StorageLive(_2);
         _2 = const {ALLOC9: &&[(Option<i32>, &[&str])]};
-        _1 = (*_2);
+        _1 = copy (*_2);
         StorageDead(_2);
         StorageDead(_1);
         _0 = const ();
diff --git a/tests/mir-opt/const_allocation2.main.GVN.after.32bit.mir b/tests/mir-opt/const_allocation2.main.GVN.after.32bit.mir
index 6499e3676aaa4..6fae163f1079f 100644
--- a/tests/mir-opt/const_allocation2.main.GVN.after.32bit.mir
+++ b/tests/mir-opt/const_allocation2.main.GVN.after.32bit.mir
@@ -9,7 +9,7 @@ fn main() -> () {
         StorageLive(_1);
         StorageLive(_2);
         _2 = const {ALLOC9: &&[(Option<i32>, &[&u8])]};
-        _1 = (*_2);
+        _1 = copy (*_2);
         StorageDead(_2);
         StorageDead(_1);
         _0 = const ();
diff --git a/tests/mir-opt/const_allocation2.main.GVN.after.64bit.mir b/tests/mir-opt/const_allocation2.main.GVN.after.64bit.mir
index 02f5ebab84772..f2bb5f46b16e5 100644
--- a/tests/mir-opt/const_allocation2.main.GVN.after.64bit.mir
+++ b/tests/mir-opt/const_allocation2.main.GVN.after.64bit.mir
@@ -9,7 +9,7 @@ fn main() -> () {
         StorageLive(_1);
         StorageLive(_2);
         _2 = const {ALLOC9: &&[(Option<i32>, &[&u8])]};
-        _1 = (*_2);
+        _1 = copy (*_2);
         StorageDead(_2);
         StorageDead(_1);
         _0 = const ();
diff --git a/tests/mir-opt/const_allocation3.main.GVN.after.32bit.mir b/tests/mir-opt/const_allocation3.main.GVN.after.32bit.mir
index c95e696946a6d..58776b446fa79 100644
--- a/tests/mir-opt/const_allocation3.main.GVN.after.32bit.mir
+++ b/tests/mir-opt/const_allocation3.main.GVN.after.32bit.mir
@@ -9,7 +9,7 @@ fn main() -> () {
         StorageLive(_1);
         StorageLive(_2);
         _2 = const {ALLOC4: &&Packed};
-        _1 = (*_2);
+        _1 = copy (*_2);
         StorageDead(_2);
         StorageDead(_1);
         _0 = const ();
diff --git a/tests/mir-opt/const_allocation3.main.GVN.after.64bit.mir b/tests/mir-opt/const_allocation3.main.GVN.after.64bit.mir
index 198bc8bd07ef1..3ccf4211971c5 100644
--- a/tests/mir-opt/const_allocation3.main.GVN.after.64bit.mir
+++ b/tests/mir-opt/const_allocation3.main.GVN.after.64bit.mir
@@ -9,7 +9,7 @@ fn main() -> () {
         StorageLive(_1);
         StorageLive(_2);
         _2 = const {ALLOC2: &&Packed};
-        _1 = (*_2);
+        _1 = copy (*_2);
         StorageDead(_2);
         StorageDead(_1);
         _0 = const ();
diff --git a/tests/mir-opt/const_goto_const_eval_fail.f.JumpThreading.diff b/tests/mir-opt/const_goto_const_eval_fail.f.JumpThreading.diff
index 4fc9254b7baed..086abeba0f848 100644
--- a/tests/mir-opt/const_goto_const_eval_fail.f.JumpThreading.diff
+++ b/tests/mir-opt/const_goto_const_eval_fail.f.JumpThreading.diff
@@ -22,7 +22,7 @@
       }
   
       bb3: {
-          switchInt(_1) -> [0: bb5, otherwise: bb4];
+          switchInt(copy _1) -> [0: bb5, otherwise: bb4];
       }
   
       bb4: {
diff --git a/tests/mir-opt/const_prop/address_of_pair.fn0.GVN.diff b/tests/mir-opt/const_prop/address_of_pair.fn0.GVN.diff
index ac372f837268b..e33185f17bcf7 100644
--- a/tests/mir-opt/const_prop/address_of_pair.fn0.GVN.diff
+++ b/tests/mir-opt/const_prop/address_of_pair.fn0.GVN.diff
@@ -34,10 +34,10 @@
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
-          _6 = (_2.1: bool);
+          _6 = copy (_2.1: bool);
           _5 = Not(move _6);
           StorageDead(_6);
-          _0 = _5;
+          _0 = copy _5;
 -         StorageDead(_5);
 +         nop;
           StorageDead(_3);
diff --git a/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-abort.diff b/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-abort.diff
index 4f0f7fa8fa274..c6d3bad0790c4 100644
--- a/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-abort.diff
@@ -24,11 +24,11 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = (const 0_i32, move _5);
-+         _4 = (const 0_i32, _1);
++         _4 = (const 0_i32, copy _1);
           StorageDead(_5);
--         _3 = (_4.0: i32);
+-         _3 = copy (_4.0: i32);
 -         _2 = Add(move _3, const 1_i32);
 +         _3 = const 0_i32;
 +         _2 = const 1_i32;
@@ -38,11 +38,11 @@
           StorageLive(_7);
           StorageLive(_8);
           StorageLive(_9);
-          _9 = _1;
+          _9 = copy _1;
 -         _8 = (move _9, const 1_i32);
-+         _8 = (_1, const 1_i32);
++         _8 = (copy _1, const 1_i32);
           StorageDead(_9);
--         _7 = (_8.1: i32);
+-         _7 = copy (_8.1: i32);
 -         _6 = Add(move _7, const 2_i32);
 +         _7 = const 1_i32;
 +         _6 = const 3_i32;
diff --git a/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-unwind.diff
index 4f0f7fa8fa274..c6d3bad0790c4 100644
--- a/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/aggregate.foo.GVN.panic-unwind.diff
@@ -24,11 +24,11 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = (const 0_i32, move _5);
-+         _4 = (const 0_i32, _1);
++         _4 = (const 0_i32, copy _1);
           StorageDead(_5);
--         _3 = (_4.0: i32);
+-         _3 = copy (_4.0: i32);
 -         _2 = Add(move _3, const 1_i32);
 +         _3 = const 0_i32;
 +         _2 = const 1_i32;
@@ -38,11 +38,11 @@
           StorageLive(_7);
           StorageLive(_8);
           StorageLive(_9);
-          _9 = _1;
+          _9 = copy _1;
 -         _8 = (move _9, const 1_i32);
-+         _8 = (_1, const 1_i32);
++         _8 = (copy _1, const 1_i32);
           StorageDead(_9);
--         _7 = (_8.1: i32);
+-         _7 = copy (_8.1: i32);
 -         _6 = Add(move _7, const 2_i32);
 +         _7 = const 1_i32;
 +         _6 = const 3_i32;
diff --git a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff
index 854e27445afb9..0a59c59c2ed2c 100644
--- a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff
@@ -18,7 +18,7 @@
           StorageLive(_2);
           StorageLive(_3);
           _3 = (const 0_i32, const 1_u8, const 2_i32);
--         _2 = (_3.1: u8);
+-         _2 = copy (_3.1: u8);
 -         _1 = Add(move _2, const 0_u8);
 +         _2 = const 1_u8;
 +         _1 = const 1_u8;
@@ -26,7 +26,7 @@
           StorageDead(_3);
           StorageLive(_4);
           StorageLive(_5);
--         _5 = _1;
+-         _5 = copy _1;
 -         _4 = foo(move _5) -> [return: bb1, unwind unreachable];
 +         _5 = const 1_u8;
 +         _4 = foo(const 1_u8) -> [return: bb1, unwind unreachable];
diff --git a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff
index f6c4b2c924097..100369a2eee31 100644
--- a/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff
@@ -18,7 +18,7 @@
           StorageLive(_2);
           StorageLive(_3);
           _3 = (const 0_i32, const 1_u8, const 2_i32);
--         _2 = (_3.1: u8);
+-         _2 = copy (_3.1: u8);
 -         _1 = Add(move _2, const 0_u8);
 +         _2 = const 1_u8;
 +         _1 = const 1_u8;
@@ -26,7 +26,7 @@
           StorageDead(_3);
           StorageLive(_4);
           StorageLive(_5);
--         _5 = _1;
+-         _5 = copy _1;
 -         _4 = foo(move _5) -> [return: bb1, unwind continue];
 +         _5 = const 1_u8;
 +         _4 = foo(const 1_u8) -> [return: bb1, unwind continue];
diff --git a/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-abort.diff
index 6d00dd5b21260..e754af95ce399 100644
--- a/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-abort.diff
@@ -19,15 +19,15 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable];
 +         _4 = const 4_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = _2[_3];
+-         _1 = copy _2[_3];
 +         _1 = const 2_u32;
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-unwind.diff
index 7e2f72ab31bce..e15a35c7fe945 100644
--- a/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-unwind.diff
@@ -19,15 +19,15 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue];
 +         _4 = const 4_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = _2[_3];
+-         _1 = copy _2[_3];
 +         _1 = const 2_u32;
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-abort.diff
index 6d00dd5b21260..e754af95ce399 100644
--- a/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-abort.diff
@@ -19,15 +19,15 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable];
 +         _4 = const 4_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = _2[_3];
+-         _1 = copy _2[_3];
 +         _1 = const 2_u32;
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-unwind.diff
index 7e2f72ab31bce..e15a35c7fe945 100644
--- a/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/array_index.main.GVN.64bit.panic-unwind.diff
@@ -19,15 +19,15 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue];
 +         _4 = const 4_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = _2[_3];
+-         _1 = copy _2[_3];
 +         _1 = const 2_u32;
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff
index 4838efba6f9d1..8c535b567c328 100644
--- a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-abort.diff
@@ -23,8 +23,8 @@
           _1 = const 0_i32;
           StorageLive(_2);
           StorageLive(_3);
--         _3 = _1;
--         _4 = Eq(_3, const 0_i32);
+-         _3 = copy _1;
+-         _4 = Eq(copy _3, const 0_i32);
 -         assert(!move _4, "attempt to divide `{}` by zero", const 1_i32) -> [success: bb1, unwind unreachable];
 +         _3 = const 0_i32;
 +         _4 = const true;
@@ -32,10 +32,10 @@
       }
   
       bb1: {
--         _5 = Eq(_3, const -1_i32);
+-         _5 = Eq(copy _3, const -1_i32);
 -         _6 = Eq(const 1_i32, const i32::MIN);
 -         _7 = BitAnd(move _5, move _6);
--         assert(!move _7, "attempt to compute `{} / {}`, which would overflow", const 1_i32, _3) -> [success: bb2, unwind unreachable];
+-         assert(!move _7, "attempt to compute `{} / {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind unreachable];
 +         _5 = const false;
 +         _6 = const false;
 +         _7 = const false;
diff --git a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff
index 7f403d6efc103..045f4d81db62e 100644
--- a/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/bad_op_div_by_zero.main.GVN.panic-unwind.diff
@@ -23,8 +23,8 @@
           _1 = const 0_i32;
           StorageLive(_2);
           StorageLive(_3);
--         _3 = _1;
--         _4 = Eq(_3, const 0_i32);
+-         _3 = copy _1;
+-         _4 = Eq(copy _3, const 0_i32);
 -         assert(!move _4, "attempt to divide `{}` by zero", const 1_i32) -> [success: bb1, unwind continue];
 +         _3 = const 0_i32;
 +         _4 = const true;
@@ -32,10 +32,10 @@
       }
   
       bb1: {
--         _5 = Eq(_3, const -1_i32);
+-         _5 = Eq(copy _3, const -1_i32);
 -         _6 = Eq(const 1_i32, const i32::MIN);
 -         _7 = BitAnd(move _5, move _6);
--         assert(!move _7, "attempt to compute `{} / {}`, which would overflow", const 1_i32, _3) -> [success: bb2, unwind continue];
+-         assert(!move _7, "attempt to compute `{} / {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind continue];
 +         _5 = const false;
 +         _6 = const false;
 +         _7 = const false;
diff --git a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff
index 59f2eb86f5095..e5a8726b855c4 100644
--- a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-abort.diff
@@ -23,8 +23,8 @@
           _1 = const 0_i32;
           StorageLive(_2);
           StorageLive(_3);
--         _3 = _1;
--         _4 = Eq(_3, const 0_i32);
+-         _3 = copy _1;
+-         _4 = Eq(copy _3, const 0_i32);
 -         assert(!move _4, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_i32) -> [success: bb1, unwind unreachable];
 +         _3 = const 0_i32;
 +         _4 = const true;
@@ -32,10 +32,10 @@
       }
   
       bb1: {
--         _5 = Eq(_3, const -1_i32);
+-         _5 = Eq(copy _3, const -1_i32);
 -         _6 = Eq(const 1_i32, const i32::MIN);
 -         _7 = BitAnd(move _5, move _6);
--         assert(!move _7, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, _3) -> [success: bb2, unwind unreachable];
+-         assert(!move _7, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind unreachable];
 +         _5 = const false;
 +         _6 = const false;
 +         _7 = const false;
diff --git a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff
index 9b866082788cd..1110ff186dc6e 100644
--- a/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/bad_op_mod_by_zero.main.GVN.panic-unwind.diff
@@ -23,8 +23,8 @@
           _1 = const 0_i32;
           StorageLive(_2);
           StorageLive(_3);
--         _3 = _1;
--         _4 = Eq(_3, const 0_i32);
+-         _3 = copy _1;
+-         _4 = Eq(copy _3, const 0_i32);
 -         assert(!move _4, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_i32) -> [success: bb1, unwind continue];
 +         _3 = const 0_i32;
 +         _4 = const true;
@@ -32,10 +32,10 @@
       }
   
       bb1: {
--         _5 = Eq(_3, const -1_i32);
+-         _5 = Eq(copy _3, const -1_i32);
 -         _6 = Eq(const 1_i32, const i32::MIN);
 -         _7 = BitAnd(move _5, move _6);
--         assert(!move _7, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, _3) -> [success: bb2, unwind continue];
+-         assert(!move _7, "attempt to compute the remainder of `{} % {}`, which would overflow", const 1_i32, copy _3) -> [success: bb2, unwind continue];
 +         _5 = const false;
 +         _6 = const false;
 +         _7 = const false;
diff --git a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-abort.diff
index 826f4c3427778..52aa4da49efaf 100644
--- a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-abort.diff
@@ -33,15 +33,15 @@
           StorageLive(_6);
           _6 = const 3_usize;
           _7 = Len((*_1));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable];
-+         _8 = Lt(const 3_usize, _7);
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable];
++         _8 = Lt(const 3_usize, copy _7);
 +         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, const 3_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _5 = (*_1)[_6];
-+         _5 = (*_1)[3 of 4];
+-         _5 = copy (*_1)[_6];
++         _5 = copy (*_1)[3 of 4];
           StorageDead(_6);
           _0 = const ();
           StorageDead(_5);
diff --git a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-unwind.diff
index 0e2ec65652f5c..242ff0e664f1d 100644
--- a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.32bit.panic-unwind.diff
@@ -33,15 +33,15 @@
           StorageLive(_6);
           _6 = const 3_usize;
           _7 = Len((*_1));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue];
-+         _8 = Lt(const 3_usize, _7);
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue];
++         _8 = Lt(const 3_usize, copy _7);
 +         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, const 3_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _5 = (*_1)[_6];
-+         _5 = (*_1)[3 of 4];
+-         _5 = copy (*_1)[_6];
++         _5 = copy (*_1)[3 of 4];
           StorageDead(_6);
           _0 = const ();
           StorageDead(_5);
diff --git a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-abort.diff
index 826f4c3427778..52aa4da49efaf 100644
--- a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-abort.diff
@@ -33,15 +33,15 @@
           StorageLive(_6);
           _6 = const 3_usize;
           _7 = Len((*_1));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable];
-+         _8 = Lt(const 3_usize, _7);
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable];
++         _8 = Lt(const 3_usize, copy _7);
 +         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, const 3_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _5 = (*_1)[_6];
-+         _5 = (*_1)[3 of 4];
+-         _5 = copy (*_1)[_6];
++         _5 = copy (*_1)[3 of 4];
           StorageDead(_6);
           _0 = const ();
           StorageDead(_5);
diff --git a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-unwind.diff
index 0e2ec65652f5c..242ff0e664f1d 100644
--- a/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/bad_op_unsafe_oob_for_slices.main.GVN.64bit.panic-unwind.diff
@@ -33,15 +33,15 @@
           StorageLive(_6);
           _6 = const 3_usize;
           _7 = Len((*_1));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue];
-+         _8 = Lt(const 3_usize, _7);
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue];
++         _8 = Lt(const 3_usize, copy _7);
 +         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, const 3_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _5 = (*_1)[_6];
-+         _5 = (*_1)[3 of 4];
+-         _5 = copy (*_1)[_6];
++         _5 = copy (*_1)[3 of 4];
           StorageDead(_6);
           _0 = const ();
           StorageDead(_5);
diff --git a/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff b/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff
index 0bd8413289e63..3fe70302b21cf 100644
--- a/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff
+++ b/tests/mir-opt/const_prop/boolean_identities.test.GVN.diff
@@ -22,22 +22,22 @@
 -         StorageLive(_3);
 +         nop;
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _3 = BitOr(move _4, const true);
 +         _3 = const true;
           StorageDead(_4);
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
 -         _5 = BitAnd(move _6, const false);
 +         _5 = const false;
           StorageDead(_6);
           StorageLive(_7);
--         _7 = _3;
+-         _7 = copy _3;
 +         _7 = const true;
           StorageLive(_8);
--         _8 = _5;
+-         _8 = copy _5;
 -         _0 = BitAnd(move _7, move _8);
 +         _8 = const false;
 +         _0 = const false;
diff --git a/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff
index a408c197fd143..d5f15b750d4ba 100644
--- a/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/boxes.main.GVN.panic-abort.diff
@@ -32,15 +32,15 @@
       bb1: {
           StorageLive(_7);
           _7 = ShallowInitBox(move _6, i32);
-          _8 = (((_7.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
+          _8 = copy (((_7.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
           (*_8) = const 42_i32;
           _3 = move _7;
           StorageDead(_7);
-          _9 = (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
-          _2 = (*_9);
+          _9 = copy (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
+          _2 = copy (*_9);
 -         _1 = Add(move _2, const 0_i32);
 -         StorageDead(_2);
-+         _1 = _2;
++         _1 = copy _2;
 +         nop;
           drop(_3) -> [return: bb2, unwind unreachable];
       }
diff --git a/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff
index 5706a739602ea..d4d4f21be6e02 100644
--- a/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/boxes.main.GVN.panic-unwind.diff
@@ -32,15 +32,15 @@
       bb1: {
           StorageLive(_7);
           _7 = ShallowInitBox(move _6, i32);
-          _8 = (((_7.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
+          _8 = copy (((_7.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
           (*_8) = const 42_i32;
           _3 = move _7;
           StorageDead(_7);
-          _9 = (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
-          _2 = (*_9);
+          _9 = copy (((_3.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
+          _2 = copy (*_9);
 -         _1 = Add(move _2, const 0_i32);
 -         StorageDead(_2);
-+         _1 = _2;
++         _1 = copy _2;
 +         nop;
           drop(_3) -> [return: bb2, unwind: bb3];
       }
diff --git a/tests/mir-opt/const_prop/discriminant.main.GVN.32bit.diff b/tests/mir-opt/const_prop/discriminant.main.GVN.32bit.diff
index 70c3c3fe7e495..2543cf6257d43 100644
--- a/tests/mir-opt/const_prop/discriminant.main.GVN.32bit.diff
+++ b/tests/mir-opt/const_prop/discriminant.main.GVN.32bit.diff
@@ -26,7 +26,7 @@
       }
   
       bb1: {
--         switchInt(((_3 as Some).0: bool)) -> [0: bb3, otherwise: bb2];
+-         switchInt(copy ((_3 as Some).0: bool)) -> [0: bb3, otherwise: bb2];
 +         switchInt(const true) -> [0: bb3, otherwise: bb2];
       }
   
diff --git a/tests/mir-opt/const_prop/discriminant.main.GVN.64bit.diff b/tests/mir-opt/const_prop/discriminant.main.GVN.64bit.diff
index 70c3c3fe7e495..2543cf6257d43 100644
--- a/tests/mir-opt/const_prop/discriminant.main.GVN.64bit.diff
+++ b/tests/mir-opt/const_prop/discriminant.main.GVN.64bit.diff
@@ -26,7 +26,7 @@
       }
   
       bb1: {
--         switchInt(((_3 as Some).0: bool)) -> [0: bb3, otherwise: bb2];
+-         switchInt(copy ((_3 as Some).0: bool)) -> [0: bb3, otherwise: bb2];
 +         switchInt(const true) -> [0: bb3, otherwise: bb2];
       }
   
diff --git a/tests/mir-opt/const_prop/indirect.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/indirect.main.GVN.panic-abort.diff
index f24b9755eaea6..208845942c76d 100644
--- a/tests/mir-opt/const_prop/indirect.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/indirect.main.GVN.panic-abort.diff
@@ -14,7 +14,7 @@
           StorageLive(_1);
           StorageLive(_2);
 -         _2 = const 2_u32 as u8 (IntToInt);
--         _3 = AddWithOverflow(_2, const 1_u8);
+-         _3 = AddWithOverflow(copy _2, const 1_u8);
 -         assert(!move (_3.1: bool), "attempt to compute `{} + {}`, which would overflow", move _2, const 1_u8) -> [success: bb1, unwind unreachable];
 +         _2 = const 2_u8;
 +         _3 = const (3_u8, false);
diff --git a/tests/mir-opt/const_prop/indirect.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/indirect.main.GVN.panic-unwind.diff
index 44ff313b5328b..4a7c69bae3ca8 100644
--- a/tests/mir-opt/const_prop/indirect.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/indirect.main.GVN.panic-unwind.diff
@@ -14,7 +14,7 @@
           StorageLive(_1);
           StorageLive(_2);
 -         _2 = const 2_u32 as u8 (IntToInt);
--         _3 = AddWithOverflow(_2, const 1_u8);
+-         _3 = AddWithOverflow(copy _2, const 1_u8);
 -         assert(!move (_3.1: bool), "attempt to compute `{} + {}`, which would overflow", move _2, const 1_u8) -> [success: bb1, unwind continue];
 +         _2 = const 2_u8;
 +         _3 = const (3_u8, false);
diff --git a/tests/mir-opt/const_prop/indirect_mutation.bar.GVN.diff b/tests/mir-opt/const_prop/indirect_mutation.bar.GVN.diff
index 99a6ba7d08abd..849a57e203061 100644
--- a/tests/mir-opt/const_prop/indirect_mutation.bar.GVN.diff
+++ b/tests/mir-opt/const_prop/indirect_mutation.bar.GVN.diff
@@ -28,7 +28,7 @@
           StorageDead(_2);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = (_1.0: i32);
+          _5 = copy (_1.0: i32);
           _4 = Eq(move _5, const 5_i32);
           StorageDead(_5);
           _0 = const ();
diff --git a/tests/mir-opt/const_prop/indirect_mutation.foo.GVN.diff b/tests/mir-opt/const_prop/indirect_mutation.foo.GVN.diff
index c21869dece65c..2435f81206bda 100644
--- a/tests/mir-opt/const_prop/indirect_mutation.foo.GVN.diff
+++ b/tests/mir-opt/const_prop/indirect_mutation.foo.GVN.diff
@@ -24,7 +24,7 @@
           StorageDead(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = (_1.0: i32);
+          _4 = copy (_1.0: i32);
           _3 = Eq(move _4, const 5_i32);
           StorageDead(_4);
           _0 = const ();
diff --git a/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-abort.diff
index de9cb7a47a2be..ab39c5be4e37d 100644
--- a/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-abort.diff
@@ -19,8 +19,8 @@
           StorageLive(_3);
           _3 = const 1_u8;
           StorageLive(_4);
--         _4 = AddWithOverflow(_2, _3);
--         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", _2, _3) -> [success: bb1, unwind unreachable];
+-         _4 = AddWithOverflow(copy _2, copy _3);
+-         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb1, unwind unreachable];
 +         _4 = const (0_u8, true);
 +         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb1, unwind unreachable];
       }
diff --git a/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-unwind.diff
index 1f19a13c1e8cf..1aea0dbb5d531 100644
--- a/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/inherit_overflow.main.GVN.panic-unwind.diff
@@ -19,8 +19,8 @@
           StorageLive(_3);
           _3 = const 1_u8;
           StorageLive(_4);
--         _4 = AddWithOverflow(_2, _3);
--         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", _2, _3) -> [success: bb1, unwind continue];
+-         _4 = AddWithOverflow(copy _2, copy _3);
+-         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb1, unwind continue];
 +         _4 = const (0_u8, true);
 +         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb1, unwind continue];
       }
diff --git a/tests/mir-opt/const_prop/invalid_constant.main.GVN.diff b/tests/mir-opt/const_prop/invalid_constant.main.GVN.diff
index f50413656049f..5e843da867923 100644
--- a/tests/mir-opt/const_prop/invalid_constant.main.GVN.diff
+++ b/tests/mir-opt/const_prop/invalid_constant.main.GVN.diff
@@ -29,13 +29,13 @@
           StorageLive(_1);
           StorageLive(_2);
           _2 = InvalidChar { int: const 1114113_u32 };
-          _1 = (_2.1: char);
+          _1 = copy (_2.1: char);
           StorageDead(_2);
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
           _5 = InvalidTag { int: const 4_u32 };
-          _4 = (_5.1: E);
+          _4 = copy (_5.1: E);
           _3 = [move _4];
           StorageDead(_4);
           StorageDead(_5);
diff --git a/tests/mir-opt/const_prop/invalid_constant.main.RemoveZsts.diff b/tests/mir-opt/const_prop/invalid_constant.main.RemoveZsts.diff
index 6e5ad8d6b81ac..6593b329756c2 100644
--- a/tests/mir-opt/const_prop/invalid_constant.main.RemoveZsts.diff
+++ b/tests/mir-opt/const_prop/invalid_constant.main.RemoveZsts.diff
@@ -31,13 +31,13 @@
           StorageLive(_1);
           StorageLive(_2);
           _2 = InvalidChar { int: const 1114113_u32 };
-          _1 = (_2.1: char);
+          _1 = copy (_2.1: char);
           StorageDead(_2);
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
           _5 = InvalidTag { int: const 4_u32 };
-          _4 = (_5.1: E);
+          _4 = copy (_5.1: E);
           _3 = [move _4];
           StorageDead(_4);
           StorageDead(_5);
@@ -47,7 +47,7 @@
 +         nop;
           StorageLive(_8);
           _8 = NoVariants { int: const 0_u32 };
--         _7 = (_8.1: Empty);
+-         _7 = copy (_8.1: Empty);
 -         _6 = [move _7];
 -         StorageDead(_7);
 +         nop;
diff --git a/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-abort.diff
index bd987c01ab16f..49ea51deed69d 100644
--- a/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-abort.diff
@@ -19,15 +19,15 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable];
 +         _4 = const 5000_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = _2[_3];
+-         _1 = copy _2[_3];
 +         _1 = const 0_u8;
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-unwind.diff
index e9ebef84ae048..103bfbcaf6426 100644
--- a/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/large_array_index.main.GVN.32bit.panic-unwind.diff
@@ -19,15 +19,15 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue];
 +         _4 = const 5000_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = _2[_3];
+-         _1 = copy _2[_3];
 +         _1 = const 0_u8;
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-abort.diff
index bd987c01ab16f..49ea51deed69d 100644
--- a/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-abort.diff
@@ -19,15 +19,15 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable];
 +         _4 = const 5000_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = _2[_3];
+-         _1 = copy _2[_3];
 +         _1 = const 0_u8;
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-unwind.diff
index e9ebef84ae048..103bfbcaf6426 100644
--- a/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/large_array_index.main.GVN.64bit.panic-unwind.diff
@@ -19,15 +19,15 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue];
 +         _4 = const 5000_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = _2[_3];
+-         _1 = copy _2[_3];
 +         _1 = const 0_u8;
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff b/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff
index 6c2aab45d48b5..290d9d62ce027 100644
--- a/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff
+++ b/tests/mir-opt/const_prop/mult_by_zero.test.GVN.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         _0 = Mul(move _2, const 0_i32);
 +         _0 = const 0_i32;
           StorageDead(_2);
diff --git a/tests/mir-opt/const_prop/mutable_variable.main.GVN.diff b/tests/mir-opt/const_prop/mutable_variable.main.GVN.diff
index 11464e3240028..cc25b6caf90d9 100644
--- a/tests/mir-opt/const_prop/mutable_variable.main.GVN.diff
+++ b/tests/mir-opt/const_prop/mutable_variable.main.GVN.diff
@@ -17,7 +17,7 @@
           _1 = const 42_i32;
           _1 = const 99_i32;
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           _0 = const ();
           StorageDead(_2);
           StorageDead(_1);
diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate.main.GVN.diff b/tests/mir-opt/const_prop/mutable_variable_aggregate.main.GVN.diff
index 7584353620ec5..3cc71eee710bb 100644
--- a/tests/mir-opt/const_prop/mutable_variable_aggregate.main.GVN.diff
+++ b/tests/mir-opt/const_prop/mutable_variable_aggregate.main.GVN.diff
@@ -18,7 +18,7 @@
 +         _1 = const (42_i32, 43_i32);
           (_1.1: i32) = const 99_i32;
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           _0 = const ();
           StorageDead(_2);
           StorageDead(_1);
diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.main.GVN.diff b/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.main.GVN.diff
index e16e2969eb895..569ad62b5cc5e 100644
--- a/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.main.GVN.diff
+++ b/tests/mir-opt/const_prop/mutable_variable_aggregate_mut_ref.main.GVN.diff
@@ -24,7 +24,7 @@
           _2 = &mut _1;
           ((*_2).1: i32) = const 99_i32;
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _0 = const ();
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-abort.diff
index 6480e480f8c58..5b4d18a3c070f 100644
--- a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-abort.diff
@@ -21,7 +21,7 @@
           (_1.1: i32) = const 99_i32;
           (_1.0: i32) = const 42_i32;
           StorageLive(_2);
-          _2 = (_1.1: i32);
+          _2 = copy (_1.1: i32);
           _0 = const ();
           StorageDead(_2);
           StorageDead(_1);
diff --git a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-unwind.diff
index fb757801082ee..d58febe368d10 100644
--- a/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/mutable_variable_aggregate_partial_read.main.GVN.panic-unwind.diff
@@ -21,7 +21,7 @@
           (_1.1: i32) = const 99_i32;
           (_1.0: i32) = const 42_i32;
           StorageLive(_2);
-          _2 = (_1.1: i32);
+          _2 = copy (_1.1: i32);
           _0 = const ();
           StorageDead(_2);
           StorageDead(_1);
diff --git a/tests/mir-opt/const_prop/mutable_variable_no_prop.main.GVN.diff b/tests/mir-opt/const_prop/mutable_variable_no_prop.main.GVN.diff
index 31c839f674900..3f8dc12f4ae57 100644
--- a/tests/mir-opt/const_prop/mutable_variable_no_prop.main.GVN.diff
+++ b/tests/mir-opt/const_prop/mutable_variable_no_prop.main.GVN.diff
@@ -22,14 +22,14 @@
           StorageLive(_3);
           StorageLive(_4);
           _4 = const {ALLOC0: *mut u32};
-          _3 = (*_4);
+          _3 = copy (*_4);
           _1 = move _3;
           StorageDead(_3);
           StorageDead(_4);
           _2 = const ();
           StorageDead(_2);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           _0 = const ();
           StorageDead(_5);
           StorageDead(_1);
diff --git a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff
index 19d79694666f2..7ca1b39d77110 100644
--- a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-abort.diff
@@ -32,14 +32,14 @@
 -         _2 = (const 1_i32, const 2_i32);
 +         _2 = const (1_i32, 2_i32);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         (_2.1: i32) = move _3;
-+         (_2.1: i32) = _1;
++         (_2.1: i32) = copy _1;
           StorageDead(_3);
           StorageLive(_4);
-          _4 = (_2.1: i32);
+          _4 = copy (_2.1: i32);
           StorageLive(_5);
-          _5 = (_2.0: i32);
+          _5 = copy (_2.0: i32);
           _0 = const ();
           StorageDead(_5);
           StorageDead(_4);
diff --git a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff
index 2bb277bf27f7f..f637951380664 100644
--- a/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/mutable_variable_unprop_assign.main.GVN.panic-unwind.diff
@@ -32,14 +32,14 @@
 -         _2 = (const 1_i32, const 2_i32);
 +         _2 = const (1_i32, 2_i32);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         (_2.1: i32) = move _3;
-+         (_2.1: i32) = _1;
++         (_2.1: i32) = copy _1;
           StorageDead(_3);
           StorageLive(_4);
-          _4 = (_2.1: i32);
+          _4 = copy (_2.1: i32);
           StorageLive(_5);
-          _5 = (_2.0: i32);
+          _5 = copy (_2.0: i32);
           _0 = const ();
           StorageDead(_5);
           StorageDead(_4);
diff --git a/tests/mir-opt/const_prop/overwrite_with_const_with_params.size_of.GVN.diff b/tests/mir-opt/const_prop/overwrite_with_const_with_params.size_of.GVN.diff
index 1eadffa4f3659..da6ef0a978b4e 100644
--- a/tests/mir-opt/const_prop/overwrite_with_const_with_params.size_of.GVN.diff
+++ b/tests/mir-opt/const_prop/overwrite_with_const_with_params.size_of.GVN.diff
@@ -12,7 +12,7 @@
           StorageLive(_1);
           _1 = const 0_usize;
           _1 = const SizeOfConst::<T>::SIZE;
-          _0 = _1;
+          _0 = copy _1;
           StorageDead(_1);
           return;
       }
diff --git a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff
index 79a95b618d17f..657fa7a5fea19 100644
--- a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-abort.diff
@@ -24,9 +24,9 @@
           StorageDead(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = read(move _5) -> [return: bb1, unwind unreachable];
-+         _4 = read(_1) -> [return: bb1, unwind unreachable];
++         _4 = read(copy _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff
index 9d1bcd92fef21..8fef6591d41d9 100644
--- a/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/pointer_expose_provenance.main.GVN.panic-unwind.diff
@@ -24,9 +24,9 @@
           StorageDead(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = read(move _5) -> [return: bb1, unwind continue];
-+         _4 = read(_1) -> [return: bb1, unwind continue];
++         _4 = read(copy _1) -> [return: bb1, unwind continue];
       }
   
       bb1: {
diff --git a/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff b/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff
index 38f235052303f..8df262b351f12 100644
--- a/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff
+++ b/tests/mir-opt/const_prop/read_immutable_static.main.GVN.diff
@@ -19,12 +19,12 @@
 +         nop;
 +         nop;
           _3 = const {ALLOC0: &u8};
--         _2 = (*_3);
+-         _2 = copy (*_3);
 +         _2 = const 2_u8;
           StorageLive(_4);
           StorageLive(_5);
           _5 = const {ALLOC0: &u8};
--         _4 = (*_5);
+-         _4 = copy (*_5);
 -         _1 = Add(move _2, move _4);
 +         _4 = const 2_u8;
 +         _1 = const 4_u8;
diff --git a/tests/mir-opt/const_prop/ref_deref.main.GVN.diff b/tests/mir-opt/const_prop/ref_deref.main.GVN.diff
index 509924a91c51d..b9e269266b0b1 100644
--- a/tests/mir-opt/const_prop/ref_deref.main.GVN.diff
+++ b/tests/mir-opt/const_prop/ref_deref.main.GVN.diff
@@ -16,7 +16,7 @@
           StorageLive(_2);
           _4 = const main::promoted[0];
           _2 = &(*_4);
--         _1 = (*_2);
+-         _1 = copy (*_2);
 +         _1 = const 4_i32;
           StorageDead(_2);
           _0 = const ();
diff --git a/tests/mir-opt/const_prop/ref_deref_project.main.GVN.diff b/tests/mir-opt/const_prop/ref_deref_project.main.GVN.diff
index 820c6cc068061..dcc13c9251c41 100644
--- a/tests/mir-opt/const_prop/ref_deref_project.main.GVN.diff
+++ b/tests/mir-opt/const_prop/ref_deref_project.main.GVN.diff
@@ -16,7 +16,7 @@
           StorageLive(_2);
           _4 = const main::promoted[0];
           _2 = &((*_4).1: i32);
--         _1 = (*_2);
+-         _1 = copy (*_2);
 +         _1 = const 5_i32;
           StorageDead(_2);
           _0 = const ();
diff --git a/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-abort.diff
index 71635b8e9c3e7..f7c1c2da01fc1 100644
--- a/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-abort.diff
@@ -21,15 +21,15 @@
           StorageLive(_4);
           _4 = const 2_usize;
 -         _5 = Len(_3);
--         _6 = Lt(_4, _5);
--         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind unreachable];
+-         _6 = Lt(copy _4, copy _5);
+-         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind unreachable];
 +         _5 = const 8_usize;
 +         _6 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _2 = _3[_4];
+-         _2 = copy _3[_4];
 -         _1 = Add(move _2, const 0_u32);
 +         _2 = const 42_u32;
 +         _1 = const 42_u32;
diff --git a/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-unwind.diff
index 84205028d6d2b..436773c855636 100644
--- a/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/repeat.main.GVN.32bit.panic-unwind.diff
@@ -21,15 +21,15 @@
           StorageLive(_4);
           _4 = const 2_usize;
 -         _5 = Len(_3);
--         _6 = Lt(_4, _5);
--         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind continue];
+-         _6 = Lt(copy _4, copy _5);
+-         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind continue];
 +         _5 = const 8_usize;
 +         _6 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _2 = _3[_4];
+-         _2 = copy _3[_4];
 -         _1 = Add(move _2, const 0_u32);
 +         _2 = const 42_u32;
 +         _1 = const 42_u32;
diff --git a/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-abort.diff
index 71635b8e9c3e7..f7c1c2da01fc1 100644
--- a/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-abort.diff
@@ -21,15 +21,15 @@
           StorageLive(_4);
           _4 = const 2_usize;
 -         _5 = Len(_3);
--         _6 = Lt(_4, _5);
--         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind unreachable];
+-         _6 = Lt(copy _4, copy _5);
+-         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind unreachable];
 +         _5 = const 8_usize;
 +         _6 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _2 = _3[_4];
+-         _2 = copy _3[_4];
 -         _1 = Add(move _2, const 0_u32);
 +         _2 = const 42_u32;
 +         _1 = const 42_u32;
diff --git a/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-unwind.diff
index 84205028d6d2b..436773c855636 100644
--- a/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/repeat.main.GVN.64bit.panic-unwind.diff
@@ -21,15 +21,15 @@
           StorageLive(_4);
           _4 = const 2_usize;
 -         _5 = Len(_3);
--         _6 = Lt(_4, _5);
--         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind continue];
+-         _6 = Lt(copy _4, copy _5);
+-         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind continue];
 +         _5 = const 8_usize;
 +         _6 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _2 = _3[_4];
+-         _2 = copy _3[_4];
 -         _1 = Add(move _2, const 0_u32);
 +         _2 = const 42_u32;
 +         _1 = const 42_u32;
diff --git a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff
index 0a20fb0e59ef0..3c73d34474c13 100644
--- a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-abort.diff
@@ -16,7 +16,7 @@
           _1 = const 1_u32;
           StorageLive(_2);
           StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 -         _2 = consume(move _3) -> [return: bb1, unwind unreachable];
 +         _3 = const 1_u32;
 +         _2 = consume(const 1_u32) -> [return: bb1, unwind unreachable];
diff --git a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff
index 8b9519d3adc49..0a7fddee39b62 100644
--- a/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/scalar_literal_propagation.main.GVN.panic-unwind.diff
@@ -16,7 +16,7 @@
           _1 = const 1_u32;
           StorageLive(_2);
           StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 -         _2 = consume(move _3) -> [return: bb1, unwind continue];
 +         _3 = const 1_u32;
 +         _2 = consume(const 1_u32) -> [return: bb1, unwind continue];
diff --git a/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-abort.diff
index 21d91d0320ae2..e834a5802c33f 100644
--- a/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-abort.diff
@@ -22,24 +22,24 @@
           StorageLive(_3);
           StorageLive(_4);
           _9 = const main::promoted[0];
-          _4 = _9;
--         _3 = _4;
+          _4 = copy _9;
+-         _3 = copy _4;
 -         _2 = move _3 as &[u32] (PointerCoercion(Unsize));
-+         _3 = _9;
-+         _2 = _9 as &[u32] (PointerCoercion(Unsize));
++         _3 = copy _9;
++         _2 = copy _9 as &[u32] (PointerCoercion(Unsize));
           StorageDead(_3);
           StorageLive(_6);
           _6 = const 1_usize;
 -         _7 = Len((*_2));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable];
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable];
 +         _7 = const 3_usize;
 +         _8 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = (*_2)[_6];
+-         _1 = copy (*_2)[_6];
 +         _1 = const 2_u32;
           StorageDead(_6);
           StorageDead(_4);
diff --git a/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-unwind.diff
index 889114c986236..55ffc50180569 100644
--- a/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/slice_len.main.GVN.32bit.panic-unwind.diff
@@ -22,24 +22,24 @@
           StorageLive(_3);
           StorageLive(_4);
           _9 = const main::promoted[0];
-          _4 = _9;
--         _3 = _4;
+          _4 = copy _9;
+-         _3 = copy _4;
 -         _2 = move _3 as &[u32] (PointerCoercion(Unsize));
-+         _3 = _9;
-+         _2 = _9 as &[u32] (PointerCoercion(Unsize));
++         _3 = copy _9;
++         _2 = copy _9 as &[u32] (PointerCoercion(Unsize));
           StorageDead(_3);
           StorageLive(_6);
           _6 = const 1_usize;
 -         _7 = Len((*_2));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue];
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue];
 +         _7 = const 3_usize;
 +         _8 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = (*_2)[_6];
+-         _1 = copy (*_2)[_6];
 +         _1 = const 2_u32;
           StorageDead(_6);
           StorageDead(_4);
diff --git a/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-abort.diff
index 21d91d0320ae2..e834a5802c33f 100644
--- a/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-abort.diff
@@ -22,24 +22,24 @@
           StorageLive(_3);
           StorageLive(_4);
           _9 = const main::promoted[0];
-          _4 = _9;
--         _3 = _4;
+          _4 = copy _9;
+-         _3 = copy _4;
 -         _2 = move _3 as &[u32] (PointerCoercion(Unsize));
-+         _3 = _9;
-+         _2 = _9 as &[u32] (PointerCoercion(Unsize));
++         _3 = copy _9;
++         _2 = copy _9 as &[u32] (PointerCoercion(Unsize));
           StorageDead(_3);
           StorageLive(_6);
           _6 = const 1_usize;
 -         _7 = Len((*_2));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable];
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable];
 +         _7 = const 3_usize;
 +         _8 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = (*_2)[_6];
+-         _1 = copy (*_2)[_6];
 +         _1 = const 2_u32;
           StorageDead(_6);
           StorageDead(_4);
diff --git a/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-unwind.diff
index 889114c986236..55ffc50180569 100644
--- a/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/slice_len.main.GVN.64bit.panic-unwind.diff
@@ -22,24 +22,24 @@
           StorageLive(_3);
           StorageLive(_4);
           _9 = const main::promoted[0];
-          _4 = _9;
--         _3 = _4;
+          _4 = copy _9;
+-         _3 = copy _4;
 -         _2 = move _3 as &[u32] (PointerCoercion(Unsize));
-+         _3 = _9;
-+         _2 = _9 as &[u32] (PointerCoercion(Unsize));
++         _3 = copy _9;
++         _2 = copy _9 as &[u32] (PointerCoercion(Unsize));
           StorageDead(_3);
           StorageLive(_6);
           _6 = const 1_usize;
 -         _7 = Len((*_2));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue];
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue];
 +         _7 = const 3_usize;
 +         _8 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = (*_2)[_6];
+-         _1 = copy (*_2)[_6];
 +         _1 = const 2_u32;
           StorageDead(_6);
           StorageDead(_4);
diff --git a/tests/mir-opt/const_prop/switch_int.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/switch_int.main.GVN.panic-abort.diff
index ee9f2d5c7f5bd..2339f110f5a1d 100644
--- a/tests/mir-opt/const_prop/switch_int.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/switch_int.main.GVN.panic-abort.diff
@@ -8,7 +8,7 @@
       bb0: {
           StorageLive(_1);
           _1 = const 1_i32;
--         switchInt(_1) -> [1: bb2, otherwise: bb1];
+-         switchInt(copy _1) -> [1: bb2, otherwise: bb1];
 +         switchInt(const 1_i32) -> [1: bb2, otherwise: bb1];
       }
   
diff --git a/tests/mir-opt/const_prop/switch_int.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/switch_int.main.GVN.panic-unwind.diff
index 143d04ac984bc..49082e6ba5260 100644
--- a/tests/mir-opt/const_prop/switch_int.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/switch_int.main.GVN.panic-unwind.diff
@@ -8,7 +8,7 @@
       bb0: {
           StorageLive(_1);
           _1 = const 1_i32;
--         switchInt(_1) -> [1: bb2, otherwise: bb1];
+-         switchInt(copy _1) -> [1: bb2, otherwise: bb1];
 +         switchInt(const 1_i32) -> [1: bb2, otherwise: bb1];
       }
   
diff --git a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff
index 7a289563c5069..de0b1a57f8080 100644
--- a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff
+++ b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff
@@ -12,7 +12,7 @@
       bb0: {
           StorageLive(_1);
 -         _1 = const 1_usize as std::boxed::Box<Never> (Transmute);
--         _2 = (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
+-         _2 = copy (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
 +         _1 = const Box::<Never>(Unique::<Never> {{ pointer: NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData::<Never> }}, std::alloc::Global);
 +         _2 = const {0x1 as *const Never};
           unreachable;
diff --git a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff
index 7a289563c5069..de0b1a57f8080 100644
--- a/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff
+++ b/tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff
@@ -12,7 +12,7 @@
       bb0: {
           StorageLive(_1);
 -         _1 = const 1_usize as std::boxed::Box<Never> (Transmute);
--         _2 = (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
+-         _2 = copy (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
 +         _1 = const Box::<Never>(Unique::<Never> {{ pointer: NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData::<Never> }}, std::alloc::Global);
 +         _2 = const {0x1 as *const Never};
           unreachable;
diff --git a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff
index bf8fece3d37b9..01d86ce8717d1 100644
--- a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-abort.diff
@@ -17,7 +17,7 @@
 +         _1 = const (1_u32, 2_u32);
           StorageLive(_2);
           StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 -         _2 = consume(move _3) -> [return: bb1, unwind unreachable];
 +         _3 = const (1_u32, 2_u32);
 +         _2 = consume(const (1_u32, 2_u32)) -> [return: bb1, unwind unreachable];
diff --git a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff
index 02a75849d8872..bd7d494212ce6 100644
--- a/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/const_prop/tuple_literal_propagation.main.GVN.panic-unwind.diff
@@ -17,7 +17,7 @@
 +         _1 = const (1_u32, 2_u32);
           StorageLive(_2);
           StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 -         _2 = consume(move _3) -> [return: bb1, unwind continue];
 +         _3 = const (1_u32, 2_u32);
 +         _2 = consume(const (1_u32, 2_u32)) -> [return: bb1, unwind continue];
diff --git a/tests/mir-opt/const_prop/while_let_loops.change_loop_body.GVN.diff b/tests/mir-opt/const_prop/while_let_loops.change_loop_body.GVN.diff
index 9548afc9d4027..f830624cae76e 100644
--- a/tests/mir-opt/const_prop/while_let_loops.change_loop_body.GVN.diff
+++ b/tests/mir-opt/const_prop/while_let_loops.change_loop_body.GVN.diff
@@ -30,7 +30,7 @@
       }
   
       bb1: {
--         switchInt(((_3 as Some).0: u32)) -> [0: bb2, otherwise: bb3];
+-         switchInt(copy ((_3 as Some).0: u32)) -> [0: bb2, otherwise: bb3];
 +         switchInt(const Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: u32) -> [0: bb2, otherwise: bb3];
       }
   
diff --git a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff
index 897592a0e2fdd..40e8c06f357e1 100644
--- a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-abort.diff
@@ -7,14 +7,14 @@
       let mut _3: &T;
   
       bb0: {
--         _2 = _1;
+-         _2 = copy _1;
           _3 = &_1;
-          _0 = opaque::<&T>(_3) -> [return: bb1, unwind unreachable];
+          _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
--         _0 = opaque::<T>(_2) -> [return: bb2, unwind unreachable];
-+         _0 = opaque::<T>(_1) -> [return: bb2, unwind unreachable];
+-         _0 = opaque::<T>(copy _2) -> [return: bb2, unwind unreachable];
++         _0 = opaque::<T>(copy _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
diff --git a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff
index 33c05af91a10e..d09c96c0f2ba1 100644
--- a/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/borrowed_local.borrowed.CopyProp.panic-unwind.diff
@@ -7,14 +7,14 @@
       let mut _3: &T;
   
       bb0: {
--         _2 = _1;
+-         _2 = copy _1;
           _3 = &_1;
-          _0 = opaque::<&T>(_3) -> [return: bb1, unwind continue];
+          _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind continue];
       }
   
       bb1: {
--         _0 = opaque::<T>(_2) -> [return: bb2, unwind continue];
-+         _0 = opaque::<T>(_1) -> [return: bb2, unwind continue];
+-         _0 = opaque::<T>(copy _2) -> [return: bb2, unwind continue];
++         _0 = opaque::<T>(copy _1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
diff --git a/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-abort.diff
index 3d6b5dffba456..7e63911d84341 100644
--- a/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-abort.diff
@@ -11,13 +11,13 @@
       bb0: {
           _1 = const 5_u8;
           _2 = &_1;
-          _3 = _1;
+          _3 = copy _1;
           _4 = &_3;
-          _0 = cmp_ref(_2, _4) -> [return: bb1, unwind unreachable];
+          _0 = cmp_ref(copy _2, copy _4) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
-          _0 = opaque::<u8>(_3) -> [return: bb2, unwind unreachable];
+          _0 = opaque::<u8>(copy _3) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
diff --git a/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-unwind.diff
index 0f29d2681de8c..8e5f8b21fe708 100644
--- a/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/borrowed_local.compare_address.CopyProp.panic-unwind.diff
@@ -11,13 +11,13 @@
       bb0: {
           _1 = const 5_u8;
           _2 = &_1;
-          _3 = _1;
+          _3 = copy _1;
           _4 = &_3;
-          _0 = cmp_ref(_2, _4) -> [return: bb1, unwind continue];
+          _0 = cmp_ref(copy _2, copy _4) -> [return: bb1, unwind continue];
       }
   
       bb1: {
-          _0 = opaque::<u8>(_3) -> [return: bb2, unwind continue];
+          _0 = opaque::<u8>(copy _3) -> [return: bb2, unwind continue];
       }
   
       bb2: {
diff --git a/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-abort.diff
index af2aeb0dcab25..99dda2a95ffa2 100644
--- a/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-abort.diff
@@ -7,13 +7,13 @@
       let mut _3: &T;
   
       bb0: {
-          _2 = _1;
+          _2 = copy _1;
           _3 = &_1;
-          _0 = opaque::<&T>(_3) -> [return: bb1, unwind unreachable];
+          _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
-          _0 = opaque::<T>(_2) -> [return: bb2, unwind unreachable];
+          _0 = opaque::<T>(copy _2) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
diff --git a/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-unwind.diff
index 040ed0aec1669..6eb48cd8dbcf3 100644
--- a/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/borrowed_local.non_freeze.CopyProp.panic-unwind.diff
@@ -7,13 +7,13 @@
       let mut _3: &T;
   
       bb0: {
-          _2 = _1;
+          _2 = copy _1;
           _3 = &_1;
-          _0 = opaque::<&T>(_3) -> [return: bb1, unwind continue];
+          _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind continue];
       }
   
       bb1: {
-          _0 = opaque::<T>(_2) -> [return: bb2, unwind continue];
+          _0 = opaque::<T>(copy _2) -> [return: bb2, unwind continue];
       }
   
       bb2: {
diff --git a/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-abort.diff
index 3334cdf92e7d7..c8889ee716ff4 100644
--- a/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-abort.diff
@@ -30,7 +30,7 @@
       }
   
       bb3: {
-          _2 = _1;
+          _2 = copy _1;
           goto -> bb6;
       }
   
@@ -41,13 +41,13 @@
   
       bb5: {
           StorageDead(_4);
-          _2 = _1;
+          _2 = copy _1;
           goto -> bb6;
       }
   
       bb6: {
           StorageDead(_3);
-          _0 = _2;
+          _0 = copy _2;
           StorageDead(_2);
           StorageDead(_1);
           return;
diff --git a/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-unwind.diff
index 2f92d8818cff3..a41c28cb8c8ab 100644
--- a/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/branch.foo.CopyProp.panic-unwind.diff
@@ -30,7 +30,7 @@
       }
   
       bb3: {
-          _2 = _1;
+          _2 = copy _1;
           goto -> bb6;
       }
   
@@ -41,13 +41,13 @@
   
       bb5: {
           StorageDead(_4);
-          _2 = _1;
+          _2 = copy _1;
           goto -> bb6;
       }
   
       bb6: {
           StorageDead(_3);
-          _0 = _2;
+          _0 = copy _2;
           StorageDead(_2);
           StorageDead(_1);
           return;
diff --git a/tests/mir-opt/copy-prop/calls.multiple_edges.CopyProp.diff b/tests/mir-opt/copy-prop/calls.multiple_edges.CopyProp.diff
index 4d56a8b25d360..9d0a1644ae4f3 100644
--- a/tests/mir-opt/copy-prop/calls.multiple_edges.CopyProp.diff
+++ b/tests/mir-opt/copy-prop/calls.multiple_edges.CopyProp.diff
@@ -6,7 +6,7 @@
       let mut _2: u8;
   
       bb0: {
-          switchInt(_1) -> [1: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [1: bb1, otherwise: bb2];
       }
   
       bb1: {
@@ -14,7 +14,7 @@
       }
   
       bb2: {
-          _0 = _2;
+          _0 = copy _2;
           return;
       }
   }
diff --git a/tests/mir-opt/copy-prop/calls.nrvo.CopyProp.diff b/tests/mir-opt/copy-prop/calls.nrvo.CopyProp.diff
index b5d56909b0ddb..29d9ec3f2fcb1 100644
--- a/tests/mir-opt/copy-prop/calls.nrvo.CopyProp.diff
+++ b/tests/mir-opt/copy-prop/calls.nrvo.CopyProp.diff
@@ -16,7 +16,7 @@
       }
   
       bb1: {
--         _0 = _1;
+-         _0 = copy _1;
 -         StorageDead(_1);
           return;
       }
diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-abort.diff
index 70674a912edd2..280908ac63a6d 100644
--- a/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-abort.diff
@@ -12,10 +12,10 @@
   
       bb0: {
 -         StorageLive(_2);
--         _2 = _1;
-+         _0 = _1;
+-         _2 = copy _1;
++         _0 = copy _1;
           _1 = const 123_i32;
--         _0 = _2;
+-         _0 = copy _2;
 -         StorageDead(_2);
           return;
       }
diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-unwind.diff
index 70674a912edd2..280908ac63a6d 100644
--- a/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/copy_propagation_arg.arg_src.CopyProp.panic-unwind.diff
@@ -12,10 +12,10 @@
   
       bb0: {
 -         StorageLive(_2);
--         _2 = _1;
-+         _0 = _1;
+-         _2 = copy _1;
++         _0 = copy _1;
           _1 = const 123_i32;
--         _0 = _2;
+-         _0 = copy _2;
 -         StorageDead(_2);
           return;
       }
diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-abort.diff
index 9ec014e2b256b..eea07d5839d44 100644
--- a/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-abort.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = dummy(move _3) -> [return: bb1, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-unwind.diff
index ef9c343a264d8..b0e5219913a59 100644
--- a/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/copy_propagation_arg.bar.CopyProp.panic-unwind.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = dummy(move _3) -> [return: bb1, unwind continue];
       }
   
diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-abort.diff
index 71facf91df78c..5fb14902fefd1 100644
--- a/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-abort.diff
@@ -8,10 +8,10 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           _1 = move _2;
           StorageDead(_2);
-          _0 = _1;
+          _0 = copy _1;
           return;
       }
   }
diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-unwind.diff
index 71facf91df78c..5fb14902fefd1 100644
--- a/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/copy_propagation_arg.baz.CopyProp.panic-unwind.diff
@@ -8,10 +8,10 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           _1 = move _2;
           StorageDead(_2);
-          _0 = _1;
+          _0 = copy _1;
           return;
       }
   }
diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-abort.diff
index 81b73e18763fd..685a290492e22 100644
--- a/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-abort.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = dummy(move _3) -> [return: bb1, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-unwind.diff
index 769089e16f34c..4a0601431abcc 100644
--- a/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/copy_propagation_arg.foo.CopyProp.panic-unwind.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = dummy(move _3) -> [return: bb1, unwind continue];
       }
   
diff --git a/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-abort.diff
index 7ba8530105179..1445b899dee20 100644
--- a/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-abort.diff
@@ -7,15 +7,15 @@
       let mut _3: NotCopy;
   
       bb0: {
--         _2 = _1;
+-         _2 = copy _1;
 -         _0 = opaque::<NotCopy>(move _1) -> [return: bb1, unwind unreachable];
-+         _0 = opaque::<NotCopy>(_1) -> [return: bb1, unwind unreachable];
++         _0 = opaque::<NotCopy>(copy _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
 -         _3 = move _2;
--         _0 = opaque::<NotCopy>(_3) -> [return: bb2, unwind unreachable];
-+         _0 = opaque::<NotCopy>(_1) -> [return: bb2, unwind unreachable];
+-         _0 = opaque::<NotCopy>(copy _3) -> [return: bb2, unwind unreachable];
++         _0 = opaque::<NotCopy>(copy _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
diff --git a/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-unwind.diff
index 7ba8530105179..1445b899dee20 100644
--- a/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/custom_move_arg.f.CopyProp.panic-unwind.diff
@@ -7,15 +7,15 @@
       let mut _3: NotCopy;
   
       bb0: {
--         _2 = _1;
+-         _2 = copy _1;
 -         _0 = opaque::<NotCopy>(move _1) -> [return: bb1, unwind unreachable];
-+         _0 = opaque::<NotCopy>(_1) -> [return: bb1, unwind unreachable];
++         _0 = opaque::<NotCopy>(copy _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
 -         _3 = move _2;
--         _0 = opaque::<NotCopy>(_3) -> [return: bb2, unwind unreachable];
-+         _0 = opaque::<NotCopy>(_1) -> [return: bb2, unwind unreachable];
+-         _0 = opaque::<NotCopy>(copy _3) -> [return: bb2, unwind unreachable];
++         _0 = opaque::<NotCopy>(copy _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
diff --git a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff
index 8f97c4e439e9d..d133091e6a438 100644
--- a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-abort.diff
@@ -27,17 +27,17 @@
   
       bb1: {
 -         StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         StorageLive(_3);
--         _3 = _2;
+-         _3 = copy _2;
 -         StorageLive(_4);
--         _4 = _3;
+-         _4 = copy _3;
 -         _1 = move _4;
 -         StorageDead(_4);
-+         _1 = _2;
++         _1 = copy _2;
           StorageLive(_5);
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
           _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff
index e343b78924ab1..bd4ad737cec13 100644
--- a/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/cycle.main.CopyProp.panic-unwind.diff
@@ -27,17 +27,17 @@
   
       bb1: {
 -         StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         StorageLive(_3);
--         _3 = _2;
+-         _3 = copy _2;
 -         StorageLive(_4);
--         _4 = _3;
+-         _4 = copy _3;
 -         _1 = move _4;
 -         StorageDead(_4);
-+         _1 = _2;
++         _1 = copy _2;
           StorageLive(_5);
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
           _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind continue];
       }
   
diff --git a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir
index 02b88d1400353..4781fdfd902a4 100644
--- a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir
+++ b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-abort.mir
@@ -11,11 +11,11 @@ fn f(_1: usize) -> usize {
     }
 
     bb0: {
-        _2 = _1;
+        _2 = copy _1;
         _1 = const 5_usize;
-        _1 = _2;
+        _1 = copy _2;
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         _0 = id::<usize>(move _4) -> [return: bb1, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir
index f8c285ff3843b..f5fded45c13b4 100644
--- a/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir
+++ b/tests/mir-opt/copy-prop/dead_stores_79191.f.CopyProp.after.panic-unwind.mir
@@ -11,11 +11,11 @@ fn f(_1: usize) -> usize {
     }
 
     bb0: {
-        _2 = _1;
+        _2 = copy _1;
         _1 = const 5_usize;
-        _1 = _2;
+        _1 = copy _2;
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         _0 = id::<usize>(move _4) -> [return: bb1, unwind continue];
     }
 
diff --git a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir
index 02b88d1400353..4781fdfd902a4 100644
--- a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir
+++ b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-abort.mir
@@ -11,11 +11,11 @@ fn f(_1: usize) -> usize {
     }
 
     bb0: {
-        _2 = _1;
+        _2 = copy _1;
         _1 = const 5_usize;
-        _1 = _2;
+        _1 = copy _2;
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         _0 = id::<usize>(move _4) -> [return: bb1, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir
index f8c285ff3843b..f5fded45c13b4 100644
--- a/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir
+++ b/tests/mir-opt/copy-prop/dead_stores_better.f.CopyProp.after.panic-unwind.mir
@@ -11,11 +11,11 @@ fn f(_1: usize) -> usize {
     }
 
     bb0: {
-        _2 = _1;
+        _2 = copy _1;
         _1 = const 5_usize;
-        _1 = _2;
+        _1 = copy _2;
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         _0 = id::<usize>(move _4) -> [return: bb1, unwind continue];
     }
 
diff --git a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff
index 51390e2abbe9a..f4411886f9a7a 100644
--- a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-abort.diff
@@ -88,15 +88,15 @@
   
       bb6: {
 -         StorageLive(_16);
-          _16 = ((_11 as Some).0: usize);
+          _16 = copy ((_11 as Some).0: usize);
           StorageLive(_17);
 -         StorageLive(_18);
--         _18 = _16;
+-         _18 = copy _16;
           _19 = Len(_2);
--         _20 = Lt(_18, _19);
--         assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, _18) -> [success: bb8, unwind unreachable];
-+         _20 = Lt(_16, _19);
-+         assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, _16) -> [success: bb8, unwind unreachable];
+-         _20 = Lt(copy _18, copy _19);
+-         assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, copy _18) -> [success: bb8, unwind unreachable];
++         _20 = Lt(copy _16, copy _19);
++         assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, copy _16) -> [success: bb8, unwind unreachable];
       }
   
       bb7: {
@@ -112,9 +112,9 @@
       }
   
       bb8: {
--         _17 = _2[_18];
-+         _17 = _2[_16];
-          _1 = Add(_1, move _17);
+-         _17 = copy _2[_18];
++         _17 = copy _2[_16];
+          _1 = Add(copy _1, move _17);
           StorageDead(_17);
 -         StorageDead(_18);
 -         _10 = const ();
diff --git a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff
index 8a2cbb68824c8..833588aa4e920 100644
--- a/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/issue_107511.main.CopyProp.panic-unwind.diff
@@ -88,15 +88,15 @@
   
       bb6: {
 -         StorageLive(_16);
-          _16 = ((_11 as Some).0: usize);
+          _16 = copy ((_11 as Some).0: usize);
           StorageLive(_17);
 -         StorageLive(_18);
--         _18 = _16;
+-         _18 = copy _16;
           _19 = Len(_2);
--         _20 = Lt(_18, _19);
--         assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, _18) -> [success: bb8, unwind continue];
-+         _20 = Lt(_16, _19);
-+         assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, _16) -> [success: bb8, unwind continue];
+-         _20 = Lt(copy _18, copy _19);
+-         assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, copy _18) -> [success: bb8, unwind continue];
++         _20 = Lt(copy _16, copy _19);
++         assert(move _20, "index out of bounds: the length is {} but the index is {}", move _19, copy _16) -> [success: bb8, unwind continue];
       }
   
       bb7: {
@@ -112,9 +112,9 @@
       }
   
       bb8: {
--         _17 = _2[_18];
-+         _17 = _2[_16];
-          _1 = Add(_1, move _17);
+-         _17 = copy _2[_18];
++         _17 = copy _2[_16];
+          _1 = Add(copy _1, move _17);
           StorageDead(_17);
 -         StorageDead(_18);
 -         _10 = const ();
diff --git a/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-abort.diff
index cf04f213efb91..da9904bfa01f5 100644
--- a/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-abort.diff
@@ -15,14 +15,14 @@
   
       bb0: {
 -         StorageLive(_2);
--         _2 = _1;
+-         _2 = copy _1;
           StorageLive(_3);
 -         StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 -         StorageLive(_5);
--         _5 = _2;
+-         _5 = copy _2;
 -         _3 = g::<T>(move _4, move _5) -> [return: bb1, unwind unreachable];
-+         _3 = g::<T>(_1, _1) -> [return: bb1, unwind unreachable];
++         _3 = g::<T>(copy _1, copy _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-unwind.diff
index 0c6a3c6d5c954..9b0de655bd262 100644
--- a/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/move_arg.f.CopyProp.panic-unwind.diff
@@ -15,14 +15,14 @@
   
       bb0: {
 -         StorageLive(_2);
--         _2 = _1;
+-         _2 = copy _1;
           StorageLive(_3);
 -         StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 -         StorageLive(_5);
--         _5 = _2;
+-         _5 = copy _2;
 -         _3 = g::<T>(move _4, move _5) -> [return: bb1, unwind continue];
-+         _3 = g::<T>(_1, _1) -> [return: bb1, unwind continue];
++         _3 = g::<T>(copy _1, copy _1) -> [return: bb1, unwind continue];
       }
   
       bb1: {
diff --git a/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-abort.diff
index b2b89968d70b0..973bcd6de8395 100644
--- a/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-abort.diff
@@ -7,11 +7,11 @@
       let mut _3: u8;
   
       bb0: {
--         _2 = _1;
+-         _2 = copy _1;
 -         _3 = move (_2.0: u8);
 -         _0 = opaque::<Foo>(move _1) -> [return: bb1, unwind unreachable];
-+         _3 = (_1.0: u8);
-+         _0 = opaque::<Foo>(_1) -> [return: bb1, unwind unreachable];
++         _3 = copy (_1.0: u8);
++         _0 = opaque::<Foo>(copy _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-unwind.diff
index b2b89968d70b0..973bcd6de8395 100644
--- a/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/move_projection.f.CopyProp.panic-unwind.diff
@@ -7,11 +7,11 @@
       let mut _3: u8;
   
       bb0: {
--         _2 = _1;
+-         _2 = copy _1;
 -         _3 = move (_2.0: u8);
 -         _0 = opaque::<Foo>(move _1) -> [return: bb1, unwind unreachable];
-+         _3 = (_1.0: u8);
-+         _0 = opaque::<Foo>(_1) -> [return: bb1, unwind unreachable];
++         _3 = copy (_1.0: u8);
++         _0 = opaque::<Foo>(copy _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/copy-prop/mutate_through_pointer.f.CopyProp.diff b/tests/mir-opt/copy-prop/mutate_through_pointer.f.CopyProp.diff
index 7f6802beeae2f..f96be62712945 100644
--- a/tests/mir-opt/copy-prop/mutate_through_pointer.f.CopyProp.diff
+++ b/tests/mir-opt/copy-prop/mutate_through_pointer.f.CopyProp.diff
@@ -8,11 +8,11 @@
       let mut _4: *mut bool;
   
       bb0: {
-          _2 = _1;
+          _2 = copy _1;
           _3 = &raw const _2;
           _4 = &raw mut (*_3);
           (*_4) = const false;
-          _0 = _1;
+          _0 = copy _1;
           return;
       }
   }
diff --git a/tests/mir-opt/copy-prop/non_dominate.f.CopyProp.diff b/tests/mir-opt/copy-prop/non_dominate.f.CopyProp.diff
index 5bf2335943cf6..6955d694e5ab2 100644
--- a/tests/mir-opt/copy-prop/non_dominate.f.CopyProp.diff
+++ b/tests/mir-opt/copy-prop/non_dominate.f.CopyProp.diff
@@ -11,18 +11,18 @@
       }
   
       bb1: {
-          _3 = _1;
-          switchInt(_3) -> [0: bb3, otherwise: bb2];
+          _3 = copy _1;
+          switchInt(copy _3) -> [0: bb3, otherwise: bb2];
       }
   
       bb2: {
-          _2 = _3;
+          _2 = copy _3;
           _1 = const false;
           goto -> bb1;
       }
   
       bb3: {
-          _0 = _2;
+          _0 = copy _2;
           return;
       }
   }
diff --git a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff
index ef30ac2fc8c09..676c5cee34387 100644
--- a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-abort.diff
@@ -30,12 +30,12 @@
           _3 = &mut (*_4);
           StorageDead(_4);
 -         StorageLive(_5);
--         _5 = _2;
+-         _5 = copy _2;
           StorageLive(_6);
 -         StorageLive(_7);
--         _7 = _5;
+-         _7 = copy _5;
 -         _6 = opaque::<*mut u8>(move _7) -> [return: bb1, unwind unreachable];
-+         _6 = opaque::<*mut u8>(_2) -> [return: bb1, unwind unreachable];
++         _6 = opaque::<*mut u8>(copy _2) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff
index a743a3e829a71..ca2232ce54a1f 100644
--- a/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/reborrow.demiraw.CopyProp.panic-unwind.diff
@@ -30,12 +30,12 @@
           _3 = &mut (*_4);
           StorageDead(_4);
 -         StorageLive(_5);
--         _5 = _2;
+-         _5 = copy _2;
           StorageLive(_6);
 -         StorageLive(_7);
--         _7 = _5;
+-         _7 = copy _5;
 -         _6 = opaque::<*mut u8>(move _7) -> [return: bb1, unwind continue];
-+         _6 = opaque::<*mut u8>(_2) -> [return: bb1, unwind continue];
++         _6 = opaque::<*mut u8>(copy _2) -> [return: bb1, unwind continue];
       }
   
       bb1: {
diff --git a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff
index 2de6f85ce64bf..1968696905fc7 100644
--- a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff
+++ b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-abort.diff
@@ -26,12 +26,12 @@
           StorageLive(_3);
           _3 = &raw mut (*_2);
 -         StorageLive(_4);
--         _4 = _2;
+-         _4 = copy _2;
           StorageLive(_5);
 -         StorageLive(_6);
--         _6 = _4;
+-         _6 = copy _4;
 -         _5 = opaque::<*mut u8>(move _6) -> [return: bb1, unwind unreachable];
-+         _5 = opaque::<*mut u8>(_2) -> [return: bb1, unwind unreachable];
++         _5 = opaque::<*mut u8>(copy _2) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff
index 2afec4898bc86..9a3c9665bc8f3 100644
--- a/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff
+++ b/tests/mir-opt/copy-prop/reborrow.miraw.CopyProp.panic-unwind.diff
@@ -26,12 +26,12 @@
           StorageLive(_3);
           _3 = &raw mut (*_2);
 -         StorageLive(_4);
--         _4 = _2;
+-         _4 = copy _2;
           StorageLive(_5);
 -         StorageLive(_6);
--         _6 = _4;
+-         _6 = copy _4;
 -         _5 = opaque::<*mut u8>(move _6) -> [return: bb1, unwind continue];
-+         _5 = opaque::<*mut u8>(_2) -> [return: bb1, unwind continue];
++         _5 = opaque::<*mut u8>(copy _2) -> [return: bb1, unwind continue];
       }
   
       bb1: {
diff --git a/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff b/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff
index 3d791734f4626..eeeac70b5b8e7 100644
--- a/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff
+++ b/tests/mir-opt/coverage/branch_match_arms.main.InstrumentCoverage.diff
@@ -71,33 +71,33 @@
       bb5: {
 +         Coverage::ExpressionUsed(2);
           StorageLive(_9);
-          _9 = ((_1 as A).0: u32);
+          _9 = copy ((_1 as A).0: u32);
           StorageLive(_10);
-          _10 = _9;
+          _10 = copy _9;
           _0 = consume(move _10) -> [return: bb12, unwind: bb14];
       }
   
       bb6: {
           StorageLive(_7);
-          _7 = ((_1 as B).0: u32);
+          _7 = copy ((_1 as B).0: u32);
           StorageLive(_8);
-          _8 = _7;
+          _8 = copy _7;
           _0 = consume(move _8) -> [return: bb11, unwind: bb14];
       }
   
       bb7: {
           StorageLive(_5);
-          _5 = ((_1 as C).0: u32);
+          _5 = copy ((_1 as C).0: u32);
           StorageLive(_6);
-          _6 = _5;
+          _6 = copy _5;
           _0 = consume(move _6) -> [return: bb10, unwind: bb14];
       }
   
       bb8: {
           StorageLive(_3);
-          _3 = ((_1 as D).0: u32);
+          _3 = copy ((_1 as D).0: u32);
           StorageLive(_4);
-          _4 = _3;
+          _4 = copy _3;
           _0 = consume(move _4) -> [return: bb9, unwind: bb14];
       }
   
diff --git a/tests/mir-opt/dataflow-const-prop/aggregate_copy.foo.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/aggregate_copy.foo.DataflowConstProp.diff
index 3b739a25cb864..8dd34d845801d 100644
--- a/tests/mir-opt/dataflow-const-prop/aggregate_copy.foo.DataflowConstProp.diff
+++ b/tests/mir-opt/dataflow-const-prop/aggregate_copy.foo.DataflowConstProp.diff
@@ -22,14 +22,14 @@
           StorageLive(_1);
           _1 = const Foo;
           StorageLive(_2);
--         _2 = _1;
+-         _2 = copy _1;
 +         _2 = const (5_u32, 3_u32);
           StorageLive(_3);
--         _3 = (_2.1: u32);
+-         _3 = copy (_2.1: u32);
 +         _3 = const 3_u32;
           StorageLive(_4);
           StorageLive(_5);
--         _5 = _3;
+-         _5 = copy _3;
 -         _4 = Ge(move _5, const 2_u32);
 -         switchInt(move _4) -> [0: bb2, otherwise: bb1];
 +         _5 = const 3_u32;
@@ -39,7 +39,7 @@
   
       bb1: {
           StorageDead(_5);
--         _0 = (_2.0: u32);
+-         _0 = copy (_2.0: u32);
 +         _0 = const 5_u32;
           goto -> bb3;
       }
diff --git a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-abort.diff
index 212ddc5b15418..a46daef435f3b 100644
--- a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-abort.diff
@@ -19,16 +19,16 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable];
 +         _4 = const 4_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = _2[_3];
-+         _1 = _2[2 of 3];
+-         _1 = copy _2[_3];
++         _1 = copy _2[2 of 3];
           StorageDead(_3);
           StorageDead(_2);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-unwind.diff
index 5c53d4f446131..1a4e15b45faad 100644
--- a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.32bit.panic-unwind.diff
@@ -19,16 +19,16 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue];
 +         _4 = const 4_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = _2[_3];
-+         _1 = _2[2 of 3];
+-         _1 = copy _2[_3];
++         _1 = copy _2[2 of 3];
           StorageDead(_3);
           StorageDead(_2);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-abort.diff
index 212ddc5b15418..a46daef435f3b 100644
--- a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-abort.diff
@@ -19,16 +19,16 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable];
 +         _4 = const 4_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = _2[_3];
-+         _1 = _2[2 of 3];
+-         _1 = copy _2[_3];
++         _1 = copy _2[2 of 3];
           StorageDead(_3);
           StorageDead(_2);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-unwind.diff
index 5c53d4f446131..1a4e15b45faad 100644
--- a/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/array_index.main.DataflowConstProp.64bit.panic-unwind.diff
@@ -19,16 +19,16 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue];
 +         _4 = const 4_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 4_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = _2[_3];
-+         _1 = _2[2 of 3];
+-         _1 = copy _2[_3];
++         _1 = copy _2[2 of 3];
           StorageDead(_3);
           StorageDead(_2);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/boolean_identities.test.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/boolean_identities.test.DataflowConstProp.diff
index 5440c38ce4bcf..89175fbad5c79 100644
--- a/tests/mir-opt/dataflow-const-prop/boolean_identities.test.DataflowConstProp.diff
+++ b/tests/mir-opt/dataflow-const-prop/boolean_identities.test.DataflowConstProp.diff
@@ -13,13 +13,13 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _3 = BitOr(move _4, const true);
 +         _3 = const true;
           StorageDead(_4);
           StorageLive(_5);
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
 -         _5 = BitAnd(move _6, const false);
 +         _5 = const false;
           StorageDead(_6);
diff --git a/tests/mir-opt/dataflow-const-prop/cast.main.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/cast.main.DataflowConstProp.diff
index 0ca446c89f2e0..f2c262f9fe2c0 100644
--- a/tests/mir-opt/dataflow-const-prop/cast.main.DataflowConstProp.diff
+++ b/tests/mir-opt/dataflow-const-prop/cast.main.DataflowConstProp.diff
@@ -20,7 +20,7 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 -         _3 = move _4 as u8 (IntToInt);
 +         _4 = const 257_i32;
 +         _3 = const 1_u8;
diff --git a/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-abort.diff
index 79ea55617481e..867e768790f6f 100644
--- a/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-abort.diff
@@ -36,11 +36,11 @@
           _2 = const 2_i32;
           StorageLive(_3);
           StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 +         _4 = const 1_i32;
           StorageLive(_5);
--         _5 = _2;
--         _6 = AddWithOverflow(_4, _5);
+-         _5 = copy _2;
+-         _6 = AddWithOverflow(copy _4, copy _5);
 -         assert(!move (_6.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, move _5) -> [success: bb1, unwind unreachable];
 +         _5 = const 2_i32;
 +         _6 = const (3_i32, false);
@@ -56,8 +56,8 @@
           _7 = const core::num::<impl i32>::MAX;
           StorageLive(_8);
           StorageLive(_9);
--         _9 = _7;
--         _10 = AddWithOverflow(_9, const 1_i32);
+-         _9 = copy _7;
+-         _10 = AddWithOverflow(copy _9, const 1_i32);
 -         assert(!move (_10.1: bool), "attempt to compute `{} + {}`, which would overflow", move _9, const 1_i32) -> [success: bb2, unwind unreachable];
 +         _9 = const i32::MAX;
 +         _10 = const (i32::MIN, true);
diff --git a/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-unwind.diff
index bd22c50dd8fcf..c22edaaec4098 100644
--- a/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/checked.main.DataflowConstProp.panic-unwind.diff
@@ -36,11 +36,11 @@
           _2 = const 2_i32;
           StorageLive(_3);
           StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 +         _4 = const 1_i32;
           StorageLive(_5);
--         _5 = _2;
--         _6 = AddWithOverflow(_4, _5);
+-         _5 = copy _2;
+-         _6 = AddWithOverflow(copy _4, copy _5);
 -         assert(!move (_6.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, move _5) -> [success: bb1, unwind continue];
 +         _5 = const 2_i32;
 +         _6 = const (3_i32, false);
@@ -56,8 +56,8 @@
           _7 = const core::num::<impl i32>::MAX;
           StorageLive(_8);
           StorageLive(_9);
--         _9 = _7;
--         _10 = AddWithOverflow(_9, const 1_i32);
+-         _9 = copy _7;
+-         _10 = AddWithOverflow(copy _9, const 1_i32);
 -         assert(!move (_10.1: bool), "attempt to compute `{} + {}`, which would overflow", move _9, const 1_i32) -> [success: bb2, unwind continue];
 +         _9 = const i32::MAX;
 +         _10 = const (i32::MIN, true);
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff
index 9d96e895c8aa5..c7870a7902b98 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff
@@ -50,7 +50,7 @@
           StorageLive(_6);
           StorageLive(_7);
 -         _7 = AlignOf([bool; 0]);
--         _6 = _7 as *mut [bool; 0] (Transmute);
+-         _6 = copy _7 as *mut [bool; 0] (Transmute);
 +         _7 = const 1_usize;
 +         _6 = const {0x1 as *mut [bool; 0]};
           StorageDead(_7);
@@ -67,7 +67,7 @@
   
       bb2: {
           StorageLive(_10);
--         _10 = _6 as *mut () (PtrToPtr);
+-         _10 = copy _6 as *mut () (PtrToPtr);
 -         _9 = NonNull::<T>::new_unchecked::precondition_check(move _10) -> [return: bb3, unwind unreachable];
 +         _10 = const {0x1 as *mut ()};
 +         _9 = NonNull::<T>::new_unchecked::precondition_check(const {0x1 as *mut ()}) -> [return: bb3, unwind unreachable];
@@ -80,8 +80,8 @@
   
       bb4: {
           StorageDead(_8);
--         _11 = _6 as *const [bool; 0] (PtrToPtr);
--         _5 = NonNull::<[bool; 0]> { pointer: _11 };
+-         _11 = copy _6 as *const [bool; 0] (PtrToPtr);
+-         _5 = NonNull::<[bool; 0]> { pointer: copy _11 };
 +         _11 = const {0x1 as *const [bool; 0]};
 +         _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};
           StorageDead(_11);
@@ -92,7 +92,7 @@
 -         _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize));
 +         _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }};
           StorageDead(_4);
--         _2 = Box::<[bool]>(_3, const std::alloc::Global);
+-         _2 = Box::<[bool]>(copy _3, const std::alloc::Global);
 +         _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global);
           StorageDead(_9);
           StorageDead(_3);
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff
index 0bdff584b01ec..f5de7a361bc10 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff
@@ -50,7 +50,7 @@
           StorageLive(_6);
           StorageLive(_7);
 -         _7 = AlignOf([bool; 0]);
--         _6 = _7 as *mut [bool; 0] (Transmute);
+-         _6 = copy _7 as *mut [bool; 0] (Transmute);
 +         _7 = const 1_usize;
 +         _6 = const {0x1 as *mut [bool; 0]};
           StorageDead(_7);
@@ -71,7 +71,7 @@
   
       bb3: {
           StorageLive(_10);
--         _10 = _6 as *mut () (PtrToPtr);
+-         _10 = copy _6 as *mut () (PtrToPtr);
 -         _9 = NonNull::<T>::new_unchecked::precondition_check(move _10) -> [return: bb4, unwind unreachable];
 +         _10 = const {0x1 as *mut ()};
 +         _9 = NonNull::<T>::new_unchecked::precondition_check(const {0x1 as *mut ()}) -> [return: bb4, unwind unreachable];
@@ -84,8 +84,8 @@
   
       bb5: {
           StorageDead(_8);
--         _11 = _6 as *const [bool; 0] (PtrToPtr);
--         _5 = NonNull::<[bool; 0]> { pointer: _11 };
+-         _11 = copy _6 as *const [bool; 0] (PtrToPtr);
+-         _5 = NonNull::<[bool; 0]> { pointer: copy _11 };
 +         _11 = const {0x1 as *const [bool; 0]};
 +         _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};
           StorageDead(_11);
@@ -96,7 +96,7 @@
 -         _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize));
 +         _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }};
           StorageDead(_4);
--         _2 = Box::<[bool]>(_3, const std::alloc::Global);
+-         _2 = Box::<[bool]>(copy _3, const std::alloc::Global);
 +         _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global);
           StorageDead(_9);
           StorageDead(_3);
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff
index 99e96fe5d70fd..3b0bc6377da62 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff
@@ -50,7 +50,7 @@
           StorageLive(_6);
           StorageLive(_7);
 -         _7 = AlignOf([bool; 0]);
--         _6 = _7 as *mut [bool; 0] (Transmute);
+-         _6 = copy _7 as *mut [bool; 0] (Transmute);
 +         _7 = const 1_usize;
 +         _6 = const {0x1 as *mut [bool; 0]};
           StorageDead(_7);
@@ -67,7 +67,7 @@
   
       bb2: {
           StorageLive(_10);
--         _10 = _6 as *mut () (PtrToPtr);
+-         _10 = copy _6 as *mut () (PtrToPtr);
 -         _9 = NonNull::<T>::new_unchecked::precondition_check(move _10) -> [return: bb3, unwind unreachable];
 +         _10 = const {0x1 as *mut ()};
 +         _9 = NonNull::<T>::new_unchecked::precondition_check(const {0x1 as *mut ()}) -> [return: bb3, unwind unreachable];
@@ -80,8 +80,8 @@
   
       bb4: {
           StorageDead(_8);
--         _11 = _6 as *const [bool; 0] (PtrToPtr);
--         _5 = NonNull::<[bool; 0]> { pointer: _11 };
+-         _11 = copy _6 as *const [bool; 0] (PtrToPtr);
+-         _5 = NonNull::<[bool; 0]> { pointer: copy _11 };
 +         _11 = const {0x1 as *const [bool; 0]};
 +         _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};
           StorageDead(_11);
@@ -92,7 +92,7 @@
 -         _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize));
 +         _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }};
           StorageDead(_4);
--         _2 = Box::<[bool]>(_3, const std::alloc::Global);
+-         _2 = Box::<[bool]>(copy _3, const std::alloc::Global);
 +         _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global);
           StorageDead(_9);
           StorageDead(_3);
diff --git a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff
index 5eefabeac3868..5dd7ad9a11773 100644
--- a/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff
@@ -50,7 +50,7 @@
           StorageLive(_6);
           StorageLive(_7);
 -         _7 = AlignOf([bool; 0]);
--         _6 = _7 as *mut [bool; 0] (Transmute);
+-         _6 = copy _7 as *mut [bool; 0] (Transmute);
 +         _7 = const 1_usize;
 +         _6 = const {0x1 as *mut [bool; 0]};
           StorageDead(_7);
@@ -71,7 +71,7 @@
   
       bb3: {
           StorageLive(_10);
--         _10 = _6 as *mut () (PtrToPtr);
+-         _10 = copy _6 as *mut () (PtrToPtr);
 -         _9 = NonNull::<T>::new_unchecked::precondition_check(move _10) -> [return: bb4, unwind unreachable];
 +         _10 = const {0x1 as *mut ()};
 +         _9 = NonNull::<T>::new_unchecked::precondition_check(const {0x1 as *mut ()}) -> [return: bb4, unwind unreachable];
@@ -84,8 +84,8 @@
   
       bb5: {
           StorageDead(_8);
--         _11 = _6 as *const [bool; 0] (PtrToPtr);
--         _5 = NonNull::<[bool; 0]> { pointer: _11 };
+-         _11 = copy _6 as *const [bool; 0] (PtrToPtr);
+-         _5 = NonNull::<[bool; 0]> { pointer: copy _11 };
 +         _11 = const {0x1 as *const [bool; 0]};
 +         _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};
           StorageDead(_11);
@@ -96,7 +96,7 @@
 -         _3 = move _4 as std::ptr::Unique<[bool]> (PointerCoercion(Unsize));
 +         _3 = const Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }};
           StorageDead(_4);
--         _2 = Box::<[bool]>(_3, const std::alloc::Global);
+-         _2 = Box::<[bool]>(copy _3, const std::alloc::Global);
 +         _2 = const Box::<[bool]>(Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }}, std::alloc::Global);
           StorageDead(_9);
           StorageDead(_3);
diff --git a/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.32bit.diff
index 9da1caf9004e8..ef3b24cd44002 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.32bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.32bit.diff
@@ -37,16 +37,16 @@
   
       bb2: {
           StorageLive(_5);
-          _5 = ((_1 as V2).0: i32);
-          _2 = _5;
+          _5 = copy ((_1 as V2).0: i32);
+          _2 = copy _5;
           StorageDead(_5);
           goto -> bb4;
       }
   
       bb3: {
           StorageLive(_4);
--         _4 = ((_1 as V1).0: i32);
--         _2 = _4;
+-         _4 = copy ((_1 as V1).0: i32);
+-         _2 = copy _4;
 +         _4 = const 0_i32;
 +         _2 = const 0_i32;
           StorageDead(_4);
diff --git a/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.64bit.diff
index 9da1caf9004e8..ef3b24cd44002 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.64bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/enum.constant.DataflowConstProp.64bit.diff
@@ -37,16 +37,16 @@
   
       bb2: {
           StorageLive(_5);
-          _5 = ((_1 as V2).0: i32);
-          _2 = _5;
+          _5 = copy ((_1 as V2).0: i32);
+          _2 = copy _5;
           StorageDead(_5);
           goto -> bb4;
       }
   
       bb3: {
           StorageLive(_4);
--         _4 = ((_1 as V1).0: i32);
--         _2 = _4;
+-         _4 = copy ((_1 as V1).0: i32);
+-         _2 = copy _4;
 +         _4 = const 0_i32;
 +         _2 = const 0_i32;
           StorageDead(_4);
diff --git a/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.32bit.diff
index 10d33767c90d9..db8352bcbcf90 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.32bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.32bit.diff
@@ -28,13 +28,13 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           switchInt(move _4) -> [0: bb2, otherwise: bb1];
       }
   
       bb1: {
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
           _3 = Option::<u8>::Some(move _5);
           StorageDead(_5);
           goto -> bb3;
@@ -63,15 +63,15 @@
   
       bb6: {
           StorageLive(_8);
-          _8 = ((_3 as Some).0: u8);
-          _6 = _8;
+          _8 = copy ((_3 as Some).0: u8);
+          _6 = copy _8;
           StorageDead(_8);
           goto -> bb7;
       }
   
       bb7: {
           StorageLive(_9);
-          _9 = _6;
+          _9 = copy _6;
           _0 = const ();
           StorageDead(_9);
           StorageDead(_6);
diff --git a/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.64bit.diff
index 10d33767c90d9..db8352bcbcf90 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.64bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/enum.multiple.DataflowConstProp.64bit.diff
@@ -28,13 +28,13 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           switchInt(move _4) -> [0: bb2, otherwise: bb1];
       }
   
       bb1: {
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
           _3 = Option::<u8>::Some(move _5);
           StorageDead(_5);
           goto -> bb3;
@@ -63,15 +63,15 @@
   
       bb6: {
           StorageLive(_8);
-          _8 = ((_3 as Some).0: u8);
-          _6 = _8;
+          _8 = copy ((_3 as Some).0: u8);
+          _6 = copy _8;
           StorageDead(_8);
           goto -> bb7;
       }
   
       bb7: {
           StorageLive(_9);
-          _9 = _6;
+          _9 = copy _6;
           _0 = const ();
           StorageDead(_9);
           StorageDead(_6);
diff --git a/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.32bit.diff
index 960e69ee9165e..e2cd73404bec3 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.32bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.32bit.diff
@@ -10,7 +10,7 @@
           discriminant(_1) = 1;
           (((_1 as variant#1).0: NonZeroUsize).0: usize) = const 0_usize;
           _2 = discriminant(_1);
-          switchInt(_2) -> [0: bb1, otherwise: bb2];
+          switchInt(copy _2) -> [0: bb1, otherwise: bb2];
       }
   
       bb1: {
diff --git a/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.64bit.diff
index 960e69ee9165e..e2cd73404bec3 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.64bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/enum.mutate_discriminant.DataflowConstProp.64bit.diff
@@ -10,7 +10,7 @@
           discriminant(_1) = 1;
           (((_1 as variant#1).0: NonZeroUsize).0: usize) = const 0_usize;
           _2 = discriminant(_1);
-          switchInt(_2) -> [0: bb1, otherwise: bb2];
+          switchInt(copy _2) -> [0: bb1, otherwise: bb2];
       }
   
       bb1: {
diff --git a/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.32bit.diff
index a64dda0d06c48..d79c163effc13 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.32bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.32bit.diff
@@ -38,16 +38,16 @@
   
       bb2: {
           StorageLive(_5);
-          _5 = ((_1 as V2).0: i32);
-          _2 = _5;
+          _5 = copy ((_1 as V2).0: i32);
+          _2 = copy _5;
           StorageDead(_5);
           goto -> bb4;
       }
   
       bb3: {
           StorageLive(_4);
--         _4 = ((_1 as V1).0: i32);
--         _2 = _4;
+-         _4 = copy ((_1 as V1).0: i32);
+-         _2 = copy _4;
 +         _4 = const 0_i32;
 +         _2 = const 0_i32;
           StorageDead(_4);
diff --git a/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.64bit.diff
index a64dda0d06c48..d79c163effc13 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.64bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/enum.simple.DataflowConstProp.64bit.diff
@@ -38,16 +38,16 @@
   
       bb2: {
           StorageLive(_5);
-          _5 = ((_1 as V2).0: i32);
-          _2 = _5;
+          _5 = copy ((_1 as V2).0: i32);
+          _2 = copy _5;
           StorageDead(_5);
           goto -> bb4;
       }
   
       bb3: {
           StorageLive(_4);
--         _4 = ((_1 as V1).0: i32);
--         _2 = _4;
+-         _4 = copy ((_1 as V1).0: i32);
+-         _2 = copy _4;
 +         _4 = const 0_i32;
 +         _2 = const 0_i32;
           StorageDead(_4);
diff --git a/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.32bit.diff
index b4d14f25fe2ab..9823a48785a5b 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.32bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.32bit.diff
@@ -44,7 +44,7 @@
           StorageLive(_1);
           StorageLive(_2);
           _2 = const {ALLOC0: &E};
--         _1 = (*_2);
+-         _1 = copy (*_2);
 +         _1 = const E::V1(0_i32);
           StorageDead(_2);
           StorageLive(_3);
@@ -60,16 +60,16 @@
   
       bb2: {
           StorageLive(_6);
-          _6 = ((_1 as V2).0: i32);
-          _3 = _6;
+          _6 = copy ((_1 as V2).0: i32);
+          _3 = copy _6;
           StorageDead(_6);
           goto -> bb4;
       }
   
       bb3: {
           StorageLive(_5);
--         _5 = ((_1 as V1).0: i32);
--         _3 = _5;
+-         _5 = copy ((_1 as V1).0: i32);
+-         _3 = copy _5;
 +         _5 = const 0_i32;
 +         _3 = const 0_i32;
           StorageDead(_5);
@@ -80,7 +80,7 @@
           StorageLive(_7);
           StorageLive(_8);
           _8 = const {ALLOC1: &&E};
-          _7 = (*_8);
+          _7 = copy (*_8);
           StorageDead(_8);
           StorageLive(_9);
           _10 = discriminant((*_7));
@@ -98,7 +98,7 @@
       bb6: {
           StorageLive(_11);
           _11 = &(((*_7) as V1).0: i32);
-          _9 = _11;
+          _9 = copy _11;
           StorageDead(_11);
           goto -> bb7;
       }
diff --git a/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.64bit.diff
index 57d02b87d1369..e4e68483f2557 100644
--- a/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.64bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/enum.statics.DataflowConstProp.64bit.diff
@@ -44,7 +44,7 @@
           StorageLive(_1);
           StorageLive(_2);
           _2 = const {ALLOC0: &E};
--         _1 = (*_2);
+-         _1 = copy (*_2);
 +         _1 = const E::V1(0_i32);
           StorageDead(_2);
           StorageLive(_3);
@@ -60,16 +60,16 @@
   
       bb2: {
           StorageLive(_6);
-          _6 = ((_1 as V2).0: i32);
-          _3 = _6;
+          _6 = copy ((_1 as V2).0: i32);
+          _3 = copy _6;
           StorageDead(_6);
           goto -> bb4;
       }
   
       bb3: {
           StorageLive(_5);
--         _5 = ((_1 as V1).0: i32);
--         _3 = _5;
+-         _5 = copy ((_1 as V1).0: i32);
+-         _3 = copy _5;
 +         _5 = const 0_i32;
 +         _3 = const 0_i32;
           StorageDead(_5);
@@ -80,7 +80,7 @@
           StorageLive(_7);
           StorageLive(_8);
           _8 = const {ALLOC1: &&E};
-          _7 = (*_8);
+          _7 = copy (*_8);
           StorageDead(_8);
           StorageLive(_9);
           _10 = discriminant((*_7));
@@ -98,7 +98,7 @@
       bb6: {
           StorageLive(_11);
           _11 = &(((*_7) as V1).0: i32);
-          _9 = _11;
+          _9 = copy _11;
           StorageDead(_11);
           goto -> bb7;
       }
diff --git a/tests/mir-opt/dataflow-const-prop/if.main.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/if.main.DataflowConstProp.diff
index 355f28b03db53..5f013b1d134db 100644
--- a/tests/mir-opt/dataflow-const-prop/if.main.DataflowConstProp.diff
+++ b/tests/mir-opt/dataflow-const-prop/if.main.DataflowConstProp.diff
@@ -37,7 +37,7 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 -         _3 = Eq(move _4, const 1_i32);
 -         switchInt(move _3) -> [0: bb2, otherwise: bb1];
 +         _4 = const 1_i32;
@@ -61,7 +61,7 @@
           StorageDead(_3);
           StorageLive(_5);
           StorageLive(_6);
--         _6 = _2;
+-         _6 = copy _2;
 -         _5 = Add(move _6, const 1_i32);
 +         _6 = const 2_i32;
 +         _5 = const 3_i32;
@@ -69,7 +69,7 @@
           StorageLive(_7);
           StorageLive(_8);
           StorageLive(_9);
--         _9 = _1;
+-         _9 = copy _1;
 -         _8 = Eq(move _9, const 1_i32);
 -         switchInt(move _8) -> [0: bb5, otherwise: bb4];
 +         _9 = const 1_i32;
@@ -79,7 +79,7 @@
   
       bb4: {
           StorageDead(_9);
--         _7 = _1;
+-         _7 = copy _1;
 +         _7 = const 1_i32;
           goto -> bb6;
       }
@@ -87,7 +87,7 @@
       bb5: {
           StorageDead(_9);
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
           _7 = Add(move _10, const 1_i32);
           StorageDead(_10);
           goto -> bb6;
@@ -97,7 +97,7 @@
           StorageDead(_8);
           StorageLive(_11);
           StorageLive(_12);
--         _12 = _7;
+-         _12 = copy _7;
 -         _11 = Add(move _12, const 1_i32);
 +         _12 = const 1_i32;
 +         _11 = const 2_i32;
diff --git a/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-abort.diff
index 8d62de0c82152..1b695e4b53c3e 100644
--- a/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-abort.diff
@@ -19,8 +19,8 @@
           StorageLive(_3);
           _3 = const 1_u8;
           StorageLive(_4);
--         _4 = AddWithOverflow(_2, _3);
--         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", _2, _3) -> [success: bb1, unwind unreachable];
+-         _4 = AddWithOverflow(copy _2, copy _3);
+-         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb1, unwind unreachable];
 +         _4 = const (0_u8, true);
 +         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb1, unwind unreachable];
       }
diff --git a/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-unwind.diff
index 25624851cb34d..a0bd8e17d8c4d 100644
--- a/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/inherit_overflow.main.DataflowConstProp.panic-unwind.diff
@@ -19,8 +19,8 @@
           StorageLive(_3);
           _3 = const 1_u8;
           StorageLive(_4);
--         _4 = AddWithOverflow(_2, _3);
--         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", _2, _3) -> [success: bb1, unwind continue];
+-         _4 = AddWithOverflow(copy _2, copy _3);
+-         assert(!move (_4.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _2, copy _3) -> [success: bb1, unwind continue];
 +         _4 = const (0_u8, true);
 +         assert(!const true, "attempt to compute `{} + {}`, which would overflow", const u8::MAX, const 1_u8) -> [success: bb1, unwind continue];
       }
diff --git a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-abort.diff
index 6c612d4672500..b7ff0b671f7bf 100644
--- a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-abort.diff
@@ -19,16 +19,16 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable];
 +         _4 = const 5000_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = _2[_3];
-+         _1 = _2[2 of 3];
+-         _1 = copy _2[_3];
++         _1 = copy _2[2 of 3];
           StorageDead(_3);
           StorageDead(_2);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-unwind.diff
index 87024da2628bf..af6e3626142fc 100644
--- a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.32bit.panic-unwind.diff
@@ -19,16 +19,16 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue];
 +         _4 = const 5000_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = _2[_3];
-+         _1 = _2[2 of 3];
+-         _1 = copy _2[_3];
++         _1 = copy _2[2 of 3];
           StorageDead(_3);
           StorageDead(_2);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-abort.diff
index 6c612d4672500..b7ff0b671f7bf 100644
--- a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-abort.diff
@@ -19,16 +19,16 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable];
 +         _4 = const 5000_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = _2[_3];
-+         _1 = _2[2 of 3];
+-         _1 = copy _2[_3];
++         _1 = copy _2[2 of 3];
           StorageDead(_3);
           StorageDead(_2);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-unwind.diff
index 87024da2628bf..af6e3626142fc 100644
--- a/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/large_array_index.main.DataflowConstProp.64bit.panic-unwind.diff
@@ -19,16 +19,16 @@
           StorageLive(_3);
           _3 = const 2_usize;
 -         _4 = Len(_2);
--         _5 = Lt(_3, _4);
--         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+-         _5 = Lt(copy _3, copy _4);
+-         assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue];
 +         _4 = const 5000_usize;
 +         _5 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 5000_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = _2[_3];
-+         _1 = _2[2 of 3];
+-         _1 = copy _2[_3];
++         _1 = copy _2[2 of 3];
           StorageDead(_3);
           StorageDead(_2);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/mult_by_zero.test.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/mult_by_zero.test.DataflowConstProp.diff
index 91bc10a562f7a..8b05386b38ae3 100644
--- a/tests/mir-opt/dataflow-const-prop/mult_by_zero.test.DataflowConstProp.diff
+++ b/tests/mir-opt/dataflow-const-prop/mult_by_zero.test.DataflowConstProp.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         _0 = Mul(move _2, const 0_i32);
 +         _0 = const 0_i32;
           StorageDead(_2);
diff --git a/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-abort.diff
index fbbfd61bbedc1..a0e83265d31c5 100644
--- a/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-abort.diff
@@ -39,7 +39,7 @@
       bb2: {
           StorageDead(_5);
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
           _0 = const ();
           StorageDead(_6);
           StorageDead(_1);
diff --git a/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-unwind.diff
index 4e1d26acfa3fc..6dead031a9f6a 100644
--- a/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/ref_without_sb.main.DataflowConstProp.panic-unwind.diff
@@ -39,7 +39,7 @@
       bb2: {
           StorageDead(_5);
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
           _0 = const ();
           StorageDead(_6);
           StorageDead(_1);
diff --git a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-abort.diff
index a18ef6c9db763..dfa541b1200d5 100644
--- a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-abort.diff
@@ -21,16 +21,16 @@
           StorageLive(_4);
           _4 = const 2_usize;
 -         _5 = Len(_3);
--         _6 = Lt(_4, _5);
--         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind unreachable];
+-         _6 = Lt(copy _4, copy _5);
+-         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind unreachable];
 +         _5 = const 8_usize;
 +         _6 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _2 = _3[_4];
-+         _2 = _3[2 of 3];
+-         _2 = copy _3[_4];
++         _2 = copy _3[2 of 3];
           _1 = Add(move _2, const 0_u32);
           StorageDead(_2);
           StorageDead(_4);
diff --git a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-unwind.diff
index 3356ef98b14a8..9ede3c5f7ac21 100644
--- a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.32bit.panic-unwind.diff
@@ -21,16 +21,16 @@
           StorageLive(_4);
           _4 = const 2_usize;
 -         _5 = Len(_3);
--         _6 = Lt(_4, _5);
--         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind continue];
+-         _6 = Lt(copy _4, copy _5);
+-         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind continue];
 +         _5 = const 8_usize;
 +         _6 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _2 = _3[_4];
-+         _2 = _3[2 of 3];
+-         _2 = copy _3[_4];
++         _2 = copy _3[2 of 3];
           _1 = Add(move _2, const 0_u32);
           StorageDead(_2);
           StorageDead(_4);
diff --git a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-abort.diff
index a18ef6c9db763..dfa541b1200d5 100644
--- a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-abort.diff
@@ -21,16 +21,16 @@
           StorageLive(_4);
           _4 = const 2_usize;
 -         _5 = Len(_3);
--         _6 = Lt(_4, _5);
--         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind unreachable];
+-         _6 = Lt(copy _4, copy _5);
+-         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind unreachable];
 +         _5 = const 8_usize;
 +         _6 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _2 = _3[_4];
-+         _2 = _3[2 of 3];
+-         _2 = copy _3[_4];
++         _2 = copy _3[2 of 3];
           _1 = Add(move _2, const 0_u32);
           StorageDead(_2);
           StorageDead(_4);
diff --git a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-unwind.diff
index 3356ef98b14a8..9ede3c5f7ac21 100644
--- a/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/repeat.main.DataflowConstProp.64bit.panic-unwind.diff
@@ -21,16 +21,16 @@
           StorageLive(_4);
           _4 = const 2_usize;
 -         _5 = Len(_3);
--         _6 = Lt(_4, _5);
--         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind continue];
+-         _6 = Lt(copy _4, copy _5);
+-         assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind continue];
 +         _5 = const 8_usize;
 +         _6 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 8_usize, const 2_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _2 = _3[_4];
-+         _2 = _3[2 of 3];
+-         _2 = copy _3[_4];
++         _2 = copy _3[2 of 3];
           _1 = Add(move _2, const 0_u32);
           StorageDead(_2);
           StorageDead(_4);
diff --git a/tests/mir-opt/dataflow-const-prop/repr_transparent.main.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/repr_transparent.main.DataflowConstProp.diff
index 98bd40ab2c3da..d0915432aaa63 100644
--- a/tests/mir-opt/dataflow-const-prop/repr_transparent.main.DataflowConstProp.diff
+++ b/tests/mir-opt/dataflow-const-prop/repr_transparent.main.DataflowConstProp.diff
@@ -22,10 +22,10 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
--         _4 = (_1.0: i32);
+-         _4 = copy (_1.0: i32);
 +         _4 = const 0_i32;
           StorageLive(_5);
--         _5 = (_1.0: i32);
+-         _5 = copy (_1.0: i32);
 -         _3 = Add(move _4, move _5);
 +         _5 = const 0_i32;
 +         _3 = const 0_i32;
diff --git a/tests/mir-opt/dataflow-const-prop/self_assign.main.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/self_assign.main.DataflowConstProp.diff
index fbdbb3fa35caf..e54a0d64b166d 100644
--- a/tests/mir-opt/dataflow-const-prop/self_assign.main.DataflowConstProp.diff
+++ b/tests/mir-opt/dataflow-const-prop/self_assign.main.DataflowConstProp.diff
@@ -20,21 +20,21 @@
           StorageLive(_1);
           _1 = const 0_i32;
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           _1 = Add(move _2, const 1_i32);
           StorageDead(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _1 = move _3;
           StorageDead(_3);
           StorageLive(_4);
           _4 = &_1;
           StorageLive(_5);
-          _5 = _4;
+          _5 = copy _4;
           _4 = move _5;
           StorageDead(_5);
           StorageLive(_6);
-          _6 = (*_4);
+          _6 = copy (*_4);
           _1 = move _6;
           StorageDead(_6);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/self_assign_add.main.DataflowConstProp.diff b/tests/mir-opt/dataflow-const-prop/self_assign_add.main.DataflowConstProp.diff
index e2468a9645d61..77762ed904132 100644
--- a/tests/mir-opt/dataflow-const-prop/self_assign_add.main.DataflowConstProp.diff
+++ b/tests/mir-opt/dataflow-const-prop/self_assign_add.main.DataflowConstProp.diff
@@ -11,8 +11,8 @@
       bb0: {
           StorageLive(_1);
           _1 = const 0_i32;
--         _1 = Add(_1, const 1_i32);
--         _1 = Add(_1, const 1_i32);
+-         _1 = Add(copy _1, const 1_i32);
+-         _1 = Add(copy _1, const 1_i32);
 +         _1 = const 1_i32;
 +         _1 = const 2_i32;
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-abort.diff
index a5e4099075101..178ebad6105ac 100644
--- a/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-abort.diff
@@ -27,7 +27,7 @@
           _3 = &raw mut (_1.0: u8);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _3;
+          _5 = copy _3;
           _4 = std::ptr::mut_ptr::<impl *mut u8>::add(move _5, const 1_usize) -> [return: bb1, unwind unreachable];
       }
   
@@ -39,7 +39,7 @@
           StorageDead(_3);
           StorageDead(_2);
           StorageLive(_6);
-          _6 = (_1.1: u8);
+          _6 = copy (_1.1: u8);
           _0 = const ();
           StorageDead(_6);
           StorageDead(_1);
diff --git a/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-unwind.diff
index ce2178ddbee61..ce2545589f183 100644
--- a/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/sibling_ptr.main.DataflowConstProp.panic-unwind.diff
@@ -27,7 +27,7 @@
           _3 = &raw mut (_1.0: u8);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _3;
+          _5 = copy _3;
           _4 = std::ptr::mut_ptr::<impl *mut u8>::add(move _5, const 1_usize) -> [return: bb1, unwind continue];
       }
   
@@ -39,7 +39,7 @@
           StorageDead(_3);
           StorageDead(_2);
           StorageLive(_6);
-          _6 = (_1.1: u8);
+          _6 = copy (_1.1: u8);
           _0 = const ();
           StorageDead(_6);
           StorageDead(_1);
diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff
index efba4a4646cd4..40632db667a8d 100644
--- a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-abort.diff
@@ -30,23 +30,23 @@
           StorageLive(_3);
           StorageLive(_4);
           _14 = const main::promoted[0];
-          _4 = _14;
-          _3 = _4;
+          _4 = copy _14;
+          _3 = copy _4;
           _2 = move _3 as &[u32] (PointerCoercion(Unsize));
           StorageDead(_3);
           StorageLive(_6);
           _6 = const 1_usize;
 -         _7 = Len((*_2));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable];
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable];
 +         _7 = const 3_usize;
 +         _8 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = (*_2)[_6];
-+         _1 = (*_2)[1 of 2];
+-         _1 = copy (*_2)[_6];
++         _1 = copy (*_2)[1 of 2];
           StorageDead(_6);
           StorageDead(_4);
           StorageDead(_2);
@@ -56,16 +56,16 @@
           StorageLive(_11);
           _11 = const 1_usize;
 -         _12 = Len((*_10));
--         _13 = Lt(_11, _12);
--         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind unreachable];
+-         _13 = Lt(copy _11, copy _12);
+-         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb2, unwind unreachable];
 +         _12 = const 3_usize;
 +         _13 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind unreachable];
       }
   
       bb2: {
--         _9 = (*_10)[_11];
-+         _9 = (*_10)[1 of 2];
+-         _9 = copy (*_10)[_11];
++         _9 = copy (*_10)[1 of 2];
           StorageDead(_11);
           StorageDead(_10);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff
index bf477d7e041e9..596b4ac9b1e5b 100644
--- a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.32bit.panic-unwind.diff
@@ -30,23 +30,23 @@
           StorageLive(_3);
           StorageLive(_4);
           _14 = const main::promoted[0];
-          _4 = _14;
-          _3 = _4;
+          _4 = copy _14;
+          _3 = copy _4;
           _2 = move _3 as &[u32] (PointerCoercion(Unsize));
           StorageDead(_3);
           StorageLive(_6);
           _6 = const 1_usize;
 -         _7 = Len((*_2));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue];
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue];
 +         _7 = const 3_usize;
 +         _8 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = (*_2)[_6];
-+         _1 = (*_2)[1 of 2];
+-         _1 = copy (*_2)[_6];
++         _1 = copy (*_2)[1 of 2];
           StorageDead(_6);
           StorageDead(_4);
           StorageDead(_2);
@@ -56,16 +56,16 @@
           StorageLive(_11);
           _11 = const 1_usize;
 -         _12 = Len((*_10));
--         _13 = Lt(_11, _12);
--         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind continue];
+-         _13 = Lt(copy _11, copy _12);
+-         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb2, unwind continue];
 +         _12 = const 3_usize;
 +         _13 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind continue];
       }
   
       bb2: {
--         _9 = (*_10)[_11];
-+         _9 = (*_10)[1 of 2];
+-         _9 = copy (*_10)[_11];
++         _9 = copy (*_10)[1 of 2];
           StorageDead(_11);
           StorageDead(_10);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff
index efba4a4646cd4..40632db667a8d 100644
--- a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-abort.diff
@@ -30,23 +30,23 @@
           StorageLive(_3);
           StorageLive(_4);
           _14 = const main::promoted[0];
-          _4 = _14;
-          _3 = _4;
+          _4 = copy _14;
+          _3 = copy _4;
           _2 = move _3 as &[u32] (PointerCoercion(Unsize));
           StorageDead(_3);
           StorageLive(_6);
           _6 = const 1_usize;
 -         _7 = Len((*_2));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind unreachable];
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind unreachable];
 +         _7 = const 3_usize;
 +         _8 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _1 = (*_2)[_6];
-+         _1 = (*_2)[1 of 2];
+-         _1 = copy (*_2)[_6];
++         _1 = copy (*_2)[1 of 2];
           StorageDead(_6);
           StorageDead(_4);
           StorageDead(_2);
@@ -56,16 +56,16 @@
           StorageLive(_11);
           _11 = const 1_usize;
 -         _12 = Len((*_10));
--         _13 = Lt(_11, _12);
--         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind unreachable];
+-         _13 = Lt(copy _11, copy _12);
+-         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb2, unwind unreachable];
 +         _12 = const 3_usize;
 +         _13 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind unreachable];
       }
   
       bb2: {
--         _9 = (*_10)[_11];
-+         _9 = (*_10)[1 of 2];
+-         _9 = copy (*_10)[_11];
++         _9 = copy (*_10)[1 of 2];
           StorageDead(_11);
           StorageDead(_10);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff
index bf477d7e041e9..596b4ac9b1e5b 100644
--- a/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/slice_len.main.DataflowConstProp.64bit.panic-unwind.diff
@@ -30,23 +30,23 @@
           StorageLive(_3);
           StorageLive(_4);
           _14 = const main::promoted[0];
-          _4 = _14;
-          _3 = _4;
+          _4 = copy _14;
+          _3 = copy _4;
           _2 = move _3 as &[u32] (PointerCoercion(Unsize));
           StorageDead(_3);
           StorageLive(_6);
           _6 = const 1_usize;
 -         _7 = Len((*_2));
--         _8 = Lt(_6, _7);
--         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb1, unwind continue];
+-         _8 = Lt(copy _6, copy _7);
+-         assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb1, unwind continue];
 +         _7 = const 3_usize;
 +         _8 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _1 = (*_2)[_6];
-+         _1 = (*_2)[1 of 2];
+-         _1 = copy (*_2)[_6];
++         _1 = copy (*_2)[1 of 2];
           StorageDead(_6);
           StorageDead(_4);
           StorageDead(_2);
@@ -56,16 +56,16 @@
           StorageLive(_11);
           _11 = const 1_usize;
 -         _12 = Len((*_10));
--         _13 = Lt(_11, _12);
--         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb2, unwind continue];
+-         _13 = Lt(copy _11, copy _12);
+-         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb2, unwind continue];
 +         _12 = const 3_usize;
 +         _13 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 3_usize, const 1_usize) -> [success: bb2, unwind continue];
       }
   
       bb2: {
--         _9 = (*_10)[_11];
-+         _9 = (*_10)[1 of 2];
+-         _9 = copy (*_10)[_11];
++         _9 = copy (*_10)[1 of 2];
           StorageDead(_11);
           StorageDead(_10);
           _0 = const ();
diff --git a/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.32bit.diff
index 5e89382ea8f46..3ea49265cee33 100644
--- a/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.32bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.32bit.diff
@@ -83,7 +83,7 @@
 +         _1 = const S(1_i32);
           StorageLive(_2);
           StorageLive(_3);
--         _3 = (_1.0: i32);
+-         _3 = copy (_1.0: i32);
 -         _2 = Add(move _3, const 2_i32);
 +         _3 = const 1_i32;
 +         _2 = const 3_i32;
@@ -91,10 +91,10 @@
           (_1.0: i32) = const 3_i32;
           StorageLive(_4);
           StorageLive(_5);
--         _5 = _2;
+-         _5 = copy _2;
 +         _5 = const 3_i32;
           StorageLive(_6);
--         _6 = (_1.0: i32);
+-         _6 = copy (_1.0: i32);
 -         _4 = Add(move _5, move _6);
 +         _6 = const 3_i32;
 +         _4 = const 6_i32;
@@ -103,35 +103,35 @@
           StorageLive(_10);
           _10 = const main::SMALL_VAL;
           StorageLive(_7);
--         _7 = (_10.0: f32);
+-         _7 = copy (_10.0: f32);
 +         _7 = const 4f32;
           StorageLive(_8);
-          _8 = (_10.1: std::option::Option<S>);
+          _8 = copy (_10.1: std::option::Option<S>);
           StorageLive(_9);
-          _9 = (_10.2: &[f32]);
+          _9 = copy (_10.2: &[f32]);
           StorageDead(_10);
           StorageLive(_14);
           _14 = const {ALLOC0: &&SmallStruct};
           _31 = deref_copy (*_14);
           StorageLive(_11);
           _32 = deref_copy (*_14);
--         _11 = ((*_32).0: f32);
+-         _11 = copy ((*_32).0: f32);
 +         _11 = const 9f32;
           StorageLive(_12);
           _33 = deref_copy (*_14);
-          _12 = ((*_33).1: std::option::Option<S>);
+          _12 = copy ((*_33).1: std::option::Option<S>);
           StorageLive(_13);
           _34 = deref_copy (*_14);
-          _13 = ((*_34).2: &[f32]);
+          _13 = copy ((*_34).2: &[f32]);
           StorageDead(_14);
           StorageLive(_15);
           StorageLive(_16);
--         _16 = _11;
+-         _16 = copy _11;
 +         _16 = const 9f32;
           StorageLive(_17);
-          _17 = _12;
+          _17 = copy _12;
           StorageLive(_18);
-          _18 = _13;
+          _18 = copy _13;
 -         _15 = SmallStruct(move _16, move _17, move _18);
 +         _15 = SmallStruct(const 9f32, move _17, move _18);
           StorageDead(_18);
@@ -140,35 +140,35 @@
           StorageLive(_22);
           _22 = const main::BIG_VAL;
           StorageLive(_19);
--         _19 = (_22.0: f32);
+-         _19 = copy (_22.0: f32);
 +         _19 = const 25f32;
           StorageLive(_20);
-          _20 = (_22.1: std::option::Option<S>);
+          _20 = copy (_22.1: std::option::Option<S>);
           StorageLive(_21);
-          _21 = (_22.2: &[f32]);
+          _21 = copy (_22.2: &[f32]);
           StorageDead(_22);
           StorageLive(_26);
           _26 = const {ALLOC1: &&BigStruct};
           _35 = deref_copy (*_26);
           StorageLive(_23);
           _36 = deref_copy (*_26);
--         _23 = ((*_36).0: f32);
+-         _23 = copy ((*_36).0: f32);
 +         _23 = const 82f32;
           StorageLive(_24);
           _37 = deref_copy (*_26);
-          _24 = ((*_37).1: std::option::Option<S>);
+          _24 = copy ((*_37).1: std::option::Option<S>);
           StorageLive(_25);
           _38 = deref_copy (*_26);
-          _25 = ((*_38).2: &[f32]);
+          _25 = copy ((*_38).2: &[f32]);
           StorageDead(_26);
           StorageLive(_27);
           StorageLive(_28);
--         _28 = _23;
+-         _28 = copy _23;
 +         _28 = const 82f32;
           StorageLive(_29);
-          _29 = _24;
+          _29 = copy _24;
           StorageLive(_30);
-          _30 = _25;
+          _30 = copy _25;
 -         _27 = BigStruct(move _28, move _29, move _30);
 +         _27 = BigStruct(const 82f32, move _29, move _30);
           StorageDead(_30);
diff --git a/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.64bit.diff
index a707d7e5e76e4..78a0944975c86 100644
--- a/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.64bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/struct.main.DataflowConstProp.64bit.diff
@@ -83,7 +83,7 @@
 +         _1 = const S(1_i32);
           StorageLive(_2);
           StorageLive(_3);
--         _3 = (_1.0: i32);
+-         _3 = copy (_1.0: i32);
 -         _2 = Add(move _3, const 2_i32);
 +         _3 = const 1_i32;
 +         _2 = const 3_i32;
@@ -91,10 +91,10 @@
           (_1.0: i32) = const 3_i32;
           StorageLive(_4);
           StorageLive(_5);
--         _5 = _2;
+-         _5 = copy _2;
 +         _5 = const 3_i32;
           StorageLive(_6);
--         _6 = (_1.0: i32);
+-         _6 = copy (_1.0: i32);
 -         _4 = Add(move _5, move _6);
 +         _6 = const 3_i32;
 +         _4 = const 6_i32;
@@ -103,35 +103,35 @@
           StorageLive(_10);
           _10 = const main::SMALL_VAL;
           StorageLive(_7);
--         _7 = (_10.0: f32);
+-         _7 = copy (_10.0: f32);
 +         _7 = const 4f32;
           StorageLive(_8);
-          _8 = (_10.1: std::option::Option<S>);
+          _8 = copy (_10.1: std::option::Option<S>);
           StorageLive(_9);
-          _9 = (_10.2: &[f32]);
+          _9 = copy (_10.2: &[f32]);
           StorageDead(_10);
           StorageLive(_14);
           _14 = const {ALLOC0: &&SmallStruct};
           _31 = deref_copy (*_14);
           StorageLive(_11);
           _32 = deref_copy (*_14);
--         _11 = ((*_32).0: f32);
+-         _11 = copy ((*_32).0: f32);
 +         _11 = const 9f32;
           StorageLive(_12);
           _33 = deref_copy (*_14);
-          _12 = ((*_33).1: std::option::Option<S>);
+          _12 = copy ((*_33).1: std::option::Option<S>);
           StorageLive(_13);
           _34 = deref_copy (*_14);
-          _13 = ((*_34).2: &[f32]);
+          _13 = copy ((*_34).2: &[f32]);
           StorageDead(_14);
           StorageLive(_15);
           StorageLive(_16);
--         _16 = _11;
+-         _16 = copy _11;
 +         _16 = const 9f32;
           StorageLive(_17);
-          _17 = _12;
+          _17 = copy _12;
           StorageLive(_18);
-          _18 = _13;
+          _18 = copy _13;
 -         _15 = SmallStruct(move _16, move _17, move _18);
 +         _15 = SmallStruct(const 9f32, move _17, move _18);
           StorageDead(_18);
@@ -140,35 +140,35 @@
           StorageLive(_22);
           _22 = const main::BIG_VAL;
           StorageLive(_19);
--         _19 = (_22.0: f32);
+-         _19 = copy (_22.0: f32);
 +         _19 = const 25f32;
           StorageLive(_20);
-          _20 = (_22.1: std::option::Option<S>);
+          _20 = copy (_22.1: std::option::Option<S>);
           StorageLive(_21);
-          _21 = (_22.2: &[f32]);
+          _21 = copy (_22.2: &[f32]);
           StorageDead(_22);
           StorageLive(_26);
           _26 = const {ALLOC1: &&BigStruct};
           _35 = deref_copy (*_26);
           StorageLive(_23);
           _36 = deref_copy (*_26);
--         _23 = ((*_36).0: f32);
+-         _23 = copy ((*_36).0: f32);
 +         _23 = const 82f32;
           StorageLive(_24);
           _37 = deref_copy (*_26);
-          _24 = ((*_37).1: std::option::Option<S>);
+          _24 = copy ((*_37).1: std::option::Option<S>);
           StorageLive(_25);
           _38 = deref_copy (*_26);
-          _25 = ((*_38).2: &[f32]);
+          _25 = copy ((*_38).2: &[f32]);
           StorageDead(_26);
           StorageLive(_27);
           StorageLive(_28);
--         _28 = _23;
+-         _28 = copy _23;
 +         _28 = const 82f32;
           StorageLive(_29);
-          _29 = _24;
+          _29 = copy _24;
           StorageLive(_30);
-          _30 = _25;
+          _30 = copy _25;
 -         _27 = BigStruct(move _28, move _29, move _30);
 +         _27 = BigStruct(const 82f32, move _29, move _30);
           StorageDead(_30);
diff --git a/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-abort.diff b/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-abort.diff
index c0f378cc21f88..e13b2aa9f7e36 100644
--- a/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-abort.diff
+++ b/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-abort.diff
@@ -17,7 +17,7 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 -         _3 = Add(move _4, const 1_i32);
 +         _4 = const 1_i32;
 +         _3 = const 2_i32;
diff --git a/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-unwind.diff b/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-unwind.diff
index 395620fec524a..4be25fdcc38d7 100644
--- a/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-unwind.diff
+++ b/tests/mir-opt/dataflow-const-prop/terminator.main.DataflowConstProp.panic-unwind.diff
@@ -17,7 +17,7 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 -         _3 = Add(move _4, const 1_i32);
 +         _4 = const 1_i32;
 +         _3 = const 2_i32;
diff --git a/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.32bit.diff
index 258e2b454ebe2..2d67ac92209b3 100644
--- a/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.32bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.32bit.diff
@@ -13,7 +13,7 @@
           StorageLive(_1);
 -         _1 = const 1_usize as std::boxed::Box<Never> (Transmute);
 +         _1 = const Box::<Never>(Unique::<Never> {{ pointer: NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData::<Never> }}, std::alloc::Global);
-          _2 = (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
+          _2 = copy (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
           unreachable;
       }
   }
diff --git a/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.64bit.diff
index 258e2b454ebe2..2d67ac92209b3 100644
--- a/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.64bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/transmute.unreachable_box.DataflowConstProp.64bit.diff
@@ -13,7 +13,7 @@
           StorageLive(_1);
 -         _1 = const 1_usize as std::boxed::Box<Never> (Transmute);
 +         _1 = const Box::<Never>(Unique::<Never> {{ pointer: NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData::<Never> }}, std::alloc::Global);
-          _2 = (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
+          _2 = copy (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
           unreachable;
       }
   }
diff --git a/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.32bit.diff b/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.32bit.diff
index e4031b65caafe..f7846823e196c 100644
--- a/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.32bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.32bit.diff
@@ -37,10 +37,10 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
--         _4 = (_1.0: i32);
+-         _4 = copy (_1.0: i32);
 +         _4 = const 1_i32;
           StorageLive(_5);
--         _5 = (_1.1: i32);
+-         _5 = copy (_1.1: i32);
 -         _3 = Add(move _4, move _5);
 +         _5 = const 2_i32;
 +         _3 = const 3_i32;
@@ -54,17 +54,17 @@
           StorageLive(_6);
           StorageLive(_7);
           StorageLive(_8);
--         _8 = (_1.0: i32);
+-         _8 = copy (_1.0: i32);
 +         _8 = const 2_i32;
           StorageLive(_9);
--         _9 = (_1.1: i32);
+-         _9 = copy (_1.1: i32);
 -         _7 = Add(move _8, move _9);
 +         _9 = const 3_i32;
 +         _7 = const 5_i32;
           StorageDead(_9);
           StorageDead(_8);
           StorageLive(_10);
--         _10 = _2;
+-         _10 = copy _2;
 -         _6 = Add(move _7, move _10);
 +         _10 = const 6_i32;
 +         _6 = const 11_i32;
@@ -72,13 +72,13 @@
           StorageDead(_7);
           StorageLive(_11);
           StorageLive(_12);
--         _12 = _2;
+-         _12 = copy _2;
 +         _12 = const 6_i32;
           StorageLive(_13);
--         _13 = _1;
+-         _13 = copy _1;
 +         _13 = const (2_i32, 3_i32);
           StorageLive(_14);
--         _14 = _6;
+-         _14 = copy _6;
 -         _11 = (move _12, move _13, move _14);
 +         _14 = const 11_i32;
 +         _11 = (const 6_i32, const (2_i32, 3_i32), const 11_i32);
diff --git a/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.64bit.diff b/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.64bit.diff
index e4031b65caafe..f7846823e196c 100644
--- a/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.64bit.diff
+++ b/tests/mir-opt/dataflow-const-prop/tuple.main.DataflowConstProp.64bit.diff
@@ -37,10 +37,10 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
--         _4 = (_1.0: i32);
+-         _4 = copy (_1.0: i32);
 +         _4 = const 1_i32;
           StorageLive(_5);
--         _5 = (_1.1: i32);
+-         _5 = copy (_1.1: i32);
 -         _3 = Add(move _4, move _5);
 +         _5 = const 2_i32;
 +         _3 = const 3_i32;
@@ -54,17 +54,17 @@
           StorageLive(_6);
           StorageLive(_7);
           StorageLive(_8);
--         _8 = (_1.0: i32);
+-         _8 = copy (_1.0: i32);
 +         _8 = const 2_i32;
           StorageLive(_9);
--         _9 = (_1.1: i32);
+-         _9 = copy (_1.1: i32);
 -         _7 = Add(move _8, move _9);
 +         _9 = const 3_i32;
 +         _7 = const 5_i32;
           StorageDead(_9);
           StorageDead(_8);
           StorageLive(_10);
--         _10 = _2;
+-         _10 = copy _2;
 -         _6 = Add(move _7, move _10);
 +         _10 = const 6_i32;
 +         _6 = const 11_i32;
@@ -72,13 +72,13 @@
           StorageDead(_7);
           StorageLive(_11);
           StorageLive(_12);
--         _12 = _2;
+-         _12 = copy _2;
 +         _12 = const 6_i32;
           StorageLive(_13);
--         _13 = _1;
+-         _13 = copy _1;
 +         _13 = const (2_i32, 3_i32);
           StorageLive(_14);
--         _14 = _6;
+-         _14 = copy _6;
 -         _11 = (move _12, move _13, move _14);
 +         _14 = const 11_i32;
 +         _11 = (const 6_i32, const (2_i32, 3_i32), const 11_i32);
diff --git a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-abort.diff b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-abort.diff
index 07fb8301b9a94..80b727dd1a451 100644
--- a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-abort.diff
+++ b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-abort.diff
@@ -5,7 +5,7 @@
       let mut _0: ();
   
       bb0: {
-          _0 = use_both(const 0_i32, (_1.1: i32)) -> [return: bb1, unwind unreachable];
+          _0 = use_both(const 0_i32, copy (_1.1: i32)) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-unwind.diff b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-unwind.diff
index cac3badfa6732..c7aff795bd8c5 100644
--- a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-unwind.diff
+++ b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_packed.DeadStoreElimination-final.panic-unwind.diff
@@ -5,7 +5,7 @@
       let mut _0: ();
   
       bb0: {
-          _0 = use_both(const 0_i32, (_1.1: i32)) -> [return: bb1, unwind continue];
+          _0 = use_both(const 0_i32, copy (_1.1: i32)) -> [return: bb1, unwind continue];
       }
   
       bb1: {
diff --git a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-abort.diff b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-abort.diff
index f9bc9405d6a4b..a09ef3e4f34a9 100644
--- a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-abort.diff
+++ b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-abort.diff
@@ -10,8 +10,8 @@
   
       bb0: {
           StorageLive(_2);
--         _2 = use_both(_1, _1) -> [return: bb1, unwind unreachable];
-+         _2 = use_both(_1, move _1) -> [return: bb1, unwind unreachable];
+-         _2 = use_both(copy _1, copy _1) -> [return: bb1, unwind unreachable];
++         _2 = use_both(copy _1, move _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-unwind.diff b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-unwind.diff
index efe165422d943..09413c99fefb1 100644
--- a/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-unwind.diff
+++ b/tests/mir-opt/dead-store-elimination/call_arg_copy.move_simple.DeadStoreElimination-final.panic-unwind.diff
@@ -10,8 +10,8 @@
   
       bb0: {
           StorageLive(_2);
--         _2 = use_both(_1, _1) -> [return: bb1, unwind continue];
-+         _2 = use_both(_1, move _1) -> [return: bb1, unwind continue];
+-         _2 = use_both(copy _1, copy _1) -> [return: bb1, unwind continue];
++         _2 = use_both(copy _1, move _1) -> [return: bb1, unwind continue];
       }
   
       bb1: {
diff --git a/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination-initial.diff
index 2766b6ce6a9fa..ff18df1efcfc9 100644
--- a/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination-initial.diff
+++ b/tests/mir-opt/dead-store-elimination/cycle.cycle.DeadStoreElimination-initial.diff
@@ -11,14 +11,14 @@
       }
   
       bb1: {
-          switchInt(_4) -> [1: bb2, otherwise: bb3];
+          switchInt(copy _4) -> [1: bb2, otherwise: bb3];
       }
   
       bb2: {
--         _5 = _3;
--         _3 = _2;
--         _2 = _1;
--         _1 = _5;
+-         _5 = copy _3;
+-         _3 = copy _2;
+-         _2 = copy _1;
+-         _1 = copy _5;
 +         nop;
 +         nop;
 +         nop;
diff --git a/tests/mir-opt/dead-store-elimination/provenance_soundness.pointer_to_int.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/provenance_soundness.pointer_to_int.DeadStoreElimination-initial.diff
index 56d5c24ae1dc4..5d054e2ea16f4 100644
--- a/tests/mir-opt/dead-store-elimination/provenance_soundness.pointer_to_int.DeadStoreElimination-initial.diff
+++ b/tests/mir-opt/dead-store-elimination/provenance_soundness.pointer_to_int.DeadStoreElimination-initial.diff
@@ -18,12 +18,12 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = move _3 as usize (PointerExposeProvenance);
           StorageDead(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           _4 = move _5 as isize (PointerExposeProvenance);
           StorageDead(_5);
           _0 = const ();
diff --git a/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-abort.diff b/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-abort.diff
index efb28ba344b2b..60742ef0e9a90 100644
--- a/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-abort.diff
+++ b/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-abort.diff
@@ -37,40 +37,40 @@
       }
   
       bb3: {
-          switchInt((*_2)[0 of 4]) -> [47: bb4, otherwise: bb2];
+          switchInt(copy (*_2)[0 of 4]) -> [47: bb4, otherwise: bb2];
       }
   
       bb4: {
-          switchInt((*_2)[1 of 4]) -> [47: bb5, otherwise: bb2];
+          switchInt(copy (*_2)[1 of 4]) -> [47: bb5, otherwise: bb2];
       }
   
       bb5: {
-          switchInt((*_2)[2 of 4]) -> [47: bb6, otherwise: bb2];
+          switchInt(copy (*_2)[2 of 4]) -> [47: bb6, otherwise: bb2];
       }
   
       bb6: {
--         switchInt((*_2)[3 of 4]) -> [47: bb13, otherwise: bb2];
-+         switchInt((*_2)[3 of 4]) -> [47: bb11, otherwise: bb2];
+-         switchInt(copy (*_2)[3 of 4]) -> [47: bb13, otherwise: bb2];
++         switchInt(copy (*_2)[3 of 4]) -> [47: bb11, otherwise: bb2];
       }
   
       bb7: {
 -         _0 = const false;
 -         goto -> bb14;
-+         switchInt((*_2)[0 of 3]) -> [47: bb8, otherwise: bb11];
++         switchInt(copy (*_2)[0 of 3]) -> [47: bb8, otherwise: bb11];
       }
   
       bb8: {
--         switchInt((*_2)[0 of 3]) -> [47: bb9, otherwise: bb7];
-+         switchInt((*_2)[1 of 3]) -> [47: bb9, otherwise: bb11];
+-         switchInt(copy (*_2)[0 of 3]) -> [47: bb9, otherwise: bb7];
++         switchInt(copy (*_2)[1 of 3]) -> [47: bb9, otherwise: bb11];
       }
   
       bb9: {
--         switchInt((*_2)[1 of 3]) -> [47: bb10, otherwise: bb7];
-+         switchInt((*_2)[2 of 3]) -> [47: bb10, 33: bb10, otherwise: bb11];
+-         switchInt(copy (*_2)[1 of 3]) -> [47: bb10, otherwise: bb7];
++         switchInt(copy (*_2)[2 of 3]) -> [47: bb10, 33: bb10, otherwise: bb11];
       }
   
       bb10: {
--         switchInt((*_2)[2 of 3]) -> [47: bb12, 33: bb11, otherwise: bb7];
+-         switchInt(copy (*_2)[2 of 3]) -> [47: bb12, 33: bb11, otherwise: bb7];
 -     }
 - 
 -     bb11: {
diff --git a/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-unwind.diff b/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-unwind.diff
index c6e2d3a551259..7337a32f525f9 100644
--- a/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-unwind.diff
+++ b/tests/mir-opt/deduplicate_blocks.is_line_doc_comment_2.DeduplicateBlocks.panic-unwind.diff
@@ -37,40 +37,40 @@
       }
   
       bb3: {
-          switchInt((*_2)[0 of 4]) -> [47: bb4, otherwise: bb2];
+          switchInt(copy (*_2)[0 of 4]) -> [47: bb4, otherwise: bb2];
       }
   
       bb4: {
-          switchInt((*_2)[1 of 4]) -> [47: bb5, otherwise: bb2];
+          switchInt(copy (*_2)[1 of 4]) -> [47: bb5, otherwise: bb2];
       }
   
       bb5: {
-          switchInt((*_2)[2 of 4]) -> [47: bb6, otherwise: bb2];
+          switchInt(copy (*_2)[2 of 4]) -> [47: bb6, otherwise: bb2];
       }
   
       bb6: {
--         switchInt((*_2)[3 of 4]) -> [47: bb13, otherwise: bb2];
-+         switchInt((*_2)[3 of 4]) -> [47: bb11, otherwise: bb2];
+-         switchInt(copy (*_2)[3 of 4]) -> [47: bb13, otherwise: bb2];
++         switchInt(copy (*_2)[3 of 4]) -> [47: bb11, otherwise: bb2];
       }
   
       bb7: {
 -         _0 = const false;
 -         goto -> bb14;
-+         switchInt((*_2)[0 of 3]) -> [47: bb8, otherwise: bb11];
++         switchInt(copy (*_2)[0 of 3]) -> [47: bb8, otherwise: bb11];
       }
   
       bb8: {
--         switchInt((*_2)[0 of 3]) -> [47: bb9, otherwise: bb7];
-+         switchInt((*_2)[1 of 3]) -> [47: bb9, otherwise: bb11];
+-         switchInt(copy (*_2)[0 of 3]) -> [47: bb9, otherwise: bb7];
++         switchInt(copy (*_2)[1 of 3]) -> [47: bb9, otherwise: bb11];
       }
   
       bb9: {
--         switchInt((*_2)[1 of 3]) -> [47: bb10, otherwise: bb7];
-+         switchInt((*_2)[2 of 3]) -> [47: bb10, 33: bb10, otherwise: bb11];
+-         switchInt(copy (*_2)[1 of 3]) -> [47: bb10, otherwise: bb7];
++         switchInt(copy (*_2)[2 of 3]) -> [47: bb10, 33: bb10, otherwise: bb11];
       }
   
       bb10: {
--         switchInt((*_2)[2 of 3]) -> [47: bb12, 33: bb11, otherwise: bb7];
+-         switchInt(copy (*_2)[2 of 3]) -> [47: bb12, 33: bb11, otherwise: bb7];
 -     }
 - 
 -     bb11: {
diff --git a/tests/mir-opt/derefer_complex_case.main.Derefer.panic-abort.diff b/tests/mir-opt/derefer_complex_case.main.Derefer.panic-abort.diff
index 4ead50e96d8b1..bac62c886688d 100644
--- a/tests/mir-opt/derefer_complex_case.main.Derefer.panic-abort.diff
+++ b/tests/mir-opt/derefer_complex_case.main.Derefer.panic-abort.diff
@@ -64,11 +64,11 @@
   
       bb5: {
           StorageLive(_12);
--         _12 = (*((_7 as Some).0: &i32));
+-         _12 = copy (*((_7 as Some).0: &i32));
 +         _15 = deref_copy ((_7 as Some).0: &i32);
-+         _12 = (*_15);
++         _12 = copy (*_15);
           StorageLive(_13);
-          _13 = _12;
+          _13 = copy _12;
           _6 = std::mem::drop::<i32>(move _13) -> [return: bb7, unwind: bb8];
       }
   
diff --git a/tests/mir-opt/derefer_complex_case.main.Derefer.panic-unwind.diff b/tests/mir-opt/derefer_complex_case.main.Derefer.panic-unwind.diff
index c7cf5f02e0ea7..55cd2e427eea9 100644
--- a/tests/mir-opt/derefer_complex_case.main.Derefer.panic-unwind.diff
+++ b/tests/mir-opt/derefer_complex_case.main.Derefer.panic-unwind.diff
@@ -64,11 +64,11 @@
   
       bb5: {
           StorageLive(_12);
--         _12 = (*((_7 as Some).0: &i32));
+-         _12 = copy (*((_7 as Some).0: &i32));
 +         _15 = deref_copy ((_7 as Some).0: &i32);
-+         _12 = (*_15);
++         _12 = copy (*_15);
           StorageLive(_13);
-          _13 = _12;
+          _13 = copy _12;
           _6 = std::mem::drop::<i32>(move _13) -> [return: bb7, unwind continue];
       }
   
diff --git a/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-abort.diff b/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-abort.diff
index f4c034517f7e7..012d2eb8b72c5 100644
--- a/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-abort.diff
+++ b/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-abort.diff
@@ -52,7 +52,7 @@
           _5 = &_6;
           _4 = &_5;
 -         PlaceMention((*(*(*(*_4)))));
--         switchInt((*(*(*(*_4))))) -> [0: bb3, otherwise: bb4];
+-         switchInt(copy (*(*(*(*_4))))) -> [0: bb3, otherwise: bb4];
 +         _10 = deref_copy (*_4);
 +         _11 = deref_copy (*_10);
 +         _12 = deref_copy (*_11);
@@ -60,7 +60,7 @@
 +         _13 = deref_copy (*_4);
 +         _14 = deref_copy (*_13);
 +         _15 = deref_copy (*_14);
-+         switchInt((*_15)) -> [0: bb3, otherwise: bb4];
++         switchInt(copy (*_15)) -> [0: bb3, otherwise: bb4];
       }
   
       bb3: {
diff --git a/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-unwind.diff b/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-unwind.diff
index e3c0c6b7dd271..43cee2923352c 100644
--- a/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-unwind.diff
+++ b/tests/mir-opt/derefer_terminator_test.main.Derefer.panic-unwind.diff
@@ -52,7 +52,7 @@
           _5 = &_6;
           _4 = &_5;
 -         PlaceMention((*(*(*(*_4)))));
--         switchInt((*(*(*(*_4))))) -> [0: bb3, otherwise: bb4];
+-         switchInt(copy (*(*(*(*_4))))) -> [0: bb3, otherwise: bb4];
 +         _10 = deref_copy (*_4);
 +         _11 = deref_copy (*_10);
 +         _12 = deref_copy (*_11);
@@ -60,7 +60,7 @@
 +         _13 = deref_copy (*_4);
 +         _14 = deref_copy (*_13);
 +         _15 = deref_copy (*_14);
-+         switchInt((*_15)) -> [0: bb3, otherwise: bb4];
++         switchInt(copy (*_15)) -> [0: bb3, otherwise: bb4];
       }
   
       bb3: {
diff --git a/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-abort.diff
index 10ec3aa555ee1..775d51ea49f34 100644
--- a/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-abort.diff
@@ -35,7 +35,7 @@
       }
   
       bb3: {
--         _2 = _1;
+-         _2 = copy _1;
 +         nop;
           goto -> bb6;
       }
@@ -47,14 +47,14 @@
   
       bb5: {
           StorageDead(_4);
--         _2 = _1;
+-         _2 = copy _1;
 +         nop;
           goto -> bb6;
       }
   
       bb6: {
           StorageDead(_3);
--         _0 = _2;
+-         _0 = copy _2;
 -         StorageDead(_2);
 -         StorageDead(_1);
 +         nop;
diff --git a/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-unwind.diff
index 759c1cabf45e7..875ef8829d083 100644
--- a/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/branch.foo.DestinationPropagation.panic-unwind.diff
@@ -35,7 +35,7 @@
       }
   
       bb3: {
--         _2 = _1;
+-         _2 = copy _1;
 +         nop;
           goto -> bb6;
       }
@@ -47,14 +47,14 @@
   
       bb5: {
           StorageDead(_4);
--         _2 = _1;
+-         _2 = copy _1;
 +         nop;
           goto -> bb6;
       }
   
       bb6: {
           StorageDead(_3);
--         _0 = _2;
+-         _0 = copy _2;
 -         StorageDead(_2);
 -         StorageDead(_1);
 +         nop;
diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-abort.diff
index 1aed07f9e6ab1..a4908c05e2e11 100644
--- a/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-abort.diff
@@ -12,11 +12,11 @@
   
       bb0: {
 -         StorageLive(_2);
--         _2 = _1;
+-         _2 = copy _1;
 +         nop;
-+         _0 = _1;
++         _0 = copy _1;
           _1 = const 123_i32;
--         _0 = _2;
+-         _0 = copy _2;
 -         StorageDead(_2);
 +         nop;
 +         nop;
diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-unwind.diff
index 1aed07f9e6ab1..a4908c05e2e11 100644
--- a/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/copy_propagation_arg.arg_src.DestinationPropagation.panic-unwind.diff
@@ -12,11 +12,11 @@
   
       bb0: {
 -         StorageLive(_2);
--         _2 = _1;
+-         _2 = copy _1;
 +         nop;
-+         _0 = _1;
++         _0 = copy _1;
           _1 = const 123_i32;
--         _0 = _2;
+-         _0 = copy _2;
 -         StorageDead(_2);
 +         nop;
 +         nop;
diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-abort.diff
index 641dea594e119..24f2b464e2cb8 100644
--- a/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-abort.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
 -         StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 -         _2 = dummy(move _3) -> [return: bb1, unwind unreachable];
 +         nop;
 +         nop;
diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-unwind.diff
index 8b2835c8ced2a..d42ac52b6319a 100644
--- a/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/copy_propagation_arg.bar.DestinationPropagation.panic-unwind.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
 -         StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 -         _2 = dummy(move _3) -> [return: bb1, unwind continue];
 +         nop;
 +         nop;
diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-abort.diff
index 4cddaec01d2d3..f1f1714b472ec 100644
--- a/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-abort.diff
@@ -8,14 +8,14 @@
   
       bb0: {
 -         StorageLive(_2);
--         _2 = _1;
+-         _2 = copy _1;
 -         _1 = move _2;
 -         StorageDead(_2);
 +         nop;
 +         nop;
 +         nop;
 +         nop;
-          _0 = _1;
+          _0 = copy _1;
           return;
       }
   }
diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-unwind.diff
index 4cddaec01d2d3..f1f1714b472ec 100644
--- a/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/copy_propagation_arg.baz.DestinationPropagation.panic-unwind.diff
@@ -8,14 +8,14 @@
   
       bb0: {
 -         StorageLive(_2);
--         _2 = _1;
+-         _2 = copy _1;
 -         _1 = move _2;
 -         StorageDead(_2);
 +         nop;
 +         nop;
 +         nop;
 +         nop;
-          _0 = _1;
+          _0 = copy _1;
           return;
       }
   }
diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff
index b461869be3189..0328fc6b745b2 100644
--- a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-abort.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
 -         StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 -         _2 = dummy(move _3) -> [return: bb1, unwind unreachable];
 +         nop;
 +         nop;
diff --git a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff
index d5c2e07c6c234..30e2248db8205 100644
--- a/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/copy_propagation_arg.foo.DestinationPropagation.panic-unwind.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
 -         StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 -         _2 = dummy(move _3) -> [return: bb1, unwind continue];
 +         nop;
 +         nop;
diff --git a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff
index 98b4ee866d2b6..5d8aaedae3742 100644
--- a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-abort.diff
@@ -31,11 +31,11 @@
   
       bb1: {
 -         StorageLive(_2);
--         _2 = _1;
+-         _2 = copy _1;
 -         StorageLive(_3);
--         _3 = _2;
+-         _3 = copy _2;
 -         StorageLive(_4);
--         _4 = _3;
+-         _4 = copy _3;
 -         _1 = move _4;
 -         StorageDead(_4);
 +         nop;
@@ -48,7 +48,7 @@
 +         nop;
           StorageLive(_5);
 -         StorageLive(_6);
--         _6 = _1;
+-         _6 = copy _1;
 +         nop;
 +         nop;
           _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind unreachable];
diff --git a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff
index 6f6e01d37b1a6..05c9bcc1d7371 100644
--- a/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/cycle.main.DestinationPropagation.panic-unwind.diff
@@ -31,11 +31,11 @@
   
       bb1: {
 -         StorageLive(_2);
--         _2 = _1;
+-         _2 = copy _1;
 -         StorageLive(_3);
--         _3 = _2;
+-         _3 = copy _2;
 -         StorageLive(_4);
--         _4 = _3;
+-         _4 = copy _3;
 -         _1 = move _4;
 -         StorageDead(_4);
 +         nop;
@@ -48,7 +48,7 @@
 +         nop;
           StorageLive(_5);
 -         StorageLive(_6);
--         _6 = _1;
+-         _6 = copy _1;
 +         nop;
 +         nop;
           _5 = std::mem::drop::<i32>(move _6) -> [return: bb2, unwind continue];
diff --git a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir
index eb160fc194a81..eb4209731c62f 100644
--- a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir
+++ b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-abort.mir
@@ -12,7 +12,7 @@ fn f(_1: usize) -> usize {
 
     bb0: {
         nop;
-        _3 = _1;
+        _3 = copy _1;
         _1 = const 5_usize;
         nop;
         nop;
diff --git a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir
index 9147de2ec473b..fe9a7376a5856 100644
--- a/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir
+++ b/tests/mir-opt/dest-prop/dead_stores_79191.f.DestinationPropagation.after.panic-unwind.mir
@@ -12,7 +12,7 @@ fn f(_1: usize) -> usize {
 
     bb0: {
         nop;
-        _3 = _1;
+        _3 = copy _1;
         _1 = const 5_usize;
         nop;
         nop;
diff --git a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir
index eb160fc194a81..eb4209731c62f 100644
--- a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir
+++ b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-abort.mir
@@ -12,7 +12,7 @@ fn f(_1: usize) -> usize {
 
     bb0: {
         nop;
-        _3 = _1;
+        _3 = copy _1;
         _1 = const 5_usize;
         nop;
         nop;
diff --git a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir
index 9147de2ec473b..fe9a7376a5856 100644
--- a/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir
+++ b/tests/mir-opt/dest-prop/dead_stores_better.f.DestinationPropagation.after.panic-unwind.mir
@@ -12,7 +12,7 @@ fn f(_1: usize) -> usize {
 
     bb0: {
         nop;
-        _3 = _1;
+        _3 = copy _1;
         _1 = const 5_usize;
         nop;
         nop;
diff --git a/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-abort.diff
index 4d34f43fd5ce6..e9fbcf20a7228 100644
--- a/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-abort.diff
@@ -18,7 +18,7 @@
           _2 = [const 0_u8; 1024];
           StorageLive(_3);
 -         StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 +         nop;
 +         nop;
           StorageLive(_5);
@@ -35,7 +35,7 @@
 +         nop;
           StorageDead(_6);
           StorageDead(_3);
-          _0 = _2;
+          _0 = copy _2;
           StorageDead(_2);
           return;
       }
diff --git a/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-unwind.diff
index 9c3cbef38d698..95d5fe1b9304b 100644
--- a/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/simple.nrvo.DestinationPropagation.panic-unwind.diff
@@ -18,7 +18,7 @@
           _2 = [const 0_u8; 1024];
           StorageLive(_3);
 -         StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 +         nop;
 +         nop;
           StorageLive(_5);
@@ -35,7 +35,7 @@
 +         nop;
           StorageDead(_6);
           StorageDead(_3);
-          _0 = _2;
+          _0 = copy _2;
           StorageDead(_2);
           return;
       }
diff --git a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff
index b596e25ddfdff..557320f017984 100644
--- a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff
+++ b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-abort.diff
@@ -22,7 +22,7 @@
           _1 = Un { us: const 1_u32 };
           StorageDead(_2);
           StorageLive(_3);
-          _3 = (_1.0: u32);
+          _3 = copy (_1.0: u32);
           StorageDead(_3);
           StorageDead(_1);
           return;
diff --git a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff
index b596e25ddfdff..557320f017984 100644
--- a/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff
+++ b/tests/mir-opt/dest-prop/union.main.DestinationPropagation.panic-unwind.diff
@@ -22,7 +22,7 @@
           _1 = Un { us: const 1_u32 };
           StorageDead(_2);
           StorageLive(_3);
-          _3 = (_1.0: u32);
+          _3 = copy (_1.0: u32);
           StorageDead(_3);
           StorageDead(_1);
           return;
diff --git a/tests/mir-opt/early_otherwise_branch.opt1.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch.opt1.EarlyOtherwiseBranch.diff
index 4af3ed3e1d1ba..51c41996678c8 100644
--- a/tests/mir-opt/early_otherwise_branch.opt1.EarlyOtherwiseBranch.diff
+++ b/tests/mir-opt/early_otherwise_branch.opt1.EarlyOtherwiseBranch.diff
@@ -20,9 +20,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
           _3 = (move _4, move _5);
           StorageDead(_5);
           StorageDead(_4);
@@ -42,9 +42,9 @@
   
       bb3: {
           StorageLive(_8);
-          _8 = (((_3.0: std::option::Option<u32>) as Some).0: u32);
+          _8 = copy (((_3.0: std::option::Option<u32>) as Some).0: u32);
           StorageLive(_9);
-          _9 = (((_3.1: std::option::Option<u32>) as Some).0: u32);
+          _9 = copy (((_3.1: std::option::Option<u32>) as Some).0: u32);
           _0 = const 0_u32;
           StorageDead(_9);
           StorageDead(_8);
diff --git a/tests/mir-opt/early_otherwise_branch.opt2.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch.opt2.EarlyOtherwiseBranch.diff
index 41ae2fd3af3f4..f17ebee9416fe 100644
--- a/tests/mir-opt/early_otherwise_branch.opt2.EarlyOtherwiseBranch.diff
+++ b/tests/mir-opt/early_otherwise_branch.opt2.EarlyOtherwiseBranch.diff
@@ -21,9 +21,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
           _3 = (move _4, move _5);
           StorageDead(_5);
           StorageDead(_4);
@@ -53,9 +53,9 @@
   
       bb5: {
           StorageLive(_9);
-          _9 = (((_3.0: std::option::Option<u32>) as Some).0: u32);
+          _9 = copy (((_3.0: std::option::Option<u32>) as Some).0: u32);
           StorageLive(_10);
-          _10 = (((_3.1: std::option::Option<u32>) as Some).0: u32);
+          _10 = copy (((_3.1: std::option::Option<u32>) as Some).0: u32);
           _0 = const 0_u32;
           StorageDead(_10);
           StorageDead(_9);
diff --git a/tests/mir-opt/early_otherwise_branch.opt3.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch.opt3.EarlyOtherwiseBranch.diff
index 302fd0bfded4b..7b94a4c2bf737 100644
--- a/tests/mir-opt/early_otherwise_branch.opt3.EarlyOtherwiseBranch.diff
+++ b/tests/mir-opt/early_otherwise_branch.opt3.EarlyOtherwiseBranch.diff
@@ -35,7 +35,7 @@
 +         StorageLive(_12);
 +         _12 = discriminant((_3.1: Option2<bool>));
 +         StorageLive(_13);
-+         _13 = Ne(_9, move _12);
++         _13 = Ne(copy _9, move _12);
 +         StorageDead(_12);
 +         switchInt(move _13) -> [0: bb7, otherwise: bb1];
       }
@@ -78,9 +78,9 @@
 -     bb7: {
 +     bb4: {
           StorageLive(_10);
-          _10 = (((_3.0: Option2<u32>) as Some).0: u32);
+          _10 = copy (((_3.0: Option2<u32>) as Some).0: u32);
           StorageLive(_11);
-          _11 = (((_3.1: Option2<bool>) as Some).0: bool);
+          _11 = copy (((_3.1: Option2<bool>) as Some).0: bool);
           _0 = const 0_u32;
           StorageDead(_11);
           StorageDead(_10);
@@ -101,7 +101,7 @@
 + 
 +     bb7: {
 +         StorageDead(_13);
-+         switchInt(_9) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb6];
++         switchInt(copy _9) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb6];
       }
   }
   
diff --git a/tests/mir-opt/early_otherwise_branch.opt4.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch.opt4.EarlyOtherwiseBranch.diff
index eef4fb3278c1c..f52795baef81b 100644
--- a/tests/mir-opt/early_otherwise_branch.opt4.EarlyOtherwiseBranch.diff
+++ b/tests/mir-opt/early_otherwise_branch.opt4.EarlyOtherwiseBranch.diff
@@ -35,7 +35,7 @@
 +         StorageLive(_12);
 +         _12 = discriminant((_3.1: Option2<u32>));
 +         StorageLive(_13);
-+         _13 = Ne(_9, move _12);
++         _13 = Ne(copy _9, move _12);
 +         StorageDead(_12);
 +         switchInt(move _13) -> [0: bb7, otherwise: bb1];
       }
@@ -78,9 +78,9 @@
 -     bb7: {
 +     bb4: {
           StorageLive(_10);
-          _10 = (((_3.0: Option2<u32>) as Some).0: u32);
+          _10 = copy (((_3.0: Option2<u32>) as Some).0: u32);
           StorageLive(_11);
-          _11 = (((_3.1: Option2<u32>) as Some).0: u32);
+          _11 = copy (((_3.1: Option2<u32>) as Some).0: u32);
           _0 = const 0_u32;
           StorageDead(_11);
           StorageDead(_10);
@@ -101,7 +101,7 @@
 + 
 +     bb7: {
 +         StorageDead(_13);
-+         switchInt(_9) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb6];
++         switchInt(copy _9) -> [0: bb4, 1: bb3, 2: bb2, otherwise: bb6];
       }
   }
   
diff --git a/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt1.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt1.EarlyOtherwiseBranch.diff
index cb03e2697ccd3..98df9934af05d 100644
--- a/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt1.EarlyOtherwiseBranch.diff
+++ b/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt1.EarlyOtherwiseBranch.diff
@@ -27,11 +27,11 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           StorageLive(_6);
-          _6 = _2;
+          _6 = copy _2;
           StorageLive(_7);
-          _7 = _3;
+          _7 = copy _3;
           _4 = (move _5, move _6, move _7);
           StorageDead(_7);
           StorageDead(_6);
@@ -72,11 +72,11 @@
   
       bb7: {
           StorageLive(_13);
-          _13 = (((_4.0: std::option::Option<u32>) as Some).0: u32);
+          _13 = copy (((_4.0: std::option::Option<u32>) as Some).0: u32);
           StorageLive(_14);
-          _14 = (((_4.1: std::option::Option<u32>) as Some).0: u32);
+          _14 = copy (((_4.1: std::option::Option<u32>) as Some).0: u32);
           StorageLive(_15);
-          _15 = (((_4.2: std::option::Option<u32>) as Some).0: u32);
+          _15 = copy (((_4.2: std::option::Option<u32>) as Some).0: u32);
           _0 = const 0_u32;
           StorageDead(_15);
           StorageDead(_14);
diff --git a/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt2.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt2.EarlyOtherwiseBranch.diff
index 5634df253a5d0..831d8cbb4d60b 100644
--- a/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt2.EarlyOtherwiseBranch.diff
+++ b/tests/mir-opt/early_otherwise_branch_3_element_tuple.opt2.EarlyOtherwiseBranch.diff
@@ -45,7 +45,7 @@
 +         StorageLive(_18);
 +         _18 = discriminant((_4.1: Option2<u32>));
 +         StorageLive(_19);
-+         _19 = Ne(_14, move _18);
++         _19 = Ne(copy _14, move _18);
 +         StorageDead(_18);
 +         switchInt(move _19) -> [0: bb10, otherwise: bb1];
       }
@@ -109,11 +109,11 @@
 -     bb10: {
 +     bb7: {
           StorageLive(_15);
-          _15 = (((_4.0: Option2<u32>) as Some).0: u32);
+          _15 = copy (((_4.0: Option2<u32>) as Some).0: u32);
           StorageLive(_16);
-          _16 = (((_4.1: Option2<u32>) as Some).0: u32);
+          _16 = copy (((_4.1: Option2<u32>) as Some).0: u32);
           StorageLive(_17);
-          _17 = (((_4.2: Option2<u32>) as Some).0: u32);
+          _17 = copy (((_4.2: Option2<u32>) as Some).0: u32);
           _0 = const 0_u32;
           StorageDead(_17);
           StorageDead(_16);
@@ -135,7 +135,7 @@
 + 
 +     bb10: {
 +         StorageDead(_19);
-+         switchInt(_14) -> [0: bb2, 1: bb3, 2: bb4, otherwise: bb9];
++         switchInt(copy _14) -> [0: bb2, 1: bb3, 2: bb4, otherwise: bb9];
       }
   }
   
diff --git a/tests/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff
index 8179d9dd11505..fec318c1ab492 100644
--- a/tests/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff
+++ b/tests/mir-opt/early_otherwise_branch_68867.try_sum.EarlyOtherwiseBranch.diff
@@ -70,9 +70,9 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           StorageLive(_6);
-          _6 = _2;
+          _6 = copy _2;
           _4 = (move _5, move _6);
           StorageDead(_6);
           StorageDead(_5);
@@ -118,15 +118,15 @@
       bb6: {
           StorageLive(_27);
           _39 = deref_copy (_4.0: &ViewportPercentageLength);
-          _27 = (((*_39) as Vmax).0: f32);
+          _27 = copy (((*_39) as Vmax).0: f32);
           StorageLive(_28);
           _40 = deref_copy (_4.1: &ViewportPercentageLength);
-          _28 = (((*_40) as Vmax).0: f32);
+          _28 = copy (((*_40) as Vmax).0: f32);
           StorageLive(_29);
           StorageLive(_30);
-          _30 = _27;
+          _30 = copy _27;
           StorageLive(_31);
-          _31 = _28;
+          _31 = copy _28;
           _29 = Add(move _30, move _31);
           StorageDead(_31);
           StorageDead(_30);
@@ -140,15 +140,15 @@
       bb7: {
           StorageLive(_22);
           _41 = deref_copy (_4.0: &ViewportPercentageLength);
-          _22 = (((*_41) as Vmin).0: f32);
+          _22 = copy (((*_41) as Vmin).0: f32);
           StorageLive(_23);
           _42 = deref_copy (_4.1: &ViewportPercentageLength);
-          _23 = (((*_42) as Vmin).0: f32);
+          _23 = copy (((*_42) as Vmin).0: f32);
           StorageLive(_24);
           StorageLive(_25);
-          _25 = _22;
+          _25 = copy _22;
           StorageLive(_26);
-          _26 = _23;
+          _26 = copy _23;
           _24 = Add(move _25, move _26);
           StorageDead(_26);
           StorageDead(_25);
@@ -162,15 +162,15 @@
       bb8: {
           StorageLive(_17);
           _43 = deref_copy (_4.0: &ViewportPercentageLength);
-          _17 = (((*_43) as Vh).0: f32);
+          _17 = copy (((*_43) as Vh).0: f32);
           StorageLive(_18);
           _44 = deref_copy (_4.1: &ViewportPercentageLength);
-          _18 = (((*_44) as Vh).0: f32);
+          _18 = copy (((*_44) as Vh).0: f32);
           StorageLive(_19);
           StorageLive(_20);
-          _20 = _17;
+          _20 = copy _17;
           StorageLive(_21);
-          _21 = _18;
+          _21 = copy _18;
           _19 = Add(move _20, move _21);
           StorageDead(_21);
           StorageDead(_20);
@@ -184,15 +184,15 @@
       bb9: {
           StorageLive(_12);
           _45 = deref_copy (_4.0: &ViewportPercentageLength);
-          _12 = (((*_45) as Vw).0: f32);
+          _12 = copy (((*_45) as Vw).0: f32);
           StorageLive(_13);
           _46 = deref_copy (_4.1: &ViewportPercentageLength);
-          _13 = (((*_46) as Vw).0: f32);
+          _13 = copy (((*_46) as Vw).0: f32);
           StorageLive(_14);
           StorageLive(_15);
-          _15 = _12;
+          _15 = copy _12;
           StorageLive(_16);
-          _16 = _13;
+          _16 = copy _13;
           _14 = Add(move _15, move _16);
           StorageDead(_16);
           StorageDead(_15);
diff --git a/tests/mir-opt/early_otherwise_branch_noopt.noopt1.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_noopt.noopt1.EarlyOtherwiseBranch.diff
index 651b1de4ddd37..8ed2274a72beb 100644
--- a/tests/mir-opt/early_otherwise_branch_noopt.noopt1.EarlyOtherwiseBranch.diff
+++ b/tests/mir-opt/early_otherwise_branch_noopt.noopt1.EarlyOtherwiseBranch.diff
@@ -29,9 +29,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
           _3 = (move _4, move _5);
           StorageDead(_5);
           StorageDead(_4);
@@ -60,7 +60,7 @@
   
       bb5: {
           StorageLive(_12);
-          _12 = (((_3.1: std::option::Option<u32>) as Some).0: u32);
+          _12 = copy (((_3.1: std::option::Option<u32>) as Some).0: u32);
           _0 = const 2_u32;
           StorageDead(_12);
           goto -> bb8;
@@ -68,7 +68,7 @@
   
       bb6: {
           StorageLive(_11);
-          _11 = (((_3.0: std::option::Option<u32>) as Some).0: u32);
+          _11 = copy (((_3.0: std::option::Option<u32>) as Some).0: u32);
           _0 = const 1_u32;
           StorageDead(_11);
           goto -> bb8;
@@ -76,9 +76,9 @@
   
       bb7: {
           StorageLive(_9);
-          _9 = (((_3.0: std::option::Option<u32>) as Some).0: u32);
+          _9 = copy (((_3.0: std::option::Option<u32>) as Some).0: u32);
           StorageLive(_10);
-          _10 = (((_3.1: std::option::Option<u32>) as Some).0: u32);
+          _10 = copy (((_3.1: std::option::Option<u32>) as Some).0: u32);
           _0 = const 0_u32;
           StorageDead(_10);
           StorageDead(_9);
diff --git a/tests/mir-opt/early_otherwise_branch_soundness.no_deref_ptr.EarlyOtherwiseBranch.diff b/tests/mir-opt/early_otherwise_branch_soundness.no_deref_ptr.EarlyOtherwiseBranch.diff
index 8eab59823f4b9..eeb8b766b5d13 100644
--- a/tests/mir-opt/early_otherwise_branch_soundness.no_deref_ptr.EarlyOtherwiseBranch.diff
+++ b/tests/mir-opt/early_otherwise_branch_soundness.no_deref_ptr.EarlyOtherwiseBranch.diff
@@ -34,8 +34,8 @@
   
       bb4: {
           StorageLive(_5);
-          _5 = (((*_2) as Some).0: i32);
-          _0 = _5;
+          _5 = copy (((*_2) as Some).0: i32);
+          _0 = copy _5;
           StorageDead(_5);
           goto -> bb5;
       }
diff --git a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff
index 085c55caaa03c..727efe4b0d95d 100644
--- a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff
+++ b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.32bit.diff
@@ -38,28 +38,28 @@
 +         StorageLive(_4);
 +         _4 = const [2_usize, 8197_usize];
 +         _5 = discriminant(_2);
-+         _6 = _5 as usize (IntToInt);
-+         _7 = _4[_6];
++         _6 = copy _5 as usize (IntToInt);
++         _7 = copy _4[_6];
 +         _8 = &raw mut _1;
-+         _9 = _8 as *mut u8 (PtrToPtr);
++         _9 = copy _8 as *mut u8 (PtrToPtr);
 +         _10 = &raw const _2;
-+         _11 = _10 as *const u8 (PtrToPtr);
++         _11 = copy _10 as *const u8 (PtrToPtr);
 +         Deinit(_8);
-+         copy_nonoverlapping(dst = _9, src = _11, count = _7);
++         copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7);
 +         StorageDead(_4);
           StorageDead(_2);
 -         _0 = move _1;
 +         StorageLive(_12);
 +         _12 = const [2_usize, 8197_usize];
 +         _13 = discriminant(_1);
-+         _14 = _13 as usize (IntToInt);
-+         _15 = _12[_14];
++         _14 = copy _13 as usize (IntToInt);
++         _15 = copy _12[_14];
 +         _16 = &raw mut _0;
-+         _17 = _16 as *mut u8 (PtrToPtr);
++         _17 = copy _16 as *mut u8 (PtrToPtr);
 +         _18 = &raw const _1;
-+         _19 = _18 as *const u8 (PtrToPtr);
++         _19 = copy _18 as *const u8 (PtrToPtr);
 +         Deinit(_16);
-+         copy_nonoverlapping(dst = _17, src = _19, count = _15);
++         copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15);
 +         StorageDead(_12);
           StorageDead(_1);
           return;
diff --git a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff
index 798b7c10fe8d5..8d0cd97f78661 100644
--- a/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff
+++ b/tests/mir-opt/enum_opt.cand.EnumSizeOpt.64bit.diff
@@ -38,28 +38,28 @@
 +         StorageLive(_4);
 +         _4 = const [2_usize, 8197_usize];
 +         _5 = discriminant(_2);
-+         _6 = _5 as usize (IntToInt);
-+         _7 = _4[_6];
++         _6 = copy _5 as usize (IntToInt);
++         _7 = copy _4[_6];
 +         _8 = &raw mut _1;
-+         _9 = _8 as *mut u8 (PtrToPtr);
++         _9 = copy _8 as *mut u8 (PtrToPtr);
 +         _10 = &raw const _2;
-+         _11 = _10 as *const u8 (PtrToPtr);
++         _11 = copy _10 as *const u8 (PtrToPtr);
 +         Deinit(_8);
-+         copy_nonoverlapping(dst = _9, src = _11, count = _7);
++         copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7);
 +         StorageDead(_4);
           StorageDead(_2);
 -         _0 = move _1;
 +         StorageLive(_12);
 +         _12 = const [2_usize, 8197_usize];
 +         _13 = discriminant(_1);
-+         _14 = _13 as usize (IntToInt);
-+         _15 = _12[_14];
++         _14 = copy _13 as usize (IntToInt);
++         _15 = copy _12[_14];
 +         _16 = &raw mut _0;
-+         _17 = _16 as *mut u8 (PtrToPtr);
++         _17 = copy _16 as *mut u8 (PtrToPtr);
 +         _18 = &raw const _1;
-+         _19 = _18 as *const u8 (PtrToPtr);
++         _19 = copy _18 as *const u8 (PtrToPtr);
 +         Deinit(_16);
-+         copy_nonoverlapping(dst = _17, src = _19, count = _15);
++         copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15);
 +         StorageDead(_12);
           StorageDead(_1);
           return;
diff --git a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff
index a04829af4b532..6d1e2a72fdb73 100644
--- a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff
+++ b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.32bit.diff
@@ -38,28 +38,28 @@
 +         StorageLive(_4);
 +         _4 = const [8197_usize, 1_usize];
 +         _5 = discriminant(_2);
-+         _6 = _5 as usize (IntToInt);
-+         _7 = _4[_6];
++         _6 = copy _5 as usize (IntToInt);
++         _7 = copy _4[_6];
 +         _8 = &raw mut _1;
-+         _9 = _8 as *mut u8 (PtrToPtr);
++         _9 = copy _8 as *mut u8 (PtrToPtr);
 +         _10 = &raw const _2;
-+         _11 = _10 as *const u8 (PtrToPtr);
++         _11 = copy _10 as *const u8 (PtrToPtr);
 +         Deinit(_8);
-+         copy_nonoverlapping(dst = _9, src = _11, count = _7);
++         copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7);
 +         StorageDead(_4);
           StorageDead(_2);
 -         _0 = move _1;
 +         StorageLive(_12);
 +         _12 = const [8197_usize, 1_usize];
 +         _13 = discriminant(_1);
-+         _14 = _13 as usize (IntToInt);
-+         _15 = _12[_14];
++         _14 = copy _13 as usize (IntToInt);
++         _15 = copy _12[_14];
 +         _16 = &raw mut _0;
-+         _17 = _16 as *mut u8 (PtrToPtr);
++         _17 = copy _16 as *mut u8 (PtrToPtr);
 +         _18 = &raw const _1;
-+         _19 = _18 as *const u8 (PtrToPtr);
++         _19 = copy _18 as *const u8 (PtrToPtr);
 +         Deinit(_16);
-+         copy_nonoverlapping(dst = _17, src = _19, count = _15);
++         copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15);
 +         StorageDead(_12);
           StorageDead(_1);
           return;
diff --git a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff
index f5521a1e22a47..4b1406d0d623b 100644
--- a/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff
+++ b/tests/mir-opt/enum_opt.unin.EnumSizeOpt.64bit.diff
@@ -38,28 +38,28 @@
 +         StorageLive(_4);
 +         _4 = const [8197_usize, 1_usize];
 +         _5 = discriminant(_2);
-+         _6 = _5 as usize (IntToInt);
-+         _7 = _4[_6];
++         _6 = copy _5 as usize (IntToInt);
++         _7 = copy _4[_6];
 +         _8 = &raw mut _1;
-+         _9 = _8 as *mut u8 (PtrToPtr);
++         _9 = copy _8 as *mut u8 (PtrToPtr);
 +         _10 = &raw const _2;
-+         _11 = _10 as *const u8 (PtrToPtr);
++         _11 = copy _10 as *const u8 (PtrToPtr);
 +         Deinit(_8);
-+         copy_nonoverlapping(dst = _9, src = _11, count = _7);
++         copy_nonoverlapping(dst = copy _9, src = copy _11, count = copy _7);
 +         StorageDead(_4);
           StorageDead(_2);
 -         _0 = move _1;
 +         StorageLive(_12);
 +         _12 = const [8197_usize, 1_usize];
 +         _13 = discriminant(_1);
-+         _14 = _13 as usize (IntToInt);
-+         _15 = _12[_14];
++         _14 = copy _13 as usize (IntToInt);
++         _15 = copy _12[_14];
 +         _16 = &raw mut _0;
-+         _17 = _16 as *mut u8 (PtrToPtr);
++         _17 = copy _16 as *mut u8 (PtrToPtr);
 +         _18 = &raw const _1;
-+         _19 = _18 as *const u8 (PtrToPtr);
++         _19 = copy _18 as *const u8 (PtrToPtr);
 +         Deinit(_16);
-+         copy_nonoverlapping(dst = _17, src = _19, count = _15);
++         copy_nonoverlapping(dst = copy _17, src = copy _19, count = copy _15);
 +         StorageDead(_12);
           StorageDead(_1);
           return;
diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-abort.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-abort.diff
index 8a701641ff9ab..ed72ca7262959 100644
--- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-abort.diff
+++ b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-abort.diff
@@ -42,13 +42,13 @@
           StorageLive(_4);
           StorageLive(_20);
           StorageLive(_21);
-          _21 = ((*_1).0: u32);
+          _21 = copy ((*_1).0: u32);
           _20 = BitAnd(move _21, const 1_u32);
           StorageDead(_21);
           _4 = Ne(move _20, const 0_u32);
           StorageDead(_20);
           StorageLive(_5);
-          switchInt(_4) -> [0: bb2, otherwise: bb1];
+          switchInt(copy _4) -> [0: bb2, otherwise: bb1];
       }
   
       bb1: {
@@ -65,7 +65,7 @@
   
       bb3: {
           StorageLive(_6);
-          _6 = ((*_1).4: std::option::Option<usize>);
+          _6 = copy ((*_1).4: std::option::Option<usize>);
           _7 = discriminant(_6);
           switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb9];
       }
@@ -73,26 +73,26 @@
       bb4: {
 -         StorageLive(_8);
 +         nop;
-          _8 = ((_6 as Some).0: usize);
+          _8 = copy ((_6 as Some).0: usize);
           StorageLive(_9);
-          _9 = _1;
+          _9 = copy _1;
           StorageLive(_10);
-          _10 = _2;
+          _10 = copy _2;
           StorageLive(_11);
-          _11 = _5;
+          _11 = copy _5;
           StorageLive(_12);
           StorageLive(_13);
           StorageLive(_14);
-          _14 = _8;
+          _14 = copy _8;
 -         _13 = move _14 as u32 (IntToInt);
-+         _13 = _8 as u32 (IntToInt);
++         _13 = copy _8 as u32 (IntToInt);
           StorageDead(_14);
           _12 = Add(move _13, const 1_u32);
           StorageDead(_13);
           StorageLive(_15);
-          _15 = _3;
+          _15 = copy _3;
 -         _0 = float_to_exponential_common_exact::<T>(move _9, move _10, move _11, move _12, move _15) -> [return: bb5, unwind unreachable];
-+         _0 = float_to_exponential_common_exact::<T>(_1, _2, move _11, move _12, _3) -> [return: bb5, unwind unreachable];
++         _0 = float_to_exponential_common_exact::<T>(copy _1, copy _2, move _11, move _12, copy _3) -> [return: bb5, unwind unreachable];
       }
   
       bb5: {
@@ -108,15 +108,15 @@
   
       bb6: {
           StorageLive(_16);
-          _16 = _1;
+          _16 = copy _1;
           StorageLive(_17);
-          _17 = _2;
+          _17 = copy _2;
           StorageLive(_18);
-          _18 = _5;
+          _18 = copy _5;
           StorageLive(_19);
-          _19 = _3;
+          _19 = copy _3;
 -         _0 = float_to_exponential_common_shortest::<T>(move _16, move _17, move _18, move _19) -> [return: bb7, unwind unreachable];
-+         _0 = float_to_exponential_common_shortest::<T>(_1, _2, move _18, _3) -> [return: bb7, unwind unreachable];
++         _0 = float_to_exponential_common_shortest::<T>(copy _1, copy _2, move _18, copy _3) -> [return: bb7, unwind unreachable];
       }
   
       bb7: {
diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-unwind.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-unwind.diff
index 5e65700ee4aae..42d9988374959 100644
--- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-unwind.diff
+++ b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.panic-unwind.diff
@@ -42,13 +42,13 @@
           StorageLive(_4);
           StorageLive(_20);
           StorageLive(_21);
-          _21 = ((*_1).0: u32);
+          _21 = copy ((*_1).0: u32);
           _20 = BitAnd(move _21, const 1_u32);
           StorageDead(_21);
           _4 = Ne(move _20, const 0_u32);
           StorageDead(_20);
           StorageLive(_5);
-          switchInt(_4) -> [0: bb2, otherwise: bb1];
+          switchInt(copy _4) -> [0: bb2, otherwise: bb1];
       }
   
       bb1: {
@@ -65,7 +65,7 @@
   
       bb3: {
           StorageLive(_6);
-          _6 = ((*_1).4: std::option::Option<usize>);
+          _6 = copy ((*_1).4: std::option::Option<usize>);
           _7 = discriminant(_6);
           switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb9];
       }
@@ -73,26 +73,26 @@
       bb4: {
 -         StorageLive(_8);
 +         nop;
-          _8 = ((_6 as Some).0: usize);
+          _8 = copy ((_6 as Some).0: usize);
           StorageLive(_9);
-          _9 = _1;
+          _9 = copy _1;
           StorageLive(_10);
-          _10 = _2;
+          _10 = copy _2;
           StorageLive(_11);
-          _11 = _5;
+          _11 = copy _5;
           StorageLive(_12);
           StorageLive(_13);
           StorageLive(_14);
-          _14 = _8;
+          _14 = copy _8;
 -         _13 = move _14 as u32 (IntToInt);
-+         _13 = _8 as u32 (IntToInt);
++         _13 = copy _8 as u32 (IntToInt);
           StorageDead(_14);
           _12 = Add(move _13, const 1_u32);
           StorageDead(_13);
           StorageLive(_15);
-          _15 = _3;
+          _15 = copy _3;
 -         _0 = float_to_exponential_common_exact::<T>(move _9, move _10, move _11, move _12, move _15) -> [return: bb5, unwind continue];
-+         _0 = float_to_exponential_common_exact::<T>(_1, _2, move _11, move _12, _3) -> [return: bb5, unwind continue];
++         _0 = float_to_exponential_common_exact::<T>(copy _1, copy _2, move _11, move _12, copy _3) -> [return: bb5, unwind continue];
       }
   
       bb5: {
@@ -108,15 +108,15 @@
   
       bb6: {
           StorageLive(_16);
-          _16 = _1;
+          _16 = copy _1;
           StorageLive(_17);
-          _17 = _2;
+          _17 = copy _2;
           StorageLive(_18);
-          _18 = _5;
+          _18 = copy _5;
           StorageLive(_19);
-          _19 = _3;
+          _19 = copy _3;
 -         _0 = float_to_exponential_common_shortest::<T>(move _16, move _17, move _18, move _19) -> [return: bb7, unwind continue];
-+         _0 = float_to_exponential_common_shortest::<T>(_1, _2, move _18, _3) -> [return: bb7, unwind continue];
++         _0 = float_to_exponential_common_shortest::<T>(copy _1, copy _2, move _18, copy _3) -> [return: bb7, unwind continue];
       }
   
       bb7: {
diff --git a/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff
index cb87d9020150a..f980645b1d092 100644
--- a/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.arithmetic.GVN.panic-abort.diff
@@ -82,12 +82,12 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         _3 = Add(move _4, const 0_u64);
-+         _3 = _1;
++         _3 = copy _1;
           StorageDead(_4);
 -         _2 = opaque::<u64>(move _3) -> [return: bb1, unwind unreachable];
-+         _2 = opaque::<u64>(_1) -> [return: bb1, unwind unreachable];
++         _2 = opaque::<u64>(copy _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
@@ -96,12 +96,12 @@
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
 -         _6 = Sub(move _7, const 0_u64);
-+         _6 = _1;
++         _6 = copy _1;
           StorageDead(_7);
 -         _5 = opaque::<u64>(move _6) -> [return: bb2, unwind unreachable];
-+         _5 = opaque::<u64>(_1) -> [return: bb2, unwind unreachable];
++         _5 = opaque::<u64>(copy _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
@@ -111,9 +111,9 @@
 -         StorageLive(_9);
 +         nop;
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
           StorageLive(_11);
-          _11 = _1;
+          _11 = copy _1;
 -         _9 = Sub(move _10, move _11);
 +         _9 = const 0_u64;
           StorageDead(_11);
@@ -129,7 +129,7 @@
           StorageLive(_12);
           StorageLive(_13);
           StorageLive(_14);
-          _14 = _1;
+          _14 = copy _1;
 -         _13 = Mul(move _14, const 0_u64);
 +         _13 = const 0_u64;
           StorageDead(_14);
@@ -143,12 +143,12 @@
           StorageLive(_15);
           StorageLive(_16);
           StorageLive(_17);
-          _17 = _1;
+          _17 = copy _1;
 -         _16 = Mul(move _17, const 1_u64);
-+         _16 = _1;
++         _16 = copy _1;
           StorageDead(_17);
 -         _15 = opaque::<u64>(move _16) -> [return: bb5, unwind unreachable];
-+         _15 = opaque::<u64>(_1) -> [return: bb5, unwind unreachable];
++         _15 = opaque::<u64>(copy _1) -> [return: bb5, unwind unreachable];
       }
   
       bb5: {
@@ -157,16 +157,16 @@
           StorageLive(_18);
           StorageLive(_19);
           StorageLive(_20);
-          _20 = _1;
+          _20 = copy _1;
 -         _21 = Eq(const 0_u64, const 0_u64);
--         assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb6, unwind unreachable];
+-         assert(!move _21, "attempt to divide `{}` by zero", copy _20) -> [success: bb6, unwind unreachable];
 +         _21 = const true;
-+         assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb6, unwind unreachable];
++         assert(!const true, "attempt to divide `{}` by zero", copy _1) -> [success: bb6, unwind unreachable];
       }
   
       bb6: {
 -         _19 = Div(move _20, const 0_u64);
-+         _19 = Div(_1, const 0_u64);
++         _19 = Div(copy _1, const 0_u64);
           StorageDead(_20);
           _18 = opaque::<u64>(move _19) -> [return: bb7, unwind unreachable];
       }
@@ -177,19 +177,19 @@
           StorageLive(_22);
           StorageLive(_23);
           StorageLive(_24);
-          _24 = _1;
+          _24 = copy _1;
 -         _25 = Eq(const 1_u64, const 0_u64);
--         assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb8, unwind unreachable];
+-         assert(!move _25, "attempt to divide `{}` by zero", copy _24) -> [success: bb8, unwind unreachable];
 +         _25 = const false;
-+         assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb8, unwind unreachable];
++         assert(!const false, "attempt to divide `{}` by zero", copy _1) -> [success: bb8, unwind unreachable];
       }
   
       bb8: {
 -         _23 = Div(move _24, const 1_u64);
-+         _23 = _1;
++         _23 = copy _1;
           StorageDead(_24);
 -         _22 = opaque::<u64>(move _23) -> [return: bb9, unwind unreachable];
-+         _22 = opaque::<u64>(_1) -> [return: bb9, unwind unreachable];
++         _22 = opaque::<u64>(copy _1) -> [return: bb9, unwind unreachable];
       }
   
       bb9: {
@@ -198,11 +198,11 @@
           StorageLive(_26);
           StorageLive(_27);
           StorageLive(_28);
-          _28 = _1;
--         _29 = Eq(_28, const 0_u64);
+          _28 = copy _1;
+-         _29 = Eq(copy _28, const 0_u64);
 -         assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable];
-+         _29 = Eq(_1, const 0_u64);
-+         assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable];
++         _29 = Eq(copy _1, const 0_u64);
++         assert(!copy _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind unreachable];
       }
   
       bb10: {
@@ -219,16 +219,16 @@
           StorageLive(_30);
           StorageLive(_31);
           StorageLive(_32);
-          _32 = _1;
--         _33 = Eq(_32, const 0_u64);
+          _32 = copy _1;
+-         _33 = Eq(copy _32, const 0_u64);
 -         assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable];
-+         _33 = _29;
-+         assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable];
++         _33 = copy _29;
++         assert(!copy _29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind unreachable];
       }
   
       bb12: {
 -         _31 = Div(const 1_u64, move _32);
-+         _31 = Div(const 1_u64, _1);
++         _31 = Div(const 1_u64, copy _1);
           StorageDead(_32);
           _30 = opaque::<u64>(move _31) -> [return: bb13, unwind unreachable];
       }
@@ -239,16 +239,16 @@
           StorageLive(_34);
           StorageLive(_35);
           StorageLive(_36);
-          _36 = _1;
+          _36 = copy _1;
 -         _37 = Eq(const 0_u64, const 0_u64);
--         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb14, unwind unreachable];
+-         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _36) -> [success: bb14, unwind unreachable];
 +         _37 = const true;
-+         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb14, unwind unreachable];
++         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb14, unwind unreachable];
       }
   
       bb14: {
 -         _35 = Rem(move _36, const 0_u64);
-+         _35 = Rem(_1, const 0_u64);
++         _35 = Rem(copy _1, const 0_u64);
           StorageDead(_36);
           _34 = opaque::<u64>(move _35) -> [return: bb15, unwind unreachable];
       }
@@ -259,11 +259,11 @@
           StorageLive(_38);
           StorageLive(_39);
           StorageLive(_40);
-          _40 = _1;
+          _40 = copy _1;
 -         _41 = Eq(const 1_u64, const 0_u64);
--         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb16, unwind unreachable];
+-         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _40) -> [success: bb16, unwind unreachable];
 +         _41 = const false;
-+         assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb16, unwind unreachable];
++         assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb16, unwind unreachable];
       }
   
       bb16: {
@@ -280,11 +280,11 @@
           StorageLive(_42);
           StorageLive(_43);
           StorageLive(_44);
-          _44 = _1;
--         _45 = Eq(_44, const 0_u64);
+          _44 = copy _1;
+-         _45 = Eq(copy _44, const 0_u64);
 -         assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable];
-+         _45 = _29;
-+         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable];
++         _45 = copy _29;
++         assert(!copy _29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind unreachable];
       }
   
       bb18: {
@@ -301,16 +301,16 @@
           StorageLive(_46);
           StorageLive(_47);
           StorageLive(_48);
-          _48 = _1;
--         _49 = Eq(_48, const 0_u64);
+          _48 = copy _1;
+-         _49 = Eq(copy _48, const 0_u64);
 -         assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable];
-+         _49 = _29;
-+         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable];
++         _49 = copy _29;
++         assert(!copy _29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind unreachable];
       }
   
       bb20: {
 -         _47 = Rem(const 1_u64, move _48);
-+         _47 = Rem(const 1_u64, _1);
++         _47 = Rem(const 1_u64, copy _1);
           StorageDead(_48);
           _46 = opaque::<u64>(move _47) -> [return: bb21, unwind unreachable];
       }
@@ -321,7 +321,7 @@
           StorageLive(_50);
           StorageLive(_51);
           StorageLive(_52);
-          _52 = _1;
+          _52 = copy _1;
 -         _51 = BitAnd(move _52, const 0_u64);
 +         _51 = const 0_u64;
           StorageDead(_52);
@@ -335,12 +335,12 @@
           StorageLive(_53);
           StorageLive(_54);
           StorageLive(_55);
-          _55 = _1;
+          _55 = copy _1;
 -         _54 = BitAnd(move _55, const core::num::<impl u64>::MAX);
-+         _54 = _1;
++         _54 = copy _1;
           StorageDead(_55);
 -         _53 = opaque::<u64>(move _54) -> [return: bb23, unwind unreachable];
-+         _53 = opaque::<u64>(_1) -> [return: bb23, unwind unreachable];
++         _53 = opaque::<u64>(copy _1) -> [return: bb23, unwind unreachable];
       }
   
       bb23: {
@@ -349,12 +349,12 @@
           StorageLive(_56);
           StorageLive(_57);
           StorageLive(_58);
-          _58 = _1;
+          _58 = copy _1;
 -         _57 = BitOr(move _58, const 0_u64);
-+         _57 = _1;
++         _57 = copy _1;
           StorageDead(_58);
 -         _56 = opaque::<u64>(move _57) -> [return: bb24, unwind unreachable];
-+         _56 = opaque::<u64>(_1) -> [return: bb24, unwind unreachable];
++         _56 = opaque::<u64>(copy _1) -> [return: bb24, unwind unreachable];
       }
   
       bb24: {
@@ -363,7 +363,7 @@
           StorageLive(_59);
           StorageLive(_60);
           StorageLive(_61);
-          _61 = _1;
+          _61 = copy _1;
 -         _60 = BitOr(move _61, const core::num::<impl u64>::MAX);
 +         _60 = const u64::MAX;
           StorageDead(_61);
@@ -377,12 +377,12 @@
           StorageLive(_62);
           StorageLive(_63);
           StorageLive(_64);
-          _64 = _1;
+          _64 = copy _1;
 -         _63 = BitXor(move _64, const 0_u64);
-+         _63 = _1;
++         _63 = copy _1;
           StorageDead(_64);
 -         _62 = opaque::<u64>(move _63) -> [return: bb26, unwind unreachable];
-+         _62 = opaque::<u64>(_1) -> [return: bb26, unwind unreachable];
++         _62 = opaque::<u64>(copy _1) -> [return: bb26, unwind unreachable];
       }
   
       bb26: {
@@ -391,9 +391,9 @@
           StorageLive(_65);
           StorageLive(_66);
           StorageLive(_67);
-          _67 = _1;
+          _67 = copy _1;
           StorageLive(_68);
-          _68 = _1;
+          _68 = copy _1;
 -         _66 = BitXor(move _67, move _68);
 +         _66 = const 0_u64;
           StorageDead(_68);
@@ -408,12 +408,12 @@
           StorageLive(_69);
           StorageLive(_70);
           StorageLive(_71);
-          _71 = _1;
+          _71 = copy _1;
 -         _70 = Shr(move _71, const 0_i32);
-+         _70 = _1;
++         _70 = copy _1;
           StorageDead(_71);
 -         _69 = opaque::<u64>(move _70) -> [return: bb28, unwind unreachable];
-+         _69 = opaque::<u64>(_1) -> [return: bb28, unwind unreachable];
++         _69 = opaque::<u64>(copy _1) -> [return: bb28, unwind unreachable];
       }
   
       bb28: {
@@ -422,12 +422,12 @@
           StorageLive(_72);
           StorageLive(_73);
           StorageLive(_74);
-          _74 = _1;
+          _74 = copy _1;
 -         _73 = Shl(move _74, const 0_i32);
-+         _73 = _1;
++         _73 = copy _1;
           StorageDead(_74);
 -         _72 = opaque::<u64>(move _73) -> [return: bb29, unwind unreachable];
-+         _72 = opaque::<u64>(_1) -> [return: bb29, unwind unreachable];
++         _72 = opaque::<u64>(copy _1) -> [return: bb29, unwind unreachable];
       }
   
       bb29: {
diff --git a/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff
index fa7536efc8e6c..b8e4967fe8b18 100644
--- a/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.arithmetic.GVN.panic-unwind.diff
@@ -82,12 +82,12 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         _3 = Add(move _4, const 0_u64);
-+         _3 = _1;
++         _3 = copy _1;
           StorageDead(_4);
 -         _2 = opaque::<u64>(move _3) -> [return: bb1, unwind continue];
-+         _2 = opaque::<u64>(_1) -> [return: bb1, unwind continue];
++         _2 = opaque::<u64>(copy _1) -> [return: bb1, unwind continue];
       }
   
       bb1: {
@@ -96,12 +96,12 @@
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
 -         _6 = Sub(move _7, const 0_u64);
-+         _6 = _1;
++         _6 = copy _1;
           StorageDead(_7);
 -         _5 = opaque::<u64>(move _6) -> [return: bb2, unwind continue];
-+         _5 = opaque::<u64>(_1) -> [return: bb2, unwind continue];
++         _5 = opaque::<u64>(copy _1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
@@ -111,9 +111,9 @@
 -         StorageLive(_9);
 +         nop;
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
           StorageLive(_11);
-          _11 = _1;
+          _11 = copy _1;
 -         _9 = Sub(move _10, move _11);
 +         _9 = const 0_u64;
           StorageDead(_11);
@@ -129,7 +129,7 @@
           StorageLive(_12);
           StorageLive(_13);
           StorageLive(_14);
-          _14 = _1;
+          _14 = copy _1;
 -         _13 = Mul(move _14, const 0_u64);
 +         _13 = const 0_u64;
           StorageDead(_14);
@@ -143,12 +143,12 @@
           StorageLive(_15);
           StorageLive(_16);
           StorageLive(_17);
-          _17 = _1;
+          _17 = copy _1;
 -         _16 = Mul(move _17, const 1_u64);
-+         _16 = _1;
++         _16 = copy _1;
           StorageDead(_17);
 -         _15 = opaque::<u64>(move _16) -> [return: bb5, unwind continue];
-+         _15 = opaque::<u64>(_1) -> [return: bb5, unwind continue];
++         _15 = opaque::<u64>(copy _1) -> [return: bb5, unwind continue];
       }
   
       bb5: {
@@ -157,16 +157,16 @@
           StorageLive(_18);
           StorageLive(_19);
           StorageLive(_20);
-          _20 = _1;
+          _20 = copy _1;
 -         _21 = Eq(const 0_u64, const 0_u64);
--         assert(!move _21, "attempt to divide `{}` by zero", _20) -> [success: bb6, unwind continue];
+-         assert(!move _21, "attempt to divide `{}` by zero", copy _20) -> [success: bb6, unwind continue];
 +         _21 = const true;
-+         assert(!const true, "attempt to divide `{}` by zero", _1) -> [success: bb6, unwind continue];
++         assert(!const true, "attempt to divide `{}` by zero", copy _1) -> [success: bb6, unwind continue];
       }
   
       bb6: {
 -         _19 = Div(move _20, const 0_u64);
-+         _19 = Div(_1, const 0_u64);
++         _19 = Div(copy _1, const 0_u64);
           StorageDead(_20);
           _18 = opaque::<u64>(move _19) -> [return: bb7, unwind continue];
       }
@@ -177,19 +177,19 @@
           StorageLive(_22);
           StorageLive(_23);
           StorageLive(_24);
-          _24 = _1;
+          _24 = copy _1;
 -         _25 = Eq(const 1_u64, const 0_u64);
--         assert(!move _25, "attempt to divide `{}` by zero", _24) -> [success: bb8, unwind continue];
+-         assert(!move _25, "attempt to divide `{}` by zero", copy _24) -> [success: bb8, unwind continue];
 +         _25 = const false;
-+         assert(!const false, "attempt to divide `{}` by zero", _1) -> [success: bb8, unwind continue];
++         assert(!const false, "attempt to divide `{}` by zero", copy _1) -> [success: bb8, unwind continue];
       }
   
       bb8: {
 -         _23 = Div(move _24, const 1_u64);
-+         _23 = _1;
++         _23 = copy _1;
           StorageDead(_24);
 -         _22 = opaque::<u64>(move _23) -> [return: bb9, unwind continue];
-+         _22 = opaque::<u64>(_1) -> [return: bb9, unwind continue];
++         _22 = opaque::<u64>(copy _1) -> [return: bb9, unwind continue];
       }
   
       bb9: {
@@ -198,11 +198,11 @@
           StorageLive(_26);
           StorageLive(_27);
           StorageLive(_28);
-          _28 = _1;
--         _29 = Eq(_28, const 0_u64);
+          _28 = copy _1;
+-         _29 = Eq(copy _28, const 0_u64);
 -         assert(!move _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind continue];
-+         _29 = Eq(_1, const 0_u64);
-+         assert(!_29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind continue];
++         _29 = Eq(copy _1, const 0_u64);
++         assert(!copy _29, "attempt to divide `{}` by zero", const 0_u64) -> [success: bb10, unwind continue];
       }
   
       bb10: {
@@ -219,16 +219,16 @@
           StorageLive(_30);
           StorageLive(_31);
           StorageLive(_32);
-          _32 = _1;
--         _33 = Eq(_32, const 0_u64);
+          _32 = copy _1;
+-         _33 = Eq(copy _32, const 0_u64);
 -         assert(!move _33, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind continue];
-+         _33 = _29;
-+         assert(!_29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind continue];
++         _33 = copy _29;
++         assert(!copy _29, "attempt to divide `{}` by zero", const 1_u64) -> [success: bb12, unwind continue];
       }
   
       bb12: {
 -         _31 = Div(const 1_u64, move _32);
-+         _31 = Div(const 1_u64, _1);
++         _31 = Div(const 1_u64, copy _1);
           StorageDead(_32);
           _30 = opaque::<u64>(move _31) -> [return: bb13, unwind continue];
       }
@@ -239,16 +239,16 @@
           StorageLive(_34);
           StorageLive(_35);
           StorageLive(_36);
-          _36 = _1;
+          _36 = copy _1;
 -         _37 = Eq(const 0_u64, const 0_u64);
--         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", _36) -> [success: bb14, unwind continue];
+-         assert(!move _37, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _36) -> [success: bb14, unwind continue];
 +         _37 = const true;
-+         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb14, unwind continue];
++         assert(!const true, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb14, unwind continue];
       }
   
       bb14: {
 -         _35 = Rem(move _36, const 0_u64);
-+         _35 = Rem(_1, const 0_u64);
++         _35 = Rem(copy _1, const 0_u64);
           StorageDead(_36);
           _34 = opaque::<u64>(move _35) -> [return: bb15, unwind continue];
       }
@@ -259,11 +259,11 @@
           StorageLive(_38);
           StorageLive(_39);
           StorageLive(_40);
-          _40 = _1;
+          _40 = copy _1;
 -         _41 = Eq(const 1_u64, const 0_u64);
--         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", _40) -> [success: bb16, unwind continue];
+-         assert(!move _41, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _40) -> [success: bb16, unwind continue];
 +         _41 = const false;
-+         assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb16, unwind continue];
++         assert(!const false, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb16, unwind continue];
       }
   
       bb16: {
@@ -280,11 +280,11 @@
           StorageLive(_42);
           StorageLive(_43);
           StorageLive(_44);
-          _44 = _1;
--         _45 = Eq(_44, const 0_u64);
+          _44 = copy _1;
+-         _45 = Eq(copy _44, const 0_u64);
 -         assert(!move _45, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind continue];
-+         _45 = _29;
-+         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind continue];
++         _45 = copy _29;
++         assert(!copy _29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 0_u64) -> [success: bb18, unwind continue];
       }
   
       bb18: {
@@ -301,16 +301,16 @@
           StorageLive(_46);
           StorageLive(_47);
           StorageLive(_48);
-          _48 = _1;
--         _49 = Eq(_48, const 0_u64);
+          _48 = copy _1;
+-         _49 = Eq(copy _48, const 0_u64);
 -         assert(!move _49, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind continue];
-+         _49 = _29;
-+         assert(!_29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind continue];
++         _49 = copy _29;
++         assert(!copy _29, "attempt to calculate the remainder of `{}` with a divisor of zero", const 1_u64) -> [success: bb20, unwind continue];
       }
   
       bb20: {
 -         _47 = Rem(const 1_u64, move _48);
-+         _47 = Rem(const 1_u64, _1);
++         _47 = Rem(const 1_u64, copy _1);
           StorageDead(_48);
           _46 = opaque::<u64>(move _47) -> [return: bb21, unwind continue];
       }
@@ -321,7 +321,7 @@
           StorageLive(_50);
           StorageLive(_51);
           StorageLive(_52);
-          _52 = _1;
+          _52 = copy _1;
 -         _51 = BitAnd(move _52, const 0_u64);
 +         _51 = const 0_u64;
           StorageDead(_52);
@@ -335,12 +335,12 @@
           StorageLive(_53);
           StorageLive(_54);
           StorageLive(_55);
-          _55 = _1;
+          _55 = copy _1;
 -         _54 = BitAnd(move _55, const core::num::<impl u64>::MAX);
-+         _54 = _1;
++         _54 = copy _1;
           StorageDead(_55);
 -         _53 = opaque::<u64>(move _54) -> [return: bb23, unwind continue];
-+         _53 = opaque::<u64>(_1) -> [return: bb23, unwind continue];
++         _53 = opaque::<u64>(copy _1) -> [return: bb23, unwind continue];
       }
   
       bb23: {
@@ -349,12 +349,12 @@
           StorageLive(_56);
           StorageLive(_57);
           StorageLive(_58);
-          _58 = _1;
+          _58 = copy _1;
 -         _57 = BitOr(move _58, const 0_u64);
-+         _57 = _1;
++         _57 = copy _1;
           StorageDead(_58);
 -         _56 = opaque::<u64>(move _57) -> [return: bb24, unwind continue];
-+         _56 = opaque::<u64>(_1) -> [return: bb24, unwind continue];
++         _56 = opaque::<u64>(copy _1) -> [return: bb24, unwind continue];
       }
   
       bb24: {
@@ -363,7 +363,7 @@
           StorageLive(_59);
           StorageLive(_60);
           StorageLive(_61);
-          _61 = _1;
+          _61 = copy _1;
 -         _60 = BitOr(move _61, const core::num::<impl u64>::MAX);
 +         _60 = const u64::MAX;
           StorageDead(_61);
@@ -377,12 +377,12 @@
           StorageLive(_62);
           StorageLive(_63);
           StorageLive(_64);
-          _64 = _1;
+          _64 = copy _1;
 -         _63 = BitXor(move _64, const 0_u64);
-+         _63 = _1;
++         _63 = copy _1;
           StorageDead(_64);
 -         _62 = opaque::<u64>(move _63) -> [return: bb26, unwind continue];
-+         _62 = opaque::<u64>(_1) -> [return: bb26, unwind continue];
++         _62 = opaque::<u64>(copy _1) -> [return: bb26, unwind continue];
       }
   
       bb26: {
@@ -391,9 +391,9 @@
           StorageLive(_65);
           StorageLive(_66);
           StorageLive(_67);
-          _67 = _1;
+          _67 = copy _1;
           StorageLive(_68);
-          _68 = _1;
+          _68 = copy _1;
 -         _66 = BitXor(move _67, move _68);
 +         _66 = const 0_u64;
           StorageDead(_68);
@@ -408,12 +408,12 @@
           StorageLive(_69);
           StorageLive(_70);
           StorageLive(_71);
-          _71 = _1;
+          _71 = copy _1;
 -         _70 = Shr(move _71, const 0_i32);
-+         _70 = _1;
++         _70 = copy _1;
           StorageDead(_71);
 -         _69 = opaque::<u64>(move _70) -> [return: bb28, unwind continue];
-+         _69 = opaque::<u64>(_1) -> [return: bb28, unwind continue];
++         _69 = opaque::<u64>(copy _1) -> [return: bb28, unwind continue];
       }
   
       bb28: {
@@ -422,12 +422,12 @@
           StorageLive(_72);
           StorageLive(_73);
           StorageLive(_74);
-          _74 = _1;
+          _74 = copy _1;
 -         _73 = Shl(move _74, const 0_i32);
-+         _73 = _1;
++         _73 = copy _1;
           StorageDead(_74);
 -         _72 = opaque::<u64>(move _73) -> [return: bb29, unwind continue];
-+         _72 = opaque::<u64>(_1) -> [return: bb29, unwind continue];
++         _72 = opaque::<u64>(copy _1) -> [return: bb29, unwind continue];
       }
   
       bb29: {
diff --git a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff
index 0e3f2459fae35..acf8bfc71beda 100644
--- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-abort.diff
@@ -30,19 +30,19 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
--         _5 = AddWithOverflow(_4, const 0_u64);
+          _4 = copy _1;
+-         _5 = AddWithOverflow(copy _4, const 0_u64);
 -         assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, const 0_u64) -> [success: bb1, unwind unreachable];
-+         _5 = AddWithOverflow(_1, const 0_u64);
-+         assert(!const false, "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind unreachable];
++         _5 = AddWithOverflow(copy _1, const 0_u64);
++         assert(!const false, "attempt to compute `{} + {}`, which would overflow", copy _1, const 0_u64) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
 -         _3 = move (_5.0: u64);
-+         _3 = _1;
++         _3 = copy _1;
           StorageDead(_4);
 -         _2 = opaque::<u64>(move _3) -> [return: bb2, unwind unreachable];
-+         _2 = opaque::<u64>(_1) -> [return: bb2, unwind unreachable];
++         _2 = opaque::<u64>(copy _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
@@ -51,19 +51,19 @@
           StorageLive(_6);
           StorageLive(_7);
           StorageLive(_8);
-          _8 = _1;
--         _9 = SubWithOverflow(_8, const 0_u64);
+          _8 = copy _1;
+-         _9 = SubWithOverflow(copy _8, const 0_u64);
 -         assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", move _8, const 0_u64) -> [success: bb3, unwind unreachable];
-+         _9 = _5;
-+         assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind unreachable];
++         _9 = copy _5;
++         assert(!const false, "attempt to compute `{} - {}`, which would overflow", copy _1, const 0_u64) -> [success: bb3, unwind unreachable];
       }
   
       bb3: {
 -         _7 = move (_9.0: u64);
-+         _7 = _1;
++         _7 = copy _1;
           StorageDead(_8);
 -         _6 = opaque::<u64>(move _7) -> [return: bb4, unwind unreachable];
-+         _6 = opaque::<u64>(_1) -> [return: bb4, unwind unreachable];
++         _6 = opaque::<u64>(copy _1) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
@@ -73,13 +73,13 @@
 -         StorageLive(_11);
 +         nop;
           StorageLive(_12);
-          _12 = _1;
+          _12 = copy _1;
           StorageLive(_13);
-          _13 = _1;
--         _14 = SubWithOverflow(_12, _13);
+          _13 = copy _1;
+-         _14 = SubWithOverflow(copy _12, copy _13);
 -         assert(!move (_14.1: bool), "attempt to compute `{} - {}`, which would overflow", move _12, move _13) -> [success: bb5, unwind unreachable];
 +         _14 = const (0_u64, false);
-+         assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, _1) -> [success: bb5, unwind unreachable];
++         assert(!const false, "attempt to compute `{} - {}`, which would overflow", copy _1, copy _1) -> [success: bb5, unwind unreachable];
       }
   
       bb5: {
@@ -98,11 +98,11 @@
           StorageLive(_15);
           StorageLive(_16);
           StorageLive(_17);
-          _17 = _1;
--         _18 = MulWithOverflow(_17, const 0_u64);
+          _17 = copy _1;
+-         _18 = MulWithOverflow(copy _17, const 0_u64);
 -         assert(!move (_18.1: bool), "attempt to compute `{} * {}`, which would overflow", move _17, const 0_u64) -> [success: bb7, unwind unreachable];
 +         _18 = const (0_u64, false);
-+         assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb7, unwind unreachable];
++         assert(!const false, "attempt to compute `{} * {}`, which would overflow", copy _1, const 0_u64) -> [success: bb7, unwind unreachable];
       }
   
       bb7: {
@@ -119,19 +119,19 @@
           StorageLive(_19);
           StorageLive(_20);
           StorageLive(_21);
-          _21 = _1;
--         _22 = MulWithOverflow(_21, const 1_u64);
+          _21 = copy _1;
+-         _22 = MulWithOverflow(copy _21, const 1_u64);
 -         assert(!move (_22.1: bool), "attempt to compute `{} * {}`, which would overflow", move _21, const 1_u64) -> [success: bb9, unwind unreachable];
-+         _22 = _5;
-+         assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb9, unwind unreachable];
++         _22 = copy _5;
++         assert(!const false, "attempt to compute `{} * {}`, which would overflow", copy _1, const 1_u64) -> [success: bb9, unwind unreachable];
       }
   
       bb9: {
 -         _20 = move (_22.0: u64);
-+         _20 = _1;
++         _20 = copy _1;
           StorageDead(_21);
 -         _19 = opaque::<u64>(move _20) -> [return: bb10, unwind unreachable];
-+         _19 = opaque::<u64>(_1) -> [return: bb10, unwind unreachable];
++         _19 = opaque::<u64>(copy _1) -> [return: bb10, unwind unreachable];
       }
   
       bb10: {
diff --git a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff
index 2873d7ef0ab13..f3f6b381a81ca 100644
--- a/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff
@@ -30,19 +30,19 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
--         _5 = AddWithOverflow(_4, const 0_u64);
+          _4 = copy _1;
+-         _5 = AddWithOverflow(copy _4, const 0_u64);
 -         assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, const 0_u64) -> [success: bb1, unwind continue];
-+         _5 = AddWithOverflow(_1, const 0_u64);
-+         assert(!const false, "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind continue];
++         _5 = AddWithOverflow(copy _1, const 0_u64);
++         assert(!const false, "attempt to compute `{} + {}`, which would overflow", copy _1, const 0_u64) -> [success: bb1, unwind continue];
       }
   
       bb1: {
 -         _3 = move (_5.0: u64);
-+         _3 = _1;
++         _3 = copy _1;
           StorageDead(_4);
 -         _2 = opaque::<u64>(move _3) -> [return: bb2, unwind continue];
-+         _2 = opaque::<u64>(_1) -> [return: bb2, unwind continue];
++         _2 = opaque::<u64>(copy _1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
@@ -51,19 +51,19 @@
           StorageLive(_6);
           StorageLive(_7);
           StorageLive(_8);
-          _8 = _1;
--         _9 = SubWithOverflow(_8, const 0_u64);
+          _8 = copy _1;
+-         _9 = SubWithOverflow(copy _8, const 0_u64);
 -         assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", move _8, const 0_u64) -> [success: bb3, unwind continue];
-+         _9 = _5;
-+         assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind continue];
++         _9 = copy _5;
++         assert(!const false, "attempt to compute `{} - {}`, which would overflow", copy _1, const 0_u64) -> [success: bb3, unwind continue];
       }
   
       bb3: {
 -         _7 = move (_9.0: u64);
-+         _7 = _1;
++         _7 = copy _1;
           StorageDead(_8);
 -         _6 = opaque::<u64>(move _7) -> [return: bb4, unwind continue];
-+         _6 = opaque::<u64>(_1) -> [return: bb4, unwind continue];
++         _6 = opaque::<u64>(copy _1) -> [return: bb4, unwind continue];
       }
   
       bb4: {
@@ -73,13 +73,13 @@
 -         StorageLive(_11);
 +         nop;
           StorageLive(_12);
-          _12 = _1;
+          _12 = copy _1;
           StorageLive(_13);
-          _13 = _1;
--         _14 = SubWithOverflow(_12, _13);
+          _13 = copy _1;
+-         _14 = SubWithOverflow(copy _12, copy _13);
 -         assert(!move (_14.1: bool), "attempt to compute `{} - {}`, which would overflow", move _12, move _13) -> [success: bb5, unwind continue];
 +         _14 = const (0_u64, false);
-+         assert(!const false, "attempt to compute `{} - {}`, which would overflow", _1, _1) -> [success: bb5, unwind continue];
++         assert(!const false, "attempt to compute `{} - {}`, which would overflow", copy _1, copy _1) -> [success: bb5, unwind continue];
       }
   
       bb5: {
@@ -98,11 +98,11 @@
           StorageLive(_15);
           StorageLive(_16);
           StorageLive(_17);
-          _17 = _1;
--         _18 = MulWithOverflow(_17, const 0_u64);
+          _17 = copy _1;
+-         _18 = MulWithOverflow(copy _17, const 0_u64);
 -         assert(!move (_18.1: bool), "attempt to compute `{} * {}`, which would overflow", move _17, const 0_u64) -> [success: bb7, unwind continue];
 +         _18 = const (0_u64, false);
-+         assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb7, unwind continue];
++         assert(!const false, "attempt to compute `{} * {}`, which would overflow", copy _1, const 0_u64) -> [success: bb7, unwind continue];
       }
   
       bb7: {
@@ -119,19 +119,19 @@
           StorageLive(_19);
           StorageLive(_20);
           StorageLive(_21);
-          _21 = _1;
--         _22 = MulWithOverflow(_21, const 1_u64);
+          _21 = copy _1;
+-         _22 = MulWithOverflow(copy _21, const 1_u64);
 -         assert(!move (_22.1: bool), "attempt to compute `{} * {}`, which would overflow", move _21, const 1_u64) -> [success: bb9, unwind continue];
-+         _22 = _5;
-+         assert(!const false, "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb9, unwind continue];
++         _22 = copy _5;
++         assert(!const false, "attempt to compute `{} * {}`, which would overflow", copy _1, const 1_u64) -> [success: bb9, unwind continue];
       }
   
       bb9: {
 -         _20 = move (_22.0: u64);
-+         _20 = _1;
++         _20 = copy _1;
           StorageDead(_21);
 -         _19 = opaque::<u64>(move _20) -> [return: bb10, unwind continue];
-+         _19 = opaque::<u64>(_1) -> [return: bb10, unwind continue];
++         _19 = opaque::<u64>(copy _1) -> [return: bb10, unwind continue];
       }
   
       bb10: {
diff --git a/tests/mir-opt/gvn.arithmetic_float.GVN.panic-abort.diff b/tests/mir-opt/gvn.arithmetic_float.GVN.panic-abort.diff
index b332100eaf03c..31a8546812673 100644
--- a/tests/mir-opt/gvn.arithmetic_float.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.arithmetic_float.GVN.panic-abort.diff
@@ -38,9 +38,9 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         _3 = Add(move _4, const 0f64);
-+         _3 = Add(_1, const 0f64);
++         _3 = Add(copy _1, const 0f64);
           StorageDead(_4);
           _2 = opaque::<f64>(move _3) -> [return: bb1, unwind unreachable];
       }
@@ -51,9 +51,9 @@
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
 -         _6 = Sub(move _7, const 0f64);
-+         _6 = Sub(_1, const 0f64);
++         _6 = Sub(copy _1, const 0f64);
           StorageDead(_7);
           _5 = opaque::<f64>(move _6) -> [return: bb2, unwind unreachable];
       }
@@ -64,9 +64,9 @@
           StorageLive(_8);
           StorageLive(_9);
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
 -         _9 = Mul(move _10, const 0f64);
-+         _9 = Mul(_1, const 0f64);
++         _9 = Mul(copy _1, const 0f64);
           StorageDead(_10);
           _8 = opaque::<f64>(move _9) -> [return: bb3, unwind unreachable];
       }
@@ -77,9 +77,9 @@
           StorageLive(_11);
           StorageLive(_12);
           StorageLive(_13);
-          _13 = _1;
+          _13 = copy _1;
 -         _12 = Div(move _13, const 0f64);
-+         _12 = Div(_1, const 0f64);
++         _12 = Div(copy _1, const 0f64);
           StorageDead(_13);
           _11 = opaque::<f64>(move _12) -> [return: bb4, unwind unreachable];
       }
@@ -90,9 +90,9 @@
           StorageLive(_14);
           StorageLive(_15);
           StorageLive(_16);
-          _16 = _1;
+          _16 = copy _1;
 -         _15 = Div(const 0f64, move _16);
-+         _15 = Div(const 0f64, _1);
++         _15 = Div(const 0f64, copy _1);
           StorageDead(_16);
           _14 = opaque::<f64>(move _15) -> [return: bb5, unwind unreachable];
       }
@@ -103,9 +103,9 @@
           StorageLive(_17);
           StorageLive(_18);
           StorageLive(_19);
-          _19 = _1;
+          _19 = copy _1;
 -         _18 = Rem(move _19, const 0f64);
-+         _18 = Rem(_1, const 0f64);
++         _18 = Rem(copy _1, const 0f64);
           StorageDead(_19);
           _17 = opaque::<f64>(move _18) -> [return: bb6, unwind unreachable];
       }
@@ -116,9 +116,9 @@
           StorageLive(_20);
           StorageLive(_21);
           StorageLive(_22);
-          _22 = _1;
+          _22 = copy _1;
 -         _21 = Rem(const 0f64, move _22);
-+         _21 = Rem(const 0f64, _1);
++         _21 = Rem(const 0f64, copy _1);
           StorageDead(_22);
           _20 = opaque::<f64>(move _21) -> [return: bb7, unwind unreachable];
       }
@@ -129,11 +129,11 @@
           StorageLive(_23);
           StorageLive(_24);
           StorageLive(_25);
-          _25 = _1;
+          _25 = copy _1;
           StorageLive(_26);
-          _26 = _1;
+          _26 = copy _1;
 -         _24 = Eq(move _25, move _26);
-+         _24 = Eq(_1, _1);
++         _24 = Eq(copy _1, copy _1);
           StorageDead(_26);
           StorageDead(_25);
           _23 = opaque::<bool>(move _24) -> [return: bb8, unwind unreachable];
@@ -145,11 +145,11 @@
           StorageLive(_27);
           StorageLive(_28);
           StorageLive(_29);
-          _29 = _1;
+          _29 = copy _1;
           StorageLive(_30);
-          _30 = _1;
+          _30 = copy _1;
 -         _28 = Ne(move _29, move _30);
-+         _28 = Ne(_1, _1);
++         _28 = Ne(copy _1, copy _1);
           StorageDead(_30);
           StorageDead(_29);
           _27 = opaque::<bool>(move _28) -> [return: bb9, unwind unreachable];
diff --git a/tests/mir-opt/gvn.arithmetic_float.GVN.panic-unwind.diff b/tests/mir-opt/gvn.arithmetic_float.GVN.panic-unwind.diff
index 28664cb0ac8ca..4e42b1af4fc95 100644
--- a/tests/mir-opt/gvn.arithmetic_float.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.arithmetic_float.GVN.panic-unwind.diff
@@ -38,9 +38,9 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         _3 = Add(move _4, const 0f64);
-+         _3 = Add(_1, const 0f64);
++         _3 = Add(copy _1, const 0f64);
           StorageDead(_4);
           _2 = opaque::<f64>(move _3) -> [return: bb1, unwind continue];
       }
@@ -51,9 +51,9 @@
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
 -         _6 = Sub(move _7, const 0f64);
-+         _6 = Sub(_1, const 0f64);
++         _6 = Sub(copy _1, const 0f64);
           StorageDead(_7);
           _5 = opaque::<f64>(move _6) -> [return: bb2, unwind continue];
       }
@@ -64,9 +64,9 @@
           StorageLive(_8);
           StorageLive(_9);
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
 -         _9 = Mul(move _10, const 0f64);
-+         _9 = Mul(_1, const 0f64);
++         _9 = Mul(copy _1, const 0f64);
           StorageDead(_10);
           _8 = opaque::<f64>(move _9) -> [return: bb3, unwind continue];
       }
@@ -77,9 +77,9 @@
           StorageLive(_11);
           StorageLive(_12);
           StorageLive(_13);
-          _13 = _1;
+          _13 = copy _1;
 -         _12 = Div(move _13, const 0f64);
-+         _12 = Div(_1, const 0f64);
++         _12 = Div(copy _1, const 0f64);
           StorageDead(_13);
           _11 = opaque::<f64>(move _12) -> [return: bb4, unwind continue];
       }
@@ -90,9 +90,9 @@
           StorageLive(_14);
           StorageLive(_15);
           StorageLive(_16);
-          _16 = _1;
+          _16 = copy _1;
 -         _15 = Div(const 0f64, move _16);
-+         _15 = Div(const 0f64, _1);
++         _15 = Div(const 0f64, copy _1);
           StorageDead(_16);
           _14 = opaque::<f64>(move _15) -> [return: bb5, unwind continue];
       }
@@ -103,9 +103,9 @@
           StorageLive(_17);
           StorageLive(_18);
           StorageLive(_19);
-          _19 = _1;
+          _19 = copy _1;
 -         _18 = Rem(move _19, const 0f64);
-+         _18 = Rem(_1, const 0f64);
++         _18 = Rem(copy _1, const 0f64);
           StorageDead(_19);
           _17 = opaque::<f64>(move _18) -> [return: bb6, unwind continue];
       }
@@ -116,9 +116,9 @@
           StorageLive(_20);
           StorageLive(_21);
           StorageLive(_22);
-          _22 = _1;
+          _22 = copy _1;
 -         _21 = Rem(const 0f64, move _22);
-+         _21 = Rem(const 0f64, _1);
++         _21 = Rem(const 0f64, copy _1);
           StorageDead(_22);
           _20 = opaque::<f64>(move _21) -> [return: bb7, unwind continue];
       }
@@ -129,11 +129,11 @@
           StorageLive(_23);
           StorageLive(_24);
           StorageLive(_25);
-          _25 = _1;
+          _25 = copy _1;
           StorageLive(_26);
-          _26 = _1;
+          _26 = copy _1;
 -         _24 = Eq(move _25, move _26);
-+         _24 = Eq(_1, _1);
++         _24 = Eq(copy _1, copy _1);
           StorageDead(_26);
           StorageDead(_25);
           _23 = opaque::<bool>(move _24) -> [return: bb8, unwind continue];
@@ -145,11 +145,11 @@
           StorageLive(_27);
           StorageLive(_28);
           StorageLive(_29);
-          _29 = _1;
+          _29 = copy _1;
           StorageLive(_30);
-          _30 = _1;
+          _30 = copy _1;
 -         _28 = Ne(move _29, move _30);
-+         _28 = Ne(_1, _1);
++         _28 = Ne(copy _1, copy _1);
           StorageDead(_30);
           StorageDead(_29);
           _27 = opaque::<bool>(move _28) -> [return: bb9, unwind continue];
diff --git a/tests/mir-opt/gvn.borrowed.GVN.panic-abort.diff b/tests/mir-opt/gvn.borrowed.GVN.panic-abort.diff
index 9520bd382eebb..b0702696e1871 100644
--- a/tests/mir-opt/gvn.borrowed.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.borrowed.GVN.panic-abort.diff
@@ -7,19 +7,19 @@
       let mut _3: &T;
   
       bb0: {
-          _2 = _1;
+          _2 = copy _1;
           _3 = &_1;
-          _0 = opaque::<&T>(_3) -> [return: bb1, unwind unreachable];
+          _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
--         _0 = opaque::<T>(_2) -> [return: bb2, unwind unreachable];
-+         _0 = opaque::<T>(_1) -> [return: bb2, unwind unreachable];
+-         _0 = opaque::<T>(copy _2) -> [return: bb2, unwind unreachable];
++         _0 = opaque::<T>(copy _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
--         _0 = opaque::<T>((*_3)) -> [return: bb3, unwind unreachable];
-+         _0 = opaque::<T>(_1) -> [return: bb3, unwind unreachable];
+-         _0 = opaque::<T>(copy (*_3)) -> [return: bb3, unwind unreachable];
++         _0 = opaque::<T>(copy _1) -> [return: bb3, unwind unreachable];
       }
   
       bb3: {
diff --git a/tests/mir-opt/gvn.borrowed.GVN.panic-unwind.diff b/tests/mir-opt/gvn.borrowed.GVN.panic-unwind.diff
index 4f5d76d564400..fe05d4deeede9 100644
--- a/tests/mir-opt/gvn.borrowed.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.borrowed.GVN.panic-unwind.diff
@@ -7,19 +7,19 @@
       let mut _3: &T;
   
       bb0: {
-          _2 = _1;
+          _2 = copy _1;
           _3 = &_1;
-          _0 = opaque::<&T>(_3) -> [return: bb1, unwind continue];
+          _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind continue];
       }
   
       bb1: {
--         _0 = opaque::<T>(_2) -> [return: bb2, unwind continue];
-+         _0 = opaque::<T>(_1) -> [return: bb2, unwind continue];
+-         _0 = opaque::<T>(copy _2) -> [return: bb2, unwind continue];
++         _0 = opaque::<T>(copy _1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
--         _0 = opaque::<T>((*_3)) -> [return: bb3, unwind continue];
-+         _0 = opaque::<T>(_1) -> [return: bb3, unwind continue];
+-         _0 = opaque::<T>(copy (*_3)) -> [return: bb3, unwind continue];
++         _0 = opaque::<T>(copy _1) -> [return: bb3, unwind continue];
       }
   
       bb3: {
diff --git a/tests/mir-opt/gvn.cast.GVN.panic-abort.diff b/tests/mir-opt/gvn.cast.GVN.panic-abort.diff
index d43198c99110d..1d523d22ca646 100644
--- a/tests/mir-opt/gvn.cast.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.cast.GVN.panic-abort.diff
@@ -116,7 +116,7 @@
           StorageLive(_4);
           StorageLive(_5);
           StorageLive(_6);
--         _6 = _1;
+-         _6 = copy _1;
 -         _5 = move _6 as u8 (IntToInt);
 +         _6 = const 1_i64;
 +         _5 = const 1_u8;
@@ -131,7 +131,7 @@
           StorageLive(_7);
           StorageLive(_8);
           StorageLive(_9);
--         _9 = _1;
+-         _9 = copy _1;
 -         _8 = move _9 as u16 (IntToInt);
 +         _9 = const 1_i64;
 +         _8 = const 1_u16;
@@ -146,7 +146,7 @@
           StorageLive(_10);
           StorageLive(_11);
           StorageLive(_12);
--         _12 = _1;
+-         _12 = copy _1;
 -         _11 = move _12 as u32 (IntToInt);
 +         _12 = const 1_i64;
 +         _11 = const 1_u32;
@@ -161,7 +161,7 @@
           StorageLive(_13);
           StorageLive(_14);
           StorageLive(_15);
--         _15 = _1;
+-         _15 = copy _1;
 -         _14 = move _15 as u64 (IntToInt);
 +         _15 = const 1_i64;
 +         _14 = const 1_u64;
@@ -176,7 +176,7 @@
           StorageLive(_16);
           StorageLive(_17);
           StorageLive(_18);
--         _18 = _1;
+-         _18 = copy _1;
 -         _17 = move _18 as i8 (IntToInt);
 +         _18 = const 1_i64;
 +         _17 = const 1_i8;
@@ -191,7 +191,7 @@
           StorageLive(_19);
           StorageLive(_20);
           StorageLive(_21);
--         _21 = _1;
+-         _21 = copy _1;
 -         _20 = move _21 as i16 (IntToInt);
 +         _21 = const 1_i64;
 +         _20 = const 1_i16;
@@ -206,7 +206,7 @@
           StorageLive(_22);
           StorageLive(_23);
           StorageLive(_24);
--         _24 = _1;
+-         _24 = copy _1;
 -         _23 = move _24 as i32 (IntToInt);
 +         _24 = const 1_i64;
 +         _23 = const 1_i32;
@@ -220,7 +220,7 @@
           StorageDead(_22);
           StorageLive(_25);
           StorageLive(_26);
--         _26 = _1;
+-         _26 = copy _1;
 -         _25 = opaque::<i64>(move _26) -> [return: bb8, unwind unreachable];
 +         _26 = const 1_i64;
 +         _25 = opaque::<i64>(const 1_i64) -> [return: bb8, unwind unreachable];
@@ -232,7 +232,7 @@
           StorageLive(_27);
           StorageLive(_28);
           StorageLive(_29);
--         _29 = _1;
+-         _29 = copy _1;
 -         _28 = move _29 as f32 (IntToFloat);
 +         _29 = const 1_i64;
 +         _28 = const 1f32;
@@ -247,7 +247,7 @@
           StorageLive(_30);
           StorageLive(_31);
           StorageLive(_32);
--         _32 = _1;
+-         _32 = copy _1;
 -         _31 = move _32 as f64 (IntToFloat);
 +         _32 = const 1_i64;
 +         _31 = const 1f64;
@@ -262,7 +262,7 @@
           StorageLive(_33);
           StorageLive(_34);
           StorageLive(_35);
--         _35 = _2;
+-         _35 = copy _2;
 -         _34 = move _35 as u8 (IntToInt);
 +         _35 = const 1_u64;
 +         _34 = const 1_u8;
@@ -277,7 +277,7 @@
           StorageLive(_36);
           StorageLive(_37);
           StorageLive(_38);
--         _38 = _2;
+-         _38 = copy _2;
 -         _37 = move _38 as u16 (IntToInt);
 +         _38 = const 1_u64;
 +         _37 = const 1_u16;
@@ -292,7 +292,7 @@
           StorageLive(_39);
           StorageLive(_40);
           StorageLive(_41);
--         _41 = _2;
+-         _41 = copy _2;
 -         _40 = move _41 as u32 (IntToInt);
 +         _41 = const 1_u64;
 +         _40 = const 1_u32;
@@ -306,7 +306,7 @@
           StorageDead(_39);
           StorageLive(_42);
           StorageLive(_43);
--         _43 = _2;
+-         _43 = copy _2;
 -         _42 = opaque::<u64>(move _43) -> [return: bb14, unwind unreachable];
 +         _43 = const 1_u64;
 +         _42 = opaque::<u64>(const 1_u64) -> [return: bb14, unwind unreachable];
@@ -318,7 +318,7 @@
           StorageLive(_44);
           StorageLive(_45);
           StorageLive(_46);
--         _46 = _2;
+-         _46 = copy _2;
 -         _45 = move _46 as i8 (IntToInt);
 +         _46 = const 1_u64;
 +         _45 = const 1_i8;
@@ -333,7 +333,7 @@
           StorageLive(_47);
           StorageLive(_48);
           StorageLive(_49);
--         _49 = _2;
+-         _49 = copy _2;
 -         _48 = move _49 as i16 (IntToInt);
 +         _49 = const 1_u64;
 +         _48 = const 1_i16;
@@ -348,7 +348,7 @@
           StorageLive(_50);
           StorageLive(_51);
           StorageLive(_52);
--         _52 = _2;
+-         _52 = copy _2;
 -         _51 = move _52 as i32 (IntToInt);
 +         _52 = const 1_u64;
 +         _51 = const 1_i32;
@@ -363,7 +363,7 @@
           StorageLive(_53);
           StorageLive(_54);
           StorageLive(_55);
--         _55 = _2;
+-         _55 = copy _2;
 -         _54 = move _55 as i64 (IntToInt);
 +         _55 = const 1_u64;
 +         _54 = const 1_i64;
@@ -378,7 +378,7 @@
           StorageLive(_56);
           StorageLive(_57);
           StorageLive(_58);
--         _58 = _2;
+-         _58 = copy _2;
 -         _57 = move _58 as f32 (IntToFloat);
 +         _58 = const 1_u64;
 +         _57 = const 1f32;
@@ -393,7 +393,7 @@
           StorageLive(_59);
           StorageLive(_60);
           StorageLive(_61);
--         _61 = _2;
+-         _61 = copy _2;
 -         _60 = move _61 as f64 (IntToFloat);
 +         _61 = const 1_u64;
 +         _60 = const 1f64;
@@ -408,7 +408,7 @@
           StorageLive(_62);
           StorageLive(_63);
           StorageLive(_64);
--         _64 = _3;
+-         _64 = copy _3;
 -         _63 = move _64 as u8 (FloatToInt);
 +         _64 = const 1f64;
 +         _63 = const 1_u8;
@@ -423,7 +423,7 @@
           StorageLive(_65);
           StorageLive(_66);
           StorageLive(_67);
--         _67 = _3;
+-         _67 = copy _3;
 -         _66 = move _67 as u16 (FloatToInt);
 +         _67 = const 1f64;
 +         _66 = const 1_u16;
@@ -438,7 +438,7 @@
           StorageLive(_68);
           StorageLive(_69);
           StorageLive(_70);
--         _70 = _3;
+-         _70 = copy _3;
 -         _69 = move _70 as u32 (FloatToInt);
 +         _70 = const 1f64;
 +         _69 = const 1_u32;
@@ -453,7 +453,7 @@
           StorageLive(_71);
           StorageLive(_72);
           StorageLive(_73);
--         _73 = _3;
+-         _73 = copy _3;
 -         _72 = move _73 as u64 (FloatToInt);
 +         _73 = const 1f64;
 +         _72 = const 1_u64;
@@ -468,7 +468,7 @@
           StorageLive(_74);
           StorageLive(_75);
           StorageLive(_76);
--         _76 = _3;
+-         _76 = copy _3;
 -         _75 = move _76 as i8 (FloatToInt);
 +         _76 = const 1f64;
 +         _75 = const 1_i8;
@@ -483,7 +483,7 @@
           StorageLive(_77);
           StorageLive(_78);
           StorageLive(_79);
--         _79 = _3;
+-         _79 = copy _3;
 -         _78 = move _79 as i16 (FloatToInt);
 +         _79 = const 1f64;
 +         _78 = const 1_i16;
@@ -498,7 +498,7 @@
           StorageLive(_80);
           StorageLive(_81);
           StorageLive(_82);
--         _82 = _3;
+-         _82 = copy _3;
 -         _81 = move _82 as i32 (FloatToInt);
 +         _82 = const 1f64;
 +         _81 = const 1_i32;
@@ -513,7 +513,7 @@
           StorageLive(_83);
           StorageLive(_84);
           StorageLive(_85);
--         _85 = _3;
+-         _85 = copy _3;
 -         _84 = move _85 as i64 (FloatToInt);
 +         _85 = const 1f64;
 +         _84 = const 1_i64;
@@ -528,7 +528,7 @@
           StorageLive(_86);
           StorageLive(_87);
           StorageLive(_88);
--         _88 = _3;
+-         _88 = copy _3;
 -         _87 = move _88 as f32 (FloatToFloat);
 +         _88 = const 1f64;
 +         _87 = const 1f32;
@@ -542,7 +542,7 @@
           StorageDead(_86);
           StorageLive(_89);
           StorageLive(_90);
--         _90 = _3;
+-         _90 = copy _3;
 -         _89 = opaque::<f64>(move _90) -> [return: bb30, unwind unreachable];
 +         _90 = const 1f64;
 +         _89 = opaque::<f64>(const 1f64) -> [return: bb30, unwind unreachable];
diff --git a/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff b/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff
index 08b97e13aa0ba..3541c10da6437 100644
--- a/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.cast.GVN.panic-unwind.diff
@@ -116,7 +116,7 @@
           StorageLive(_4);
           StorageLive(_5);
           StorageLive(_6);
--         _6 = _1;
+-         _6 = copy _1;
 -         _5 = move _6 as u8 (IntToInt);
 +         _6 = const 1_i64;
 +         _5 = const 1_u8;
@@ -131,7 +131,7 @@
           StorageLive(_7);
           StorageLive(_8);
           StorageLive(_9);
--         _9 = _1;
+-         _9 = copy _1;
 -         _8 = move _9 as u16 (IntToInt);
 +         _9 = const 1_i64;
 +         _8 = const 1_u16;
@@ -146,7 +146,7 @@
           StorageLive(_10);
           StorageLive(_11);
           StorageLive(_12);
--         _12 = _1;
+-         _12 = copy _1;
 -         _11 = move _12 as u32 (IntToInt);
 +         _12 = const 1_i64;
 +         _11 = const 1_u32;
@@ -161,7 +161,7 @@
           StorageLive(_13);
           StorageLive(_14);
           StorageLive(_15);
--         _15 = _1;
+-         _15 = copy _1;
 -         _14 = move _15 as u64 (IntToInt);
 +         _15 = const 1_i64;
 +         _14 = const 1_u64;
@@ -176,7 +176,7 @@
           StorageLive(_16);
           StorageLive(_17);
           StorageLive(_18);
--         _18 = _1;
+-         _18 = copy _1;
 -         _17 = move _18 as i8 (IntToInt);
 +         _18 = const 1_i64;
 +         _17 = const 1_i8;
@@ -191,7 +191,7 @@
           StorageLive(_19);
           StorageLive(_20);
           StorageLive(_21);
--         _21 = _1;
+-         _21 = copy _1;
 -         _20 = move _21 as i16 (IntToInt);
 +         _21 = const 1_i64;
 +         _20 = const 1_i16;
@@ -206,7 +206,7 @@
           StorageLive(_22);
           StorageLive(_23);
           StorageLive(_24);
--         _24 = _1;
+-         _24 = copy _1;
 -         _23 = move _24 as i32 (IntToInt);
 +         _24 = const 1_i64;
 +         _23 = const 1_i32;
@@ -220,7 +220,7 @@
           StorageDead(_22);
           StorageLive(_25);
           StorageLive(_26);
--         _26 = _1;
+-         _26 = copy _1;
 -         _25 = opaque::<i64>(move _26) -> [return: bb8, unwind continue];
 +         _26 = const 1_i64;
 +         _25 = opaque::<i64>(const 1_i64) -> [return: bb8, unwind continue];
@@ -232,7 +232,7 @@
           StorageLive(_27);
           StorageLive(_28);
           StorageLive(_29);
--         _29 = _1;
+-         _29 = copy _1;
 -         _28 = move _29 as f32 (IntToFloat);
 +         _29 = const 1_i64;
 +         _28 = const 1f32;
@@ -247,7 +247,7 @@
           StorageLive(_30);
           StorageLive(_31);
           StorageLive(_32);
--         _32 = _1;
+-         _32 = copy _1;
 -         _31 = move _32 as f64 (IntToFloat);
 +         _32 = const 1_i64;
 +         _31 = const 1f64;
@@ -262,7 +262,7 @@
           StorageLive(_33);
           StorageLive(_34);
           StorageLive(_35);
--         _35 = _2;
+-         _35 = copy _2;
 -         _34 = move _35 as u8 (IntToInt);
 +         _35 = const 1_u64;
 +         _34 = const 1_u8;
@@ -277,7 +277,7 @@
           StorageLive(_36);
           StorageLive(_37);
           StorageLive(_38);
--         _38 = _2;
+-         _38 = copy _2;
 -         _37 = move _38 as u16 (IntToInt);
 +         _38 = const 1_u64;
 +         _37 = const 1_u16;
@@ -292,7 +292,7 @@
           StorageLive(_39);
           StorageLive(_40);
           StorageLive(_41);
--         _41 = _2;
+-         _41 = copy _2;
 -         _40 = move _41 as u32 (IntToInt);
 +         _41 = const 1_u64;
 +         _40 = const 1_u32;
@@ -306,7 +306,7 @@
           StorageDead(_39);
           StorageLive(_42);
           StorageLive(_43);
--         _43 = _2;
+-         _43 = copy _2;
 -         _42 = opaque::<u64>(move _43) -> [return: bb14, unwind continue];
 +         _43 = const 1_u64;
 +         _42 = opaque::<u64>(const 1_u64) -> [return: bb14, unwind continue];
@@ -318,7 +318,7 @@
           StorageLive(_44);
           StorageLive(_45);
           StorageLive(_46);
--         _46 = _2;
+-         _46 = copy _2;
 -         _45 = move _46 as i8 (IntToInt);
 +         _46 = const 1_u64;
 +         _45 = const 1_i8;
@@ -333,7 +333,7 @@
           StorageLive(_47);
           StorageLive(_48);
           StorageLive(_49);
--         _49 = _2;
+-         _49 = copy _2;
 -         _48 = move _49 as i16 (IntToInt);
 +         _49 = const 1_u64;
 +         _48 = const 1_i16;
@@ -348,7 +348,7 @@
           StorageLive(_50);
           StorageLive(_51);
           StorageLive(_52);
--         _52 = _2;
+-         _52 = copy _2;
 -         _51 = move _52 as i32 (IntToInt);
 +         _52 = const 1_u64;
 +         _51 = const 1_i32;
@@ -363,7 +363,7 @@
           StorageLive(_53);
           StorageLive(_54);
           StorageLive(_55);
--         _55 = _2;
+-         _55 = copy _2;
 -         _54 = move _55 as i64 (IntToInt);
 +         _55 = const 1_u64;
 +         _54 = const 1_i64;
@@ -378,7 +378,7 @@
           StorageLive(_56);
           StorageLive(_57);
           StorageLive(_58);
--         _58 = _2;
+-         _58 = copy _2;
 -         _57 = move _58 as f32 (IntToFloat);
 +         _58 = const 1_u64;
 +         _57 = const 1f32;
@@ -393,7 +393,7 @@
           StorageLive(_59);
           StorageLive(_60);
           StorageLive(_61);
--         _61 = _2;
+-         _61 = copy _2;
 -         _60 = move _61 as f64 (IntToFloat);
 +         _61 = const 1_u64;
 +         _60 = const 1f64;
@@ -408,7 +408,7 @@
           StorageLive(_62);
           StorageLive(_63);
           StorageLive(_64);
--         _64 = _3;
+-         _64 = copy _3;
 -         _63 = move _64 as u8 (FloatToInt);
 +         _64 = const 1f64;
 +         _63 = const 1_u8;
@@ -423,7 +423,7 @@
           StorageLive(_65);
           StorageLive(_66);
           StorageLive(_67);
--         _67 = _3;
+-         _67 = copy _3;
 -         _66 = move _67 as u16 (FloatToInt);
 +         _67 = const 1f64;
 +         _66 = const 1_u16;
@@ -438,7 +438,7 @@
           StorageLive(_68);
           StorageLive(_69);
           StorageLive(_70);
--         _70 = _3;
+-         _70 = copy _3;
 -         _69 = move _70 as u32 (FloatToInt);
 +         _70 = const 1f64;
 +         _69 = const 1_u32;
@@ -453,7 +453,7 @@
           StorageLive(_71);
           StorageLive(_72);
           StorageLive(_73);
--         _73 = _3;
+-         _73 = copy _3;
 -         _72 = move _73 as u64 (FloatToInt);
 +         _73 = const 1f64;
 +         _72 = const 1_u64;
@@ -468,7 +468,7 @@
           StorageLive(_74);
           StorageLive(_75);
           StorageLive(_76);
--         _76 = _3;
+-         _76 = copy _3;
 -         _75 = move _76 as i8 (FloatToInt);
 +         _76 = const 1f64;
 +         _75 = const 1_i8;
@@ -483,7 +483,7 @@
           StorageLive(_77);
           StorageLive(_78);
           StorageLive(_79);
--         _79 = _3;
+-         _79 = copy _3;
 -         _78 = move _79 as i16 (FloatToInt);
 +         _79 = const 1f64;
 +         _78 = const 1_i16;
@@ -498,7 +498,7 @@
           StorageLive(_80);
           StorageLive(_81);
           StorageLive(_82);
--         _82 = _3;
+-         _82 = copy _3;
 -         _81 = move _82 as i32 (FloatToInt);
 +         _82 = const 1f64;
 +         _81 = const 1_i32;
@@ -513,7 +513,7 @@
           StorageLive(_83);
           StorageLive(_84);
           StorageLive(_85);
--         _85 = _3;
+-         _85 = copy _3;
 -         _84 = move _85 as i64 (FloatToInt);
 +         _85 = const 1f64;
 +         _84 = const 1_i64;
@@ -528,7 +528,7 @@
           StorageLive(_86);
           StorageLive(_87);
           StorageLive(_88);
--         _88 = _3;
+-         _88 = copy _3;
 -         _87 = move _88 as f32 (FloatToFloat);
 +         _88 = const 1f64;
 +         _87 = const 1f32;
@@ -542,7 +542,7 @@
           StorageDead(_86);
           StorageLive(_89);
           StorageLive(_90);
--         _90 = _3;
+-         _90 = copy _3;
 -         _89 = opaque::<f64>(move _90) -> [return: bb30, unwind continue];
 +         _90 = const 1f64;
 +         _89 = opaque::<f64>(const 1f64) -> [return: bb30, unwind continue];
diff --git a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff
index 757ab959813a4..f66aed0f44150 100644
--- a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-abort.diff
@@ -52,70 +52,70 @@
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
 -         _5 = move _6 as *const u32 (PtrToPtr);
-+         _5 = _1 as *const u32 (PtrToPtr);
++         _5 = copy _1 as *const u32 (PtrToPtr);
           StorageDead(_6);
           StorageLive(_7);
 -         StorageLive(_8);
 +         nop;
           StorageLive(_9);
-          _9 = _2;
+          _9 = copy _2;
 -         _8 = move _9 as *const u32 (PtrToPtr);
-+         _8 = _2 as *const u32 (PtrToPtr);
++         _8 = copy _2 as *const u32 (PtrToPtr);
           StorageDead(_9);
 -         _7 = move _8 as *const u32 (PtrToPtr);
 -         StorageDead(_8);
-+         _7 = _8;
++         _7 = copy _8;
 +         nop;
           StorageLive(_10);
 -         StorageLive(_11);
 +         nop;
           StorageLive(_12);
-          _12 = _3;
+          _12 = copy _3;
 -         _11 = move _12 as *const u32 (PtrToPtr);
-+         _11 = _3 as *const u32 (PtrToPtr);
++         _11 = copy _3 as *const u32 (PtrToPtr);
           StorageDead(_12);
 -         _10 = move _11 as *const u32 (PtrToPtr);
 -         StorageDead(_11);
 -         StorageLive(_13);
-+         _10 = _11;
++         _10 = copy _11;
 +         nop;
 +         nop;
           StorageLive(_14);
-          _14 = _4;
+          _14 = copy _4;
 -         _13 = move _14 as *const u32 (PtrToPtr);
-+         _13 = _4 as *const u32 (PtrToPtr);
++         _13 = copy _4 as *const u32 (PtrToPtr);
           StorageDead(_14);
           StorageLive(_15);
           StorageLive(_16);
-          _16 = _5;
+          _16 = copy _5;
           StorageLive(_17);
--         _17 = _7;
+-         _17 = copy _7;
 -         _15 = Eq(move _16, move _17);
-+         _17 = _8;
-+         _15 = Eq(_5, _8);
++         _17 = copy _8;
++         _15 = Eq(copy _5, copy _8);
           StorageDead(_17);
           StorageDead(_16);
           StorageLive(_18);
           StorageLive(_19);
--         _19 = _7;
-+         _19 = _8;
+-         _19 = copy _7;
++         _19 = copy _8;
           StorageLive(_20);
--         _20 = _10;
+-         _20 = copy _10;
 -         _18 = Eq(move _19, move _20);
-+         _20 = _11;
-+         _18 = Eq(_2, _3);
++         _20 = copy _11;
++         _18 = Eq(copy _2, copy _3);
           StorageDead(_20);
           StorageDead(_19);
           StorageLive(_21);
           StorageLive(_22);
--         _22 = _10;
-+         _22 = _11;
+-         _22 = copy _10;
++         _22 = copy _11;
           StorageLive(_23);
-          _23 = _13;
+          _23 = copy _13;
 -         _21 = Eq(move _22, move _23);
-+         _21 = Eq(_11, _13);
++         _21 = Eq(copy _11, copy _13);
           StorageDead(_23);
           StorageDead(_22);
           _0 = const ();
diff --git a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff
index 757ab959813a4..f66aed0f44150 100644
--- a/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.cast_pointer_eq.GVN.panic-unwind.diff
@@ -52,70 +52,70 @@
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
 -         _5 = move _6 as *const u32 (PtrToPtr);
-+         _5 = _1 as *const u32 (PtrToPtr);
++         _5 = copy _1 as *const u32 (PtrToPtr);
           StorageDead(_6);
           StorageLive(_7);
 -         StorageLive(_8);
 +         nop;
           StorageLive(_9);
-          _9 = _2;
+          _9 = copy _2;
 -         _8 = move _9 as *const u32 (PtrToPtr);
-+         _8 = _2 as *const u32 (PtrToPtr);
++         _8 = copy _2 as *const u32 (PtrToPtr);
           StorageDead(_9);
 -         _7 = move _8 as *const u32 (PtrToPtr);
 -         StorageDead(_8);
-+         _7 = _8;
++         _7 = copy _8;
 +         nop;
           StorageLive(_10);
 -         StorageLive(_11);
 +         nop;
           StorageLive(_12);
-          _12 = _3;
+          _12 = copy _3;
 -         _11 = move _12 as *const u32 (PtrToPtr);
-+         _11 = _3 as *const u32 (PtrToPtr);
++         _11 = copy _3 as *const u32 (PtrToPtr);
           StorageDead(_12);
 -         _10 = move _11 as *const u32 (PtrToPtr);
 -         StorageDead(_11);
 -         StorageLive(_13);
-+         _10 = _11;
++         _10 = copy _11;
 +         nop;
 +         nop;
           StorageLive(_14);
-          _14 = _4;
+          _14 = copy _4;
 -         _13 = move _14 as *const u32 (PtrToPtr);
-+         _13 = _4 as *const u32 (PtrToPtr);
++         _13 = copy _4 as *const u32 (PtrToPtr);
           StorageDead(_14);
           StorageLive(_15);
           StorageLive(_16);
-          _16 = _5;
+          _16 = copy _5;
           StorageLive(_17);
--         _17 = _7;
+-         _17 = copy _7;
 -         _15 = Eq(move _16, move _17);
-+         _17 = _8;
-+         _15 = Eq(_5, _8);
++         _17 = copy _8;
++         _15 = Eq(copy _5, copy _8);
           StorageDead(_17);
           StorageDead(_16);
           StorageLive(_18);
           StorageLive(_19);
--         _19 = _7;
-+         _19 = _8;
+-         _19 = copy _7;
++         _19 = copy _8;
           StorageLive(_20);
--         _20 = _10;
+-         _20 = copy _10;
 -         _18 = Eq(move _19, move _20);
-+         _20 = _11;
-+         _18 = Eq(_2, _3);
++         _20 = copy _11;
++         _18 = Eq(copy _2, copy _3);
           StorageDead(_20);
           StorageDead(_19);
           StorageLive(_21);
           StorageLive(_22);
--         _22 = _10;
-+         _22 = _11;
+-         _22 = copy _10;
++         _22 = copy _11;
           StorageLive(_23);
-          _23 = _13;
+          _23 = copy _13;
 -         _21 = Eq(move _22, move _23);
-+         _21 = Eq(_11, _13);
++         _21 = Eq(copy _11, copy _13);
           StorageDead(_23);
           StorageDead(_22);
           _0 = const ();
diff --git a/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-abort.diff b/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-abort.diff
index 8133f6e0b0078..d9f945d2c41e8 100644
--- a/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-abort.diff
@@ -22,19 +22,19 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = move _5 as *const () (PtrToPtr);
-+         _4 = _1 as *const () (PtrToPtr);
++         _4 = copy _1 as *const () (PtrToPtr);
           StorageDead(_5);
 -         _3 = move _4 as usize (Transmute);
-+         _3 = _1 as usize (Transmute);
++         _3 = copy _1 as usize (Transmute);
           StorageDead(_4);
           StorageLive(_6);
           StorageLive(_7);
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
 -         _7 = move _8 as *const () (PtrToPtr);
-+         _7 = _2 as *const () (PtrToPtr);
++         _7 = copy _2 as *const () (PtrToPtr);
           StorageDead(_8);
           _6 = move _7 as usize (Transmute);
           StorageDead(_7);
diff --git a/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-unwind.diff b/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-unwind.diff
index 8133f6e0b0078..d9f945d2c41e8 100644
--- a/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.cast_pointer_then_transmute.GVN.panic-unwind.diff
@@ -22,19 +22,19 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = move _5 as *const () (PtrToPtr);
-+         _4 = _1 as *const () (PtrToPtr);
++         _4 = copy _1 as *const () (PtrToPtr);
           StorageDead(_5);
 -         _3 = move _4 as usize (Transmute);
-+         _3 = _1 as usize (Transmute);
++         _3 = copy _1 as usize (Transmute);
           StorageDead(_4);
           StorageLive(_6);
           StorageLive(_7);
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
 -         _7 = move _8 as *const () (PtrToPtr);
-+         _7 = _2 as *const () (PtrToPtr);
++         _7 = copy _2 as *const () (PtrToPtr);
           StorageDead(_8);
           _6 = move _7 as usize (Transmute);
           StorageDead(_7);
diff --git a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff
index 6e5bdb16595be..fd09310fabdeb 100644
--- a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-abort.diff
@@ -25,28 +25,28 @@
 -         StorageLive(_2);
 +         nop;
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = move _3 as *const [u8; 4] (PtrToPtr);
-+         _2 = _1 as *const [u8; 4] (PtrToPtr);
++         _2 = copy _1 as *const [u8; 4] (PtrToPtr);
           StorageDead(_3);
 -         StorageLive(_4);
 +         nop;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _4 = move _5 as *const u8 (PtrToPtr);
-+         _4 = _1 as *const u8 (PtrToPtr);
++         _4 = copy _1 as *const u8 (PtrToPtr);
           StorageDead(_5);
 -         StorageLive(_6);
 +         nop;
           StorageLive(_7);
-          _7 = _4;
+          _7 = copy _4;
 -         _6 = move _7 as *const () (PtrToPtr);
-+         _6 = _1 as *const () (PtrToPtr);
++         _6 = copy _1 as *const () (PtrToPtr);
           StorageDead(_7);
           StorageLive(_8);
-          _8 = _6;
+          _8 = copy _6;
 -         _0 = *const [u8] from (move _8, const 4_usize);
-+         _0 = *const [u8] from (_1, const 4_usize);
++         _0 = *const [u8] from (copy _1, const 4_usize);
           StorageDead(_8);
 -         StorageDead(_6);
 -         StorageDead(_4);
diff --git a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff
index 6e5bdb16595be..fd09310fabdeb 100644
--- a/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.casts_before_aggregate_raw_ptr.GVN.panic-unwind.diff
@@ -25,28 +25,28 @@
 -         StorageLive(_2);
 +         nop;
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = move _3 as *const [u8; 4] (PtrToPtr);
-+         _2 = _1 as *const [u8; 4] (PtrToPtr);
++         _2 = copy _1 as *const [u8; 4] (PtrToPtr);
           StorageDead(_3);
 -         StorageLive(_4);
 +         nop;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _4 = move _5 as *const u8 (PtrToPtr);
-+         _4 = _1 as *const u8 (PtrToPtr);
++         _4 = copy _1 as *const u8 (PtrToPtr);
           StorageDead(_5);
 -         StorageLive(_6);
 +         nop;
           StorageLive(_7);
-          _7 = _4;
+          _7 = copy _4;
 -         _6 = move _7 as *const () (PtrToPtr);
-+         _6 = _1 as *const () (PtrToPtr);
++         _6 = copy _1 as *const () (PtrToPtr);
           StorageDead(_7);
           StorageLive(_8);
-          _8 = _6;
+          _8 = copy _6;
 -         _0 = *const [u8] from (move _8, const 4_usize);
-+         _0 = *const [u8] from (_1, const 4_usize);
++         _0 = *const [u8] from (copy _1, const 4_usize);
           StorageDead(_8);
 -         StorageDead(_6);
 -         StorageDead(_4);
diff --git a/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff b/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff
index fefdf14bddcd0..7b25dedbb887c 100644
--- a/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.comparison.GVN.panic-abort.diff
@@ -26,9 +26,9 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
 -         _4 = Eq(move _5, move _6);
 +         _4 = const true;
           StorageDead(_6);
@@ -43,9 +43,9 @@
           StorageLive(_7);
           StorageLive(_8);
           StorageLive(_9);
-          _9 = _1;
+          _9 = copy _1;
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
 -         _8 = Ne(move _9, move _10);
 +         _8 = const false;
           StorageDead(_10);
@@ -60,11 +60,11 @@
           StorageLive(_11);
           StorageLive(_12);
           StorageLive(_13);
-          _13 = _1;
+          _13 = copy _1;
           StorageLive(_14);
-          _14 = _2;
+          _14 = copy _2;
 -         _12 = Eq(move _13, move _14);
-+         _12 = Eq(_1, _2);
++         _12 = Eq(copy _1, copy _2);
           StorageDead(_14);
           StorageDead(_13);
           _11 = opaque::<bool>(move _12) -> [return: bb3, unwind unreachable];
@@ -76,11 +76,11 @@
           StorageLive(_15);
           StorageLive(_16);
           StorageLive(_17);
-          _17 = _1;
+          _17 = copy _1;
           StorageLive(_18);
-          _18 = _2;
+          _18 = copy _2;
 -         _16 = Ne(move _17, move _18);
-+         _16 = Ne(_1, _2);
++         _16 = Ne(copy _1, copy _2);
           StorageDead(_18);
           StorageDead(_17);
           _15 = opaque::<bool>(move _16) -> [return: bb4, unwind unreachable];
diff --git a/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff b/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff
index 9f19b2b59fa54..416ae1ee5595d 100644
--- a/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.comparison.GVN.panic-unwind.diff
@@ -26,9 +26,9 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
 -         _4 = Eq(move _5, move _6);
 +         _4 = const true;
           StorageDead(_6);
@@ -43,9 +43,9 @@
           StorageLive(_7);
           StorageLive(_8);
           StorageLive(_9);
-          _9 = _1;
+          _9 = copy _1;
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
 -         _8 = Ne(move _9, move _10);
 +         _8 = const false;
           StorageDead(_10);
@@ -60,11 +60,11 @@
           StorageLive(_11);
           StorageLive(_12);
           StorageLive(_13);
-          _13 = _1;
+          _13 = copy _1;
           StorageLive(_14);
-          _14 = _2;
+          _14 = copy _2;
 -         _12 = Eq(move _13, move _14);
-+         _12 = Eq(_1, _2);
++         _12 = Eq(copy _1, copy _2);
           StorageDead(_14);
           StorageDead(_13);
           _11 = opaque::<bool>(move _12) -> [return: bb3, unwind continue];
@@ -76,11 +76,11 @@
           StorageLive(_15);
           StorageLive(_16);
           StorageLive(_17);
-          _17 = _1;
+          _17 = copy _1;
           StorageLive(_18);
-          _18 = _2;
+          _18 = copy _2;
 -         _16 = Ne(move _17, move _18);
-+         _16 = Ne(_1, _2);
++         _16 = Ne(copy _1, copy _2);
           StorageDead(_18);
           StorageDead(_17);
           _15 = opaque::<bool>(move _16) -> [return: bb4, unwind continue];
diff --git a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff
index c417c51f9b7de..3f052ee19fdfe 100644
--- a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-abort.diff
@@ -32,7 +32,7 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
--         _5 = _2;
+-         _5 = copy _2;
 +         _5 = const usize::MAX;
           StorageLive(_6);
           StorageLive(_7);
@@ -51,18 +51,18 @@
           StorageDead(_6);
           StorageDead(_5);
           StorageLive(_8);
--         _8 = _2;
+-         _8 = copy _2;
 +         _8 = const usize::MAX;
           _9 = Len((*_1));
--         _10 = Lt(_8, _9);
--         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind unreachable];
-+         _10 = Lt(const usize::MAX, _9);
+-         _10 = Lt(copy _8, copy _9);
+-         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind unreachable];
++         _10 = Lt(const usize::MAX, copy _9);
 +         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, const usize::MAX) -> [success: bb3, unwind unreachable];
       }
   
       bb3: {
--         _3 = (*_1)[_8];
-+         _3 = (*_1)[_2];
+-         _3 = copy (*_1)[_8];
++         _3 = copy (*_1)[_2];
           StorageDead(_8);
           goto -> bb6;
       }
@@ -73,15 +73,15 @@
           StorageLive(_11);
           _11 = const 0_usize;
           _12 = Len((*_1));
--         _13 = Lt(_11, _12);
--         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb5, unwind unreachable];
-+         _13 = Lt(const 0_usize, _12);
+-         _13 = Lt(copy _11, copy _12);
+-         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb5, unwind unreachable];
++         _13 = Lt(const 0_usize, copy _12);
 +         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, const 0_usize) -> [success: bb5, unwind unreachable];
       }
   
       bb5: {
--         _3 = (*_1)[_11];
-+         _3 = (*_1)[0 of 1];
+-         _3 = copy (*_1)[_11];
++         _3 = copy (*_1)[0 of 1];
           StorageDead(_11);
           goto -> bb6;
       }
@@ -89,7 +89,7 @@
       bb6: {
           StorageDead(_4);
           StorageLive(_14);
-          _14 = _3;
+          _14 = copy _3;
           _0 = opaque::<T>(move _14) -> [return: bb7, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff
index 7a23fbe7cc00e..84b738c7804e0 100644
--- a/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.constant_index_overflow.GVN.panic-unwind.diff
@@ -32,7 +32,7 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
--         _5 = _2;
+-         _5 = copy _2;
 +         _5 = const usize::MAX;
           StorageLive(_6);
           StorageLive(_7);
@@ -51,18 +51,18 @@
           StorageDead(_6);
           StorageDead(_5);
           StorageLive(_8);
--         _8 = _2;
+-         _8 = copy _2;
 +         _8 = const usize::MAX;
           _9 = Len((*_1));
--         _10 = Lt(_8, _9);
--         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind continue];
-+         _10 = Lt(const usize::MAX, _9);
+-         _10 = Lt(copy _8, copy _9);
+-         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind continue];
++         _10 = Lt(const usize::MAX, copy _9);
 +         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, const usize::MAX) -> [success: bb3, unwind continue];
       }
   
       bb3: {
--         _3 = (*_1)[_8];
-+         _3 = (*_1)[_2];
+-         _3 = copy (*_1)[_8];
++         _3 = copy (*_1)[_2];
           StorageDead(_8);
           goto -> bb6;
       }
@@ -73,15 +73,15 @@
           StorageLive(_11);
           _11 = const 0_usize;
           _12 = Len((*_1));
--         _13 = Lt(_11, _12);
--         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb5, unwind continue];
-+         _13 = Lt(const 0_usize, _12);
+-         _13 = Lt(copy _11, copy _12);
+-         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb5, unwind continue];
++         _13 = Lt(const 0_usize, copy _12);
 +         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, const 0_usize) -> [success: bb5, unwind continue];
       }
   
       bb5: {
--         _3 = (*_1)[_11];
-+         _3 = (*_1)[0 of 1];
+-         _3 = copy (*_1)[_11];
++         _3 = copy (*_1)[0 of 1];
           StorageDead(_11);
           goto -> bb6;
       }
@@ -89,7 +89,7 @@
       bb6: {
           StorageDead(_4);
           StorageLive(_14);
-          _14 = _3;
+          _14 = copy _3;
           _0 = opaque::<T>(move _14) -> [return: bb7, unwind continue];
       }
   
diff --git a/tests/mir-opt/gvn.dereferences.GVN.panic-abort.diff b/tests/mir-opt/gvn.dereferences.GVN.panic-abort.diff
index 906835530d863..a763614dc644b 100644
--- a/tests/mir-opt/gvn.dereferences.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.dereferences.GVN.panic-abort.diff
@@ -48,7 +48,7 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = (*_1);
+          _5 = copy (*_1);
           _4 = opaque::<u32>(move _5) -> [return: bb1, unwind unreachable];
       }
   
@@ -57,7 +57,7 @@
           StorageDead(_4);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = (*_1);
+          _7 = copy (*_1);
           _6 = opaque::<u32>(move _7) -> [return: bb2, unwind unreachable];
       }
   
@@ -68,7 +68,7 @@
           _8 = &raw const (*_1);
           StorageLive(_9);
           StorageLive(_10);
-          _10 = (*_8);
+          _10 = copy (*_8);
           _9 = opaque::<u32>(move _10) -> [return: bb3, unwind unreachable];
       }
   
@@ -77,7 +77,7 @@
           StorageDead(_9);
           StorageLive(_11);
           StorageLive(_12);
-          _12 = (*_8);
+          _12 = copy (*_8);
           _11 = opaque::<u32>(move _12) -> [return: bb4, unwind unreachable];
       }
   
@@ -88,7 +88,7 @@
           _13 = &raw mut (*_1);
           StorageLive(_14);
           StorageLive(_15);
-          _15 = (*_13);
+          _15 = copy (*_13);
           _14 = opaque::<u32>(move _15) -> [return: bb5, unwind unreachable];
       }
   
@@ -97,7 +97,7 @@
           StorageDead(_14);
           StorageLive(_16);
           StorageLive(_17);
-          _17 = (*_13);
+          _17 = copy (*_13);
           _16 = opaque::<u32>(move _17) -> [return: bb6, unwind unreachable];
       }
   
@@ -109,9 +109,9 @@
           StorageLive(_19);
 -         StorageLive(_20);
 +         nop;
-          _20 = (*_18);
+          _20 = copy (*_18);
 -         _19 = opaque::<u32>(move _20) -> [return: bb7, unwind unreachable];
-+         _19 = opaque::<u32>(_20) -> [return: bb7, unwind unreachable];
++         _19 = opaque::<u32>(copy _20) -> [return: bb7, unwind unreachable];
       }
   
       bb7: {
@@ -120,10 +120,10 @@
           StorageDead(_19);
           StorageLive(_21);
           StorageLive(_22);
--         _22 = (*_18);
+-         _22 = copy (*_18);
 -         _21 = opaque::<u32>(move _22) -> [return: bb8, unwind unreachable];
-+         _22 = _20;
-+         _21 = opaque::<u32>(_20) -> [return: bb8, unwind unreachable];
++         _22 = copy _20;
++         _21 = opaque::<u32>(copy _20) -> [return: bb8, unwind unreachable];
       }
   
       bb8: {
@@ -140,7 +140,7 @@
           StorageDead(_23);
           StorageLive(_25);
           StorageLive(_26);
-          _26 = (*_2);
+          _26 = copy (*_2);
           _25 = opaque::<impl Copy>(move _26) -> [return: bb10, unwind unreachable];
       }
   
@@ -149,7 +149,7 @@
           StorageDead(_25);
           StorageLive(_27);
           StorageLive(_28);
-          _28 = (*_2);
+          _28 = copy (*_2);
           _27 = opaque::<impl Copy>(move _28) -> [return: bb11, unwind unreachable];
       }
   
@@ -159,9 +159,9 @@
           StorageLive(_29);
 -         StorageLive(_30);
 +         nop;
-          _30 = ((*_3).0: u32);
+          _30 = copy ((*_3).0: u32);
 -         _29 = opaque::<u32>(move _30) -> [return: bb12, unwind unreachable];
-+         _29 = opaque::<u32>(_30) -> [return: bb12, unwind unreachable];
++         _29 = opaque::<u32>(copy _30) -> [return: bb12, unwind unreachable];
       }
   
       bb12: {
@@ -170,10 +170,10 @@
           StorageDead(_29);
           StorageLive(_31);
           StorageLive(_32);
--         _32 = ((*_3).0: u32);
+-         _32 = copy ((*_3).0: u32);
 -         _31 = opaque::<u32>(move _32) -> [return: bb13, unwind unreachable];
-+         _32 = _30;
-+         _31 = opaque::<u32>(_30) -> [return: bb13, unwind unreachable];
++         _32 = copy _30;
++         _31 = opaque::<u32>(copy _30) -> [return: bb13, unwind unreachable];
       }
   
       bb13: {
diff --git a/tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff b/tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff
index 006b5da646c1c..ca6fda483642c 100644
--- a/tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.dereferences.GVN.panic-unwind.diff
@@ -48,7 +48,7 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = (*_1);
+          _5 = copy (*_1);
           _4 = opaque::<u32>(move _5) -> [return: bb1, unwind continue];
       }
   
@@ -57,7 +57,7 @@
           StorageDead(_4);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = (*_1);
+          _7 = copy (*_1);
           _6 = opaque::<u32>(move _7) -> [return: bb2, unwind continue];
       }
   
@@ -68,7 +68,7 @@
           _8 = &raw const (*_1);
           StorageLive(_9);
           StorageLive(_10);
-          _10 = (*_8);
+          _10 = copy (*_8);
           _9 = opaque::<u32>(move _10) -> [return: bb3, unwind continue];
       }
   
@@ -77,7 +77,7 @@
           StorageDead(_9);
           StorageLive(_11);
           StorageLive(_12);
-          _12 = (*_8);
+          _12 = copy (*_8);
           _11 = opaque::<u32>(move _12) -> [return: bb4, unwind continue];
       }
   
@@ -88,7 +88,7 @@
           _13 = &raw mut (*_1);
           StorageLive(_14);
           StorageLive(_15);
-          _15 = (*_13);
+          _15 = copy (*_13);
           _14 = opaque::<u32>(move _15) -> [return: bb5, unwind continue];
       }
   
@@ -97,7 +97,7 @@
           StorageDead(_14);
           StorageLive(_16);
           StorageLive(_17);
-          _17 = (*_13);
+          _17 = copy (*_13);
           _16 = opaque::<u32>(move _17) -> [return: bb6, unwind continue];
       }
   
@@ -109,9 +109,9 @@
           StorageLive(_19);
 -         StorageLive(_20);
 +         nop;
-          _20 = (*_18);
+          _20 = copy (*_18);
 -         _19 = opaque::<u32>(move _20) -> [return: bb7, unwind continue];
-+         _19 = opaque::<u32>(_20) -> [return: bb7, unwind continue];
++         _19 = opaque::<u32>(copy _20) -> [return: bb7, unwind continue];
       }
   
       bb7: {
@@ -120,10 +120,10 @@
           StorageDead(_19);
           StorageLive(_21);
           StorageLive(_22);
--         _22 = (*_18);
+-         _22 = copy (*_18);
 -         _21 = opaque::<u32>(move _22) -> [return: bb8, unwind continue];
-+         _22 = _20;
-+         _21 = opaque::<u32>(_20) -> [return: bb8, unwind continue];
++         _22 = copy _20;
++         _21 = opaque::<u32>(copy _20) -> [return: bb8, unwind continue];
       }
   
       bb8: {
@@ -140,7 +140,7 @@
           StorageDead(_23);
           StorageLive(_25);
           StorageLive(_26);
-          _26 = (*_2);
+          _26 = copy (*_2);
           _25 = opaque::<impl Copy>(move _26) -> [return: bb10, unwind continue];
       }
   
@@ -149,7 +149,7 @@
           StorageDead(_25);
           StorageLive(_27);
           StorageLive(_28);
-          _28 = (*_2);
+          _28 = copy (*_2);
           _27 = opaque::<impl Copy>(move _28) -> [return: bb11, unwind continue];
       }
   
@@ -159,9 +159,9 @@
           StorageLive(_29);
 -         StorageLive(_30);
 +         nop;
-          _30 = ((*_3).0: u32);
+          _30 = copy ((*_3).0: u32);
 -         _29 = opaque::<u32>(move _30) -> [return: bb12, unwind continue];
-+         _29 = opaque::<u32>(_30) -> [return: bb12, unwind continue];
++         _29 = opaque::<u32>(copy _30) -> [return: bb12, unwind continue];
       }
   
       bb12: {
@@ -170,10 +170,10 @@
           StorageDead(_29);
           StorageLive(_31);
           StorageLive(_32);
--         _32 = ((*_3).0: u32);
+-         _32 = copy ((*_3).0: u32);
 -         _31 = opaque::<u32>(move _32) -> [return: bb13, unwind continue];
-+         _32 = _30;
-+         _31 = opaque::<u32>(_30) -> [return: bb13, unwind continue];
++         _32 = copy _30;
++         _31 = opaque::<u32>(copy _30) -> [return: bb13, unwind continue];
       }
   
       bb13: {
diff --git a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff
index 7ae1fae68e887..18c2897d52870 100644
--- a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-abort.diff
@@ -16,22 +16,22 @@
   
       bb0: {
           _7 = (const "a",);
-          _1 = (_7.0: &str) as u128 (Transmute);
-          _5 = identity::<&str>((_7.0: &str)) -> [return: bb1, unwind unreachable];
+          _1 = copy (_7.0: &str) as u128 (Transmute);
+          _5 = identity::<&str>(copy (_7.0: &str)) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
-          _3 = _5 as u128 (Transmute);
+          _3 = copy _5 as u128 (Transmute);
           _8 = const "a";
-          _2 = _8 as u128 (Transmute);
-          _6 = identity::<&str>(_8) -> [return: bb2, unwind unreachable];
+          _2 = copy _8 as u128 (Transmute);
+          _6 = identity::<&str>(copy _8) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
-          _4 = _6 as u128 (Transmute);
-          _9 = Eq(_1, _2);
-          _10 = Eq(_3, _4);
-          _0 = (_9, _10);
+          _4 = copy _6 as u128 (Transmute);
+          _9 = Eq(copy _1, copy _2);
+          _10 = Eq(copy _3, copy _4);
+          _0 = (copy _9, copy _10);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff
index 8c96edaa280ea..55f382e926e7a 100644
--- a/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.duplicate_slice.GVN.panic-unwind.diff
@@ -16,22 +16,22 @@
   
       bb0: {
           _7 = (const "a",);
-          _1 = (_7.0: &str) as u128 (Transmute);
-          _5 = identity::<&str>((_7.0: &str)) -> [return: bb1, unwind continue];
+          _1 = copy (_7.0: &str) as u128 (Transmute);
+          _5 = identity::<&str>(copy (_7.0: &str)) -> [return: bb1, unwind continue];
       }
   
       bb1: {
-          _3 = _5 as u128 (Transmute);
+          _3 = copy _5 as u128 (Transmute);
           _8 = const "a";
-          _2 = _8 as u128 (Transmute);
-          _6 = identity::<&str>(_8) -> [return: bb2, unwind continue];
+          _2 = copy _8 as u128 (Transmute);
+          _6 = identity::<&str>(copy _8) -> [return: bb2, unwind continue];
       }
   
       bb2: {
-          _4 = _6 as u128 (Transmute);
-          _9 = Eq(_1, _2);
-          _10 = Eq(_3, _4);
-          _0 = (_9, _10);
+          _4 = copy _6 as u128 (Transmute);
+          _9 = Eq(copy _1, copy _2);
+          _10 = Eq(copy _3, copy _4);
+          _0 = (copy _9, copy _10);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff
index b5c0cee784688..42075d11b6cd6 100644
--- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-abort.diff
@@ -40,9 +40,9 @@
           _1 = identity::<u8> as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer));
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = opaque::<fn(u8) -> u8>(move _3) -> [return: bb1, unwind unreachable];
-+         _2 = opaque::<fn(u8) -> u8>(_1) -> [return: bb1, unwind unreachable];
++         _2 = opaque::<fn(u8) -> u8>(copy _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
@@ -53,9 +53,9 @@
           _4 = identity::<u8> as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer));
           StorageLive(_5);
           StorageLive(_6);
-          _6 = _4;
+          _6 = copy _4;
 -         _5 = opaque::<fn(u8) -> u8>(move _6) -> [return: bb2, unwind unreachable];
-+         _5 = opaque::<fn(u8) -> u8>(_4) -> [return: bb2, unwind unreachable];
++         _5 = opaque::<fn(u8) -> u8>(copy _4) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
@@ -68,16 +68,16 @@
 +         _7 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
 +         nop;
           StorageLive(_9);
--         _9 = _7;
+-         _9 = copy _7;
 -         _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe)));
 +         _9 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
 +         _8 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
           StorageDead(_9);
           StorageLive(_10);
           StorageLive(_11);
-          _11 = _8;
+          _11 = copy _8;
 -         _10 = opaque::<fn()>(move _11) -> [return: bb3, unwind unreachable];
-+         _10 = opaque::<fn()>(_8) -> [return: bb3, unwind unreachable];
++         _10 = opaque::<fn()>(copy _8) -> [return: bb3, unwind unreachable];
       }
   
       bb3: {
@@ -86,16 +86,16 @@
 -         StorageLive(_12);
 +         nop;
           StorageLive(_13);
--         _13 = _7;
+-         _13 = copy _7;
 -         _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe)));
 +         _13 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
 +         _12 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
           StorageDead(_13);
           StorageLive(_14);
           StorageLive(_15);
-          _15 = _12;
+          _15 = copy _12;
 -         _14 = opaque::<fn()>(move _15) -> [return: bb4, unwind unreachable];
-+         _14 = opaque::<fn()>(_12) -> [return: bb4, unwind unreachable];
++         _14 = opaque::<fn()>(copy _12) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
diff --git a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff
index 7bc6573c13d4d..f6ad045bbfa05 100644
--- a/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.fn_pointers.GVN.panic-unwind.diff
@@ -40,9 +40,9 @@
           _1 = identity::<u8> as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer));
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = opaque::<fn(u8) -> u8>(move _3) -> [return: bb1, unwind continue];
-+         _2 = opaque::<fn(u8) -> u8>(_1) -> [return: bb1, unwind continue];
++         _2 = opaque::<fn(u8) -> u8>(copy _1) -> [return: bb1, unwind continue];
       }
   
       bb1: {
@@ -53,9 +53,9 @@
           _4 = identity::<u8> as fn(u8) -> u8 (PointerCoercion(ReifyFnPointer));
           StorageLive(_5);
           StorageLive(_6);
-          _6 = _4;
+          _6 = copy _4;
 -         _5 = opaque::<fn(u8) -> u8>(move _6) -> [return: bb2, unwind continue];
-+         _5 = opaque::<fn(u8) -> u8>(_4) -> [return: bb2, unwind continue];
++         _5 = opaque::<fn(u8) -> u8>(copy _4) -> [return: bb2, unwind continue];
       }
   
       bb2: {
@@ -68,16 +68,16 @@
 +         _7 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
 +         nop;
           StorageLive(_9);
--         _9 = _7;
+-         _9 = copy _7;
 -         _8 = move _9 as fn() (PointerCoercion(ClosureFnPointer(Safe)));
 +         _9 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
 +         _8 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
           StorageDead(_9);
           StorageLive(_10);
           StorageLive(_11);
-          _11 = _8;
+          _11 = copy _8;
 -         _10 = opaque::<fn()>(move _11) -> [return: bb3, unwind continue];
-+         _10 = opaque::<fn()>(_8) -> [return: bb3, unwind continue];
++         _10 = opaque::<fn()>(copy _8) -> [return: bb3, unwind continue];
       }
   
       bb3: {
@@ -86,16 +86,16 @@
 -         StorageLive(_12);
 +         nop;
           StorageLive(_13);
--         _13 = _7;
+-         _13 = copy _7;
 -         _12 = move _13 as fn() (PointerCoercion(ClosureFnPointer(Safe)));
 +         _13 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21};
 +         _12 = const ZeroSized: {closure@$DIR/gvn.rs:615:19: 615:21} as fn() (PointerCoercion(ClosureFnPointer(Safe)));
           StorageDead(_13);
           StorageLive(_14);
           StorageLive(_15);
-          _15 = _12;
+          _15 = copy _12;
 -         _14 = opaque::<fn()>(move _15) -> [return: bb4, unwind continue];
-+         _14 = opaque::<fn()>(_12) -> [return: bb4, unwind continue];
++         _14 = opaque::<fn()>(copy _12) -> [return: bb4, unwind continue];
       }
   
       bb4: {
diff --git a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff
index 1d462a8a23c2e..770c673077533 100644
--- a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-abort.diff
@@ -17,21 +17,21 @@
       let mut _15: <B as std::ptr::Pointee>::Metadata;
   
       bb0: {
-          _4 = _1 as *const T (PtrToPtr);
-          _5 = PtrMetadata(_4);
-          _6 = _1 as *const (&A, [T]) (PtrToPtr);
--         _7 = PtrMetadata(_6);
-+         _7 = PtrMetadata(_1);
-          _8 = _2 as *const (T, B) (PtrToPtr);
-          _9 = PtrMetadata(_8);
-          _10 = _2 as *const (T, A) (PtrToPtr);
--         _11 = PtrMetadata(_10);
-+         _11 = PtrMetadata(_2);
-          _12 = _3 as *mut A (PtrToPtr);
-          _13 = PtrMetadata(_12);
-          _14 = _3 as *mut B (PtrToPtr);
--         _15 = PtrMetadata(_14);
-+         _15 = PtrMetadata(_3);
+          _4 = copy _1 as *const T (PtrToPtr);
+          _5 = PtrMetadata(copy _4);
+          _6 = copy _1 as *const (&A, [T]) (PtrToPtr);
+-         _7 = PtrMetadata(copy _6);
++         _7 = PtrMetadata(copy _1);
+          _8 = copy _2 as *const (T, B) (PtrToPtr);
+          _9 = PtrMetadata(copy _8);
+          _10 = copy _2 as *const (T, A) (PtrToPtr);
+-         _11 = PtrMetadata(copy _10);
++         _11 = PtrMetadata(copy _2);
+          _12 = copy _3 as *mut A (PtrToPtr);
+          _13 = PtrMetadata(copy _12);
+          _14 = copy _3 as *mut B (PtrToPtr);
+-         _15 = PtrMetadata(copy _14);
++         _15 = PtrMetadata(copy _3);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff
index 1d462a8a23c2e..770c673077533 100644
--- a/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.generic_cast_metadata.GVN.panic-unwind.diff
@@ -17,21 +17,21 @@
       let mut _15: <B as std::ptr::Pointee>::Metadata;
   
       bb0: {
-          _4 = _1 as *const T (PtrToPtr);
-          _5 = PtrMetadata(_4);
-          _6 = _1 as *const (&A, [T]) (PtrToPtr);
--         _7 = PtrMetadata(_6);
-+         _7 = PtrMetadata(_1);
-          _8 = _2 as *const (T, B) (PtrToPtr);
-          _9 = PtrMetadata(_8);
-          _10 = _2 as *const (T, A) (PtrToPtr);
--         _11 = PtrMetadata(_10);
-+         _11 = PtrMetadata(_2);
-          _12 = _3 as *mut A (PtrToPtr);
-          _13 = PtrMetadata(_12);
-          _14 = _3 as *mut B (PtrToPtr);
--         _15 = PtrMetadata(_14);
-+         _15 = PtrMetadata(_3);
+          _4 = copy _1 as *const T (PtrToPtr);
+          _5 = PtrMetadata(copy _4);
+          _6 = copy _1 as *const (&A, [T]) (PtrToPtr);
+-         _7 = PtrMetadata(copy _6);
++         _7 = PtrMetadata(copy _1);
+          _8 = copy _2 as *const (T, B) (PtrToPtr);
+          _9 = PtrMetadata(copy _8);
+          _10 = copy _2 as *const (T, A) (PtrToPtr);
+-         _11 = PtrMetadata(copy _10);
++         _11 = PtrMetadata(copy _2);
+          _12 = copy _3 as *mut A (PtrToPtr);
+          _13 = PtrMetadata(copy _12);
+          _14 = copy _3 as *mut B (PtrToPtr);
+-         _15 = PtrMetadata(copy _14);
++         _15 = PtrMetadata(copy _3);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.indirect_static.GVN.panic-abort.diff b/tests/mir-opt/gvn.indirect_static.GVN.panic-abort.diff
index e84f91e495d9c..97f41f89fb243 100644
--- a/tests/mir-opt/gvn.indirect_static.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.indirect_static.GVN.panic-abort.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           _1 = const {ALLOC0: &Option<u8>};
-          _2 = (((*_1) as variant#1).0: u8);
+          _2 = copy (((*_1) as variant#1).0: u8);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.indirect_static.GVN.panic-unwind.diff b/tests/mir-opt/gvn.indirect_static.GVN.panic-unwind.diff
index e84f91e495d9c..97f41f89fb243 100644
--- a/tests/mir-opt/gvn.indirect_static.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.indirect_static.GVN.panic-unwind.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           _1 = const {ALLOC0: &Option<u8>};
-          _2 = (((*_1) as variant#1).0: u8);
+          _2 = copy (((*_1) as variant#1).0: u8);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff
index c877d8a3c0e54..936fa3db82a73 100644
--- a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-abort.diff
@@ -22,14 +22,14 @@
 -         StorageLive(_3);
 +         nop;
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _3 = move _4 as *const [i32] (PtrToPtr);
-+         _3 = _2 as *const [i32] (PtrToPtr);
++         _3 = copy _2 as *const [i32] (PtrToPtr);
           StorageDead(_4);
           StorageLive(_5);
-          _5 = _3;
+          _5 = copy _3;
 -         _0 = PtrMetadata(move _5);
-+         _0 = PtrMetadata(_1);
++         _0 = PtrMetadata(copy _1);
           StorageDead(_5);
 -         StorageDead(_3);
 -         StorageDead(_2);
diff --git a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff
index c877d8a3c0e54..936fa3db82a73 100644
--- a/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.manual_slice_mut_len.GVN.panic-unwind.diff
@@ -22,14 +22,14 @@
 -         StorageLive(_3);
 +         nop;
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _3 = move _4 as *const [i32] (PtrToPtr);
-+         _3 = _2 as *const [i32] (PtrToPtr);
++         _3 = copy _2 as *const [i32] (PtrToPtr);
           StorageDead(_4);
           StorageLive(_5);
-          _5 = _3;
+          _5 = copy _3;
 -         _0 = PtrMetadata(move _5);
-+         _0 = PtrMetadata(_1);
++         _0 = PtrMetadata(copy _1);
           StorageDead(_5);
 -         StorageDead(_3);
 -         StorageDead(_2);
diff --git a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff
index 73dbabb56b353..3ed6c2b5308fb 100644
--- a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-abort.diff
@@ -15,12 +15,12 @@
 -         StorageLive(_2);
 +         nop;
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = *const [i32] from (move _3, const 1_usize);
-+         _2 = *const [i32] from (_1, const 1_usize);
++         _2 = *const [i32] from (copy _1, const 1_usize);
           StorageDead(_3);
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _0 = PtrMetadata(move _4);
 +         _0 = const 1_usize;
           StorageDead(_4);
diff --git a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff
index 73dbabb56b353..3ed6c2b5308fb 100644
--- a/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.meta_of_ref_to_slice.GVN.panic-unwind.diff
@@ -15,12 +15,12 @@
 -         StorageLive(_2);
 +         nop;
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = *const [i32] from (move _3, const 1_usize);
-+         _2 = *const [i32] from (_1, const 1_usize);
++         _2 = *const [i32] from (copy _1, const 1_usize);
           StorageDead(_3);
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _0 = PtrMetadata(move _4);
 +         _0 = const 1_usize;
           StorageDead(_4);
diff --git a/tests/mir-opt/gvn.multiple_branches.GVN.panic-abort.diff b/tests/mir-opt/gvn.multiple_branches.GVN.panic-abort.diff
index 29ca1ba5902e1..f300ce7e8846f 100644
--- a/tests/mir-opt/gvn.multiple_branches.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.multiple_branches.GVN.panic-abort.diff
@@ -41,9 +41,9 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         switchInt(move _5) -> [0: bb4, otherwise: bb1];
-+         switchInt(_1) -> [0: bb4, otherwise: bb1];
++         switchInt(copy _1) -> [0: bb4, otherwise: bb1];
       }
   
       bb1: {
@@ -51,15 +51,15 @@
 -         StorageLive(_7);
 +         nop;
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
           StorageLive(_9);
-          _9 = _3;
+          _9 = copy _3;
 -         _7 = Add(move _8, move _9);
-+         _7 = Add(_2, _3);
++         _7 = Add(copy _2, copy _3);
           StorageDead(_9);
           StorageDead(_8);
 -         _6 = opaque::<u8>(move _7) -> [return: bb2, unwind unreachable];
-+         _6 = opaque::<u8>(_7) -> [return: bb2, unwind unreachable];
++         _6 = opaque::<u8>(copy _7) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
@@ -69,15 +69,15 @@
           StorageLive(_10);
           StorageLive(_11);
           StorageLive(_12);
-          _12 = _2;
+          _12 = copy _2;
           StorageLive(_13);
-          _13 = _3;
+          _13 = copy _3;
 -         _11 = Add(move _12, move _13);
-+         _11 = _7;
++         _11 = copy _7;
           StorageDead(_13);
           StorageDead(_12);
 -         _10 = opaque::<u8>(move _11) -> [return: bb3, unwind unreachable];
-+         _10 = opaque::<u8>(_7) -> [return: bb3, unwind unreachable];
++         _10 = opaque::<u8>(copy _7) -> [return: bb3, unwind unreachable];
       }
   
       bb3: {
@@ -92,15 +92,15 @@
 -         StorageLive(_15);
 +         nop;
           StorageLive(_16);
-          _16 = _2;
+          _16 = copy _2;
           StorageLive(_17);
-          _17 = _3;
+          _17 = copy _3;
 -         _15 = Add(move _16, move _17);
-+         _15 = Add(_2, _3);
++         _15 = Add(copy _2, copy _3);
           StorageDead(_17);
           StorageDead(_16);
 -         _14 = opaque::<u8>(move _15) -> [return: bb5, unwind unreachable];
-+         _14 = opaque::<u8>(_15) -> [return: bb5, unwind unreachable];
++         _14 = opaque::<u8>(copy _15) -> [return: bb5, unwind unreachable];
       }
   
       bb5: {
@@ -110,15 +110,15 @@
           StorageLive(_18);
           StorageLive(_19);
           StorageLive(_20);
-          _20 = _2;
+          _20 = copy _2;
           StorageLive(_21);
-          _21 = _3;
+          _21 = copy _3;
 -         _19 = Add(move _20, move _21);
-+         _19 = _15;
++         _19 = copy _15;
           StorageDead(_21);
           StorageDead(_20);
 -         _18 = opaque::<u8>(move _19) -> [return: bb6, unwind unreachable];
-+         _18 = opaque::<u8>(_15) -> [return: bb6, unwind unreachable];
++         _18 = opaque::<u8>(copy _15) -> [return: bb6, unwind unreachable];
       }
   
       bb6: {
@@ -135,15 +135,15 @@
 -         StorageLive(_23);
 +         nop;
           StorageLive(_24);
-          _24 = _2;
+          _24 = copy _2;
           StorageLive(_25);
-          _25 = _3;
+          _25 = copy _3;
 -         _23 = Add(move _24, move _25);
-+         _23 = Add(_2, _3);
++         _23 = Add(copy _2, copy _3);
           StorageDead(_25);
           StorageDead(_24);
 -         _22 = opaque::<u8>(move _23) -> [return: bb8, unwind unreachable];
-+         _22 = opaque::<u8>(_23) -> [return: bb8, unwind unreachable];
++         _22 = opaque::<u8>(copy _23) -> [return: bb8, unwind unreachable];
       }
   
       bb8: {
@@ -151,24 +151,24 @@
 +         nop;
           StorageDead(_22);
           StorageLive(_26);
-          _26 = _1;
+          _26 = copy _1;
 -         switchInt(move _26) -> [0: bb11, otherwise: bb9];
-+         switchInt(_1) -> [0: bb11, otherwise: bb9];
++         switchInt(copy _1) -> [0: bb11, otherwise: bb9];
       }
   
       bb9: {
           StorageLive(_27);
           StorageLive(_28);
           StorageLive(_29);
-          _29 = _2;
+          _29 = copy _2;
           StorageLive(_30);
-          _30 = _3;
+          _30 = copy _3;
 -         _28 = Add(move _29, move _30);
-+         _28 = _23;
++         _28 = copy _23;
           StorageDead(_30);
           StorageDead(_29);
 -         _27 = opaque::<u8>(move _28) -> [return: bb10, unwind unreachable];
-+         _27 = opaque::<u8>(_23) -> [return: bb10, unwind unreachable];
++         _27 = opaque::<u8>(copy _23) -> [return: bb10, unwind unreachable];
       }
   
       bb10: {
@@ -182,15 +182,15 @@
           StorageLive(_31);
           StorageLive(_32);
           StorageLive(_33);
-          _33 = _2;
+          _33 = copy _2;
           StorageLive(_34);
-          _34 = _3;
+          _34 = copy _3;
 -         _32 = Add(move _33, move _34);
-+         _32 = _23;
++         _32 = copy _23;
           StorageDead(_34);
           StorageDead(_33);
 -         _31 = opaque::<u8>(move _32) -> [return: bb12, unwind unreachable];
-+         _31 = opaque::<u8>(_23) -> [return: bb12, unwind unreachable];
++         _31 = opaque::<u8>(copy _23) -> [return: bb12, unwind unreachable];
       }
   
       bb12: {
diff --git a/tests/mir-opt/gvn.multiple_branches.GVN.panic-unwind.diff b/tests/mir-opt/gvn.multiple_branches.GVN.panic-unwind.diff
index 5394dc8be8a04..f34765534cc8c 100644
--- a/tests/mir-opt/gvn.multiple_branches.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.multiple_branches.GVN.panic-unwind.diff
@@ -41,9 +41,9 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         switchInt(move _5) -> [0: bb4, otherwise: bb1];
-+         switchInt(_1) -> [0: bb4, otherwise: bb1];
++         switchInt(copy _1) -> [0: bb4, otherwise: bb1];
       }
   
       bb1: {
@@ -51,15 +51,15 @@
 -         StorageLive(_7);
 +         nop;
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
           StorageLive(_9);
-          _9 = _3;
+          _9 = copy _3;
 -         _7 = Add(move _8, move _9);
-+         _7 = Add(_2, _3);
++         _7 = Add(copy _2, copy _3);
           StorageDead(_9);
           StorageDead(_8);
 -         _6 = opaque::<u8>(move _7) -> [return: bb2, unwind continue];
-+         _6 = opaque::<u8>(_7) -> [return: bb2, unwind continue];
++         _6 = opaque::<u8>(copy _7) -> [return: bb2, unwind continue];
       }
   
       bb2: {
@@ -69,15 +69,15 @@
           StorageLive(_10);
           StorageLive(_11);
           StorageLive(_12);
-          _12 = _2;
+          _12 = copy _2;
           StorageLive(_13);
-          _13 = _3;
+          _13 = copy _3;
 -         _11 = Add(move _12, move _13);
-+         _11 = _7;
++         _11 = copy _7;
           StorageDead(_13);
           StorageDead(_12);
 -         _10 = opaque::<u8>(move _11) -> [return: bb3, unwind continue];
-+         _10 = opaque::<u8>(_7) -> [return: bb3, unwind continue];
++         _10 = opaque::<u8>(copy _7) -> [return: bb3, unwind continue];
       }
   
       bb3: {
@@ -92,15 +92,15 @@
 -         StorageLive(_15);
 +         nop;
           StorageLive(_16);
-          _16 = _2;
+          _16 = copy _2;
           StorageLive(_17);
-          _17 = _3;
+          _17 = copy _3;
 -         _15 = Add(move _16, move _17);
-+         _15 = Add(_2, _3);
++         _15 = Add(copy _2, copy _3);
           StorageDead(_17);
           StorageDead(_16);
 -         _14 = opaque::<u8>(move _15) -> [return: bb5, unwind continue];
-+         _14 = opaque::<u8>(_15) -> [return: bb5, unwind continue];
++         _14 = opaque::<u8>(copy _15) -> [return: bb5, unwind continue];
       }
   
       bb5: {
@@ -110,15 +110,15 @@
           StorageLive(_18);
           StorageLive(_19);
           StorageLive(_20);
-          _20 = _2;
+          _20 = copy _2;
           StorageLive(_21);
-          _21 = _3;
+          _21 = copy _3;
 -         _19 = Add(move _20, move _21);
-+         _19 = _15;
++         _19 = copy _15;
           StorageDead(_21);
           StorageDead(_20);
 -         _18 = opaque::<u8>(move _19) -> [return: bb6, unwind continue];
-+         _18 = opaque::<u8>(_15) -> [return: bb6, unwind continue];
++         _18 = opaque::<u8>(copy _15) -> [return: bb6, unwind continue];
       }
   
       bb6: {
@@ -135,15 +135,15 @@
 -         StorageLive(_23);
 +         nop;
           StorageLive(_24);
-          _24 = _2;
+          _24 = copy _2;
           StorageLive(_25);
-          _25 = _3;
+          _25 = copy _3;
 -         _23 = Add(move _24, move _25);
-+         _23 = Add(_2, _3);
++         _23 = Add(copy _2, copy _3);
           StorageDead(_25);
           StorageDead(_24);
 -         _22 = opaque::<u8>(move _23) -> [return: bb8, unwind continue];
-+         _22 = opaque::<u8>(_23) -> [return: bb8, unwind continue];
++         _22 = opaque::<u8>(copy _23) -> [return: bb8, unwind continue];
       }
   
       bb8: {
@@ -151,24 +151,24 @@
 +         nop;
           StorageDead(_22);
           StorageLive(_26);
-          _26 = _1;
+          _26 = copy _1;
 -         switchInt(move _26) -> [0: bb11, otherwise: bb9];
-+         switchInt(_1) -> [0: bb11, otherwise: bb9];
++         switchInt(copy _1) -> [0: bb11, otherwise: bb9];
       }
   
       bb9: {
           StorageLive(_27);
           StorageLive(_28);
           StorageLive(_29);
-          _29 = _2;
+          _29 = copy _2;
           StorageLive(_30);
-          _30 = _3;
+          _30 = copy _3;
 -         _28 = Add(move _29, move _30);
-+         _28 = _23;
++         _28 = copy _23;
           StorageDead(_30);
           StorageDead(_29);
 -         _27 = opaque::<u8>(move _28) -> [return: bb10, unwind continue];
-+         _27 = opaque::<u8>(_23) -> [return: bb10, unwind continue];
++         _27 = opaque::<u8>(copy _23) -> [return: bb10, unwind continue];
       }
   
       bb10: {
@@ -182,15 +182,15 @@
           StorageLive(_31);
           StorageLive(_32);
           StorageLive(_33);
-          _33 = _2;
+          _33 = copy _2;
           StorageLive(_34);
-          _34 = _3;
+          _34 = copy _3;
 -         _32 = Add(move _33, move _34);
-+         _32 = _23;
++         _32 = copy _23;
           StorageDead(_34);
           StorageDead(_33);
 -         _31 = opaque::<u8>(move _32) -> [return: bb12, unwind continue];
-+         _31 = opaque::<u8>(_23) -> [return: bb12, unwind continue];
++         _31 = opaque::<u8>(copy _23) -> [return: bb12, unwind continue];
       }
   
       bb12: {
diff --git a/tests/mir-opt/gvn.non_freeze.GVN.panic-abort.diff b/tests/mir-opt/gvn.non_freeze.GVN.panic-abort.diff
index 7b6ed09611846..377b4d7670cdf 100644
--- a/tests/mir-opt/gvn.non_freeze.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.non_freeze.GVN.panic-abort.diff
@@ -7,17 +7,17 @@
       let mut _3: &T;
   
       bb0: {
-          _2 = _1;
+          _2 = copy _1;
           _3 = &_1;
-          _0 = opaque::<&T>(_3) -> [return: bb1, unwind unreachable];
+          _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
-          _0 = opaque::<T>(_2) -> [return: bb2, unwind unreachable];
+          _0 = opaque::<T>(copy _2) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
-          _0 = opaque::<T>((*_3)) -> [return: bb3, unwind unreachable];
+          _0 = opaque::<T>(copy (*_3)) -> [return: bb3, unwind unreachable];
       }
   
       bb3: {
diff --git a/tests/mir-opt/gvn.non_freeze.GVN.panic-unwind.diff b/tests/mir-opt/gvn.non_freeze.GVN.panic-unwind.diff
index 641a2f4609acf..988eee07cc98f 100644
--- a/tests/mir-opt/gvn.non_freeze.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.non_freeze.GVN.panic-unwind.diff
@@ -7,17 +7,17 @@
       let mut _3: &T;
   
       bb0: {
-          _2 = _1;
+          _2 = copy _1;
           _3 = &_1;
-          _0 = opaque::<&T>(_3) -> [return: bb1, unwind continue];
+          _0 = opaque::<&T>(copy _3) -> [return: bb1, unwind continue];
       }
   
       bb1: {
-          _0 = opaque::<T>(_2) -> [return: bb2, unwind continue];
+          _0 = opaque::<T>(copy _2) -> [return: bb2, unwind continue];
       }
   
       bb2: {
-          _0 = opaque::<T>((*_3)) -> [return: bb3, unwind continue];
+          _0 = opaque::<T>(copy (*_3)) -> [return: bb3, unwind continue];
       }
   
       bb3: {
diff --git a/tests/mir-opt/gvn.references.GVN.panic-abort.diff b/tests/mir-opt/gvn.references.GVN.panic-abort.diff
index 7799c61144526..62a487dee8215 100644
--- a/tests/mir-opt/gvn.references.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.references.GVN.panic-abort.diff
@@ -120,11 +120,11 @@
           StorageLive(_21);
 -         _21 = move _18;
 -         _20 = S::<&mut impl Sized>(move _21);
-+         _21 = _18;
-+         _20 = S::<&mut impl Sized>(_18);
++         _21 = copy _18;
++         _20 = S::<&mut impl Sized>(copy _18);
           StorageDead(_21);
 -         _19 = move (_20.0: &mut impl Sized);
-+         _19 = _18;
++         _19 = copy _18;
           StorageDead(_20);
           StorageLive(_22);
           StorageLive(_23);
diff --git a/tests/mir-opt/gvn.references.GVN.panic-unwind.diff b/tests/mir-opt/gvn.references.GVN.panic-unwind.diff
index 880e7913fa94c..6dd986907fcc6 100644
--- a/tests/mir-opt/gvn.references.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.references.GVN.panic-unwind.diff
@@ -120,11 +120,11 @@
           StorageLive(_21);
 -         _21 = move _18;
 -         _20 = S::<&mut impl Sized>(move _21);
-+         _21 = _18;
-+         _20 = S::<&mut impl Sized>(_18);
++         _21 = copy _18;
++         _20 = S::<&mut impl Sized>(copy _18);
           StorageDead(_21);
 -         _19 = move (_20.0: &mut impl Sized);
-+         _19 = _18;
++         _19 = copy _18;
           StorageDead(_20);
           StorageLive(_22);
           StorageLive(_23);
diff --git a/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-abort.diff b/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-abort.diff
index 8b4bfb70401b3..98cb34810bc0c 100644
--- a/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-abort.diff
@@ -7,9 +7,9 @@
       let mut _4: *const u8;
   
       bb0: {
-          _3 = (*_1) as *const u8 (PtrToPtr);
-          _4 = _2 as *const u8 (PtrToPtr);
-          _0 = Eq(_3, _4);
+          _3 = copy (*_1) as *const u8 (PtrToPtr);
+          _4 = copy _2 as *const u8 (PtrToPtr);
+          _0 = Eq(copy _3, copy _4);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-unwind.diff b/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-unwind.diff
index 8b4bfb70401b3..98cb34810bc0c 100644
--- a/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.remove_casts_must_change_both_sides.GVN.panic-unwind.diff
@@ -7,9 +7,9 @@
       let mut _4: *const u8;
   
       bb0: {
-          _3 = (*_1) as *const u8 (PtrToPtr);
-          _4 = _2 as *const u8 (PtrToPtr);
-          _0 = Eq(_3, _4);
+          _3 = copy (*_1) as *const u8 (PtrToPtr);
+          _4 = copy _2 as *const u8 (PtrToPtr);
+          _0 = Eq(copy _3, copy _4);
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff b/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff
index 37915f8578d21..ef2eb1a66779d 100644
--- a/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.repeat.GVN.panic-abort.diff
@@ -28,34 +28,34 @@
           _1 = const 5_i32;
           StorageLive(_2);
           StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 +         _3 = const 5_i32;
           StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 +         _4 = const 5_i32;
           StorageLive(_5);
--         _5 = _1;
+-         _5 = copy _1;
 +         _5 = const 5_i32;
           StorageLive(_6);
--         _6 = _1;
+-         _6 = copy _1;
 +         _6 = const 5_i32;
           StorageLive(_7);
--         _7 = _1;
+-         _7 = copy _1;
 +         _7 = const 5_i32;
           StorageLive(_8);
--         _8 = _1;
+-         _8 = copy _1;
 +         _8 = const 5_i32;
           StorageLive(_9);
--         _9 = _1;
+-         _9 = copy _1;
 +         _9 = const 5_i32;
           StorageLive(_10);
--         _10 = _1;
+-         _10 = copy _1;
 +         _10 = const 5_i32;
           StorageLive(_11);
--         _11 = _1;
+-         _11 = copy _1;
 +         _11 = const 5_i32;
           StorageLive(_12);
--         _12 = _1;
+-         _12 = copy _1;
 -         _2 = [move _3, move _4, move _5, move _6, move _7, move _8, move _9, move _10, move _11, move _12];
 +         _12 = const 5_i32;
 +         _2 = [const 5_i32; 10];
diff --git a/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff b/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff
index 37915f8578d21..ef2eb1a66779d 100644
--- a/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.repeat.GVN.panic-unwind.diff
@@ -28,34 +28,34 @@
           _1 = const 5_i32;
           StorageLive(_2);
           StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 +         _3 = const 5_i32;
           StorageLive(_4);
--         _4 = _1;
+-         _4 = copy _1;
 +         _4 = const 5_i32;
           StorageLive(_5);
--         _5 = _1;
+-         _5 = copy _1;
 +         _5 = const 5_i32;
           StorageLive(_6);
--         _6 = _1;
+-         _6 = copy _1;
 +         _6 = const 5_i32;
           StorageLive(_7);
--         _7 = _1;
+-         _7 = copy _1;
 +         _7 = const 5_i32;
           StorageLive(_8);
--         _8 = _1;
+-         _8 = copy _1;
 +         _8 = const 5_i32;
           StorageLive(_9);
--         _9 = _1;
+-         _9 = copy _1;
 +         _9 = const 5_i32;
           StorageLive(_10);
--         _10 = _1;
+-         _10 = copy _1;
 +         _10 = const 5_i32;
           StorageLive(_11);
--         _11 = _1;
+-         _11 = copy _1;
 +         _11 = const 5_i32;
           StorageLive(_12);
--         _12 = _1;
+-         _12 = copy _1;
 -         _2 = [move _3, move _4, move _5, move _6, move _7, move _8, move _9, move _10, move _11, move _12];
 +         _12 = const 5_i32;
 +         _2 = [const 5_i32; 10];
diff --git a/tests/mir-opt/gvn.repeated_index.GVN.panic-abort.diff b/tests/mir-opt/gvn.repeated_index.GVN.panic-abort.diff
index 8ce05c9b340fe..d4b22d05f6c78 100644
--- a/tests/mir-opt/gvn.repeated_index.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.repeated_index.GVN.panic-abort.diff
@@ -24,27 +24,27 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         _3 = [move _4; N];
-+         _3 = [_1; N];
++         _3 = [copy _1; N];
           StorageDead(_4);
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
           _7 = const 0_usize;
 -         _8 = Len(_3);
--         _9 = Lt(_7, _8);
--         assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb1, unwind unreachable];
+-         _9 = Lt(copy _7, copy _8);
+-         assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb1, unwind unreachable];
 +         _8 = const N;
 +         _9 = Lt(const 0_usize, const N);
 +         assert(move _9, "index out of bounds: the length is {} but the index is {}", const N, const 0_usize) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
--         _6 = _3[_7];
+-         _6 = copy _3[_7];
 -         _5 = opaque::<T>(move _6) -> [return: bb2, unwind unreachable];
-+         _6 = _1;
-+         _5 = opaque::<T>(_1) -> [return: bb2, unwind unreachable];
++         _6 = copy _1;
++         _5 = opaque::<T>(copy _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
@@ -54,20 +54,20 @@
           StorageLive(_10);
           StorageLive(_11);
           StorageLive(_12);
-          _12 = _2;
+          _12 = copy _2;
 -         _13 = Len(_3);
--         _14 = Lt(_12, _13);
--         assert(move _14, "index out of bounds: the length is {} but the index is {}", move _13, _12) -> [success: bb3, unwind unreachable];
+-         _14 = Lt(copy _12, copy _13);
+-         assert(move _14, "index out of bounds: the length is {} but the index is {}", move _13, copy _12) -> [success: bb3, unwind unreachable];
 +         _13 = const N;
-+         _14 = Lt(_2, const N);
-+         assert(move _14, "index out of bounds: the length is {} but the index is {}", const N, _2) -> [success: bb3, unwind unreachable];
++         _14 = Lt(copy _2, const N);
++         assert(move _14, "index out of bounds: the length is {} but the index is {}", const N, copy _2) -> [success: bb3, unwind unreachable];
       }
   
       bb3: {
--         _11 = _3[_12];
+-         _11 = copy _3[_12];
 -         _10 = opaque::<T>(move _11) -> [return: bb4, unwind unreachable];
-+         _11 = _1;
-+         _10 = opaque::<T>(_1) -> [return: bb4, unwind unreachable];
++         _11 = copy _1;
++         _10 = opaque::<T>(copy _1) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
diff --git a/tests/mir-opt/gvn.repeated_index.GVN.panic-unwind.diff b/tests/mir-opt/gvn.repeated_index.GVN.panic-unwind.diff
index 7ed547eeb4ade..708c0f92e542e 100644
--- a/tests/mir-opt/gvn.repeated_index.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.repeated_index.GVN.panic-unwind.diff
@@ -24,27 +24,27 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         _3 = [move _4; N];
-+         _3 = [_1; N];
++         _3 = [copy _1; N];
           StorageDead(_4);
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
           _7 = const 0_usize;
 -         _8 = Len(_3);
--         _9 = Lt(_7, _8);
--         assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb1, unwind continue];
+-         _9 = Lt(copy _7, copy _8);
+-         assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb1, unwind continue];
 +         _8 = const N;
 +         _9 = Lt(const 0_usize, const N);
 +         assert(move _9, "index out of bounds: the length is {} but the index is {}", const N, const 0_usize) -> [success: bb1, unwind continue];
       }
   
       bb1: {
--         _6 = _3[_7];
+-         _6 = copy _3[_7];
 -         _5 = opaque::<T>(move _6) -> [return: bb2, unwind continue];
-+         _6 = _1;
-+         _5 = opaque::<T>(_1) -> [return: bb2, unwind continue];
++         _6 = copy _1;
++         _5 = opaque::<T>(copy _1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
@@ -54,20 +54,20 @@
           StorageLive(_10);
           StorageLive(_11);
           StorageLive(_12);
-          _12 = _2;
+          _12 = copy _2;
 -         _13 = Len(_3);
--         _14 = Lt(_12, _13);
--         assert(move _14, "index out of bounds: the length is {} but the index is {}", move _13, _12) -> [success: bb3, unwind continue];
+-         _14 = Lt(copy _12, copy _13);
+-         assert(move _14, "index out of bounds: the length is {} but the index is {}", move _13, copy _12) -> [success: bb3, unwind continue];
 +         _13 = const N;
-+         _14 = Lt(_2, const N);
-+         assert(move _14, "index out of bounds: the length is {} but the index is {}", const N, _2) -> [success: bb3, unwind continue];
++         _14 = Lt(copy _2, const N);
++         assert(move _14, "index out of bounds: the length is {} but the index is {}", const N, copy _2) -> [success: bb3, unwind continue];
       }
   
       bb3: {
--         _11 = _3[_12];
+-         _11 = copy _3[_12];
 -         _10 = opaque::<T>(move _11) -> [return: bb4, unwind continue];
-+         _11 = _1;
-+         _10 = opaque::<T>(_1) -> [return: bb4, unwind continue];
++         _11 = copy _1;
++         _10 = opaque::<T>(copy _1) -> [return: bb4, unwind continue];
       }
   
       bb4: {
diff --git a/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff b/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff
index fd5fa035d816c..1a6204e4ac8ae 100644
--- a/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.slice_const_length.GVN.panic-abort.diff
@@ -30,12 +30,12 @@
 +         nop;
           _4 = const 123_usize;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
           StorageLive(_6);
--         _6 = _4;
+-         _6 = copy _4;
 -         _0 = *const [i32] from (move _5, move _6);
 +         _6 = const 123_usize;
-+         _0 = *const [i32] from (_2, const 123_usize);
++         _0 = *const [i32] from (copy _2, const 123_usize);
           StorageDead(_6);
           StorageDead(_5);
 -         StorageDead(_4);
diff --git a/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff b/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff
index 98945cf9724db..62d57b0fe2831 100644
--- a/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.slice_const_length.GVN.panic-unwind.diff
@@ -30,12 +30,12 @@
 +         nop;
           _4 = const 123_usize;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
           StorageLive(_6);
--         _6 = _4;
+-         _6 = copy _4;
 -         _0 = *const [i32] from (move _5, move _6);
 +         _6 = const 123_usize;
-+         _0 = *const [i32] from (_2, const 123_usize);
++         _0 = *const [i32] from (copy _2, const 123_usize);
           StorageDead(_6);
           StorageDead(_5);
 -         StorageDead(_4);
diff --git a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff
index 75bcd2a8d72cf..4a2cc25189191 100644
--- a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-abort.diff
@@ -20,27 +20,27 @@
 -         StorageLive(_3);
 +         nop;
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = *const [u16] from (move _4, move _5);
-+         _3 = *const [u16] from (_1, _2);
++         _3 = *const [u16] from (copy _1, copy _2);
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _3;
+          _7 = copy _3;
 -         _6 = move _7 as *const u16 (PtrToPtr);
-+         _6 = _1;
++         _6 = copy _1;
           StorageDead(_7);
           StorageLive(_8);
           StorageLive(_9);
-          _9 = _3;
+          _9 = copy _3;
 -         _8 = move _9 as *const f32 (PtrToPtr);
-+         _8 = _1 as *const f32 (PtrToPtr);
++         _8 = copy _1 as *const f32 (PtrToPtr);
           StorageDead(_9);
 -         _0 = (move _6, move _8);
-+         _0 = (_1, move _8);
++         _0 = (copy _1, move _8);
           StorageDead(_8);
           StorageDead(_6);
 -         StorageDead(_3);
diff --git a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff
index 75bcd2a8d72cf..4a2cc25189191 100644
--- a/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.slice_from_raw_parts_as_ptr.GVN.panic-unwind.diff
@@ -20,27 +20,27 @@
 -         StorageLive(_3);
 +         nop;
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = *const [u16] from (move _4, move _5);
-+         _3 = *const [u16] from (_1, _2);
++         _3 = *const [u16] from (copy _1, copy _2);
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _3;
+          _7 = copy _3;
 -         _6 = move _7 as *const u16 (PtrToPtr);
-+         _6 = _1;
++         _6 = copy _1;
           StorageDead(_7);
           StorageLive(_8);
           StorageLive(_9);
-          _9 = _3;
+          _9 = copy _3;
 -         _8 = move _9 as *const f32 (PtrToPtr);
-+         _8 = _1 as *const f32 (PtrToPtr);
++         _8 = copy _1 as *const f32 (PtrToPtr);
           StorageDead(_9);
 -         _0 = (move _6, move _8);
-+         _0 = (_1, move _8);
++         _0 = (copy _1, move _8);
           StorageDead(_8);
           StorageDead(_6);
 -         StorageDead(_3);
diff --git a/tests/mir-opt/gvn.slices.GVN.panic-abort.diff b/tests/mir-opt/gvn.slices.GVN.panic-abort.diff
index fb67e3d599404..e8e99b44e721b 100644
--- a/tests/mir-opt/gvn.slices.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.slices.GVN.panic-abort.diff
@@ -87,22 +87,22 @@
           _1 = const "my favourite slice";
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = opaque::<&str>(move _3) -> [return: bb1, unwind unreachable];
-+         _2 = opaque::<&str>(_1) -> [return: bb1, unwind unreachable];
++         _2 = opaque::<&str>(copy _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
           StorageDead(_3);
           StorageDead(_2);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
           StorageLive(_6);
--         _6 = _4;
+-         _6 = copy _4;
 -         _5 = opaque::<&str>(move _6) -> [return: bb2, unwind unreachable];
-+         _6 = _1;
-+         _5 = opaque::<&str>(_1) -> [return: bb2, unwind unreachable];
++         _6 = copy _1;
++         _5 = opaque::<&str>(copy _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
@@ -138,24 +138,24 @@
 -         _8 = (move _9, move _12);
 -         StorageDead(_12);
 -         StorageDead(_9);
-+         _8 = (_9, _12);
++         _8 = (copy _9, copy _12);
 +         nop;
 +         nop;
           StorageLive(_15);
--         _15 = (_8.0: &*const u8);
-+         _15 = _9;
+-         _15 = copy (_8.0: &*const u8);
++         _15 = copy _9;
           StorageLive(_16);
--         _16 = (_8.1: &*const u8);
-+         _16 = _12;
+-         _16 = copy (_8.1: &*const u8);
++         _16 = copy _12;
           StorageLive(_17);
           StorageLive(_18);
--         _18 = (*_15);
-+         _18 = _10;
+-         _18 = copy (*_15);
++         _18 = copy _10;
           StorageLive(_19);
--         _19 = (*_16);
+-         _19 = copy (*_16);
 -         _17 = Eq(move _18, move _19);
-+         _19 = _13;
-+         _17 = Eq(_10, _13);
++         _19 = copy _13;
++         _17 = Eq(copy _10, copy _13);
           switchInt(move _17) -> [0: bb6, otherwise: bb5];
       }
   
@@ -180,9 +180,9 @@
           StorageDead(_30);
           StorageLive(_31);
           StorageLive(_32);
-          _32 = _29;
+          _32 = copy _29;
 -         _31 = opaque::<&[u8]>(move _32) -> [return: bb7, unwind unreachable];
-+         _31 = opaque::<&[u8]>(_29) -> [return: bb7, unwind unreachable];
++         _31 = opaque::<&[u8]>(copy _29) -> [return: bb7, unwind unreachable];
       }
   
       bb6: {
@@ -244,24 +244,24 @@
 -         _34 = (move _35, move _38);
 -         StorageDead(_38);
 -         StorageDead(_35);
-+         _34 = (_35, _38);
++         _34 = (copy _35, copy _38);
 +         nop;
 +         nop;
           StorageLive(_41);
--         _41 = (_34.0: &*const u8);
-+         _41 = _35;
+-         _41 = copy (_34.0: &*const u8);
++         _41 = copy _35;
           StorageLive(_42);
--         _42 = (_34.1: &*const u8);
-+         _42 = _38;
+-         _42 = copy (_34.1: &*const u8);
++         _42 = copy _38;
           StorageLive(_43);
           StorageLive(_44);
--         _44 = (*_41);
-+         _44 = _36;
+-         _44 = copy (*_41);
++         _44 = copy _36;
           StorageLive(_45);
--         _45 = (*_42);
+-         _45 = copy (*_42);
 -         _43 = Eq(move _44, move _45);
-+         _45 = _39;
-+         _43 = Eq(_36, _39);
++         _45 = copy _39;
++         _43 = Eq(copy _36, copy _39);
           switchInt(move _43) -> [0: bb11, otherwise: bb10];
       }
   
diff --git a/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff b/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff
index ae3013b011e9a..4296d4d4a5945 100644
--- a/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.slices.GVN.panic-unwind.diff
@@ -87,22 +87,22 @@
           _1 = const "my favourite slice";
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = opaque::<&str>(move _3) -> [return: bb1, unwind continue];
-+         _2 = opaque::<&str>(_1) -> [return: bb1, unwind continue];
++         _2 = opaque::<&str>(copy _1) -> [return: bb1, unwind continue];
       }
   
       bb1: {
           StorageDead(_3);
           StorageDead(_2);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
           StorageLive(_6);
--         _6 = _4;
+-         _6 = copy _4;
 -         _5 = opaque::<&str>(move _6) -> [return: bb2, unwind continue];
-+         _6 = _1;
-+         _5 = opaque::<&str>(_1) -> [return: bb2, unwind continue];
++         _6 = copy _1;
++         _5 = opaque::<&str>(copy _1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
@@ -138,24 +138,24 @@
 -         _8 = (move _9, move _12);
 -         StorageDead(_12);
 -         StorageDead(_9);
-+         _8 = (_9, _12);
++         _8 = (copy _9, copy _12);
 +         nop;
 +         nop;
           StorageLive(_15);
--         _15 = (_8.0: &*const u8);
-+         _15 = _9;
+-         _15 = copy (_8.0: &*const u8);
++         _15 = copy _9;
           StorageLive(_16);
--         _16 = (_8.1: &*const u8);
-+         _16 = _12;
+-         _16 = copy (_8.1: &*const u8);
++         _16 = copy _12;
           StorageLive(_17);
           StorageLive(_18);
--         _18 = (*_15);
-+         _18 = _10;
+-         _18 = copy (*_15);
++         _18 = copy _10;
           StorageLive(_19);
--         _19 = (*_16);
+-         _19 = copy (*_16);
 -         _17 = Eq(move _18, move _19);
-+         _19 = _13;
-+         _17 = Eq(_10, _13);
++         _19 = copy _13;
++         _17 = Eq(copy _10, copy _13);
           switchInt(move _17) -> [0: bb6, otherwise: bb5];
       }
   
@@ -180,9 +180,9 @@
           StorageDead(_30);
           StorageLive(_31);
           StorageLive(_32);
-          _32 = _29;
+          _32 = copy _29;
 -         _31 = opaque::<&[u8]>(move _32) -> [return: bb7, unwind continue];
-+         _31 = opaque::<&[u8]>(_29) -> [return: bb7, unwind continue];
++         _31 = opaque::<&[u8]>(copy _29) -> [return: bb7, unwind continue];
       }
   
       bb6: {
@@ -244,24 +244,24 @@
 -         _34 = (move _35, move _38);
 -         StorageDead(_38);
 -         StorageDead(_35);
-+         _34 = (_35, _38);
++         _34 = (copy _35, copy _38);
 +         nop;
 +         nop;
           StorageLive(_41);
--         _41 = (_34.0: &*const u8);
-+         _41 = _35;
+-         _41 = copy (_34.0: &*const u8);
++         _41 = copy _35;
           StorageLive(_42);
--         _42 = (_34.1: &*const u8);
-+         _42 = _38;
+-         _42 = copy (_34.1: &*const u8);
++         _42 = copy _38;
           StorageLive(_43);
           StorageLive(_44);
--         _44 = (*_41);
-+         _44 = _36;
+-         _44 = copy (*_41);
++         _44 = copy _36;
           StorageLive(_45);
--         _45 = (*_42);
+-         _45 = copy (*_42);
 -         _43 = Eq(move _44, move _45);
-+         _45 = _39;
-+         _43 = Eq(_36, _39);
++         _45 = copy _39;
++         _43 = Eq(copy _36, copy _39);
           switchInt(move _43) -> [0: bb11, otherwise: bb10];
       }
   
diff --git a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff
index ba9e507560d67..7a479bc55da75 100644
--- a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-abort.diff
@@ -195,15 +195,15 @@
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
           StorageLive(_7);
-          _7 = _2;
+          _7 = copy _2;
 -         _5 = Add(move _6, move _7);
-+         _5 = Add(_1, _2);
++         _5 = Add(copy _1, copy _2);
           StorageDead(_7);
           StorageDead(_6);
 -         _4 = opaque::<u64>(move _5) -> [return: bb1, unwind unreachable];
-+         _4 = opaque::<u64>(_5) -> [return: bb1, unwind unreachable];
++         _4 = opaque::<u64>(copy _5) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
@@ -214,15 +214,15 @@
 -         StorageLive(_9);
 +         nop;
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
           StorageLive(_11);
-          _11 = _2;
+          _11 = copy _2;
 -         _9 = Mul(move _10, move _11);
-+         _9 = Mul(_1, _2);
++         _9 = Mul(copy _1, copy _2);
           StorageDead(_11);
           StorageDead(_10);
 -         _8 = opaque::<u64>(move _9) -> [return: bb2, unwind unreachable];
-+         _8 = opaque::<u64>(_9) -> [return: bb2, unwind unreachable];
++         _8 = opaque::<u64>(copy _9) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
@@ -233,15 +233,15 @@
 -         StorageLive(_13);
 +         nop;
           StorageLive(_14);
-          _14 = _1;
+          _14 = copy _1;
           StorageLive(_15);
-          _15 = _2;
+          _15 = copy _2;
 -         _13 = Sub(move _14, move _15);
-+         _13 = Sub(_1, _2);
++         _13 = Sub(copy _1, copy _2);
           StorageDead(_15);
           StorageDead(_14);
 -         _12 = opaque::<u64>(move _13) -> [return: bb3, unwind unreachable];
-+         _12 = opaque::<u64>(_13) -> [return: bb3, unwind unreachable];
++         _12 = opaque::<u64>(copy _13) -> [return: bb3, unwind unreachable];
       }
   
       bb3: {
@@ -252,22 +252,22 @@
 -         StorageLive(_17);
 +         nop;
           StorageLive(_18);
-          _18 = _1;
+          _18 = copy _1;
           StorageLive(_19);
-          _19 = _2;
--         _20 = Eq(_19, const 0_u64);
--         assert(!move _20, "attempt to divide `{}` by zero", _18) -> [success: bb4, unwind unreachable];
-+         _20 = Eq(_2, const 0_u64);
-+         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb4, unwind unreachable];
+          _19 = copy _2;
+-         _20 = Eq(copy _19, const 0_u64);
+-         assert(!move _20, "attempt to divide `{}` by zero", copy _18) -> [success: bb4, unwind unreachable];
++         _20 = Eq(copy _2, const 0_u64);
++         assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb4, unwind unreachable];
       }
   
       bb4: {
 -         _17 = Div(move _18, move _19);
-+         _17 = Div(_1, _2);
++         _17 = Div(copy _1, copy _2);
           StorageDead(_19);
           StorageDead(_18);
 -         _16 = opaque::<u64>(move _17) -> [return: bb5, unwind unreachable];
-+         _16 = opaque::<u64>(_17) -> [return: bb5, unwind unreachable];
++         _16 = opaque::<u64>(copy _17) -> [return: bb5, unwind unreachable];
       }
   
       bb5: {
@@ -278,22 +278,22 @@
 -         StorageLive(_22);
 +         nop;
           StorageLive(_23);
-          _23 = _1;
+          _23 = copy _1;
           StorageLive(_24);
-          _24 = _2;
--         _25 = Eq(_24, const 0_u64);
--         assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", _23) -> [success: bb6, unwind unreachable];
-+         _25 = _20;
-+         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb6, unwind unreachable];
+          _24 = copy _2;
+-         _25 = Eq(copy _24, const 0_u64);
+-         assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _23) -> [success: bb6, unwind unreachable];
++         _25 = copy _20;
++         assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb6, unwind unreachable];
       }
   
       bb6: {
 -         _22 = Rem(move _23, move _24);
-+         _22 = Rem(_1, _2);
++         _22 = Rem(copy _1, copy _2);
           StorageDead(_24);
           StorageDead(_23);
 -         _21 = opaque::<u64>(move _22) -> [return: bb7, unwind unreachable];
-+         _21 = opaque::<u64>(_22) -> [return: bb7, unwind unreachable];
++         _21 = opaque::<u64>(copy _22) -> [return: bb7, unwind unreachable];
       }
   
       bb7: {
@@ -304,15 +304,15 @@
 -         StorageLive(_27);
 +         nop;
           StorageLive(_28);
-          _28 = _1;
+          _28 = copy _1;
           StorageLive(_29);
-          _29 = _2;
+          _29 = copy _2;
 -         _27 = BitAnd(move _28, move _29);
-+         _27 = BitAnd(_1, _2);
++         _27 = BitAnd(copy _1, copy _2);
           StorageDead(_29);
           StorageDead(_28);
 -         _26 = opaque::<u64>(move _27) -> [return: bb8, unwind unreachable];
-+         _26 = opaque::<u64>(_27) -> [return: bb8, unwind unreachable];
++         _26 = opaque::<u64>(copy _27) -> [return: bb8, unwind unreachable];
       }
   
       bb8: {
@@ -323,15 +323,15 @@
 -         StorageLive(_31);
 +         nop;
           StorageLive(_32);
-          _32 = _1;
+          _32 = copy _1;
           StorageLive(_33);
-          _33 = _2;
+          _33 = copy _2;
 -         _31 = BitOr(move _32, move _33);
-+         _31 = BitOr(_1, _2);
++         _31 = BitOr(copy _1, copy _2);
           StorageDead(_33);
           StorageDead(_32);
 -         _30 = opaque::<u64>(move _31) -> [return: bb9, unwind unreachable];
-+         _30 = opaque::<u64>(_31) -> [return: bb9, unwind unreachable];
++         _30 = opaque::<u64>(copy _31) -> [return: bb9, unwind unreachable];
       }
   
       bb9: {
@@ -342,15 +342,15 @@
 -         StorageLive(_35);
 +         nop;
           StorageLive(_36);
-          _36 = _1;
+          _36 = copy _1;
           StorageLive(_37);
-          _37 = _2;
+          _37 = copy _2;
 -         _35 = BitXor(move _36, move _37);
-+         _35 = BitXor(_1, _2);
++         _35 = BitXor(copy _1, copy _2);
           StorageDead(_37);
           StorageDead(_36);
 -         _34 = opaque::<u64>(move _35) -> [return: bb10, unwind unreachable];
-+         _34 = opaque::<u64>(_35) -> [return: bb10, unwind unreachable];
++         _34 = opaque::<u64>(copy _35) -> [return: bb10, unwind unreachable];
       }
   
       bb10: {
@@ -361,15 +361,15 @@
 -         StorageLive(_39);
 +         nop;
           StorageLive(_40);
-          _40 = _1;
+          _40 = copy _1;
           StorageLive(_41);
-          _41 = _2;
+          _41 = copy _2;
 -         _39 = Shl(move _40, move _41);
-+         _39 = Shl(_1, _2);
++         _39 = Shl(copy _1, copy _2);
           StorageDead(_41);
           StorageDead(_40);
 -         _38 = opaque::<u64>(move _39) -> [return: bb11, unwind unreachable];
-+         _38 = opaque::<u64>(_39) -> [return: bb11, unwind unreachable];
++         _38 = opaque::<u64>(copy _39) -> [return: bb11, unwind unreachable];
       }
   
       bb11: {
@@ -380,15 +380,15 @@
 -         StorageLive(_43);
 +         nop;
           StorageLive(_44);
-          _44 = _1;
+          _44 = copy _1;
           StorageLive(_45);
-          _45 = _2;
+          _45 = copy _2;
 -         _43 = Shr(move _44, move _45);
-+         _43 = Shr(_1, _2);
++         _43 = Shr(copy _1, copy _2);
           StorageDead(_45);
           StorageDead(_44);
 -         _42 = opaque::<u64>(move _43) -> [return: bb12, unwind unreachable];
-+         _42 = opaque::<u64>(_43) -> [return: bb12, unwind unreachable];
++         _42 = opaque::<u64>(copy _43) -> [return: bb12, unwind unreachable];
       }
   
       bb12: {
@@ -399,12 +399,12 @@
 -         StorageLive(_47);
 +         nop;
           StorageLive(_48);
-          _48 = _1;
+          _48 = copy _1;
 -         _47 = move _48 as u32 (IntToInt);
-+         _47 = _1 as u32 (IntToInt);
++         _47 = copy _1 as u32 (IntToInt);
           StorageDead(_48);
 -         _46 = opaque::<u32>(move _47) -> [return: bb13, unwind unreachable];
-+         _46 = opaque::<u32>(_47) -> [return: bb13, unwind unreachable];
++         _46 = opaque::<u32>(copy _47) -> [return: bb13, unwind unreachable];
       }
   
       bb13: {
@@ -415,12 +415,12 @@
 -         StorageLive(_50);
 +         nop;
           StorageLive(_51);
-          _51 = _1;
+          _51 = copy _1;
 -         _50 = move _51 as f32 (IntToFloat);
-+         _50 = _1 as f32 (IntToFloat);
++         _50 = copy _1 as f32 (IntToFloat);
           StorageDead(_51);
 -         _49 = opaque::<f32>(move _50) -> [return: bb14, unwind unreachable];
-+         _49 = opaque::<f32>(_50) -> [return: bb14, unwind unreachable];
++         _49 = opaque::<f32>(copy _50) -> [return: bb14, unwind unreachable];
       }
   
       bb14: {
@@ -431,12 +431,12 @@
 -         StorageLive(_53);
 +         nop;
           StorageLive(_54);
-          _54 = _1;
+          _54 = copy _1;
 -         _53 = S::<u64>(move _54);
-+         _53 = S::<u64>(_1);
++         _53 = S::<u64>(copy _1);
           StorageDead(_54);
 -         _52 = opaque::<S<u64>>(move _53) -> [return: bb15, unwind unreachable];
-+         _52 = opaque::<S<u64>>(_53) -> [return: bb15, unwind unreachable];
++         _52 = opaque::<S<u64>>(copy _53) -> [return: bb15, unwind unreachable];
       }
   
       bb15: {
@@ -447,14 +447,14 @@
           StorageLive(_56);
           StorageLive(_57);
           StorageLive(_58);
-          _58 = _1;
+          _58 = copy _1;
 -         _57 = S::<u64>(move _58);
-+         _57 = _53;
++         _57 = copy _53;
           StorageDead(_58);
--         _56 = (_57.0: u64);
+-         _56 = copy (_57.0: u64);
 -         _55 = opaque::<u64>(move _56) -> [return: bb16, unwind unreachable];
-+         _56 = _1;
-+         _55 = opaque::<u64>(_1) -> [return: bb16, unwind unreachable];
++         _56 = copy _1;
++         _55 = opaque::<u64>(copy _1) -> [return: bb16, unwind unreachable];
       }
   
       bb16: {
@@ -464,15 +464,15 @@
           StorageLive(_59);
           StorageLive(_60);
           StorageLive(_61);
-          _61 = _1;
+          _61 = copy _1;
           StorageLive(_62);
-          _62 = _2;
+          _62 = copy _2;
 -         _60 = Add(move _61, move _62);
-+         _60 = _5;
++         _60 = copy _5;
           StorageDead(_62);
           StorageDead(_61);
 -         _59 = opaque::<u64>(move _60) -> [return: bb17, unwind unreachable];
-+         _59 = opaque::<u64>(_5) -> [return: bb17, unwind unreachable];
++         _59 = opaque::<u64>(copy _5) -> [return: bb17, unwind unreachable];
       }
   
       bb17: {
@@ -481,15 +481,15 @@
           StorageLive(_63);
           StorageLive(_64);
           StorageLive(_65);
-          _65 = _1;
+          _65 = copy _1;
           StorageLive(_66);
-          _66 = _2;
+          _66 = copy _2;
 -         _64 = Mul(move _65, move _66);
-+         _64 = _9;
++         _64 = copy _9;
           StorageDead(_66);
           StorageDead(_65);
 -         _63 = opaque::<u64>(move _64) -> [return: bb18, unwind unreachable];
-+         _63 = opaque::<u64>(_9) -> [return: bb18, unwind unreachable];
++         _63 = opaque::<u64>(copy _9) -> [return: bb18, unwind unreachable];
       }
   
       bb18: {
@@ -498,15 +498,15 @@
           StorageLive(_67);
           StorageLive(_68);
           StorageLive(_69);
-          _69 = _1;
+          _69 = copy _1;
           StorageLive(_70);
-          _70 = _2;
+          _70 = copy _2;
 -         _68 = Sub(move _69, move _70);
-+         _68 = _13;
++         _68 = copy _13;
           StorageDead(_70);
           StorageDead(_69);
 -         _67 = opaque::<u64>(move _68) -> [return: bb19, unwind unreachable];
-+         _67 = opaque::<u64>(_13) -> [return: bb19, unwind unreachable];
++         _67 = opaque::<u64>(copy _13) -> [return: bb19, unwind unreachable];
       }
   
       bb19: {
@@ -515,22 +515,22 @@
           StorageLive(_71);
           StorageLive(_72);
           StorageLive(_73);
-          _73 = _1;
+          _73 = copy _1;
           StorageLive(_74);
-          _74 = _2;
--         _75 = Eq(_74, const 0_u64);
--         assert(!move _75, "attempt to divide `{}` by zero", _73) -> [success: bb20, unwind unreachable];
-+         _75 = _20;
-+         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind unreachable];
+          _74 = copy _2;
+-         _75 = Eq(copy _74, const 0_u64);
+-         assert(!move _75, "attempt to divide `{}` by zero", copy _73) -> [success: bb20, unwind unreachable];
++         _75 = copy _20;
++         assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb20, unwind unreachable];
       }
   
       bb20: {
 -         _72 = Div(move _73, move _74);
-+         _72 = _17;
++         _72 = copy _17;
           StorageDead(_74);
           StorageDead(_73);
 -         _71 = opaque::<u64>(move _72) -> [return: bb21, unwind unreachable];
-+         _71 = opaque::<u64>(_17) -> [return: bb21, unwind unreachable];
++         _71 = opaque::<u64>(copy _17) -> [return: bb21, unwind unreachable];
       }
   
       bb21: {
@@ -539,22 +539,22 @@
           StorageLive(_76);
           StorageLive(_77);
           StorageLive(_78);
-          _78 = _1;
+          _78 = copy _1;
           StorageLive(_79);
-          _79 = _2;
--         _80 = Eq(_79, const 0_u64);
--         assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", _78) -> [success: bb22, unwind unreachable];
-+         _80 = _20;
-+         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind unreachable];
+          _79 = copy _2;
+-         _80 = Eq(copy _79, const 0_u64);
+-         assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _78) -> [success: bb22, unwind unreachable];
++         _80 = copy _20;
++         assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb22, unwind unreachable];
       }
   
       bb22: {
 -         _77 = Rem(move _78, move _79);
-+         _77 = _22;
++         _77 = copy _22;
           StorageDead(_79);
           StorageDead(_78);
 -         _76 = opaque::<u64>(move _77) -> [return: bb23, unwind unreachable];
-+         _76 = opaque::<u64>(_22) -> [return: bb23, unwind unreachable];
++         _76 = opaque::<u64>(copy _22) -> [return: bb23, unwind unreachable];
       }
   
       bb23: {
@@ -563,15 +563,15 @@
           StorageLive(_81);
           StorageLive(_82);
           StorageLive(_83);
-          _83 = _1;
+          _83 = copy _1;
           StorageLive(_84);
-          _84 = _2;
+          _84 = copy _2;
 -         _82 = BitAnd(move _83, move _84);
-+         _82 = _27;
++         _82 = copy _27;
           StorageDead(_84);
           StorageDead(_83);
 -         _81 = opaque::<u64>(move _82) -> [return: bb24, unwind unreachable];
-+         _81 = opaque::<u64>(_27) -> [return: bb24, unwind unreachable];
++         _81 = opaque::<u64>(copy _27) -> [return: bb24, unwind unreachable];
       }
   
       bb24: {
@@ -580,15 +580,15 @@
           StorageLive(_85);
           StorageLive(_86);
           StorageLive(_87);
-          _87 = _1;
+          _87 = copy _1;
           StorageLive(_88);
-          _88 = _2;
+          _88 = copy _2;
 -         _86 = BitOr(move _87, move _88);
-+         _86 = _31;
++         _86 = copy _31;
           StorageDead(_88);
           StorageDead(_87);
 -         _85 = opaque::<u64>(move _86) -> [return: bb25, unwind unreachable];
-+         _85 = opaque::<u64>(_31) -> [return: bb25, unwind unreachable];
++         _85 = opaque::<u64>(copy _31) -> [return: bb25, unwind unreachable];
       }
   
       bb25: {
@@ -597,15 +597,15 @@
           StorageLive(_89);
           StorageLive(_90);
           StorageLive(_91);
-          _91 = _1;
+          _91 = copy _1;
           StorageLive(_92);
-          _92 = _2;
+          _92 = copy _2;
 -         _90 = BitXor(move _91, move _92);
-+         _90 = _35;
++         _90 = copy _35;
           StorageDead(_92);
           StorageDead(_91);
 -         _89 = opaque::<u64>(move _90) -> [return: bb26, unwind unreachable];
-+         _89 = opaque::<u64>(_35) -> [return: bb26, unwind unreachable];
++         _89 = opaque::<u64>(copy _35) -> [return: bb26, unwind unreachable];
       }
   
       bb26: {
@@ -614,15 +614,15 @@
           StorageLive(_93);
           StorageLive(_94);
           StorageLive(_95);
-          _95 = _1;
+          _95 = copy _1;
           StorageLive(_96);
-          _96 = _2;
+          _96 = copy _2;
 -         _94 = Shl(move _95, move _96);
-+         _94 = _39;
++         _94 = copy _39;
           StorageDead(_96);
           StorageDead(_95);
 -         _93 = opaque::<u64>(move _94) -> [return: bb27, unwind unreachable];
-+         _93 = opaque::<u64>(_39) -> [return: bb27, unwind unreachable];
++         _93 = opaque::<u64>(copy _39) -> [return: bb27, unwind unreachable];
       }
   
       bb27: {
@@ -631,15 +631,15 @@
           StorageLive(_97);
           StorageLive(_98);
           StorageLive(_99);
-          _99 = _1;
+          _99 = copy _1;
           StorageLive(_100);
-          _100 = _2;
+          _100 = copy _2;
 -         _98 = Shr(move _99, move _100);
-+         _98 = _43;
++         _98 = copy _43;
           StorageDead(_100);
           StorageDead(_99);
 -         _97 = opaque::<u64>(move _98) -> [return: bb28, unwind unreachable];
-+         _97 = opaque::<u64>(_43) -> [return: bb28, unwind unreachable];
++         _97 = opaque::<u64>(copy _43) -> [return: bb28, unwind unreachable];
       }
   
       bb28: {
@@ -648,12 +648,12 @@
           StorageLive(_101);
           StorageLive(_102);
           StorageLive(_103);
-          _103 = _1;
+          _103 = copy _1;
 -         _102 = move _103 as u32 (IntToInt);
-+         _102 = _47;
++         _102 = copy _47;
           StorageDead(_103);
 -         _101 = opaque::<u32>(move _102) -> [return: bb29, unwind unreachable];
-+         _101 = opaque::<u32>(_47) -> [return: bb29, unwind unreachable];
++         _101 = opaque::<u32>(copy _47) -> [return: bb29, unwind unreachable];
       }
   
       bb29: {
@@ -662,12 +662,12 @@
           StorageLive(_104);
           StorageLive(_105);
           StorageLive(_106);
-          _106 = _1;
+          _106 = copy _1;
 -         _105 = move _106 as f32 (IntToFloat);
-+         _105 = _50;
++         _105 = copy _50;
           StorageDead(_106);
 -         _104 = opaque::<f32>(move _105) -> [return: bb30, unwind unreachable];
-+         _104 = opaque::<f32>(_50) -> [return: bb30, unwind unreachable];
++         _104 = opaque::<f32>(copy _50) -> [return: bb30, unwind unreachable];
       }
   
       bb30: {
@@ -676,12 +676,12 @@
           StorageLive(_107);
           StorageLive(_108);
           StorageLive(_109);
-          _109 = _1;
+          _109 = copy _1;
 -         _108 = S::<u64>(move _109);
-+         _108 = _53;
++         _108 = copy _53;
           StorageDead(_109);
 -         _107 = opaque::<S<u64>>(move _108) -> [return: bb31, unwind unreachable];
-+         _107 = opaque::<S<u64>>(_53) -> [return: bb31, unwind unreachable];
++         _107 = opaque::<S<u64>>(copy _53) -> [return: bb31, unwind unreachable];
       }
   
       bb31: {
@@ -691,14 +691,14 @@
           StorageLive(_111);
           StorageLive(_112);
           StorageLive(_113);
-          _113 = _1;
+          _113 = copy _1;
 -         _112 = S::<u64>(move _113);
-+         _112 = _53;
++         _112 = copy _53;
           StorageDead(_113);
--         _111 = (_112.0: u64);
+-         _111 = copy (_112.0: u64);
 -         _110 = opaque::<u64>(move _111) -> [return: bb32, unwind unreachable];
-+         _111 = _1;
-+         _110 = opaque::<u64>(_1) -> [return: bb32, unwind unreachable];
++         _111 = copy _1;
++         _110 = opaque::<u64>(copy _1) -> [return: bb32, unwind unreachable];
       }
   
       bb32: {
@@ -710,21 +710,21 @@
 +         nop;
           StorageLive(_116);
           StorageLive(_117);
-          _117 = _1;
+          _117 = copy _1;
           StorageLive(_118);
-          _118 = _2;
+          _118 = copy _2;
 -         _116 = Mul(move _117, move _118);
-+         _116 = _9;
++         _116 = copy _9;
           StorageDead(_118);
           StorageDead(_117);
           StorageLive(_119);
-          _119 = _2;
+          _119 = copy _2;
 -         _115 = Sub(move _116, move _119);
-+         _115 = Sub(_9, _2);
++         _115 = Sub(copy _9, copy _2);
           StorageDead(_119);
           StorageDead(_116);
 -         _114 = opaque::<u64>(move _115) -> [return: bb33, unwind unreachable];
-+         _114 = opaque::<u64>(_115) -> [return: bb33, unwind unreachable];
++         _114 = opaque::<u64>(copy _115) -> [return: bb33, unwind unreachable];
       }
   
       bb33: {
@@ -735,21 +735,21 @@
           StorageLive(_121);
           StorageLive(_122);
           StorageLive(_123);
-          _123 = _1;
+          _123 = copy _1;
           StorageLive(_124);
-          _124 = _2;
+          _124 = copy _2;
 -         _122 = Mul(move _123, move _124);
-+         _122 = _9;
++         _122 = copy _9;
           StorageDead(_124);
           StorageDead(_123);
           StorageLive(_125);
-          _125 = _2;
+          _125 = copy _2;
 -         _121 = Sub(move _122, move _125);
-+         _121 = _115;
++         _121 = copy _115;
           StorageDead(_125);
           StorageDead(_122);
 -         _120 = opaque::<u64>(move _121) -> [return: bb34, unwind unreachable];
-+         _120 = opaque::<u64>(_115) -> [return: bb34, unwind unreachable];
++         _120 = opaque::<u64>(copy _115) -> [return: bb34, unwind unreachable];
       }
   
       bb34: {
@@ -762,16 +762,16 @@
 -         StorageLive(_129);
 +         nop;
 +         nop;
-          _129 = (*_126);
+          _129 = copy (*_126);
           StorageLive(_130);
-          _130 = _1;
+          _130 = copy _1;
 -         _128 = Add(move _129, move _130);
-+         _128 = Add(_129, _1);
++         _128 = Add(copy _129, copy _1);
           StorageDead(_130);
 -         StorageDead(_129);
 -         _127 = opaque::<u64>(move _128) -> [return: bb35, unwind unreachable];
 +         nop;
-+         _127 = opaque::<u64>(_128) -> [return: bb35, unwind unreachable];
++         _127 = opaque::<u64>(copy _128) -> [return: bb35, unwind unreachable];
       }
   
       bb35: {
@@ -781,16 +781,16 @@
           StorageLive(_131);
           StorageLive(_132);
           StorageLive(_133);
--         _133 = (*_126);
-+         _133 = _129;
+-         _133 = copy (*_126);
++         _133 = copy _129;
           StorageLive(_134);
-          _134 = _1;
+          _134 = copy _1;
 -         _132 = Add(move _133, move _134);
-+         _132 = _128;
++         _132 = copy _128;
           StorageDead(_134);
           StorageDead(_133);
 -         _131 = opaque::<u64>(move _132) -> [return: bb36, unwind unreachable];
-+         _131 = opaque::<u64>(_128) -> [return: bb36, unwind unreachable];
++         _131 = opaque::<u64>(copy _128) -> [return: bb36, unwind unreachable];
       }
   
       bb36: {
@@ -801,11 +801,11 @@
           StorageLive(_136);
           StorageLive(_137);
           StorageLive(_138);
-          _138 = (*_135);
+          _138 = copy (*_135);
           StorageLive(_139);
-          _139 = _1;
+          _139 = copy _1;
 -         _137 = Add(move _138, move _139);
-+         _137 = Add(move _138, _1);
++         _137 = Add(move _138, copy _1);
           StorageDead(_139);
           StorageDead(_138);
           _136 = opaque::<u64>(move _137) -> [return: bb37, unwind unreachable];
@@ -817,11 +817,11 @@
           StorageLive(_140);
           StorageLive(_141);
           StorageLive(_142);
-          _142 = (*_135);
+          _142 = copy (*_135);
           StorageLive(_143);
-          _143 = _1;
+          _143 = copy _1;
 -         _141 = Add(move _142, move _143);
-+         _141 = Add(move _142, _1);
++         _141 = Add(move _142, copy _1);
           StorageDead(_143);
           StorageDead(_142);
           _140 = opaque::<u64>(move _141) -> [return: bb38, unwind unreachable];
@@ -836,11 +836,11 @@
           StorageLive(_146);
           StorageLive(_147);
           StorageLive(_148);
-          _148 = (*_145);
+          _148 = copy (*_145);
           StorageLive(_149);
-          _149 = _1;
+          _149 = copy _1;
 -         _147 = Add(move _148, move _149);
-+         _147 = Add(move _148, _1);
++         _147 = Add(move _148, copy _1);
           StorageDead(_149);
           StorageDead(_148);
           _146 = opaque::<u64>(move _147) -> [return: bb39, unwind unreachable];
@@ -852,11 +852,11 @@
           StorageLive(_150);
           StorageLive(_151);
           StorageLive(_152);
-          _152 = (*_145);
+          _152 = copy (*_145);
           StorageLive(_153);
-          _153 = _1;
+          _153 = copy _1;
 -         _151 = Add(move _152, move _153);
-+         _151 = Add(move _152, _1);
++         _151 = Add(move _152, copy _1);
           StorageDead(_153);
           StorageDead(_152);
           _150 = opaque::<u64>(move _151) -> [return: bb40, unwind unreachable];
@@ -870,11 +870,11 @@
           StorageLive(_155);
           StorageLive(_156);
           StorageLive(_157);
-          _157 = (*_154);
+          _157 = copy (*_154);
           StorageLive(_158);
-          _158 = _1;
+          _158 = copy _1;
 -         _156 = Add(move _157, move _158);
-+         _156 = Add(move _157, _1);
++         _156 = Add(move _157, copy _1);
           StorageDead(_158);
           StorageDead(_157);
           _155 = opaque::<u64>(move _156) -> [return: bb41, unwind unreachable];
@@ -886,11 +886,11 @@
           StorageLive(_159);
           StorageLive(_160);
           StorageLive(_161);
-          _161 = (*_154);
+          _161 = copy (*_154);
           StorageLive(_162);
-          _162 = _1;
+          _162 = copy _1;
 -         _160 = Add(move _161, move _162);
-+         _160 = Add(move _161, _1);
++         _160 = Add(move _161, copy _1);
           StorageDead(_162);
           StorageDead(_161);
           _159 = opaque::<u64>(move _160) -> [return: bb42, unwind unreachable];
@@ -910,16 +910,16 @@
 -         StorageLive(_166);
 +         nop;
 +         nop;
-          _166 = (*_163);
+          _166 = copy (*_163);
           StorageLive(_167);
-          _167 = _1;
+          _167 = copy _1;
 -         _165 = Add(move _166, move _167);
-+         _165 = Add(_166, _1);
++         _165 = Add(copy _166, copy _1);
           StorageDead(_167);
 -         StorageDead(_166);
 -         _164 = opaque::<u64>(move _165) -> [return: bb43, unwind unreachable];
 +         nop;
-+         _164 = opaque::<u64>(_165) -> [return: bb43, unwind unreachable];
++         _164 = opaque::<u64>(copy _165) -> [return: bb43, unwind unreachable];
       }
   
       bb43: {
@@ -929,16 +929,16 @@
           StorageLive(_168);
           StorageLive(_169);
           StorageLive(_170);
--         _170 = (*_163);
-+         _170 = _166;
+-         _170 = copy (*_163);
++         _170 = copy _166;
           StorageLive(_171);
-          _171 = _1;
+          _171 = copy _1;
 -         _169 = Add(move _170, move _171);
-+         _169 = _165;
++         _169 = copy _165;
           StorageDead(_171);
           StorageDead(_170);
 -         _168 = opaque::<u64>(move _169) -> [return: bb44, unwind unreachable];
-+         _168 = opaque::<u64>(_165) -> [return: bb44, unwind unreachable];
++         _168 = opaque::<u64>(copy _165) -> [return: bb44, unwind unreachable];
       }
   
       bb44: {
diff --git a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff
index 41c0153613010..3ca5238663c28 100644
--- a/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.subexpression_elimination.GVN.panic-unwind.diff
@@ -195,15 +195,15 @@
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
           StorageLive(_7);
-          _7 = _2;
+          _7 = copy _2;
 -         _5 = Add(move _6, move _7);
-+         _5 = Add(_1, _2);
++         _5 = Add(copy _1, copy _2);
           StorageDead(_7);
           StorageDead(_6);
 -         _4 = opaque::<u64>(move _5) -> [return: bb1, unwind continue];
-+         _4 = opaque::<u64>(_5) -> [return: bb1, unwind continue];
++         _4 = opaque::<u64>(copy _5) -> [return: bb1, unwind continue];
       }
   
       bb1: {
@@ -214,15 +214,15 @@
 -         StorageLive(_9);
 +         nop;
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
           StorageLive(_11);
-          _11 = _2;
+          _11 = copy _2;
 -         _9 = Mul(move _10, move _11);
-+         _9 = Mul(_1, _2);
++         _9 = Mul(copy _1, copy _2);
           StorageDead(_11);
           StorageDead(_10);
 -         _8 = opaque::<u64>(move _9) -> [return: bb2, unwind continue];
-+         _8 = opaque::<u64>(_9) -> [return: bb2, unwind continue];
++         _8 = opaque::<u64>(copy _9) -> [return: bb2, unwind continue];
       }
   
       bb2: {
@@ -233,15 +233,15 @@
 -         StorageLive(_13);
 +         nop;
           StorageLive(_14);
-          _14 = _1;
+          _14 = copy _1;
           StorageLive(_15);
-          _15 = _2;
+          _15 = copy _2;
 -         _13 = Sub(move _14, move _15);
-+         _13 = Sub(_1, _2);
++         _13 = Sub(copy _1, copy _2);
           StorageDead(_15);
           StorageDead(_14);
 -         _12 = opaque::<u64>(move _13) -> [return: bb3, unwind continue];
-+         _12 = opaque::<u64>(_13) -> [return: bb3, unwind continue];
++         _12 = opaque::<u64>(copy _13) -> [return: bb3, unwind continue];
       }
   
       bb3: {
@@ -252,22 +252,22 @@
 -         StorageLive(_17);
 +         nop;
           StorageLive(_18);
-          _18 = _1;
+          _18 = copy _1;
           StorageLive(_19);
-          _19 = _2;
--         _20 = Eq(_19, const 0_u64);
--         assert(!move _20, "attempt to divide `{}` by zero", _18) -> [success: bb4, unwind continue];
-+         _20 = Eq(_2, const 0_u64);
-+         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb4, unwind continue];
+          _19 = copy _2;
+-         _20 = Eq(copy _19, const 0_u64);
+-         assert(!move _20, "attempt to divide `{}` by zero", copy _18) -> [success: bb4, unwind continue];
++         _20 = Eq(copy _2, const 0_u64);
++         assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb4, unwind continue];
       }
   
       bb4: {
 -         _17 = Div(move _18, move _19);
-+         _17 = Div(_1, _2);
++         _17 = Div(copy _1, copy _2);
           StorageDead(_19);
           StorageDead(_18);
 -         _16 = opaque::<u64>(move _17) -> [return: bb5, unwind continue];
-+         _16 = opaque::<u64>(_17) -> [return: bb5, unwind continue];
++         _16 = opaque::<u64>(copy _17) -> [return: bb5, unwind continue];
       }
   
       bb5: {
@@ -278,22 +278,22 @@
 -         StorageLive(_22);
 +         nop;
           StorageLive(_23);
-          _23 = _1;
+          _23 = copy _1;
           StorageLive(_24);
-          _24 = _2;
--         _25 = Eq(_24, const 0_u64);
--         assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", _23) -> [success: bb6, unwind continue];
-+         _25 = _20;
-+         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb6, unwind continue];
+          _24 = copy _2;
+-         _25 = Eq(copy _24, const 0_u64);
+-         assert(!move _25, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _23) -> [success: bb6, unwind continue];
++         _25 = copy _20;
++         assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb6, unwind continue];
       }
   
       bb6: {
 -         _22 = Rem(move _23, move _24);
-+         _22 = Rem(_1, _2);
++         _22 = Rem(copy _1, copy _2);
           StorageDead(_24);
           StorageDead(_23);
 -         _21 = opaque::<u64>(move _22) -> [return: bb7, unwind continue];
-+         _21 = opaque::<u64>(_22) -> [return: bb7, unwind continue];
++         _21 = opaque::<u64>(copy _22) -> [return: bb7, unwind continue];
       }
   
       bb7: {
@@ -304,15 +304,15 @@
 -         StorageLive(_27);
 +         nop;
           StorageLive(_28);
-          _28 = _1;
+          _28 = copy _1;
           StorageLive(_29);
-          _29 = _2;
+          _29 = copy _2;
 -         _27 = BitAnd(move _28, move _29);
-+         _27 = BitAnd(_1, _2);
++         _27 = BitAnd(copy _1, copy _2);
           StorageDead(_29);
           StorageDead(_28);
 -         _26 = opaque::<u64>(move _27) -> [return: bb8, unwind continue];
-+         _26 = opaque::<u64>(_27) -> [return: bb8, unwind continue];
++         _26 = opaque::<u64>(copy _27) -> [return: bb8, unwind continue];
       }
   
       bb8: {
@@ -323,15 +323,15 @@
 -         StorageLive(_31);
 +         nop;
           StorageLive(_32);
-          _32 = _1;
+          _32 = copy _1;
           StorageLive(_33);
-          _33 = _2;
+          _33 = copy _2;
 -         _31 = BitOr(move _32, move _33);
-+         _31 = BitOr(_1, _2);
++         _31 = BitOr(copy _1, copy _2);
           StorageDead(_33);
           StorageDead(_32);
 -         _30 = opaque::<u64>(move _31) -> [return: bb9, unwind continue];
-+         _30 = opaque::<u64>(_31) -> [return: bb9, unwind continue];
++         _30 = opaque::<u64>(copy _31) -> [return: bb9, unwind continue];
       }
   
       bb9: {
@@ -342,15 +342,15 @@
 -         StorageLive(_35);
 +         nop;
           StorageLive(_36);
-          _36 = _1;
+          _36 = copy _1;
           StorageLive(_37);
-          _37 = _2;
+          _37 = copy _2;
 -         _35 = BitXor(move _36, move _37);
-+         _35 = BitXor(_1, _2);
++         _35 = BitXor(copy _1, copy _2);
           StorageDead(_37);
           StorageDead(_36);
 -         _34 = opaque::<u64>(move _35) -> [return: bb10, unwind continue];
-+         _34 = opaque::<u64>(_35) -> [return: bb10, unwind continue];
++         _34 = opaque::<u64>(copy _35) -> [return: bb10, unwind continue];
       }
   
       bb10: {
@@ -361,15 +361,15 @@
 -         StorageLive(_39);
 +         nop;
           StorageLive(_40);
-          _40 = _1;
+          _40 = copy _1;
           StorageLive(_41);
-          _41 = _2;
+          _41 = copy _2;
 -         _39 = Shl(move _40, move _41);
-+         _39 = Shl(_1, _2);
++         _39 = Shl(copy _1, copy _2);
           StorageDead(_41);
           StorageDead(_40);
 -         _38 = opaque::<u64>(move _39) -> [return: bb11, unwind continue];
-+         _38 = opaque::<u64>(_39) -> [return: bb11, unwind continue];
++         _38 = opaque::<u64>(copy _39) -> [return: bb11, unwind continue];
       }
   
       bb11: {
@@ -380,15 +380,15 @@
 -         StorageLive(_43);
 +         nop;
           StorageLive(_44);
-          _44 = _1;
+          _44 = copy _1;
           StorageLive(_45);
-          _45 = _2;
+          _45 = copy _2;
 -         _43 = Shr(move _44, move _45);
-+         _43 = Shr(_1, _2);
++         _43 = Shr(copy _1, copy _2);
           StorageDead(_45);
           StorageDead(_44);
 -         _42 = opaque::<u64>(move _43) -> [return: bb12, unwind continue];
-+         _42 = opaque::<u64>(_43) -> [return: bb12, unwind continue];
++         _42 = opaque::<u64>(copy _43) -> [return: bb12, unwind continue];
       }
   
       bb12: {
@@ -399,12 +399,12 @@
 -         StorageLive(_47);
 +         nop;
           StorageLive(_48);
-          _48 = _1;
+          _48 = copy _1;
 -         _47 = move _48 as u32 (IntToInt);
-+         _47 = _1 as u32 (IntToInt);
++         _47 = copy _1 as u32 (IntToInt);
           StorageDead(_48);
 -         _46 = opaque::<u32>(move _47) -> [return: bb13, unwind continue];
-+         _46 = opaque::<u32>(_47) -> [return: bb13, unwind continue];
++         _46 = opaque::<u32>(copy _47) -> [return: bb13, unwind continue];
       }
   
       bb13: {
@@ -415,12 +415,12 @@
 -         StorageLive(_50);
 +         nop;
           StorageLive(_51);
-          _51 = _1;
+          _51 = copy _1;
 -         _50 = move _51 as f32 (IntToFloat);
-+         _50 = _1 as f32 (IntToFloat);
++         _50 = copy _1 as f32 (IntToFloat);
           StorageDead(_51);
 -         _49 = opaque::<f32>(move _50) -> [return: bb14, unwind continue];
-+         _49 = opaque::<f32>(_50) -> [return: bb14, unwind continue];
++         _49 = opaque::<f32>(copy _50) -> [return: bb14, unwind continue];
       }
   
       bb14: {
@@ -431,12 +431,12 @@
 -         StorageLive(_53);
 +         nop;
           StorageLive(_54);
-          _54 = _1;
+          _54 = copy _1;
 -         _53 = S::<u64>(move _54);
-+         _53 = S::<u64>(_1);
++         _53 = S::<u64>(copy _1);
           StorageDead(_54);
 -         _52 = opaque::<S<u64>>(move _53) -> [return: bb15, unwind continue];
-+         _52 = opaque::<S<u64>>(_53) -> [return: bb15, unwind continue];
++         _52 = opaque::<S<u64>>(copy _53) -> [return: bb15, unwind continue];
       }
   
       bb15: {
@@ -447,14 +447,14 @@
           StorageLive(_56);
           StorageLive(_57);
           StorageLive(_58);
-          _58 = _1;
+          _58 = copy _1;
 -         _57 = S::<u64>(move _58);
-+         _57 = _53;
++         _57 = copy _53;
           StorageDead(_58);
--         _56 = (_57.0: u64);
+-         _56 = copy (_57.0: u64);
 -         _55 = opaque::<u64>(move _56) -> [return: bb16, unwind continue];
-+         _56 = _1;
-+         _55 = opaque::<u64>(_1) -> [return: bb16, unwind continue];
++         _56 = copy _1;
++         _55 = opaque::<u64>(copy _1) -> [return: bb16, unwind continue];
       }
   
       bb16: {
@@ -464,15 +464,15 @@
           StorageLive(_59);
           StorageLive(_60);
           StorageLive(_61);
-          _61 = _1;
+          _61 = copy _1;
           StorageLive(_62);
-          _62 = _2;
+          _62 = copy _2;
 -         _60 = Add(move _61, move _62);
-+         _60 = _5;
++         _60 = copy _5;
           StorageDead(_62);
           StorageDead(_61);
 -         _59 = opaque::<u64>(move _60) -> [return: bb17, unwind continue];
-+         _59 = opaque::<u64>(_5) -> [return: bb17, unwind continue];
++         _59 = opaque::<u64>(copy _5) -> [return: bb17, unwind continue];
       }
   
       bb17: {
@@ -481,15 +481,15 @@
           StorageLive(_63);
           StorageLive(_64);
           StorageLive(_65);
-          _65 = _1;
+          _65 = copy _1;
           StorageLive(_66);
-          _66 = _2;
+          _66 = copy _2;
 -         _64 = Mul(move _65, move _66);
-+         _64 = _9;
++         _64 = copy _9;
           StorageDead(_66);
           StorageDead(_65);
 -         _63 = opaque::<u64>(move _64) -> [return: bb18, unwind continue];
-+         _63 = opaque::<u64>(_9) -> [return: bb18, unwind continue];
++         _63 = opaque::<u64>(copy _9) -> [return: bb18, unwind continue];
       }
   
       bb18: {
@@ -498,15 +498,15 @@
           StorageLive(_67);
           StorageLive(_68);
           StorageLive(_69);
-          _69 = _1;
+          _69 = copy _1;
           StorageLive(_70);
-          _70 = _2;
+          _70 = copy _2;
 -         _68 = Sub(move _69, move _70);
-+         _68 = _13;
++         _68 = copy _13;
           StorageDead(_70);
           StorageDead(_69);
 -         _67 = opaque::<u64>(move _68) -> [return: bb19, unwind continue];
-+         _67 = opaque::<u64>(_13) -> [return: bb19, unwind continue];
++         _67 = opaque::<u64>(copy _13) -> [return: bb19, unwind continue];
       }
   
       bb19: {
@@ -515,22 +515,22 @@
           StorageLive(_71);
           StorageLive(_72);
           StorageLive(_73);
-          _73 = _1;
+          _73 = copy _1;
           StorageLive(_74);
-          _74 = _2;
--         _75 = Eq(_74, const 0_u64);
--         assert(!move _75, "attempt to divide `{}` by zero", _73) -> [success: bb20, unwind continue];
-+         _75 = _20;
-+         assert(!_20, "attempt to divide `{}` by zero", _1) -> [success: bb20, unwind continue];
+          _74 = copy _2;
+-         _75 = Eq(copy _74, const 0_u64);
+-         assert(!move _75, "attempt to divide `{}` by zero", copy _73) -> [success: bb20, unwind continue];
++         _75 = copy _20;
++         assert(!copy _20, "attempt to divide `{}` by zero", copy _1) -> [success: bb20, unwind continue];
       }
   
       bb20: {
 -         _72 = Div(move _73, move _74);
-+         _72 = _17;
++         _72 = copy _17;
           StorageDead(_74);
           StorageDead(_73);
 -         _71 = opaque::<u64>(move _72) -> [return: bb21, unwind continue];
-+         _71 = opaque::<u64>(_17) -> [return: bb21, unwind continue];
++         _71 = opaque::<u64>(copy _17) -> [return: bb21, unwind continue];
       }
   
       bb21: {
@@ -539,22 +539,22 @@
           StorageLive(_76);
           StorageLive(_77);
           StorageLive(_78);
-          _78 = _1;
+          _78 = copy _1;
           StorageLive(_79);
-          _79 = _2;
--         _80 = Eq(_79, const 0_u64);
--         assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", _78) -> [success: bb22, unwind continue];
-+         _80 = _20;
-+         assert(!_20, "attempt to calculate the remainder of `{}` with a divisor of zero", _1) -> [success: bb22, unwind continue];
+          _79 = copy _2;
+-         _80 = Eq(copy _79, const 0_u64);
+-         assert(!move _80, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _78) -> [success: bb22, unwind continue];
++         _80 = copy _20;
++         assert(!copy _20, "attempt to calculate the remainder of `{}` with a divisor of zero", copy _1) -> [success: bb22, unwind continue];
       }
   
       bb22: {
 -         _77 = Rem(move _78, move _79);
-+         _77 = _22;
++         _77 = copy _22;
           StorageDead(_79);
           StorageDead(_78);
 -         _76 = opaque::<u64>(move _77) -> [return: bb23, unwind continue];
-+         _76 = opaque::<u64>(_22) -> [return: bb23, unwind continue];
++         _76 = opaque::<u64>(copy _22) -> [return: bb23, unwind continue];
       }
   
       bb23: {
@@ -563,15 +563,15 @@
           StorageLive(_81);
           StorageLive(_82);
           StorageLive(_83);
-          _83 = _1;
+          _83 = copy _1;
           StorageLive(_84);
-          _84 = _2;
+          _84 = copy _2;
 -         _82 = BitAnd(move _83, move _84);
-+         _82 = _27;
++         _82 = copy _27;
           StorageDead(_84);
           StorageDead(_83);
 -         _81 = opaque::<u64>(move _82) -> [return: bb24, unwind continue];
-+         _81 = opaque::<u64>(_27) -> [return: bb24, unwind continue];
++         _81 = opaque::<u64>(copy _27) -> [return: bb24, unwind continue];
       }
   
       bb24: {
@@ -580,15 +580,15 @@
           StorageLive(_85);
           StorageLive(_86);
           StorageLive(_87);
-          _87 = _1;
+          _87 = copy _1;
           StorageLive(_88);
-          _88 = _2;
+          _88 = copy _2;
 -         _86 = BitOr(move _87, move _88);
-+         _86 = _31;
++         _86 = copy _31;
           StorageDead(_88);
           StorageDead(_87);
 -         _85 = opaque::<u64>(move _86) -> [return: bb25, unwind continue];
-+         _85 = opaque::<u64>(_31) -> [return: bb25, unwind continue];
++         _85 = opaque::<u64>(copy _31) -> [return: bb25, unwind continue];
       }
   
       bb25: {
@@ -597,15 +597,15 @@
           StorageLive(_89);
           StorageLive(_90);
           StorageLive(_91);
-          _91 = _1;
+          _91 = copy _1;
           StorageLive(_92);
-          _92 = _2;
+          _92 = copy _2;
 -         _90 = BitXor(move _91, move _92);
-+         _90 = _35;
++         _90 = copy _35;
           StorageDead(_92);
           StorageDead(_91);
 -         _89 = opaque::<u64>(move _90) -> [return: bb26, unwind continue];
-+         _89 = opaque::<u64>(_35) -> [return: bb26, unwind continue];
++         _89 = opaque::<u64>(copy _35) -> [return: bb26, unwind continue];
       }
   
       bb26: {
@@ -614,15 +614,15 @@
           StorageLive(_93);
           StorageLive(_94);
           StorageLive(_95);
-          _95 = _1;
+          _95 = copy _1;
           StorageLive(_96);
-          _96 = _2;
+          _96 = copy _2;
 -         _94 = Shl(move _95, move _96);
-+         _94 = _39;
++         _94 = copy _39;
           StorageDead(_96);
           StorageDead(_95);
 -         _93 = opaque::<u64>(move _94) -> [return: bb27, unwind continue];
-+         _93 = opaque::<u64>(_39) -> [return: bb27, unwind continue];
++         _93 = opaque::<u64>(copy _39) -> [return: bb27, unwind continue];
       }
   
       bb27: {
@@ -631,15 +631,15 @@
           StorageLive(_97);
           StorageLive(_98);
           StorageLive(_99);
-          _99 = _1;
+          _99 = copy _1;
           StorageLive(_100);
-          _100 = _2;
+          _100 = copy _2;
 -         _98 = Shr(move _99, move _100);
-+         _98 = _43;
++         _98 = copy _43;
           StorageDead(_100);
           StorageDead(_99);
 -         _97 = opaque::<u64>(move _98) -> [return: bb28, unwind continue];
-+         _97 = opaque::<u64>(_43) -> [return: bb28, unwind continue];
++         _97 = opaque::<u64>(copy _43) -> [return: bb28, unwind continue];
       }
   
       bb28: {
@@ -648,12 +648,12 @@
           StorageLive(_101);
           StorageLive(_102);
           StorageLive(_103);
-          _103 = _1;
+          _103 = copy _1;
 -         _102 = move _103 as u32 (IntToInt);
-+         _102 = _47;
++         _102 = copy _47;
           StorageDead(_103);
 -         _101 = opaque::<u32>(move _102) -> [return: bb29, unwind continue];
-+         _101 = opaque::<u32>(_47) -> [return: bb29, unwind continue];
++         _101 = opaque::<u32>(copy _47) -> [return: bb29, unwind continue];
       }
   
       bb29: {
@@ -662,12 +662,12 @@
           StorageLive(_104);
           StorageLive(_105);
           StorageLive(_106);
-          _106 = _1;
+          _106 = copy _1;
 -         _105 = move _106 as f32 (IntToFloat);
-+         _105 = _50;
++         _105 = copy _50;
           StorageDead(_106);
 -         _104 = opaque::<f32>(move _105) -> [return: bb30, unwind continue];
-+         _104 = opaque::<f32>(_50) -> [return: bb30, unwind continue];
++         _104 = opaque::<f32>(copy _50) -> [return: bb30, unwind continue];
       }
   
       bb30: {
@@ -676,12 +676,12 @@
           StorageLive(_107);
           StorageLive(_108);
           StorageLive(_109);
-          _109 = _1;
+          _109 = copy _1;
 -         _108 = S::<u64>(move _109);
-+         _108 = _53;
++         _108 = copy _53;
           StorageDead(_109);
 -         _107 = opaque::<S<u64>>(move _108) -> [return: bb31, unwind continue];
-+         _107 = opaque::<S<u64>>(_53) -> [return: bb31, unwind continue];
++         _107 = opaque::<S<u64>>(copy _53) -> [return: bb31, unwind continue];
       }
   
       bb31: {
@@ -691,14 +691,14 @@
           StorageLive(_111);
           StorageLive(_112);
           StorageLive(_113);
-          _113 = _1;
+          _113 = copy _1;
 -         _112 = S::<u64>(move _113);
-+         _112 = _53;
++         _112 = copy _53;
           StorageDead(_113);
--         _111 = (_112.0: u64);
+-         _111 = copy (_112.0: u64);
 -         _110 = opaque::<u64>(move _111) -> [return: bb32, unwind continue];
-+         _111 = _1;
-+         _110 = opaque::<u64>(_1) -> [return: bb32, unwind continue];
++         _111 = copy _1;
++         _110 = opaque::<u64>(copy _1) -> [return: bb32, unwind continue];
       }
   
       bb32: {
@@ -710,21 +710,21 @@
 +         nop;
           StorageLive(_116);
           StorageLive(_117);
-          _117 = _1;
+          _117 = copy _1;
           StorageLive(_118);
-          _118 = _2;
+          _118 = copy _2;
 -         _116 = Mul(move _117, move _118);
-+         _116 = _9;
++         _116 = copy _9;
           StorageDead(_118);
           StorageDead(_117);
           StorageLive(_119);
-          _119 = _2;
+          _119 = copy _2;
 -         _115 = Sub(move _116, move _119);
-+         _115 = Sub(_9, _2);
++         _115 = Sub(copy _9, copy _2);
           StorageDead(_119);
           StorageDead(_116);
 -         _114 = opaque::<u64>(move _115) -> [return: bb33, unwind continue];
-+         _114 = opaque::<u64>(_115) -> [return: bb33, unwind continue];
++         _114 = opaque::<u64>(copy _115) -> [return: bb33, unwind continue];
       }
   
       bb33: {
@@ -735,21 +735,21 @@
           StorageLive(_121);
           StorageLive(_122);
           StorageLive(_123);
-          _123 = _1;
+          _123 = copy _1;
           StorageLive(_124);
-          _124 = _2;
+          _124 = copy _2;
 -         _122 = Mul(move _123, move _124);
-+         _122 = _9;
++         _122 = copy _9;
           StorageDead(_124);
           StorageDead(_123);
           StorageLive(_125);
-          _125 = _2;
+          _125 = copy _2;
 -         _121 = Sub(move _122, move _125);
-+         _121 = _115;
++         _121 = copy _115;
           StorageDead(_125);
           StorageDead(_122);
 -         _120 = opaque::<u64>(move _121) -> [return: bb34, unwind continue];
-+         _120 = opaque::<u64>(_115) -> [return: bb34, unwind continue];
++         _120 = opaque::<u64>(copy _115) -> [return: bb34, unwind continue];
       }
   
       bb34: {
@@ -762,16 +762,16 @@
 -         StorageLive(_129);
 +         nop;
 +         nop;
-          _129 = (*_126);
+          _129 = copy (*_126);
           StorageLive(_130);
-          _130 = _1;
+          _130 = copy _1;
 -         _128 = Add(move _129, move _130);
-+         _128 = Add(_129, _1);
++         _128 = Add(copy _129, copy _1);
           StorageDead(_130);
 -         StorageDead(_129);
 -         _127 = opaque::<u64>(move _128) -> [return: bb35, unwind continue];
 +         nop;
-+         _127 = opaque::<u64>(_128) -> [return: bb35, unwind continue];
++         _127 = opaque::<u64>(copy _128) -> [return: bb35, unwind continue];
       }
   
       bb35: {
@@ -781,16 +781,16 @@
           StorageLive(_131);
           StorageLive(_132);
           StorageLive(_133);
--         _133 = (*_126);
-+         _133 = _129;
+-         _133 = copy (*_126);
++         _133 = copy _129;
           StorageLive(_134);
-          _134 = _1;
+          _134 = copy _1;
 -         _132 = Add(move _133, move _134);
-+         _132 = _128;
++         _132 = copy _128;
           StorageDead(_134);
           StorageDead(_133);
 -         _131 = opaque::<u64>(move _132) -> [return: bb36, unwind continue];
-+         _131 = opaque::<u64>(_128) -> [return: bb36, unwind continue];
++         _131 = opaque::<u64>(copy _128) -> [return: bb36, unwind continue];
       }
   
       bb36: {
@@ -801,11 +801,11 @@
           StorageLive(_136);
           StorageLive(_137);
           StorageLive(_138);
-          _138 = (*_135);
+          _138 = copy (*_135);
           StorageLive(_139);
-          _139 = _1;
+          _139 = copy _1;
 -         _137 = Add(move _138, move _139);
-+         _137 = Add(move _138, _1);
++         _137 = Add(move _138, copy _1);
           StorageDead(_139);
           StorageDead(_138);
           _136 = opaque::<u64>(move _137) -> [return: bb37, unwind continue];
@@ -817,11 +817,11 @@
           StorageLive(_140);
           StorageLive(_141);
           StorageLive(_142);
-          _142 = (*_135);
+          _142 = copy (*_135);
           StorageLive(_143);
-          _143 = _1;
+          _143 = copy _1;
 -         _141 = Add(move _142, move _143);
-+         _141 = Add(move _142, _1);
++         _141 = Add(move _142, copy _1);
           StorageDead(_143);
           StorageDead(_142);
           _140 = opaque::<u64>(move _141) -> [return: bb38, unwind continue];
@@ -836,11 +836,11 @@
           StorageLive(_146);
           StorageLive(_147);
           StorageLive(_148);
-          _148 = (*_145);
+          _148 = copy (*_145);
           StorageLive(_149);
-          _149 = _1;
+          _149 = copy _1;
 -         _147 = Add(move _148, move _149);
-+         _147 = Add(move _148, _1);
++         _147 = Add(move _148, copy _1);
           StorageDead(_149);
           StorageDead(_148);
           _146 = opaque::<u64>(move _147) -> [return: bb39, unwind continue];
@@ -852,11 +852,11 @@
           StorageLive(_150);
           StorageLive(_151);
           StorageLive(_152);
-          _152 = (*_145);
+          _152 = copy (*_145);
           StorageLive(_153);
-          _153 = _1;
+          _153 = copy _1;
 -         _151 = Add(move _152, move _153);
-+         _151 = Add(move _152, _1);
++         _151 = Add(move _152, copy _1);
           StorageDead(_153);
           StorageDead(_152);
           _150 = opaque::<u64>(move _151) -> [return: bb40, unwind continue];
@@ -870,11 +870,11 @@
           StorageLive(_155);
           StorageLive(_156);
           StorageLive(_157);
-          _157 = (*_154);
+          _157 = copy (*_154);
           StorageLive(_158);
-          _158 = _1;
+          _158 = copy _1;
 -         _156 = Add(move _157, move _158);
-+         _156 = Add(move _157, _1);
++         _156 = Add(move _157, copy _1);
           StorageDead(_158);
           StorageDead(_157);
           _155 = opaque::<u64>(move _156) -> [return: bb41, unwind continue];
@@ -886,11 +886,11 @@
           StorageLive(_159);
           StorageLive(_160);
           StorageLive(_161);
-          _161 = (*_154);
+          _161 = copy (*_154);
           StorageLive(_162);
-          _162 = _1;
+          _162 = copy _1;
 -         _160 = Add(move _161, move _162);
-+         _160 = Add(move _161, _1);
++         _160 = Add(move _161, copy _1);
           StorageDead(_162);
           StorageDead(_161);
           _159 = opaque::<u64>(move _160) -> [return: bb42, unwind continue];
@@ -910,16 +910,16 @@
 -         StorageLive(_166);
 +         nop;
 +         nop;
-          _166 = (*_163);
+          _166 = copy (*_163);
           StorageLive(_167);
-          _167 = _1;
+          _167 = copy _1;
 -         _165 = Add(move _166, move _167);
-+         _165 = Add(_166, _1);
++         _165 = Add(copy _166, copy _1);
           StorageDead(_167);
 -         StorageDead(_166);
 -         _164 = opaque::<u64>(move _165) -> [return: bb43, unwind continue];
 +         nop;
-+         _164 = opaque::<u64>(_165) -> [return: bb43, unwind continue];
++         _164 = opaque::<u64>(copy _165) -> [return: bb43, unwind continue];
       }
   
       bb43: {
@@ -929,16 +929,16 @@
           StorageLive(_168);
           StorageLive(_169);
           StorageLive(_170);
--         _170 = (*_163);
-+         _170 = _166;
+-         _170 = copy (*_163);
++         _170 = copy _166;
           StorageLive(_171);
-          _171 = _1;
+          _171 = copy _1;
 -         _169 = Add(move _170, move _171);
-+         _169 = _165;
++         _169 = copy _165;
           StorageDead(_171);
           StorageDead(_170);
 -         _168 = opaque::<u64>(move _169) -> [return: bb44, unwind continue];
-+         _168 = opaque::<u64>(_165) -> [return: bb44, unwind continue];
++         _168 = opaque::<u64>(copy _165) -> [return: bb44, unwind continue];
       }
   
       bb44: {
diff --git a/tests/mir-opt/gvn.unary.GVN.panic-abort.diff b/tests/mir-opt/gvn.unary.GVN.panic-abort.diff
index 9469032f294e3..d14aec6df5fae 100644
--- a/tests/mir-opt/gvn.unary.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.unary.GVN.panic-abort.diff
@@ -37,15 +37,15 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = Neg(move _5);
-+         _4 = Neg(_1);
++         _4 = Neg(copy _1);
           StorageDead(_5);
 -         _3 = Neg(move _4);
-+         _3 = _1;
++         _3 = copy _1;
           StorageDead(_4);
 -         _2 = opaque::<i64>(move _3) -> [return: bb1, unwind unreachable];
-+         _2 = opaque::<i64>(_1) -> [return: bb1, unwind unreachable];
++         _2 = opaque::<i64>(copy _1) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
@@ -54,23 +54,23 @@
 -         StorageLive(_6);
 +         nop;
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
 -         _6 = Lt(move _7, const 13_i64);
-+         _6 = Lt(_1, const 13_i64);
++         _6 = Lt(copy _1, const 13_i64);
           StorageDead(_7);
           StorageLive(_8);
           StorageLive(_9);
           StorageLive(_10);
           StorageLive(_11);
-          _11 = _6;
+          _11 = copy _6;
 -         _10 = Not(move _11);
-+         _10 = Not(_6);
++         _10 = Not(copy _6);
           StorageDead(_11);
 -         _9 = Not(move _10);
-+         _9 = _6;
++         _9 = copy _6;
           StorageDead(_10);
 -         _8 = opaque::<bool>(move _9) -> [return: bb2, unwind unreachable];
-+         _8 = opaque::<bool>(_6) -> [return: bb2, unwind unreachable];
++         _8 = opaque::<bool>(copy _6) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
@@ -80,12 +80,12 @@
 -         StorageLive(_13);
 +         nop;
           StorageLive(_14);
-          _14 = _1;
+          _14 = copy _1;
 -         _13 = Ne(move _14, const 15_i64);
-+         _13 = Ne(_1, const 15_i64);
++         _13 = Ne(copy _1, const 15_i64);
           StorageDead(_14);
 -         _12 = opaque::<bool>(move _13) -> [return: bb3, unwind unreachable];
-+         _12 = opaque::<bool>(_13) -> [return: bb3, unwind unreachable];
++         _12 = opaque::<bool>(copy _13) -> [return: bb3, unwind unreachable];
       }
   
       bb3: {
@@ -96,15 +96,15 @@
           StorageLive(_16);
           StorageLive(_17);
           StorageLive(_18);
-          _18 = _1;
+          _18 = copy _1;
 -         _17 = Eq(move _18, const 15_i64);
-+         _17 = Eq(_1, const 15_i64);
++         _17 = Eq(copy _1, const 15_i64);
           StorageDead(_18);
 -         _16 = Not(move _17);
-+         _16 = _13;
++         _16 = copy _13;
           StorageDead(_17);
 -         _15 = opaque::<bool>(move _16) -> [return: bb4, unwind unreachable];
-+         _15 = opaque::<bool>(_13) -> [return: bb4, unwind unreachable];
++         _15 = opaque::<bool>(copy _13) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
@@ -114,12 +114,12 @@
 -         StorageLive(_20);
 +         nop;
           StorageLive(_21);
-          _21 = _1;
+          _21 = copy _1;
 -         _20 = Eq(move _21, const 35_i64);
-+         _20 = Eq(_1, const 35_i64);
++         _20 = Eq(copy _1, const 35_i64);
           StorageDead(_21);
 -         _19 = opaque::<bool>(move _20) -> [return: bb5, unwind unreachable];
-+         _19 = opaque::<bool>(_20) -> [return: bb5, unwind unreachable];
++         _19 = opaque::<bool>(copy _20) -> [return: bb5, unwind unreachable];
       }
   
       bb5: {
@@ -130,15 +130,15 @@
           StorageLive(_23);
           StorageLive(_24);
           StorageLive(_25);
-          _25 = _1;
+          _25 = copy _1;
 -         _24 = Ne(move _25, const 35_i64);
-+         _24 = Ne(_1, const 35_i64);
++         _24 = Ne(copy _1, const 35_i64);
           StorageDead(_25);
 -         _23 = Not(move _24);
-+         _23 = _20;
++         _23 = copy _20;
           StorageDead(_24);
 -         _22 = opaque::<bool>(move _23) -> [return: bb6, unwind unreachable];
-+         _22 = opaque::<bool>(_20) -> [return: bb6, unwind unreachable];
++         _22 = opaque::<bool>(copy _20) -> [return: bb6, unwind unreachable];
       }
   
       bb6: {
diff --git a/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff b/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff
index e672f6fb6ba71..5978f1faa1f68 100644
--- a/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.unary.GVN.panic-unwind.diff
@@ -37,15 +37,15 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = Neg(move _5);
-+         _4 = Neg(_1);
++         _4 = Neg(copy _1);
           StorageDead(_5);
 -         _3 = Neg(move _4);
-+         _3 = _1;
++         _3 = copy _1;
           StorageDead(_4);
 -         _2 = opaque::<i64>(move _3) -> [return: bb1, unwind continue];
-+         _2 = opaque::<i64>(_1) -> [return: bb1, unwind continue];
++         _2 = opaque::<i64>(copy _1) -> [return: bb1, unwind continue];
       }
   
       bb1: {
@@ -54,23 +54,23 @@
 -         StorageLive(_6);
 +         nop;
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
 -         _6 = Lt(move _7, const 13_i64);
-+         _6 = Lt(_1, const 13_i64);
++         _6 = Lt(copy _1, const 13_i64);
           StorageDead(_7);
           StorageLive(_8);
           StorageLive(_9);
           StorageLive(_10);
           StorageLive(_11);
-          _11 = _6;
+          _11 = copy _6;
 -         _10 = Not(move _11);
-+         _10 = Not(_6);
++         _10 = Not(copy _6);
           StorageDead(_11);
 -         _9 = Not(move _10);
-+         _9 = _6;
++         _9 = copy _6;
           StorageDead(_10);
 -         _8 = opaque::<bool>(move _9) -> [return: bb2, unwind continue];
-+         _8 = opaque::<bool>(_6) -> [return: bb2, unwind continue];
++         _8 = opaque::<bool>(copy _6) -> [return: bb2, unwind continue];
       }
   
       bb2: {
@@ -80,12 +80,12 @@
 -         StorageLive(_13);
 +         nop;
           StorageLive(_14);
-          _14 = _1;
+          _14 = copy _1;
 -         _13 = Ne(move _14, const 15_i64);
-+         _13 = Ne(_1, const 15_i64);
++         _13 = Ne(copy _1, const 15_i64);
           StorageDead(_14);
 -         _12 = opaque::<bool>(move _13) -> [return: bb3, unwind continue];
-+         _12 = opaque::<bool>(_13) -> [return: bb3, unwind continue];
++         _12 = opaque::<bool>(copy _13) -> [return: bb3, unwind continue];
       }
   
       bb3: {
@@ -96,15 +96,15 @@
           StorageLive(_16);
           StorageLive(_17);
           StorageLive(_18);
-          _18 = _1;
+          _18 = copy _1;
 -         _17 = Eq(move _18, const 15_i64);
-+         _17 = Eq(_1, const 15_i64);
++         _17 = Eq(copy _1, const 15_i64);
           StorageDead(_18);
 -         _16 = Not(move _17);
-+         _16 = _13;
++         _16 = copy _13;
           StorageDead(_17);
 -         _15 = opaque::<bool>(move _16) -> [return: bb4, unwind continue];
-+         _15 = opaque::<bool>(_13) -> [return: bb4, unwind continue];
++         _15 = opaque::<bool>(copy _13) -> [return: bb4, unwind continue];
       }
   
       bb4: {
@@ -114,12 +114,12 @@
 -         StorageLive(_20);
 +         nop;
           StorageLive(_21);
-          _21 = _1;
+          _21 = copy _1;
 -         _20 = Eq(move _21, const 35_i64);
-+         _20 = Eq(_1, const 35_i64);
++         _20 = Eq(copy _1, const 35_i64);
           StorageDead(_21);
 -         _19 = opaque::<bool>(move _20) -> [return: bb5, unwind continue];
-+         _19 = opaque::<bool>(_20) -> [return: bb5, unwind continue];
++         _19 = opaque::<bool>(copy _20) -> [return: bb5, unwind continue];
       }
   
       bb5: {
@@ -130,15 +130,15 @@
           StorageLive(_23);
           StorageLive(_24);
           StorageLive(_25);
-          _25 = _1;
+          _25 = copy _1;
 -         _24 = Ne(move _25, const 35_i64);
-+         _24 = Ne(_1, const 35_i64);
++         _24 = Ne(copy _1, const 35_i64);
           StorageDead(_25);
 -         _23 = Not(move _24);
-+         _23 = _20;
++         _23 = copy _20;
           StorageDead(_24);
 -         _22 = opaque::<bool>(move _23) -> [return: bb6, unwind continue];
-+         _22 = opaque::<bool>(_20) -> [return: bb6, unwind continue];
++         _22 = opaque::<bool>(copy _20) -> [return: bb6, unwind continue];
       }
   
       bb6: {
diff --git a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff
index 3eed0473f7fc2..bb938f3ba6a9a 100644
--- a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-abort.diff
@@ -58,10 +58,10 @@
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
--         _7 = _1;
+-         _7 = copy _1;
 +         _7 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_8);
--         _8 = _3;
+-         _8 = copy _3;
 -         _6 = Eq(move _7, move _8);
 +         _8 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _6 = const false;
@@ -77,10 +77,10 @@
           StorageLive(_9);
           StorageLive(_10);
           StorageLive(_11);
--         _11 = _1;
+-         _11 = copy _1;
 +         _11 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_12);
--         _12 = _3;
+-         _12 = copy _3;
 -         _10 = Ne(move _11, move _12);
 +         _12 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _10 = const true;
@@ -96,10 +96,10 @@
           StorageLive(_13);
           StorageLive(_14);
           StorageLive(_15);
--         _15 = _1;
+-         _15 = copy _1;
 +         _15 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_16);
--         _16 = _3;
+-         _16 = copy _3;
 -         _14 = Lt(move _15, move _16);
 +         _16 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _14 = const true;
@@ -115,10 +115,10 @@
           StorageLive(_17);
           StorageLive(_18);
           StorageLive(_19);
--         _19 = _1;
+-         _19 = copy _1;
 +         _19 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_20);
--         _20 = _3;
+-         _20 = copy _3;
 -         _18 = Le(move _19, move _20);
 +         _20 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _18 = const true;
@@ -134,10 +134,10 @@
           StorageLive(_21);
           StorageLive(_22);
           StorageLive(_23);
--         _23 = _1;
+-         _23 = copy _1;
 +         _23 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_24);
--         _24 = _3;
+-         _24 = copy _3;
 -         _22 = Gt(move _23, move _24);
 +         _24 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _22 = const false;
@@ -153,10 +153,10 @@
           StorageLive(_25);
           StorageLive(_26);
           StorageLive(_27);
--         _27 = _1;
+-         _27 = copy _1;
 +         _27 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_28);
--         _28 = _3;
+-         _28 = copy _3;
 -         _26 = Ge(move _27, move _28);
 +         _28 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _26 = const false;
diff --git a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff
index 9a6e255a872ea..81432d687eb32 100644
--- a/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.wide_ptr_integer.GVN.panic-unwind.diff
@@ -58,10 +58,10 @@
           StorageLive(_5);
           StorageLive(_6);
           StorageLive(_7);
--         _7 = _1;
+-         _7 = copy _1;
 +         _7 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_8);
--         _8 = _3;
+-         _8 = copy _3;
 -         _6 = Eq(move _7, move _8);
 +         _8 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _6 = const false;
@@ -77,10 +77,10 @@
           StorageLive(_9);
           StorageLive(_10);
           StorageLive(_11);
--         _11 = _1;
+-         _11 = copy _1;
 +         _11 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_12);
--         _12 = _3;
+-         _12 = copy _3;
 -         _10 = Ne(move _11, move _12);
 +         _12 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _10 = const true;
@@ -96,10 +96,10 @@
           StorageLive(_13);
           StorageLive(_14);
           StorageLive(_15);
--         _15 = _1;
+-         _15 = copy _1;
 +         _15 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_16);
--         _16 = _3;
+-         _16 = copy _3;
 -         _14 = Lt(move _15, move _16);
 +         _16 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _14 = const true;
@@ -115,10 +115,10 @@
           StorageLive(_17);
           StorageLive(_18);
           StorageLive(_19);
--         _19 = _1;
+-         _19 = copy _1;
 +         _19 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_20);
--         _20 = _3;
+-         _20 = copy _3;
 -         _18 = Le(move _19, move _20);
 +         _20 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _18 = const true;
@@ -134,10 +134,10 @@
           StorageLive(_21);
           StorageLive(_22);
           StorageLive(_23);
--         _23 = _1;
+-         _23 = copy _1;
 +         _23 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_24);
--         _24 = _3;
+-         _24 = copy _3;
 -         _22 = Gt(move _23, move _24);
 +         _24 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _22 = const false;
@@ -153,10 +153,10 @@
           StorageLive(_25);
           StorageLive(_26);
           StorageLive(_27);
--         _27 = _1;
+-         _27 = copy _1;
 +         _27 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
           StorageLive(_28);
--         _28 = _3;
+-         _28 = copy _3;
 -         _26 = Ge(move _27, move _28);
 +         _28 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
 +         _26 = const false;
diff --git a/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff
index 629c222568203..c58362e391c43 100644
--- a/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-abort.diff
@@ -69,7 +69,7 @@
           _2 = &raw const (*_3);
 -         _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
 -         StorageDead(_2);
-+         _1 = _2;
++         _1 = copy _2;
 +         nop;
           StorageDead(_5);
           StorageDead(_3);
@@ -87,24 +87,24 @@
           _8 = &raw const (*_9);
 -         _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
 -         StorageDead(_8);
-+         _7 = _8;
++         _7 = copy _8;
 +         nop;
           StorageDead(_11);
           StorageDead(_9);
           StorageLive(_13);
           StorageLive(_14);
           StorageLive(_15);
--         _15 = _1;
-+         _15 = _2;
+-         _15 = copy _1;
++         _15 = copy _2;
           StorageLive(_16);
           StorageLive(_17);
--         _17 = _7;
+-         _17 = copy _7;
 -         _16 = move _17 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _17 = _8;
-+         _16 = _8;
++         _17 = copy _8;
++         _16 = copy _8;
           StorageDead(_17);
 -         _14 = Eq(move _15, move _16);
-+         _14 = Eq(_2, _8);
++         _14 = Eq(copy _2, copy _8);
           StorageDead(_16);
           StorageDead(_15);
           _13 = opaque::<bool>(move _14) -> [return: bb1, unwind unreachable];
@@ -116,17 +116,17 @@
           StorageLive(_18);
           StorageLive(_19);
           StorageLive(_20);
--         _20 = _1;
-+         _20 = _2;
+-         _20 = copy _1;
++         _20 = copy _2;
           StorageLive(_21);
           StorageLive(_22);
--         _22 = _7;
+-         _22 = copy _7;
 -         _21 = move _22 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _22 = _8;
-+         _21 = _8;
++         _22 = copy _8;
++         _21 = copy _8;
           StorageDead(_22);
 -         _19 = Ne(move _20, move _21);
-+         _19 = Ne(_2, _8);
++         _19 = Ne(copy _2, copy _8);
           StorageDead(_21);
           StorageDead(_20);
           _18 = opaque::<bool>(move _19) -> [return: bb2, unwind unreachable];
@@ -138,17 +138,17 @@
           StorageLive(_23);
           StorageLive(_24);
           StorageLive(_25);
--         _25 = _1;
-+         _25 = _2;
+-         _25 = copy _1;
++         _25 = copy _2;
           StorageLive(_26);
           StorageLive(_27);
--         _27 = _7;
+-         _27 = copy _7;
 -         _26 = move _27 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _27 = _8;
-+         _26 = _8;
++         _27 = copy _8;
++         _26 = copy _8;
           StorageDead(_27);
 -         _24 = Lt(move _25, move _26);
-+         _24 = Lt(_2, _8);
++         _24 = Lt(copy _2, copy _8);
           StorageDead(_26);
           StorageDead(_25);
           _23 = opaque::<bool>(move _24) -> [return: bb3, unwind unreachable];
@@ -160,17 +160,17 @@
           StorageLive(_28);
           StorageLive(_29);
           StorageLive(_30);
--         _30 = _1;
-+         _30 = _2;
+-         _30 = copy _1;
++         _30 = copy _2;
           StorageLive(_31);
           StorageLive(_32);
--         _32 = _7;
+-         _32 = copy _7;
 -         _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _32 = _8;
-+         _31 = _8;
++         _32 = copy _8;
++         _31 = copy _8;
           StorageDead(_32);
 -         _29 = Le(move _30, move _31);
-+         _29 = Le(_2, _8);
++         _29 = Le(copy _2, copy _8);
           StorageDead(_31);
           StorageDead(_30);
           _28 = opaque::<bool>(move _29) -> [return: bb4, unwind unreachable];
@@ -182,17 +182,17 @@
           StorageLive(_33);
           StorageLive(_34);
           StorageLive(_35);
--         _35 = _1;
-+         _35 = _2;
+-         _35 = copy _1;
++         _35 = copy _2;
           StorageLive(_36);
           StorageLive(_37);
--         _37 = _7;
+-         _37 = copy _7;
 -         _36 = move _37 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _37 = _8;
-+         _36 = _8;
++         _37 = copy _8;
++         _36 = copy _8;
           StorageDead(_37);
 -         _34 = Gt(move _35, move _36);
-+         _34 = Gt(_2, _8);
++         _34 = Gt(copy _2, copy _8);
           StorageDead(_36);
           StorageDead(_35);
           _33 = opaque::<bool>(move _34) -> [return: bb5, unwind unreachable];
@@ -204,17 +204,17 @@
           StorageLive(_38);
           StorageLive(_39);
           StorageLive(_40);
--         _40 = _1;
-+         _40 = _2;
+-         _40 = copy _1;
++         _40 = copy _2;
           StorageLive(_41);
           StorageLive(_42);
--         _42 = _7;
+-         _42 = copy _7;
 -         _41 = move _42 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _42 = _8;
-+         _41 = _8;
++         _42 = copy _8;
++         _41 = copy _8;
           StorageDead(_42);
 -         _39 = Ge(move _40, move _41);
-+         _39 = Ge(_2, _8);
++         _39 = Ge(copy _2, copy _8);
           StorageDead(_41);
           StorageDead(_40);
           _38 = opaque::<bool>(move _39) -> [return: bb6, unwind unreachable];
diff --git a/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff
index 3380bc84cb807..b29ee862c81a3 100644
--- a/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.wide_ptr_provenance.GVN.panic-unwind.diff
@@ -69,7 +69,7 @@
           _2 = &raw const (*_3);
 -         _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
 -         StorageDead(_2);
-+         _1 = _2;
++         _1 = copy _2;
 +         nop;
           StorageDead(_5);
           StorageDead(_3);
@@ -87,24 +87,24 @@
           _8 = &raw const (*_9);
 -         _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
 -         StorageDead(_8);
-+         _7 = _8;
++         _7 = copy _8;
 +         nop;
           StorageDead(_11);
           StorageDead(_9);
           StorageLive(_13);
           StorageLive(_14);
           StorageLive(_15);
--         _15 = _1;
-+         _15 = _2;
+-         _15 = copy _1;
++         _15 = copy _2;
           StorageLive(_16);
           StorageLive(_17);
--         _17 = _7;
+-         _17 = copy _7;
 -         _16 = move _17 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _17 = _8;
-+         _16 = _8;
++         _17 = copy _8;
++         _16 = copy _8;
           StorageDead(_17);
 -         _14 = Eq(move _15, move _16);
-+         _14 = Eq(_2, _8);
++         _14 = Eq(copy _2, copy _8);
           StorageDead(_16);
           StorageDead(_15);
           _13 = opaque::<bool>(move _14) -> [return: bb1, unwind continue];
@@ -116,17 +116,17 @@
           StorageLive(_18);
           StorageLive(_19);
           StorageLive(_20);
--         _20 = _1;
-+         _20 = _2;
+-         _20 = copy _1;
++         _20 = copy _2;
           StorageLive(_21);
           StorageLive(_22);
--         _22 = _7;
+-         _22 = copy _7;
 -         _21 = move _22 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _22 = _8;
-+         _21 = _8;
++         _22 = copy _8;
++         _21 = copy _8;
           StorageDead(_22);
 -         _19 = Ne(move _20, move _21);
-+         _19 = Ne(_2, _8);
++         _19 = Ne(copy _2, copy _8);
           StorageDead(_21);
           StorageDead(_20);
           _18 = opaque::<bool>(move _19) -> [return: bb2, unwind continue];
@@ -138,17 +138,17 @@
           StorageLive(_23);
           StorageLive(_24);
           StorageLive(_25);
--         _25 = _1;
-+         _25 = _2;
+-         _25 = copy _1;
++         _25 = copy _2;
           StorageLive(_26);
           StorageLive(_27);
--         _27 = _7;
+-         _27 = copy _7;
 -         _26 = move _27 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _27 = _8;
-+         _26 = _8;
++         _27 = copy _8;
++         _26 = copy _8;
           StorageDead(_27);
 -         _24 = Lt(move _25, move _26);
-+         _24 = Lt(_2, _8);
++         _24 = Lt(copy _2, copy _8);
           StorageDead(_26);
           StorageDead(_25);
           _23 = opaque::<bool>(move _24) -> [return: bb3, unwind continue];
@@ -160,17 +160,17 @@
           StorageLive(_28);
           StorageLive(_29);
           StorageLive(_30);
--         _30 = _1;
-+         _30 = _2;
+-         _30 = copy _1;
++         _30 = copy _2;
           StorageLive(_31);
           StorageLive(_32);
--         _32 = _7;
+-         _32 = copy _7;
 -         _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _32 = _8;
-+         _31 = _8;
++         _32 = copy _8;
++         _31 = copy _8;
           StorageDead(_32);
 -         _29 = Le(move _30, move _31);
-+         _29 = Le(_2, _8);
++         _29 = Le(copy _2, copy _8);
           StorageDead(_31);
           StorageDead(_30);
           _28 = opaque::<bool>(move _29) -> [return: bb4, unwind continue];
@@ -182,17 +182,17 @@
           StorageLive(_33);
           StorageLive(_34);
           StorageLive(_35);
--         _35 = _1;
-+         _35 = _2;
+-         _35 = copy _1;
++         _35 = copy _2;
           StorageLive(_36);
           StorageLive(_37);
--         _37 = _7;
+-         _37 = copy _7;
 -         _36 = move _37 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _37 = _8;
-+         _36 = _8;
++         _37 = copy _8;
++         _36 = copy _8;
           StorageDead(_37);
 -         _34 = Gt(move _35, move _36);
-+         _34 = Gt(_2, _8);
++         _34 = Gt(copy _2, copy _8);
           StorageDead(_36);
           StorageDead(_35);
           _33 = opaque::<bool>(move _34) -> [return: bb5, unwind continue];
@@ -204,17 +204,17 @@
           StorageLive(_38);
           StorageLive(_39);
           StorageLive(_40);
--         _40 = _1;
-+         _40 = _2;
+-         _40 = copy _1;
++         _40 = copy _2;
           StorageLive(_41);
           StorageLive(_42);
--         _42 = _7;
+-         _42 = copy _7;
 -         _41 = move _42 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _42 = _8;
-+         _41 = _8;
++         _42 = copy _8;
++         _41 = copy _8;
           StorageDead(_42);
 -         _39 = Ge(move _40, move _41);
-+         _39 = Ge(_2, _8);
++         _39 = Ge(copy _2, copy _8);
           StorageDead(_41);
           StorageDead(_40);
           _38 = opaque::<bool>(move _39) -> [return: bb6, unwind continue];
diff --git a/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-abort.diff b/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-abort.diff
index da1662615d240..f4c38b7ab071e 100644
--- a/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-abort.diff
@@ -75,8 +75,8 @@
           StorageLive(_8);
           _8 = const 0_usize;
 -         _9 = Len((*_1));
--         _10 = Lt(_8, _9);
--         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb1, unwind unreachable];
+-         _10 = Lt(copy _8, copy _9);
+-         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb1, unwind unreachable];
 +         _9 = const 2_usize;
 +         _10 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 2_usize, const 0_usize) -> [success: bb1, unwind unreachable];
@@ -91,7 +91,7 @@
           _4 = &raw const (*_5);
 -         _3 = move _4 as *const dyn std::marker::Send (PointerCoercion(Unsize));
 -         StorageDead(_4);
-+         _3 = _4;
++         _3 = copy _4;
 +         nop;
           StorageDead(_7);
           StorageDead(_5);
@@ -104,8 +104,8 @@
           StorageLive(_16);
           _16 = const 1_usize;
 -         _17 = Len((*_1));
--         _18 = Lt(_16, _17);
--         assert(move _18, "index out of bounds: the length is {} but the index is {}", move _17, _16) -> [success: bb2, unwind unreachable];
+-         _18 = Lt(copy _16, copy _17);
+-         assert(move _18, "index out of bounds: the length is {} but the index is {}", move _17, copy _16) -> [success: bb2, unwind unreachable];
 +         _17 = const 2_usize;
 +         _18 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 2_usize, const 1_usize) -> [success: bb2, unwind unreachable];
@@ -120,24 +120,24 @@
           _12 = &raw const (*_13);
 -         _11 = move _12 as *const dyn std::marker::Send (PointerCoercion(Unsize));
 -         StorageDead(_12);
-+         _11 = _12;
++         _11 = copy _12;
 +         nop;
           StorageDead(_15);
           StorageDead(_13);
           StorageLive(_19);
           StorageLive(_20);
           StorageLive(_21);
--         _21 = _3;
-+         _21 = _4;
+-         _21 = copy _3;
++         _21 = copy _4;
           StorageLive(_22);
           StorageLive(_23);
--         _23 = _11;
+-         _23 = copy _11;
 -         _22 = move _23 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _23 = _12;
-+         _22 = _12;
++         _23 = copy _12;
++         _22 = copy _12;
           StorageDead(_23);
 -         _20 = Eq(move _21, move _22);
-+         _20 = Eq(_4, _12);
++         _20 = Eq(copy _4, copy _12);
           StorageDead(_22);
           StorageDead(_21);
           _19 = opaque::<bool>(move _20) -> [return: bb3, unwind unreachable];
@@ -149,17 +149,17 @@
           StorageLive(_24);
           StorageLive(_25);
           StorageLive(_26);
--         _26 = _3;
-+         _26 = _4;
+-         _26 = copy _3;
++         _26 = copy _4;
           StorageLive(_27);
           StorageLive(_28);
--         _28 = _11;
+-         _28 = copy _11;
 -         _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _28 = _12;
-+         _27 = _12;
++         _28 = copy _12;
++         _27 = copy _12;
           StorageDead(_28);
 -         _25 = Ne(move _26, move _27);
-+         _25 = Ne(_4, _12);
++         _25 = Ne(copy _4, copy _12);
           StorageDead(_27);
           StorageDead(_26);
           _24 = opaque::<bool>(move _25) -> [return: bb4, unwind unreachable];
@@ -171,17 +171,17 @@
           StorageLive(_29);
           StorageLive(_30);
           StorageLive(_31);
--         _31 = _3;
-+         _31 = _4;
+-         _31 = copy _3;
++         _31 = copy _4;
           StorageLive(_32);
           StorageLive(_33);
--         _33 = _11;
+-         _33 = copy _11;
 -         _32 = move _33 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _33 = _12;
-+         _32 = _12;
++         _33 = copy _12;
++         _32 = copy _12;
           StorageDead(_33);
 -         _30 = Lt(move _31, move _32);
-+         _30 = Lt(_4, _12);
++         _30 = Lt(copy _4, copy _12);
           StorageDead(_32);
           StorageDead(_31);
           _29 = opaque::<bool>(move _30) -> [return: bb5, unwind unreachable];
@@ -193,17 +193,17 @@
           StorageLive(_34);
           StorageLive(_35);
           StorageLive(_36);
--         _36 = _3;
-+         _36 = _4;
+-         _36 = copy _3;
++         _36 = copy _4;
           StorageLive(_37);
           StorageLive(_38);
--         _38 = _11;
+-         _38 = copy _11;
 -         _37 = move _38 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _38 = _12;
-+         _37 = _12;
++         _38 = copy _12;
++         _37 = copy _12;
           StorageDead(_38);
 -         _35 = Le(move _36, move _37);
-+         _35 = Le(_4, _12);
++         _35 = Le(copy _4, copy _12);
           StorageDead(_37);
           StorageDead(_36);
           _34 = opaque::<bool>(move _35) -> [return: bb6, unwind unreachable];
@@ -215,17 +215,17 @@
           StorageLive(_39);
           StorageLive(_40);
           StorageLive(_41);
--         _41 = _3;
-+         _41 = _4;
+-         _41 = copy _3;
++         _41 = copy _4;
           StorageLive(_42);
           StorageLive(_43);
--         _43 = _11;
+-         _43 = copy _11;
 -         _42 = move _43 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _43 = _12;
-+         _42 = _12;
++         _43 = copy _12;
++         _42 = copy _12;
           StorageDead(_43);
 -         _40 = Gt(move _41, move _42);
-+         _40 = Gt(_4, _12);
++         _40 = Gt(copy _4, copy _12);
           StorageDead(_42);
           StorageDead(_41);
           _39 = opaque::<bool>(move _40) -> [return: bb7, unwind unreachable];
@@ -237,17 +237,17 @@
           StorageLive(_44);
           StorageLive(_45);
           StorageLive(_46);
--         _46 = _3;
-+         _46 = _4;
+-         _46 = copy _3;
++         _46 = copy _4;
           StorageLive(_47);
           StorageLive(_48);
--         _48 = _11;
+-         _48 = copy _11;
 -         _47 = move _48 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _48 = _12;
-+         _47 = _12;
++         _48 = copy _12;
++         _47 = copy _12;
           StorageDead(_48);
 -         _45 = Ge(move _46, move _47);
-+         _45 = Ge(_4, _12);
++         _45 = Ge(copy _4, copy _12);
           StorageDead(_47);
           StorageDead(_46);
           _44 = opaque::<bool>(move _45) -> [return: bb8, unwind unreachable];
diff --git a/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-unwind.diff
index 6c4f3a91264b5..03f2d129a9b6f 100644
--- a/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.wide_ptr_same_provenance.GVN.panic-unwind.diff
@@ -75,8 +75,8 @@
           StorageLive(_8);
           _8 = const 0_usize;
 -         _9 = Len((*_1));
--         _10 = Lt(_8, _9);
--         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb1, unwind continue];
+-         _10 = Lt(copy _8, copy _9);
+-         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb1, unwind continue];
 +         _9 = const 2_usize;
 +         _10 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 2_usize, const 0_usize) -> [success: bb1, unwind continue];
@@ -91,7 +91,7 @@
           _4 = &raw const (*_5);
 -         _3 = move _4 as *const dyn std::marker::Send (PointerCoercion(Unsize));
 -         StorageDead(_4);
-+         _3 = _4;
++         _3 = copy _4;
 +         nop;
           StorageDead(_7);
           StorageDead(_5);
@@ -104,8 +104,8 @@
           StorageLive(_16);
           _16 = const 1_usize;
 -         _17 = Len((*_1));
--         _18 = Lt(_16, _17);
--         assert(move _18, "index out of bounds: the length is {} but the index is {}", move _17, _16) -> [success: bb2, unwind continue];
+-         _18 = Lt(copy _16, copy _17);
+-         assert(move _18, "index out of bounds: the length is {} but the index is {}", move _17, copy _16) -> [success: bb2, unwind continue];
 +         _17 = const 2_usize;
 +         _18 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 2_usize, const 1_usize) -> [success: bb2, unwind continue];
@@ -120,24 +120,24 @@
           _12 = &raw const (*_13);
 -         _11 = move _12 as *const dyn std::marker::Send (PointerCoercion(Unsize));
 -         StorageDead(_12);
-+         _11 = _12;
++         _11 = copy _12;
 +         nop;
           StorageDead(_15);
           StorageDead(_13);
           StorageLive(_19);
           StorageLive(_20);
           StorageLive(_21);
--         _21 = _3;
-+         _21 = _4;
+-         _21 = copy _3;
++         _21 = copy _4;
           StorageLive(_22);
           StorageLive(_23);
--         _23 = _11;
+-         _23 = copy _11;
 -         _22 = move _23 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _23 = _12;
-+         _22 = _12;
++         _23 = copy _12;
++         _22 = copy _12;
           StorageDead(_23);
 -         _20 = Eq(move _21, move _22);
-+         _20 = Eq(_4, _12);
++         _20 = Eq(copy _4, copy _12);
           StorageDead(_22);
           StorageDead(_21);
           _19 = opaque::<bool>(move _20) -> [return: bb3, unwind continue];
@@ -149,17 +149,17 @@
           StorageLive(_24);
           StorageLive(_25);
           StorageLive(_26);
--         _26 = _3;
-+         _26 = _4;
+-         _26 = copy _3;
++         _26 = copy _4;
           StorageLive(_27);
           StorageLive(_28);
--         _28 = _11;
+-         _28 = copy _11;
 -         _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _28 = _12;
-+         _27 = _12;
++         _28 = copy _12;
++         _27 = copy _12;
           StorageDead(_28);
 -         _25 = Ne(move _26, move _27);
-+         _25 = Ne(_4, _12);
++         _25 = Ne(copy _4, copy _12);
           StorageDead(_27);
           StorageDead(_26);
           _24 = opaque::<bool>(move _25) -> [return: bb4, unwind continue];
@@ -171,17 +171,17 @@
           StorageLive(_29);
           StorageLive(_30);
           StorageLive(_31);
--         _31 = _3;
-+         _31 = _4;
+-         _31 = copy _3;
++         _31 = copy _4;
           StorageLive(_32);
           StorageLive(_33);
--         _33 = _11;
+-         _33 = copy _11;
 -         _32 = move _33 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _33 = _12;
-+         _32 = _12;
++         _33 = copy _12;
++         _32 = copy _12;
           StorageDead(_33);
 -         _30 = Lt(move _31, move _32);
-+         _30 = Lt(_4, _12);
++         _30 = Lt(copy _4, copy _12);
           StorageDead(_32);
           StorageDead(_31);
           _29 = opaque::<bool>(move _30) -> [return: bb5, unwind continue];
@@ -193,17 +193,17 @@
           StorageLive(_34);
           StorageLive(_35);
           StorageLive(_36);
--         _36 = _3;
-+         _36 = _4;
+-         _36 = copy _3;
++         _36 = copy _4;
           StorageLive(_37);
           StorageLive(_38);
--         _38 = _11;
+-         _38 = copy _11;
 -         _37 = move _38 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _38 = _12;
-+         _37 = _12;
++         _38 = copy _12;
++         _37 = copy _12;
           StorageDead(_38);
 -         _35 = Le(move _36, move _37);
-+         _35 = Le(_4, _12);
++         _35 = Le(copy _4, copy _12);
           StorageDead(_37);
           StorageDead(_36);
           _34 = opaque::<bool>(move _35) -> [return: bb6, unwind continue];
@@ -215,17 +215,17 @@
           StorageLive(_39);
           StorageLive(_40);
           StorageLive(_41);
--         _41 = _3;
-+         _41 = _4;
+-         _41 = copy _3;
++         _41 = copy _4;
           StorageLive(_42);
           StorageLive(_43);
--         _43 = _11;
+-         _43 = copy _11;
 -         _42 = move _43 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _43 = _12;
-+         _42 = _12;
++         _43 = copy _12;
++         _42 = copy _12;
           StorageDead(_43);
 -         _40 = Gt(move _41, move _42);
-+         _40 = Gt(_4, _12);
++         _40 = Gt(copy _4, copy _12);
           StorageDead(_42);
           StorageDead(_41);
           _39 = opaque::<bool>(move _40) -> [return: bb7, unwind continue];
@@ -237,17 +237,17 @@
           StorageLive(_44);
           StorageLive(_45);
           StorageLive(_46);
--         _46 = _3;
-+         _46 = _4;
+-         _46 = copy _3;
++         _46 = copy _4;
           StorageLive(_47);
           StorageLive(_48);
--         _48 = _11;
+-         _48 = copy _11;
 -         _47 = move _48 as *const dyn std::marker::Send (PointerCoercion(Unsize));
-+         _48 = _12;
-+         _47 = _12;
++         _48 = copy _12;
++         _47 = copy _12;
           StorageDead(_48);
 -         _45 = Ge(move _46, move _47);
-+         _45 = Ge(_4, _12);
++         _45 = Ge(copy _4, copy _12);
           StorageDead(_47);
           StorageDead(_46);
           _44 = opaque::<bool>(move _45) -> [return: bb8, unwind continue];
diff --git a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff
index a5c29c191ad5c..0433152bb4f29 100644
--- a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-abort.diff
@@ -16,9 +16,9 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Option::<T>::Some(move _3);
-+         _2 = Option::<T>::Some(_1);
++         _2 = Option::<T>::Some(copy _1);
           StorageDead(_3);
 -         _4 = discriminant(_2);
 -         switchInt(move _4) -> [0: bb2, 1: bb3, otherwise: bb1];
@@ -37,10 +37,10 @@
   
       bb3: {
           StorageLive(_5);
--         _5 = ((_2 as Some).0: T);
--         _0 = _5;
-+         _5 = _1;
-+         _0 = _1;
+-         _5 = copy ((_2 as Some).0: T);
+-         _0 = copy _5;
++         _5 = copy _1;
++         _0 = copy _1;
           StorageDead(_5);
           StorageDead(_2);
           return;
diff --git a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff
index 6f2e52482716d..5722c865c2f9f 100644
--- a/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.wrap_unwrap.GVN.panic-unwind.diff
@@ -16,9 +16,9 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Option::<T>::Some(move _3);
-+         _2 = Option::<T>::Some(_1);
++         _2 = Option::<T>::Some(copy _1);
           StorageDead(_3);
 -         _4 = discriminant(_2);
 -         switchInt(move _4) -> [0: bb2, 1: bb3, otherwise: bb1];
@@ -37,10 +37,10 @@
   
       bb3: {
           StorageLive(_5);
--         _5 = ((_2 as Some).0: T);
--         _0 = _5;
-+         _5 = _1;
-+         _0 = _1;
+-         _5 = copy ((_2 as Some).0: T);
+-         _0 = copy _5;
++         _5 = copy _1;
++         _0 = copy _1;
           StorageDead(_5);
           StorageDead(_2);
           return;
diff --git a/tests/mir-opt/gvn_copy_moves.fn0.GVN.diff b/tests/mir-opt/gvn_copy_moves.fn0.GVN.diff
index b12de636f58b1..c364da7a3cc68 100644
--- a/tests/mir-opt/gvn_copy_moves.fn0.GVN.diff
+++ b/tests/mir-opt/gvn_copy_moves.fn0.GVN.diff
@@ -14,10 +14,10 @@
           _2 = [const 42_u128; 6];
 -         _2[_1] = const 1_u128;
 +         _2[1 of 2] = const 1_u128;
-          _3 = (_2,);
-          _4 = _3;
--         _5 = fn1(move (_3.0: [u128; 6]), _4) -> [return: bb1, unwind unreachable];
-+         _5 = fn1((_3.0: [u128; 6]), _3) -> [return: bb1, unwind unreachable];
+          _3 = (copy _2,);
+          _4 = copy _3;
+-         _5 = fn1(move (_3.0: [u128; 6]), copy _4) -> [return: bb1, unwind unreachable];
++         _5 = fn1(copy (_3.0: [u128; 6]), copy _3) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
diff --git a/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff b/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff
index 3af78d9b6ce98..1e378d30a3e9d 100644
--- a/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff
+++ b/tests/mir-opt/gvn_ptr_eq_with_constant.main.GVN.diff
@@ -25,20 +25,20 @@
           StorageLive(_2);
           StorageLive(_3);
 -         _3 = AlignOf(u8);
--         _2 = _3 as *mut u8 (Transmute);
+-         _2 = copy _3 as *mut u8 (Transmute);
 +         _3 = const 1_usize;
 +         _2 = const {0x1 as *mut u8};
           StorageDead(_3);
           StorageLive(_4);
           StorageLive(_5);
--         _5 = _2;
--         _4 = _2 as *const u8 (PtrToPtr);
+-         _5 = copy _2;
+-         _4 = copy _2 as *const u8 (PtrToPtr);
 +         _5 = const {0x1 as *mut u8};
 +         _4 = const {0x1 as *const u8};
           StorageDead(_5);
           StorageLive(_6);
 -         _6 = const Foo::<u8>::SENTINEL as *const u8 (PtrToPtr);
--         _1 = Eq(_4, _6);
+-         _1 = Eq(copy _4, copy _6);
 +         _6 = const {0x1 as *const u8};
 +         _1 = const true;
           StorageDead(_6);
diff --git a/tests/mir-opt/gvn_uninhabited.f.GVN.panic-abort.diff b/tests/mir-opt/gvn_uninhabited.f.GVN.panic-abort.diff
index 626367766d76d..37b7b0d2c9db3 100644
--- a/tests/mir-opt/gvn_uninhabited.f.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn_uninhabited.f.GVN.panic-abort.diff
@@ -17,14 +17,14 @@
           StorageLive(_3);
           _5 = const f::promoted[0];
           _3 = &(*_5);
--         _2 = ((*_3).1: E);
-+         _2 = ((*_5).1: E);
+-         _2 = copy ((*_3).1: E);
++         _2 = copy ((*_5).1: E);
           StorageLive(_1);
--         _1 = ((_2 as A).1: u32);
+-         _1 = copy ((_2 as A).1: u32);
 +         _1 = const 0_u32;
           StorageDead(_3);
           StorageDead(_2);
--         _0 = _1;
+-         _0 = copy _1;
 +         _0 = const 0_u32;
           StorageDead(_1);
           return;
diff --git a/tests/mir-opt/gvn_uninhabited.f.GVN.panic-unwind.diff b/tests/mir-opt/gvn_uninhabited.f.GVN.panic-unwind.diff
index 626367766d76d..37b7b0d2c9db3 100644
--- a/tests/mir-opt/gvn_uninhabited.f.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn_uninhabited.f.GVN.panic-unwind.diff
@@ -17,14 +17,14 @@
           StorageLive(_3);
           _5 = const f::promoted[0];
           _3 = &(*_5);
--         _2 = ((*_3).1: E);
-+         _2 = ((*_5).1: E);
+-         _2 = copy ((*_3).1: E);
++         _2 = copy ((*_5).1: E);
           StorageLive(_1);
--         _1 = ((_2 as A).1: u32);
+-         _1 = copy ((_2 as A).1: u32);
 +         _1 = const 0_u32;
           StorageDead(_3);
           StorageDead(_2);
--         _0 = _1;
+-         _0 = copy _1;
 +         _0 = const 0_u32;
           StorageDead(_1);
           return;
diff --git a/tests/mir-opt/if_condition_int.dont_opt_bool.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.dont_opt_bool.SimplifyComparisonIntegral.diff
index 083515aebc69d..2350faa05d3f0 100644
--- a/tests/mir-opt/if_condition_int.dont_opt_bool.SimplifyComparisonIntegral.diff
+++ b/tests/mir-opt/if_condition_int.dont_opt_bool.SimplifyComparisonIntegral.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
       }
   
diff --git a/tests/mir-opt/if_condition_int.dont_opt_floats.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.dont_opt_floats.SimplifyComparisonIntegral.diff
index 15319586062b8..94570017730df 100644
--- a/tests/mir-opt/if_condition_int.dont_opt_floats.SimplifyComparisonIntegral.diff
+++ b/tests/mir-opt/if_condition_int.dont_opt_floats.SimplifyComparisonIntegral.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = Eq(move _3, const -42f32);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
       }
diff --git a/tests/mir-opt/if_condition_int.dont_remove_comparison.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.dont_remove_comparison.SimplifyComparisonIntegral.diff
index 218d7fd59b735..d19b4148405e2 100644
--- a/tests/mir-opt/if_condition_int.dont_remove_comparison.SimplifyComparisonIntegral.diff
+++ b/tests/mir-opt/if_condition_int.dont_remove_comparison.SimplifyComparisonIntegral.diff
@@ -17,11 +17,11 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Eq(move _3, const 17_i8);
 -         StorageDead(_3);
--         switchInt(_2) -> [0: bb2, otherwise: bb1];
-+         _2 = Eq(_3, const 17_i8);
+-         switchInt(copy _2) -> [0: bb2, otherwise: bb1];
++         _2 = Eq(copy _3, const 17_i8);
 +         nop;
 +         switchInt(move _3) -> [17: bb1, otherwise: bb2];
       }
@@ -30,7 +30,7 @@
 +         StorageDead(_3);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _2;
+          _7 = copy _2;
           _6 = move _7 as i32 (IntToInt);
           StorageDead(_7);
           _0 = Add(const 100_i32, move _6);
@@ -42,7 +42,7 @@
 +         StorageDead(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
           _4 = move _5 as i32 (IntToInt);
           StorageDead(_5);
           _0 = Add(const 10_i32, move _4);
diff --git a/tests/mir-opt/if_condition_int.opt_char.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.opt_char.SimplifyComparisonIntegral.diff
index fedbd6cdd24a6..e47b7e5225983 100644
--- a/tests/mir-opt/if_condition_int.opt_char.SimplifyComparisonIntegral.diff
+++ b/tests/mir-opt/if_condition_int.opt_char.SimplifyComparisonIntegral.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Eq(move _3, const 'x');
 -         switchInt(move _2) -> [0: bb2, otherwise: bb1];
 +         nop;
diff --git a/tests/mir-opt/if_condition_int.opt_i8.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.opt_i8.SimplifyComparisonIntegral.diff
index 9c38d8fe06577..b6cdc6af8bf48 100644
--- a/tests/mir-opt/if_condition_int.opt_i8.SimplifyComparisonIntegral.diff
+++ b/tests/mir-opt/if_condition_int.opt_i8.SimplifyComparisonIntegral.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Eq(move _3, const 42_i8);
 -         switchInt(move _2) -> [0: bb2, otherwise: bb1];
 +         nop;
diff --git a/tests/mir-opt/if_condition_int.opt_multiple_ifs.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.opt_multiple_ifs.SimplifyComparisonIntegral.diff
index 8c85ce78565c3..31745ac732a22 100644
--- a/tests/mir-opt/if_condition_int.opt_multiple_ifs.SimplifyComparisonIntegral.diff
+++ b/tests/mir-opt/if_condition_int.opt_multiple_ifs.SimplifyComparisonIntegral.diff
@@ -12,7 +12,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Eq(move _3, const 42_u32);
 -         switchInt(move _2) -> [0: bb2, otherwise: bb1];
 +         nop;
@@ -29,7 +29,7 @@
           StorageDead(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = Ne(move _5, const 21_u32);
 -         switchInt(move _4) -> [0: bb4, otherwise: bb3];
 +         nop;
diff --git a/tests/mir-opt/if_condition_int.opt_negative.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.opt_negative.SimplifyComparisonIntegral.diff
index 876ed61e9fa3a..d747985f6e135 100644
--- a/tests/mir-opt/if_condition_int.opt_negative.SimplifyComparisonIntegral.diff
+++ b/tests/mir-opt/if_condition_int.opt_negative.SimplifyComparisonIntegral.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Eq(move _3, const -42_i32);
 -         switchInt(move _2) -> [0: bb2, otherwise: bb1];
 +         nop;
diff --git a/tests/mir-opt/if_condition_int.opt_u32.SimplifyComparisonIntegral.diff b/tests/mir-opt/if_condition_int.opt_u32.SimplifyComparisonIntegral.diff
index ed3eb47dd3d9d..1d6809a9438a0 100644
--- a/tests/mir-opt/if_condition_int.opt_u32.SimplifyComparisonIntegral.diff
+++ b/tests/mir-opt/if_condition_int.opt_u32.SimplifyComparisonIntegral.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Eq(move _3, const 42_u32);
 -         switchInt(move _2) -> [0: bb2, otherwise: bb1];
 +         nop;
diff --git a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff
index 4e495c37fbc9a..2d64d49ce5c13 100644
--- a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-abort.diff
@@ -21,17 +21,17 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = <Q as Query>::cache::<T>(move _3) -> [return: bb1, unwind unreachable];
       }
   
       bb1: {
           StorageDead(_3);
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _0 = try_execute_query::<<Q as Query>::C>(move _4) -> [return: bb2, unwind unreachable];
 +         StorageLive(_5);
-+         _5 = _4 as &dyn Cache<V = <Q as Query>::V> (PointerCoercion(Unsize));
++         _5 = copy _4 as &dyn Cache<V = <Q as Query>::V> (PointerCoercion(Unsize));
 +         _0 = <dyn Cache<V = <Q as Query>::V> as Cache>::store_nocache(move _5) -> [return: bb2, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff
index 7fdb7618212a9..c5e9654e19cfd 100644
--- a/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/dyn_trait.get_query.Inline.panic-unwind.diff
@@ -21,17 +21,17 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = <Q as Query>::cache::<T>(move _3) -> [return: bb1, unwind continue];
       }
   
       bb1: {
           StorageDead(_3);
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _0 = try_execute_query::<<Q as Query>::C>(move _4) -> [return: bb2, unwind continue];
 +         StorageLive(_5);
-+         _5 = _4 as &dyn Cache<V = <Q as Query>::V> (PointerCoercion(Unsize));
++         _5 = copy _4 as &dyn Cache<V = <Q as Query>::V> (PointerCoercion(Unsize));
 +         _0 = <dyn Cache<V = <Q as Query>::V> as Cache>::store_nocache(move _5) -> [return: bb2, unwind continue];
       }
   
diff --git a/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-abort.diff b/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-abort.diff
index 8df4408690b74..13bc54424d1db 100644
--- a/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-abort.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           _0 = <dyn Cache<V = V> as Cache>::store_nocache(move _2) -> [return: bb1, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-unwind.diff b/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-unwind.diff
index 43a0621f766d4..35d4db3780275 100644
--- a/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/dyn_trait.mk_cycle.Inline.panic-unwind.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           _0 = <dyn Cache<V = V> as Cache>::store_nocache(move _2) -> [return: bb1, unwind continue];
       }
   
diff --git a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff
index e72c312f54966..f02ca6233173f 100644
--- a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-abort.diff
@@ -13,7 +13,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = move _3 as &dyn Cache<V = <C as Cache>::V> (PointerCoercion(Unsize));
           StorageDead(_3);
 -         _0 = mk_cycle::<<C as Cache>::V>(move _2) -> [return: bb1, unwind unreachable];
diff --git a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff
index 46728f9e2e659..31080dff4ded7 100644
--- a/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/dyn_trait.try_execute_query.Inline.panic-unwind.diff
@@ -13,7 +13,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = move _3 as &dyn Cache<V = <C as Cache>::V> (PointerCoercion(Unsize));
           StorageDead(_3);
 -         _0 = mk_cycle::<<C as Cache>::V>(move _2) -> [return: bb1, unwind continue];
diff --git a/tests/mir-opt/inline/inline_any_operand.bar.Inline.after.mir b/tests/mir-opt/inline/inline_any_operand.bar.Inline.after.mir
index 2d0b71e0a645b..0ee5968419a06 100644
--- a/tests/mir-opt/inline/inline_any_operand.bar.Inline.after.mir
+++ b/tests/mir-opt/inline/inline_any_operand.bar.Inline.after.mir
@@ -18,12 +18,12 @@ fn bar() -> bool {
         StorageLive(_1);
         _1 = foo;
         StorageLive(_2);
-        _2 = _1;
+        _2 = copy _1;
         StorageLive(_3);
         _3 = const 1_i32;
         StorageLive(_4);
         _4 = const -1_i32;
-        _0 = Eq(_3, _4);
+        _0 = Eq(copy _3, copy _4);
         StorageDead(_4);
         StorageDead(_3);
         StorageDead(_2);
diff --git a/tests/mir-opt/inline/inline_closure.foo.Inline.after.mir b/tests/mir-opt/inline/inline_closure.foo.Inline.after.mir
index 8a60f4b1bdc6f..5bc227c87df17 100644
--- a/tests/mir-opt/inline/inline_closure.foo.Inline.after.mir
+++ b/tests/mir-opt/inline/inline_closure.foo.Inline.after.mir
@@ -26,15 +26,15 @@ fn foo(_1: T, _2: i32) -> i32 {
         _4 = &_3;
         StorageLive(_5);
         StorageLive(_6);
-        _6 = _2;
+        _6 = copy _2;
         StorageLive(_7);
-        _7 = _2;
+        _7 = copy _2;
         _5 = (move _6, move _7);
         StorageLive(_8);
         _8 = move (_5.0: i32);
         StorageLive(_9);
         _9 = move (_5.1: i32);
-        _0 = _8;
+        _0 = copy _8;
         StorageDead(_9);
         StorageDead(_8);
         StorageDead(_7);
diff --git a/tests/mir-opt/inline/inline_closure_borrows_arg.foo.Inline.after.mir b/tests/mir-opt/inline/inline_closure_borrows_arg.foo.Inline.after.mir
index f524b054b61bd..7930111cf2296 100644
--- a/tests/mir-opt/inline/inline_closure_borrows_arg.foo.Inline.after.mir
+++ b/tests/mir-opt/inline/inline_closure_borrows_arg.foo.Inline.after.mir
@@ -26,15 +26,15 @@ fn foo(_1: T, _2: &i32) -> i32 {
         _4 = &_3;
         StorageLive(_5);
         StorageLive(_6);
-        _6 = _2;
+        _6 = copy _2;
         StorageLive(_7);
-        _7 = _2;
+        _7 = copy _2;
         _5 = (move _6, move _7);
         StorageLive(_8);
         _8 = move (_5.0: &i32);
         StorageLive(_9);
         _9 = move (_5.1: &i32);
-        _0 = (*_8);
+        _0 = copy (*_8);
         StorageDead(_9);
         StorageDead(_8);
         StorageDead(_7);
diff --git a/tests/mir-opt/inline/inline_closure_captures.foo.Inline.after.mir b/tests/mir-opt/inline/inline_closure_captures.foo.Inline.after.mir
index 2f9d28ea09376..17e6e39a86bc7 100644
--- a/tests/mir-opt/inline/inline_closure_captures.foo.Inline.after.mir
+++ b/tests/mir-opt/inline/inline_closure_captures.foo.Inline.after.mir
@@ -34,18 +34,18 @@ fn foo(_1: T, _2: i32) -> (i32, T) {
         _6 = &_3;
         StorageLive(_7);
         StorageLive(_8);
-        _8 = _2;
+        _8 = copy _2;
         _7 = (move _8,);
         StorageLive(_9);
         _9 = move (_7.0: i32);
         StorageLive(_10);
         StorageLive(_12);
         StorageLive(_11);
-        _10 = ((*_6).0: &i32);
-        _11 = (*_10);
+        _10 = copy ((*_6).0: &i32);
+        _11 = copy (*_10);
         StorageLive(_13);
-        _12 = ((*_6).1: &T);
-        _13 = (*_12);
+        _12 = copy ((*_6).1: &T);
+        _13 = copy (*_12);
         _0 = (move _11, move _13);
         StorageDead(_13);
         StorageDead(_11);
diff --git a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff
index 07031a298bc36..94017f028cccf 100644
--- a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-abort.diff
@@ -34,13 +34,13 @@
 -         _4 = g() -> [return: bb1, unwind unreachable];
 +         _4 = {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8 (#0)};
 +         _3 = &mut _4;
-+         _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: _3 };
++         _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: copy _3 };
 +         StorageDead(_3);
 +         StorageLive(_5);
 +         _5 = const false;
 +         StorageLive(_6);
 +         StorageLive(_7);
-+         _6 = (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8});
++         _6 = copy (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8});
 +         _7 = discriminant((*_6));
 +         switchInt(move _7) -> [0: bb3, 1: bb7, 3: bb8, otherwise: bb9];
       }
@@ -68,7 +68,7 @@
 -         StorageDead(_2);
 -         drop(_4) -> [return: bb4, unwind unreachable];
 +         StorageLive(_8);
-+         switchInt(_5) -> [0: bb4, otherwise: bb5];
++         switchInt(copy _5) -> [0: bb4, otherwise: bb5];
       }
   
       bb4: {
@@ -99,7 +99,7 @@
 +     bb8: {
 +         StorageLive(_8);
 +         StorageDead(_8);
-+         _1 = CoroutineState::<i32, bool>::Complete(_5);
++         _1 = CoroutineState::<i32, bool>::Complete(copy _5);
 +         discriminant((*_6)) = 1;
 +         goto -> bb2;
 +     }
diff --git a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff
index ab6c62b0baf56..858f9ace9b40a 100644
--- a/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_coroutine.main.Inline.panic-unwind.diff
@@ -34,13 +34,13 @@
 -         _4 = g() -> [return: bb1, unwind continue];
 +         _4 = {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8 (#0)};
 +         _3 = &mut _4;
-+         _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: _3 };
++         _2 = Pin::<&mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8}> { __pointer: copy _3 };
 +         StorageDead(_3);
 +         StorageLive(_5);
 +         _5 = const false;
 +         StorageLive(_6);
 +         StorageLive(_7);
-+         _6 = (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8});
++         _6 = copy (_2.0: &mut {coroutine@$DIR/inline_coroutine.rs:20:5: 20:8});
 +         _7 = discriminant((*_6));
 +         switchInt(move _7) -> [0: bb5, 1: bb9, 3: bb10, otherwise: bb11];
       }
@@ -84,7 +84,7 @@
 -         drop(_4) -> [return: bb6, unwind terminate(cleanup)];
 +     bb5: {
 +         StorageLive(_8);
-+         switchInt(_5) -> [0: bb6, otherwise: bb7];
++         switchInt(copy _5) -> [0: bb6, otherwise: bb7];
       }
   
 -     bb6 (cleanup): {
@@ -113,7 +113,7 @@
 +     bb10: {
 +         StorageLive(_8);
 +         StorageDead(_8);
-+         _1 = CoroutineState::<i32, bool>::Complete(_5);
++         _1 = CoroutineState::<i32, bool>::Complete(copy _5);
 +         discriminant((*_6)) = 1;
 +         goto -> bb4;
 +     }
diff --git a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff
index d675695eb1047..bda855865153a 100644
--- a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-abort.diff
@@ -16,7 +16,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = Gt(move _3, const 0_i32);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
       }
@@ -24,7 +24,7 @@
       bb1: {
           StorageDead(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           _0 = move _4 as u32 (IntToInt);
           StorageDead(_4);
           StorageDead(_2);
diff --git a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff
index 1142616115fb7..ecd72d2b37fa9 100644
--- a/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_diverging.g.Inline.panic-unwind.diff
@@ -16,7 +16,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = Gt(move _3, const 0_i32);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
       }
@@ -24,7 +24,7 @@
       bb1: {
           StorageDead(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           _0 = move _4 as u32 (IntToInt);
           StorageDead(_4);
           StorageDead(_2);
diff --git a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff
index 2bbb830fc7790..338dca85e5c9f 100644
--- a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-abort.diff
@@ -40,7 +40,7 @@
 + 
 +     bb2: {
 +         StorageDead(_5);
-+         _1 = (_4, _6);
++         _1 = (copy _4, copy _6);
 +         drop(_2) -> [return: bb3, unwind unreachable];
 +     }
 + 
diff --git a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff
index bc4f2d24df0b5..a77cb913bfd03 100644
--- a/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_diverging.h.Inline.panic-unwind.diff
@@ -43,7 +43,7 @@
 +         StorageDead(_5);
 +         StorageLive(_7);
 +         _7 = move _4;
-+         _1 = (move _7, _6);
++         _1 = (move _7, copy _6);
 +         StorageDead(_7);
 +         StorageDead(_4);
 +         drop(_2) -> [return: bb3, unwind continue];
diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-abort.mir
index 522f772c6f48e..9b28aeb271df3 100644
--- a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-abort.mir
+++ b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-abort.mir
@@ -9,7 +9,7 @@ fn marked_inline_direct(_1: i32) -> () {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
+        _3 = copy _1;
         _2 = call_twice(move _3) -> [return: bb1, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-unwind.mir
index 722b02eeba806..929c89940dcb5 100644
--- a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_direct.Inline.after.panic-unwind.mir
@@ -9,7 +9,7 @@ fn marked_inline_direct(_1: i32) -> () {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
+        _3 = copy _1;
         _2 = call_twice(move _3) -> [return: bb1, unwind continue];
     }
 
diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-abort.mir
index 63b91cbce2d60..374ed294d8b26 100644
--- a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-abort.mir
+++ b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-abort.mir
@@ -12,7 +12,7 @@ fn marked_inline_indirect(_1: i32) -> () {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
+        _3 = copy _1;
         StorageLive(_4);
         _4 = call_twice(move _3) -> [return: bb1, unwind unreachable];
     }
diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-unwind.mir
index 7c84e98dd516c..97bed8020bad7 100644
--- a/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/inline_more_in_non_inline.marked_inline_indirect.Inline.after.panic-unwind.mir
@@ -12,7 +12,7 @@ fn marked_inline_indirect(_1: i32) -> () {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
+        _3 = copy _1;
         StorageLive(_4);
         _4 = call_twice(move _3) -> [return: bb1, unwind continue];
     }
diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-abort.mir
index 989014b8b476d..cffe0e96f5c94 100644
--- a/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-abort.mir
+++ b/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-abort.mir
@@ -13,10 +13,10 @@ fn monomorphic_not_inline(_1: i32) -> () {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
+        _3 = copy _1;
         StorageLive(_4);
         StorageLive(_5);
-        _4 = other_thing(_3) -> [return: bb2, unwind unreachable];
+        _4 = other_thing(copy _3) -> [return: bb2, unwind unreachable];
     }
 
     bb1: {
diff --git a/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-unwind.mir
index bd200719bbbe9..7f3a093012bcd 100644
--- a/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/inline_more_in_non_inline.monomorphic_not_inline.Inline.after.panic-unwind.mir
@@ -13,10 +13,10 @@ fn monomorphic_not_inline(_1: i32) -> () {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
+        _3 = copy _1;
         StorageLive(_4);
         StorageLive(_5);
-        _4 = other_thing(_3) -> [return: bb2, unwind continue];
+        _4 = other_thing(copy _3) -> [return: bb2, unwind continue];
     }
 
     bb1: {
diff --git a/tests/mir-opt/inline/inline_retag.bar.Inline.after.mir b/tests/mir-opt/inline/inline_retag.bar.Inline.after.mir
index ec3c79e2a3749..9a256ea19496a 100644
--- a/tests/mir-opt/inline/inline_retag.bar.Inline.after.mir
+++ b/tests/mir-opt/inline/inline_retag.bar.Inline.after.mir
@@ -26,25 +26,25 @@ fn bar() -> bool {
         StorageLive(_1);
         _1 = foo;
         StorageLive(_2);
-        _2 = _1;
+        _2 = copy _1;
         StorageLive(_3);
         StorageLive(_4);
         _10 = const bar::promoted[1];
         Retag(_10);
-        _4 = _10;
-        _3 = _4;
+        _4 = copy _10;
+        _3 = copy _4;
         StorageLive(_6);
         StorageLive(_7);
         _9 = const bar::promoted[0];
         Retag(_9);
-        _7 = _9;
-        _6 = _7;
+        _7 = copy _9;
+        _6 = copy _7;
         Retag(_3);
         Retag(_6);
         StorageLive(_11);
-        _11 = (*_3);
+        _11 = copy (*_3);
         StorageLive(_12);
-        _12 = (*_6);
+        _12 = copy (*_6);
         _0 = Eq(move _11, move _12);
         StorageDead(_12);
         StorageDead(_11);
diff --git a/tests/mir-opt/inline/inline_shims.clone.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_shims.clone.Inline.panic-abort.diff
index 8117e58fa51a3..26b4dc357f337 100644
--- a/tests/mir-opt/inline/inline_shims.clone.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_shims.clone.Inline.panic-abort.diff
@@ -15,7 +15,7 @@
 -     }
 - 
 -     bb1: {
-+         _0 = (*_2);
++         _0 = copy (*_2);
           StorageDead(_2);
           return;
       }
diff --git a/tests/mir-opt/inline/inline_shims.clone.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_shims.clone.Inline.panic-unwind.diff
index 00e92a0f5e5af..faa12d5c73605 100644
--- a/tests/mir-opt/inline/inline_shims.clone.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_shims.clone.Inline.panic-unwind.diff
@@ -15,7 +15,7 @@
 -     }
 - 
 -     bb1: {
-+         _0 = (*_2);
++         _0 = copy (*_2);
           StorageDead(_2);
           return;
       }
diff --git a/tests/mir-opt/inline/inline_shims.drop.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_shims.drop.Inline.panic-abort.diff
index 2a36ccaab110a..581244074b36c 100644
--- a/tests/mir-opt/inline/inline_shims.drop.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/inline_shims.drop.Inline.panic-abort.diff
@@ -20,7 +20,7 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         _3 = std::ptr::drop_in_place::<Vec<A>>(move _4) -> [return: bb1, unwind unreachable];
 +         StorageLive(_6);
 +         StorageLive(_7);
@@ -34,7 +34,7 @@
           StorageDead(_4);
           StorageDead(_3);
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _0 = std::ptr::drop_in_place::<Option<B>>(move _5) -> [return: bb2, unwind unreachable];
 +         StorageLive(_8);
 +         StorageLive(_9);
diff --git a/tests/mir-opt/inline/inline_shims.drop.Inline.panic-unwind.diff b/tests/mir-opt/inline/inline_shims.drop.Inline.panic-unwind.diff
index e11561076e641..d89ca003d77b3 100644
--- a/tests/mir-opt/inline/inline_shims.drop.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/inline_shims.drop.Inline.panic-unwind.diff
@@ -16,7 +16,7 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           _3 = std::ptr::drop_in_place::<Vec<A>>(move _4) -> [return: bb1, unwind continue];
       }
   
@@ -24,7 +24,7 @@
           StorageDead(_4);
           StorageDead(_3);
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _0 = std::ptr::drop_in_place::<Option<B>>(move _5) -> [return: bb2, unwind continue];
 +         StorageLive(_6);
 +         StorageLive(_7);
diff --git a/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-abort.mir
index d7b4302b06d9f..8355cd0070de3 100644
--- a/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-abort.mir
+++ b/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-abort.mir
@@ -7,7 +7,7 @@ fn test(_1: &dyn X) -> u32 {
 
     bb0: {
         StorageLive(_2);
-        _2 = _1;
+        _2 = copy _1;
         _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-unwind.mir
index 0d6f3e61f71f3..ebfbfeb0b13eb 100644
--- a/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/inline_trait_method.test.Inline.after.panic-unwind.mir
@@ -7,7 +7,7 @@ fn test(_1: &dyn X) -> u32 {
 
     bb0: {
         StorageLive(_2);
-        _2 = _1;
+        _2 = copy _1;
         _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind continue];
     }
 
diff --git a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir
index af79c7ce1968a..1105dba06ac41 100644
--- a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir
+++ b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-abort.mir
@@ -12,7 +12,7 @@ fn test2(_1: &dyn X) -> bool {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
+        _3 = copy _1;
         _2 = move _3;
         StorageDead(_3);
         _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind unreachable];
diff --git a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir
index bf5a56b8e6240..faa6ef47b18a4 100644
--- a/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/inline_trait_method_2.test2.Inline.after.panic-unwind.mir
@@ -12,7 +12,7 @@ fn test2(_1: &dyn X) -> bool {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
+        _3 = copy _1;
         _2 = move _3;
         StorageDead(_3);
         _0 = <dyn X as X>::y(move _2) -> [return: bb1, unwind continue];
diff --git a/tests/mir-opt/inline/issue_106141.outer.Inline.panic-abort.diff b/tests/mir-opt/inline/issue_106141.outer.Inline.panic-abort.diff
index 2ab79cc2a509e..e87a565f0fc98 100644
--- a/tests/mir-opt/inline/issue_106141.outer.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/issue_106141.outer.Inline.panic-abort.diff
@@ -25,12 +25,12 @@
   
       bb1: {
 +         StorageLive(_3);
-+         _2 = Lt(_0, const 1_usize);
-+         assert(move _2, "index out of bounds: the length is {} but the index is {}", const 1_usize, _0) -> [success: bb2, unwind unreachable];
++         _2 = Lt(copy _0, const 1_usize);
++         assert(move _2, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _0) -> [success: bb2, unwind unreachable];
 +     }
 + 
 +     bb2: {
-+         _3 = (*_1)[_0];
++         _3 = copy (*_1)[_0];
 +         switchInt(move _3) -> [0: bb3, otherwise: bb4];
 +     }
 + 
diff --git a/tests/mir-opt/inline/issue_106141.outer.Inline.panic-unwind.diff b/tests/mir-opt/inline/issue_106141.outer.Inline.panic-unwind.diff
index 4d96a86288596..834851b75adf1 100644
--- a/tests/mir-opt/inline/issue_106141.outer.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/issue_106141.outer.Inline.panic-unwind.diff
@@ -25,12 +25,12 @@
   
       bb1: {
 +         StorageLive(_3);
-+         _2 = Lt(_0, const 1_usize);
-+         assert(move _2, "index out of bounds: the length is {} but the index is {}", const 1_usize, _0) -> [success: bb2, unwind continue];
++         _2 = Lt(copy _0, const 1_usize);
++         assert(move _2, "index out of bounds: the length is {} but the index is {}", const 1_usize, copy _0) -> [success: bb2, unwind continue];
 +     }
 + 
 +     bb2: {
-+         _3 = (*_1)[_0];
++         _3 = copy (*_1)[_0];
 +         switchInt(move _3) -> [0: bb3, otherwise: bb4];
 +     }
 + 
diff --git a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.a.Inline.after.mir b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.a.Inline.after.mir
index 8c457037ec971..a48a9a0bb0c46 100644
--- a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.a.Inline.after.mir
+++ b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.a.Inline.after.mir
@@ -14,11 +14,11 @@ fn a(_1: &mut [T]) -> &mut [T] {
         StorageLive(_2);
         StorageLive(_3);
         StorageLive(_4);
-        _4 = _1;
-        _3 = _4;
-        _2 = _3;
+        _4 = copy _1;
+        _3 = copy _4;
+        _2 = copy _3;
         StorageDead(_4);
-        _0 = _2;
+        _0 = copy _2;
         StorageDead(_3);
         StorageDead(_2);
         return;
diff --git a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.b.Inline.after.mir b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.b.Inline.after.mir
index e27d9fe38c7e2..02aadfc1de064 100644
--- a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.b.Inline.after.mir
+++ b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.b.Inline.after.mir
@@ -16,17 +16,17 @@ fn b(_1: &mut Box<T>) -> &mut T {
         StorageLive(_2);
         StorageLive(_3);
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         StorageLive(_5);
         StorageLive(_6);
-        _5 = (*_4);
-        _6 = (((_5.0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>).0: *const T);
+        _5 = copy (*_4);
+        _6 = copy (((_5.0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>).0: *const T);
         _3 = &mut (*_6);
         StorageDead(_6);
         StorageDead(_5);
-        _2 = _3;
+        _2 = copy _3;
         StorageDead(_4);
-        _0 = _2;
+        _0 = copy _2;
         StorageDead(_3);
         StorageDead(_2);
         return;
diff --git a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.c.Inline.after.mir b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.c.Inline.after.mir
index da0464c64d697..2d88f9e55249f 100644
--- a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.c.Inline.after.mir
+++ b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.c.Inline.after.mir
@@ -12,9 +12,9 @@ fn c(_1: &[T]) -> &[T] {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
-        _2 = _3;
-        _0 = _2;
+        _3 = copy _1;
+        _2 = copy _3;
+        _0 = copy _2;
         StorageDead(_3);
         StorageDead(_2);
         return;
diff --git a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.d.Inline.after.mir b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.d.Inline.after.mir
index 25eaedfc842d2..1ea347510fdb4 100644
--- a/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.d.Inline.after.mir
+++ b/tests/mir-opt/inline/issue_58867_inline_as_ref_as_mut.d.Inline.after.mir
@@ -14,15 +14,15 @@ fn d(_1: &Box<T>) -> &T {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = _1;
+        _3 = copy _1;
         StorageLive(_4);
         StorageLive(_5);
-        _4 = (*_3);
-        _5 = (((_4.0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>).0: *const T);
+        _4 = copy (*_3);
+        _5 = copy (((_4.0: std::ptr::Unique<T>).0: std::ptr::NonNull<T>).0: *const T);
         _2 = &(*_5);
         StorageDead(_5);
         StorageDead(_4);
-        _0 = _2;
+        _0 = copy _2;
         StorageDead(_3);
         StorageDead(_2);
         return;
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff
index 0d9d58316ea19..f36157a762c27 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-abort.diff
@@ -18,9 +18,9 @@
   
       bb0: {
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _0 = core::num::<impl u16>::unchecked_shl(move _3, move _4) -> [return: bb1, unwind unreachable];
 +         StorageLive(_6);
 +         StorageLive(_5);
@@ -29,12 +29,12 @@
       }
   
       bb1: {
-+         _6 = core::num::<impl u16>::unchecked_shl::precondition_check(_4) -> [return: bb2, unwind unreachable];
++         _6 = core::num::<impl u16>::unchecked_shl::precondition_check(copy _4) -> [return: bb2, unwind unreachable];
 +     }
 + 
 +     bb2: {
 +         StorageDead(_5);
-+         _0 = ShlUnchecked(_3, _4);
++         _0 = ShlUnchecked(copy _3, copy _4);
 +         StorageDead(_6);
           StorageDead(_4);
           StorageDead(_3);
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff
index 82f7eceaa1808..be1b066c6c1b4 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.Inline.panic-unwind.diff
@@ -18,9 +18,9 @@
   
       bb0: {
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _0 = core::num::<impl u16>::unchecked_shl(move _3, move _4) -> [return: bb1, unwind continue];
 +         StorageLive(_6);
 +         StorageLive(_5);
@@ -29,12 +29,12 @@
       }
   
       bb1: {
-+         _6 = core::num::<impl u16>::unchecked_shl::precondition_check(_4) -> [return: bb2, unwind unreachable];
++         _6 = core::num::<impl u16>::unchecked_shl::precondition_check(copy _4) -> [return: bb2, unwind unreachable];
 +     }
 + 
 +     bb2: {
 +         StorageDead(_5);
-+         _0 = ShlUnchecked(_3, _4);
++         _0 = ShlUnchecked(copy _3, copy _4);
 +         StorageDead(_6);
           StorageDead(_4);
           StorageDead(_3);
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir
index dc27685ee79b2..611273ab08d74 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-abort.mir
@@ -12,7 +12,7 @@ fn unchecked_shl_unsigned_smaller(_1: u16, _2: u32) -> u16 {
     }
 
     bb0: {
-        _0 = ShlUnchecked(_1, _2);
+        _0 = ShlUnchecked(copy _1, copy _2);
         return;
     }
 }
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir
index dc27685ee79b2..611273ab08d74 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shl_unsigned_smaller.PreCodegen.after.panic-unwind.mir
@@ -12,7 +12,7 @@ fn unchecked_shl_unsigned_smaller(_1: u16, _2: u32) -> u16 {
     }
 
     bb0: {
-        _0 = ShlUnchecked(_1, _2);
+        _0 = ShlUnchecked(copy _1, copy _2);
         return;
     }
 }
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-abort.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-abort.diff
index 6894b24669908..360687f3c4e7f 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-abort.diff
@@ -18,9 +18,9 @@
   
       bb0: {
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _0 = core::num::<impl i64>::unchecked_shr(move _3, move _4) -> [return: bb1, unwind unreachable];
 +         StorageLive(_6);
 +         StorageLive(_5);
@@ -29,12 +29,12 @@
       }
   
       bb1: {
-+         _6 = core::num::<impl i64>::unchecked_shr::precondition_check(_4) -> [return: bb2, unwind unreachable];
++         _6 = core::num::<impl i64>::unchecked_shr::precondition_check(copy _4) -> [return: bb2, unwind unreachable];
 +     }
 + 
 +     bb2: {
 +         StorageDead(_5);
-+         _0 = ShrUnchecked(_3, _4);
++         _0 = ShrUnchecked(copy _3, copy _4);
 +         StorageDead(_6);
           StorageDead(_4);
           StorageDead(_3);
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-unwind.diff b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-unwind.diff
index 070f4a1c5c835..986df55df0372 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.Inline.panic-unwind.diff
@@ -18,9 +18,9 @@
   
       bb0: {
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _0 = core::num::<impl i64>::unchecked_shr(move _3, move _4) -> [return: bb1, unwind continue];
 +         StorageLive(_6);
 +         StorageLive(_5);
@@ -29,12 +29,12 @@
       }
   
       bb1: {
-+         _6 = core::num::<impl i64>::unchecked_shr::precondition_check(_4) -> [return: bb2, unwind unreachable];
++         _6 = core::num::<impl i64>::unchecked_shr::precondition_check(copy _4) -> [return: bb2, unwind unreachable];
 +     }
 + 
 +     bb2: {
 +         StorageDead(_5);
-+         _0 = ShrUnchecked(_3, _4);
++         _0 = ShrUnchecked(copy _3, copy _4);
 +         StorageDead(_6);
           StorageDead(_4);
           StorageDead(_3);
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-abort.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-abort.mir
index 54f093b87d19f..f4ddd0bca04d9 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-abort.mir
@@ -12,7 +12,7 @@ fn unchecked_shr_signed_bigger(_1: i64, _2: u32) -> i64 {
     }
 
     bb0: {
-        _0 = ShrUnchecked(_1, _2);
+        _0 = ShrUnchecked(copy _1, copy _2);
         return;
     }
 }
diff --git a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-unwind.mir
index 54f093b87d19f..f4ddd0bca04d9 100644
--- a/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/unchecked_shifts.unchecked_shr_signed_bigger.PreCodegen.after.panic-unwind.mir
@@ -12,7 +12,7 @@ fn unchecked_shr_signed_bigger(_1: i64, _2: u32) -> i64 {
     }
 
     bb0: {
-        _0 = ShrUnchecked(_1, _2);
+        _0 = ShrUnchecked(copy _1, copy _2);
         return;
     }
 }
diff --git a/tests/mir-opt/inline/unsized_argument.caller.Inline.diff b/tests/mir-opt/inline/unsized_argument.caller.Inline.diff
index 37083973fd159..70671e2089a01 100644
--- a/tests/mir-opt/inline/unsized_argument.caller.Inline.diff
+++ b/tests/mir-opt/inline/unsized_argument.caller.Inline.diff
@@ -12,7 +12,7 @@
           StorageLive(_2);
           StorageLive(_3);
           _3 = move _1;
-          _4 = (((_3.0: std::ptr::Unique<[i32]>).0: std::ptr::NonNull<[i32]>).0: *const [i32]);
+          _4 = copy (((_3.0: std::ptr::Unique<[i32]>).0: std::ptr::NonNull<[i32]>).0: *const [i32]);
           _2 = callee(move (*_4)) -> [return: bb1, unwind: bb3];
       }
   
diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-abort.diff b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-abort.diff
index c1f7879cf0e8c..28878736ed7cd 100644
--- a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-abort.diff
@@ -36,7 +36,7 @@
 +     bb2: {
 +         StorageLive(_4);
 +         _4 = UbChecks();
-+         assume(_4);
++         assume(copy _4);
 +         _5 = unreachable_unchecked::precondition_check() -> [return: bb1, unwind unreachable];
 +     }
 + 
diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-unwind.diff b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-unwind.diff
index 5271e538dafe4..27b6bb6a5bb23 100644
--- a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.Inline.panic-unwind.diff
@@ -40,7 +40,7 @@
 +     bb2: {
 +         StorageLive(_4);
 +         _4 = UbChecks();
-+         assume(_4);
++         assume(copy _4);
 +         _5 = unreachable_unchecked::precondition_check() -> [return: bb1, unwind unreachable];
 +     }
 + 
diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-abort.mir b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-abort.mir
index dcab8a679a875..66ab5e1b96228 100644
--- a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-abort.mir
@@ -22,7 +22,7 @@ fn unwrap_unchecked(_1: Option<T>) -> T {
     }
 
     bb1: {
-        _0 = ((_1 as Some).0: T);
+        _0 = copy ((_1 as Some).0: T);
         StorageDead(_2);
         return;
     }
diff --git a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-unwind.mir
index dcab8a679a875..66ab5e1b96228 100644
--- a/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/inline/unwrap_unchecked.unwrap_unchecked.PreCodegen.after.panic-unwind.mir
@@ -22,7 +22,7 @@ fn unwrap_unchecked(_1: Option<T>) -> T {
     }
 
     bb1: {
-        _0 = ((_1 as Some).0: T);
+        _0 = copy ((_1 as Some).0: T);
         StorageDead(_2);
         return;
     }
diff --git a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff
index f8715789cec14..1e33e222b27f6 100644
--- a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff
+++ b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff
@@ -85,7 +85,7 @@
 -     }
 - 
 -     bb2: {
-+         _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}> { __pointer: _5 };
++         _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}> { __pointer: copy _5 };
           StorageDead(_5);
           StorageLive(_6);
           StorageLive(_7);
@@ -160,7 +160,7 @@
 +         StorageLive(_14);
 +         _14 = ();
 +         StorageLive(_41);
-+         _41 = Option::<()>::Some(_14);
++         _41 = Option::<()>::Some(copy _14);
 +         _13 = std::future::Ready::<()>(move _41);
 +         StorageDead(_41);
 +         StorageDead(_14);
@@ -193,7 +193,7 @@
 +         StorageLive(_22);
 +         StorageLive(_23);
 +         StorageLive(_24);
-+         _24 = _31;
++         _24 = copy _31;
 +         _23 = move _24;
 +         _22 = &mut (*_23);
 +         StorageDead(_24);
@@ -231,8 +231,8 @@
 + 
 +     bb10: {
 +         StorageLive(_26);
-+         _26 = ((_18 as Ready).0: ());
-+         _30 = _26;
++         _26 = copy ((_18 as Ready).0: ());
++         _30 = copy _26;
 +         StorageDead(_26);
 +         StorageDead(_23);
 +         StorageDead(_21);
diff --git a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff
index 494f5591e3250..b1840beb3efcc 100644
--- a/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff
+++ b/tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff
@@ -87,7 +87,7 @@
 -     }
 - 
 -     bb2: {
-+         _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}> { __pointer: _5 };
++         _4 = Pin::<&mut {async fn body of ActionPermit<'_, T>::perform()}> { __pointer: copy _5 };
           StorageDead(_5);
           StorageLive(_6);
           StorageLive(_7);
@@ -177,7 +177,7 @@
 +         StorageLive(_14);
 +         _14 = ();
 +         StorageLive(_43);
-+         _43 = Option::<()>::Some(_14);
++         _43 = Option::<()>::Some(copy _14);
 +         _13 = std::future::Ready::<()>(move _43);
 +         StorageDead(_43);
 +         StorageDead(_14);
@@ -212,7 +212,7 @@
 +         StorageLive(_22);
 +         StorageLive(_23);
 +         StorageLive(_24);
-+         _24 = _31;
++         _24 = copy _31;
 +         _23 = move _24;
 +         _22 = &mut (*_23);
 +         StorageDead(_24);
@@ -250,8 +250,8 @@
 + 
 +     bb12: {
 +         StorageLive(_26);
-+         _26 = ((_18 as Ready).0: ());
-+         _30 = _26;
++         _26 = copy ((_18 as Ready).0: ());
++         _30 = copy _26;
 +         StorageDead(_26);
 +         StorageDead(_23);
 +         StorageDead(_21);
diff --git a/tests/mir-opt/instsimplify/bool_compare.eq_false.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.eq_false.InstSimplify-after-simplifycfg.diff
index fea5f4f02ceb9..4762123184b65 100644
--- a/tests/mir-opt/instsimplify/bool_compare.eq_false.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/bool_compare.eq_false.InstSimplify-after-simplifycfg.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Eq(move _3, const false);
 +         _2 = Not(move _3);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
diff --git a/tests/mir-opt/instsimplify/bool_compare.eq_true.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.eq_true.InstSimplify-after-simplifycfg.diff
index 9a509ccfa67b1..6fae0acf439d2 100644
--- a/tests/mir-opt/instsimplify/bool_compare.eq_true.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/bool_compare.eq_true.InstSimplify-after-simplifycfg.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Eq(move _3, const true);
 +         _2 = move _3;
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
diff --git a/tests/mir-opt/instsimplify/bool_compare.false_eq.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.false_eq.InstSimplify-after-simplifycfg.diff
index e4ec4c80579ed..7975a808d4f2b 100644
--- a/tests/mir-opt/instsimplify/bool_compare.false_eq.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/bool_compare.false_eq.InstSimplify-after-simplifycfg.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Eq(const false, move _3);
 +         _2 = Not(move _3);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
diff --git a/tests/mir-opt/instsimplify/bool_compare.false_ne.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.false_ne.InstSimplify-after-simplifycfg.diff
index 3aea55f4db4f2..80d0cd62007b4 100644
--- a/tests/mir-opt/instsimplify/bool_compare.false_ne.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/bool_compare.false_ne.InstSimplify-after-simplifycfg.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Ne(const false, move _3);
 +         _2 = move _3;
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
diff --git a/tests/mir-opt/instsimplify/bool_compare.ne_false.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.ne_false.InstSimplify-after-simplifycfg.diff
index b6e891088a1df..c0f8b5261c276 100644
--- a/tests/mir-opt/instsimplify/bool_compare.ne_false.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/bool_compare.ne_false.InstSimplify-after-simplifycfg.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Ne(move _3, const false);
 +         _2 = move _3;
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
diff --git a/tests/mir-opt/instsimplify/bool_compare.ne_true.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.ne_true.InstSimplify-after-simplifycfg.diff
index 974738bb3a9ee..4627b31440887 100644
--- a/tests/mir-opt/instsimplify/bool_compare.ne_true.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/bool_compare.ne_true.InstSimplify-after-simplifycfg.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Ne(move _3, const true);
 +         _2 = Not(move _3);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
diff --git a/tests/mir-opt/instsimplify/bool_compare.true_eq.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.true_eq.InstSimplify-after-simplifycfg.diff
index 240835bf7f22a..91ca1ba553e02 100644
--- a/tests/mir-opt/instsimplify/bool_compare.true_eq.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/bool_compare.true_eq.InstSimplify-after-simplifycfg.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Eq(const true, move _3);
 +         _2 = move _3;
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
diff --git a/tests/mir-opt/instsimplify/bool_compare.true_ne.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/bool_compare.true_ne.InstSimplify-after-simplifycfg.diff
index 1e2b2c27f5707..744c61b987d1a 100644
--- a/tests/mir-opt/instsimplify/bool_compare.true_ne.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/bool_compare.true_ne.InstSimplify-after-simplifycfg.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = Ne(const true, move _3);
 +         _2 = Not(move _3);
           switchInt(move _2) -> [0: bb2, otherwise: bb1];
diff --git a/tests/mir-opt/instsimplify/casts.redundant.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/casts.redundant.InstSimplify-after-simplifycfg.diff
index 7001589d9e3c8..afa25ecdbfba4 100644
--- a/tests/mir-opt/instsimplify/casts.redundant.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/casts.redundant.InstSimplify-after-simplifycfg.diff
@@ -15,16 +15,16 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _4;
+          _5 = copy _4;
 -         _3 = move _5 as *const &u8 (PtrToPtr);
 +         _3 = move _5;
           StorageDead(_5);
           StorageDead(_4);
 -         _2 = move _3 as *const &u8 (PtrToPtr);
 +         _2 = move _3;
-          _0 = _2;
+          _0 = copy _2;
           StorageDead(_3);
           StorageDead(_2);
           return;
diff --git a/tests/mir-opt/instsimplify/casts.roundtrip.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/casts.roundtrip.InstSimplify-after-simplifycfg.diff
index e1045db973078..12e2913a8ca8d 100644
--- a/tests/mir-opt/instsimplify/casts.roundtrip.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/casts.roundtrip.InstSimplify-after-simplifycfg.diff
@@ -12,7 +12,7 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           _3 = move _4 as *mut u8 (PtrToPtr);
           _2 = move _3 as *const u8 (PtrToPtr);
           StorageDead(_4);
diff --git a/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-abort.diff b/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-abort.diff
index a7de09ca38682..f39df7ffca0fb 100644
--- a/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-abort.diff
+++ b/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-abort.diff
@@ -31,38 +31,38 @@
           _3 = const 0_usize;
 -         _4 = Len(_1);
 +         _4 = const 2_usize;
-          _5 = Lt(_3, _4);
-          assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind unreachable];
+          _5 = Lt(copy _3, copy _4);
+          assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind unreachable];
       }
   
       bb1: {
-          _2 = _1[_3];
+          _2 = copy _1[_3];
           StorageDead(_3);
           StorageLive(_6);
           StorageLive(_7);
           _7 = const 1_usize;
 -         _8 = Len(_1);
 +         _8 = const 2_usize;
-          _9 = Lt(_7, _8);
-          assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb2, unwind unreachable];
+          _9 = Lt(copy _7, copy _8);
+          assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb2, unwind unreachable];
       }
   
       bb2: {
-          _6 = _1[_7];
+          _6 = copy _1[_7];
           StorageDead(_7);
           StorageLive(_10);
           StorageLive(_11);
-          _11 = _2;
+          _11 = copy _2;
           StorageLive(_12);
-          _12 = _2;
+          _12 = copy _2;
           _10 = Mul(move _11, move _12);
           StorageDead(_12);
           StorageDead(_11);
           StorageLive(_13);
           StorageLive(_14);
-          _14 = _6;
+          _14 = copy _6;
           StorageLive(_15);
-          _15 = _6;
+          _15 = copy _6;
           _13 = Mul(move _14, move _15);
           StorageDead(_15);
           StorageDead(_14);
diff --git a/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff b/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff
index c15f7e47fe36f..0e7d5653c6820 100644
--- a/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff
+++ b/tests/mir-opt/instsimplify/combine_array_len.norm2.InstSimplify-after-simplifycfg.panic-unwind.diff
@@ -31,38 +31,38 @@
           _3 = const 0_usize;
 -         _4 = Len(_1);
 +         _4 = const 2_usize;
-          _5 = Lt(_3, _4);
-          assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind continue];
+          _5 = Lt(copy _3, copy _4);
+          assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind continue];
       }
   
       bb1: {
-          _2 = _1[_3];
+          _2 = copy _1[_3];
           StorageDead(_3);
           StorageLive(_6);
           StorageLive(_7);
           _7 = const 1_usize;
 -         _8 = Len(_1);
 +         _8 = const 2_usize;
-          _9 = Lt(_7, _8);
-          assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb2, unwind continue];
+          _9 = Lt(copy _7, copy _8);
+          assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb2, unwind continue];
       }
   
       bb2: {
-          _6 = _1[_7];
+          _6 = copy _1[_7];
           StorageDead(_7);
           StorageLive(_10);
           StorageLive(_11);
-          _11 = _2;
+          _11 = copy _2;
           StorageLive(_12);
-          _12 = _2;
+          _12 = copy _2;
           _10 = Mul(move _11, move _12);
           StorageDead(_12);
           StorageDead(_11);
           StorageLive(_13);
           StorageLive(_14);
-          _14 = _6;
+          _14 = copy _6;
           StorageLive(_15);
-          _15 = _6;
+          _15 = copy _6;
           _13 = Mul(move _14, move _15);
           StorageDead(_15);
           StorageDead(_14);
diff --git a/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-abort.diff b/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-abort.diff
index c6f858d89eb2c..d0b50c597c4f7 100644
--- a/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-abort.diff
+++ b/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-abort.diff
@@ -20,7 +20,7 @@
           StorageLive(_4);
           _4 = &((*_1).0: T);
 -         _3 = &(*_4);
-+         _3 = _4;
++         _3 = copy _4;
           _2 = <T as Clone>::clone(move _3) -> [return: bb1, unwind unreachable];
       }
   
@@ -32,8 +32,8 @@
           _7 = &((*_1).1: u64);
 -         _6 = &(*_7);
 -         _5 = <u64 as Clone>::clone(move _6) -> [return: bb2, unwind unreachable];
-+         _6 = _7;
-+         _5 = (*_6);
++         _6 = copy _7;
++         _5 = copy (*_6);
 +         goto -> bb2;
       }
   
@@ -45,8 +45,8 @@
           _10 = &((*_1).2: [f32; 3]);
 -         _9 = &(*_10);
 -         _8 = <[f32; 3] as Clone>::clone(move _9) -> [return: bb3, unwind unreachable];
-+         _9 = _10;
-+         _8 = (*_9);
++         _9 = copy _10;
++         _8 = copy (*_9);
 +         goto -> bb3;
       }
   
diff --git a/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-unwind.diff b/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-unwind.diff
index 691ab1f0e7fb7..b8f4f348530a3 100644
--- a/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-unwind.diff
+++ b/tests/mir-opt/instsimplify/combine_clone_of_primitives.{impl#0}-clone.InstSimplify-after-simplifycfg.panic-unwind.diff
@@ -20,7 +20,7 @@
           StorageLive(_4);
           _4 = &((*_1).0: T);
 -         _3 = &(*_4);
-+         _3 = _4;
++         _3 = copy _4;
           _2 = <T as Clone>::clone(move _3) -> [return: bb1, unwind continue];
       }
   
@@ -32,8 +32,8 @@
           _7 = &((*_1).1: u64);
 -         _6 = &(*_7);
 -         _5 = <u64 as Clone>::clone(move _6) -> [return: bb2, unwind: bb4];
-+         _6 = _7;
-+         _5 = (*_6);
++         _6 = copy _7;
++         _5 = copy (*_6);
 +         goto -> bb2;
       }
   
@@ -45,8 +45,8 @@
           _10 = &((*_1).2: [f32; 3]);
 -         _9 = &(*_10);
 -         _8 = <[f32; 3] as Clone>::clone(move _9) -> [return: bb3, unwind: bb4];
-+         _9 = _10;
-+         _8 = (*_9);
++         _9 = copy _10;
++         _8 = copy (*_9);
 +         goto -> bb3;
       }
   
diff --git a/tests/mir-opt/instsimplify/duplicate_switch_targets.assert_zero.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/duplicate_switch_targets.assert_zero.InstSimplify-after-simplifycfg.diff
index 7596aa203086e..5d74f0f75db95 100644
--- a/tests/mir-opt/instsimplify/duplicate_switch_targets.assert_zero.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/duplicate_switch_targets.assert_zero.InstSimplify-after-simplifycfg.diff
@@ -5,8 +5,8 @@
       let mut _0: u8;
   
       bb0: {
--         switchInt(_1) -> [0: bb2, 1: bb1, otherwise: bb1];
-+         switchInt(_1) -> [0: bb2, otherwise: bb1];
+-         switchInt(copy _1) -> [0: bb2, 1: bb1, otherwise: bb1];
++         switchInt(copy _1) -> [0: bb2, otherwise: bb1];
       }
   
       bb1: {
@@ -14,7 +14,7 @@
       }
   
       bb2: {
-          _0 = _1;
+          _0 = copy _1;
           return;
       }
   }
diff --git a/tests/mir-opt/instsimplify/ref_of_deref.pointers.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/ref_of_deref.pointers.InstSimplify-after-simplifycfg.diff
index ca26f0240f9de..b2f720be9e166 100644
--- a/tests/mir-opt/instsimplify/ref_of_deref.pointers.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/ref_of_deref.pointers.InstSimplify-after-simplifycfg.diff
@@ -39,12 +39,12 @@
           _5 = &mut (*_2);
           StorageLive(_6);
 -         _6 = &raw const (*_1);
-+         _6 = _1;
++         _6 = copy _1;
           StorageLive(_7);
           _7 = &raw const (*_2);
           StorageLive(_8);
 -         _8 = &raw mut (*_2);
-+         _8 = _2;
++         _8 = copy _2;
           _0 = const ();
           StorageDead(_8);
           StorageDead(_7);
diff --git a/tests/mir-opt/instsimplify/ref_of_deref.references.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/ref_of_deref.references.InstSimplify-after-simplifycfg.diff
index 928ee3acaa028..4ea9da46c55d6 100644
--- a/tests/mir-opt/instsimplify/ref_of_deref.references.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/ref_of_deref.references.InstSimplify-after-simplifycfg.diff
@@ -33,12 +33,12 @@
       bb0: {
           StorageLive(_3);
 -         _3 = &(*_1);
-+         _3 = _1;
++         _3 = copy _1;
           StorageLive(_4);
           _4 = &(*_2);
           StorageLive(_5);
 -         _5 = &mut (*_2);
-+         _5 = _2;
++         _5 = copy _2;
           StorageLive(_6);
           _6 = &raw const (*_1);
           StorageLive(_7);
diff --git a/tests/mir-opt/instsimplify/ub_check.unwrap_unchecked.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/instsimplify/ub_check.unwrap_unchecked.InstSimplify-after-simplifycfg.diff
index 7ef77e76d1297..5fee9a6733dd0 100644
--- a/tests/mir-opt/instsimplify/ub_check.unwrap_unchecked.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/instsimplify/ub_check.unwrap_unchecked.InstSimplify-after-simplifycfg.diff
@@ -21,7 +21,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           StorageLive(_3);
           StorageLive(_5);
           _3 = discriminant(_2);
@@ -36,7 +36,7 @@
           StorageLive(_4);
 -         _4 = UbChecks();
 +         _4 = const false;
-          assume(_4);
+          assume(copy _4);
           _5 = unreachable_unchecked::precondition_check() -> [return: bb1, unwind unreachable];
       }
   
diff --git a/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff b/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff
index 311de9e1c93f3..ac88fe67bb86f 100644
--- a/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff
+++ b/tests/mir-opt/issue_101973.inner.GVN.panic-abort.diff
@@ -29,22 +29,22 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           nop;
 -         StorageLive(_14);
--         _14 = BitAnd(_5, const 255_u32);
+-         _14 = BitAnd(copy _5, const 255_u32);
 -         _4 = BitOr(const 0_u32, move _14);
 -         StorageDead(_14);
 +         nop;
-+         _14 = BitAnd(_1, const 255_u32);
-+         _4 = _14;
++         _14 = BitAnd(copy _1, const 255_u32);
++         _4 = copy _14;
 +         nop;
           StorageDead(_5);
           StorageLive(_6);
           StorageLive(_7);
           StorageLive(_8);
           StorageLive(_9);
-          _9 = _1;
+          _9 = copy _1;
 -         _10 = const 8_i32 as u32 (IntToInt);
 -         _11 = Lt(move _10, const 32_u32);
 -         assert(move _11, "attempt to shift right by `{}`, which would overflow", const 8_i32) -> [success: bb1, unwind unreachable];
@@ -55,7 +55,7 @@
   
       bb1: {
 -         _8 = Shr(move _9, const 8_i32);
-+         _8 = Shr(_1, const 8_i32);
++         _8 = Shr(copy _1, const 8_i32);
           StorageDead(_9);
           _7 = BitAnd(move _8, const 15_u32);
           StorageDead(_8);
@@ -71,7 +71,7 @@
           _6 = Shl(move _7, const 1_i32);
           StorageDead(_7);
 -         _3 = rotate_right::<u32>(move _4, move _6) -> [return: bb3, unwind unreachable];
-+         _3 = rotate_right::<u32>(_14, move _6) -> [return: bb3, unwind unreachable];
++         _3 = rotate_right::<u32>(copy _14, move _6) -> [return: bb3, unwind unreachable];
       }
   
       bb3: {
diff --git a/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff b/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff
index c5fd042161d27..96c3cae2d334a 100644
--- a/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff
+++ b/tests/mir-opt/issue_101973.inner.GVN.panic-unwind.diff
@@ -29,22 +29,22 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           nop;
 -         StorageLive(_14);
--         _14 = BitAnd(_5, const 255_u32);
+-         _14 = BitAnd(copy _5, const 255_u32);
 -         _4 = BitOr(const 0_u32, move _14);
 -         StorageDead(_14);
 +         nop;
-+         _14 = BitAnd(_1, const 255_u32);
-+         _4 = _14;
++         _14 = BitAnd(copy _1, const 255_u32);
++         _4 = copy _14;
 +         nop;
           StorageDead(_5);
           StorageLive(_6);
           StorageLive(_7);
           StorageLive(_8);
           StorageLive(_9);
-          _9 = _1;
+          _9 = copy _1;
 -         _10 = const 8_i32 as u32 (IntToInt);
 -         _11 = Lt(move _10, const 32_u32);
 -         assert(move _11, "attempt to shift right by `{}`, which would overflow", const 8_i32) -> [success: bb1, unwind continue];
@@ -55,7 +55,7 @@
   
       bb1: {
 -         _8 = Shr(move _9, const 8_i32);
-+         _8 = Shr(_1, const 8_i32);
++         _8 = Shr(copy _1, const 8_i32);
           StorageDead(_9);
           _7 = BitAnd(move _8, const 15_u32);
           StorageDead(_8);
@@ -71,7 +71,7 @@
           _6 = Shl(move _7, const 1_i32);
           StorageDead(_7);
 -         _3 = rotate_right::<u32>(move _4, move _6) -> [return: bb3, unwind unreachable];
-+         _3 = rotate_right::<u32>(_14, move _6) -> [return: bb3, unwind unreachable];
++         _3 = rotate_right::<u32>(copy _14, move _6) -> [return: bb3, unwind unreachable];
       }
   
       bb3: {
diff --git a/tests/mir-opt/issue_38669.main.SimplifyCfg-initial.after.mir b/tests/mir-opt/issue_38669.main.SimplifyCfg-initial.after.mir
index 632b5580656d6..66dbbc0c044b3 100644
--- a/tests/mir-opt/issue_38669.main.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/issue_38669.main.SimplifyCfg-initial.after.mir
@@ -25,7 +25,7 @@ fn main() -> () {
     bb2: {
         StorageLive(_3);
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         switchInt(move _4) -> [0: bb4, otherwise: bb3];
     }
 
diff --git a/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-abort.diff b/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-abort.diff
index 4469270a9b232..cf9522301281b 100644
--- a/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-abort.diff
+++ b/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-abort.diff
@@ -63,7 +63,7 @@
 +     }
 + 
 +     bb8 (cleanup): {
-+         switchInt(_5) -> [0: bb6, otherwise: bb7];
++         switchInt(copy _5) -> [0: bb6, otherwise: bb7];
       }
   }
   
diff --git a/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-unwind.diff b/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-unwind.diff
index 4469270a9b232..cf9522301281b 100644
--- a/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-unwind.diff
+++ b/tests/mir-opt/issue_41110.main.ElaborateDrops.panic-unwind.diff
@@ -63,7 +63,7 @@
 +     }
 + 
 +     bb8 (cleanup): {
-+         switchInt(_5) -> [0: bb6, otherwise: bb7];
++         switchInt(copy _5) -> [0: bb6, otherwise: bb7];
       }
   }
   
diff --git a/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-abort.diff b/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-abort.diff
index 78184f6aeeb1c..15fd95a63fff0 100644
--- a/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-abort.diff
+++ b/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-abort.diff
@@ -93,7 +93,7 @@
 +     }
 + 
 +     bb12 (cleanup): {
-+         switchInt(_6) -> [0: bb10, otherwise: bb11];
++         switchInt(copy _6) -> [0: bb10, otherwise: bb11];
       }
   }
   
diff --git a/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-unwind.diff b/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-unwind.diff
index 688887c3c1f52..4a0067981cb7a 100644
--- a/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-unwind.diff
+++ b/tests/mir-opt/issue_41110.test.ElaborateDrops.panic-unwind.diff
@@ -93,7 +93,7 @@
 +     }
 + 
 +     bb12 (cleanup): {
-+         switchInt(_6) -> [0: bb10, otherwise: bb11];
++         switchInt(copy _6) -> [0: bb10, otherwise: bb11];
       }
   }
   
diff --git a/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-abort.diff b/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-abort.diff
index 55d2629a5519c..e2726464ef3ad 100644
--- a/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-abort.diff
+++ b/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-abort.diff
@@ -115,7 +115,7 @@
 +     }
 + 
 +     bb15 (cleanup): {
-+         switchInt(_7) -> [0: bb12, otherwise: bb14];
++         switchInt(copy _7) -> [0: bb12, otherwise: bb14];
 +     }
 + 
 +     bb16: {
@@ -132,7 +132,7 @@
 +     }
 + 
 +     bb19: {
-+         switchInt(_7) -> [0: bb13, otherwise: bb18];
++         switchInt(copy _7) -> [0: bb13, otherwise: bb18];
 +     }
 + 
 +     bb20 (cleanup): {
@@ -141,7 +141,7 @@
 +     }
 + 
 +     bb21 (cleanup): {
-+         switchInt(_7) -> [0: bb12, otherwise: bb20];
++         switchInt(copy _7) -> [0: bb12, otherwise: bb20];
       }
   }
   
diff --git a/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-unwind.diff b/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-unwind.diff
index c731b5646f681..7efa3330e66a7 100644
--- a/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-unwind.diff
+++ b/tests/mir-opt/issue_41888.main.ElaborateDrops.panic-unwind.diff
@@ -115,7 +115,7 @@
 +     }
 + 
 +     bb15 (cleanup): {
-+         switchInt(_7) -> [0: bb12, otherwise: bb14];
++         switchInt(copy _7) -> [0: bb12, otherwise: bb14];
 +     }
 + 
 +     bb16: {
@@ -132,7 +132,7 @@
 +     }
 + 
 +     bb19: {
-+         switchInt(_7) -> [0: bb13, otherwise: bb18];
++         switchInt(copy _7) -> [0: bb13, otherwise: bb18];
 +     }
 + 
 +     bb20 (cleanup): {
@@ -141,7 +141,7 @@
 +     }
 + 
 +     bb21 (cleanup): {
-+         switchInt(_7) -> [0: bb12, otherwise: bb20];
++         switchInt(copy _7) -> [0: bb12, otherwise: bb20];
       }
   }
   
diff --git a/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-abort.mir b/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-abort.mir
index 3104baa5fdbd4..736a8bbca49c7 100644
--- a/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-abort.mir
+++ b/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-abort.mir
@@ -54,8 +54,8 @@ fn test() -> Option<Box<u32>> {
 
     bb4: {
         StorageLive(_12);
-        _12 = ((_6 as Continue).0: u32);
-        (*_5) = _12;
+        _12 = copy ((_6 as Continue).0: u32);
+        (*_5) = copy _12;
         StorageDead(_12);
         _1 = move _5;
         drop(_5) -> [return: bb7, unwind: bb11];
@@ -63,9 +63,9 @@ fn test() -> Option<Box<u32>> {
 
     bb5: {
         StorageLive(_9);
-        _9 = ((_6 as Break).0: std::option::Option<std::convert::Infallible>);
+        _9 = copy ((_6 as Break).0: std::option::Option<std::convert::Infallible>);
         StorageLive(_11);
-        _11 = _9;
+        _11 = copy _9;
         _0 = <Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual(move _11) -> [return: bb6, unwind: bb12];
     }
 
diff --git a/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-unwind.mir b/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-unwind.mir
index da33c83011516..1acb1ae20b698 100644
--- a/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-unwind.mir
+++ b/tests/mir-opt/issue_62289.test.ElaborateDrops.before.panic-unwind.mir
@@ -54,8 +54,8 @@ fn test() -> Option<Box<u32>> {
 
     bb4: {
         StorageLive(_12);
-        _12 = ((_6 as Continue).0: u32);
-        (*_5) = _12;
+        _12 = copy ((_6 as Continue).0: u32);
+        (*_5) = copy _12;
         StorageDead(_12);
         _1 = move _5;
         drop(_5) -> [return: bb7, unwind: bb11];
@@ -63,9 +63,9 @@ fn test() -> Option<Box<u32>> {
 
     bb5: {
         StorageLive(_9);
-        _9 = ((_6 as Break).0: std::option::Option<std::convert::Infallible>);
+        _9 = copy ((_6 as Break).0: std::option::Option<std::convert::Infallible>);
         StorageLive(_11);
-        _11 = _9;
+        _11 = copy _9;
         _0 = <Option<Box<u32>> as FromResidual<Option<Infallible>>>::from_residual(move _11) -> [return: bb6, unwind: bb12];
     }
 
diff --git a/tests/mir-opt/issue_72181.bar.built.after.mir b/tests/mir-opt/issue_72181.bar.built.after.mir
index b6cc7d2219569..569c4a0062829 100644
--- a/tests/mir-opt/issue_72181.bar.built.after.mir
+++ b/tests/mir-opt/issue_72181.bar.built.after.mir
@@ -9,8 +9,8 @@ fn bar(_1: [(Never, u32); 1]) -> u32 {
 
     bb0: {
         StorageLive(_2);
-        _2 = (_1[0 of 1].1: u32);
-        _0 = _2;
+        _2 = copy (_1[0 of 1].1: u32);
+        _0 = copy _2;
         StorageDead(_2);
         return;
     }
diff --git a/tests/mir-opt/issue_72181.foo.built.after.mir b/tests/mir-opt/issue_72181.foo.built.after.mir
index f78942cc56fdc..314cf8b367f57 100644
--- a/tests/mir-opt/issue_72181.foo.built.after.mir
+++ b/tests/mir-opt/issue_72181.foo.built.after.mir
@@ -11,12 +11,12 @@ fn foo(_1: [(Never, u32); 1]) -> u32 {
         StorageLive(_2);
         _2 = const 0_usize;
         _3 = Len(_1);
-        _4 = Lt(_2, _3);
-        assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, _2) -> [success: bb1, unwind: bb2];
+        _4 = Lt(copy _2, copy _3);
+        assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, copy _2) -> [success: bb1, unwind: bb2];
     }
 
     bb1: {
-        _0 = (_1[_2].1: u32);
+        _0 = copy (_1[_2].1: u32);
         StorageDead(_2);
         return;
     }
diff --git a/tests/mir-opt/issue_72181.main.built.after.mir b/tests/mir-opt/issue_72181.main.built.after.mir
index 89d351d5172ce..aade84a6dd2e8 100644
--- a/tests/mir-opt/issue_72181.main.built.after.mir
+++ b/tests/mir-opt/issue_72181.main.built.after.mir
@@ -39,8 +39,8 @@ fn main() -> () {
         StorageLive(_6);
         _6 = const 0_usize;
         _7 = Len(_2);
-        _8 = Lt(_6, _7);
-        assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, _6) -> [success: bb3, unwind: bb5];
+        _8 = Lt(copy _6, copy _7);
+        assert(move _8, "index out of bounds: the length is {} but the index is {}", move _7, copy _6) -> [success: bb3, unwind: bb5];
     }
 
     bb2: {
@@ -49,7 +49,7 @@ fn main() -> () {
     }
 
     bb3: {
-        _5 = (_2[_6].0: u64);
+        _5 = copy (_2[_6].0: u64);
         PlaceMention(_5);
         StorageDead(_6);
         StorageDead(_5);
diff --git a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
index 861ee1d3d3d46..f03691ad67316 100644
--- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
+++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff
@@ -24,9 +24,9 @@
   
       bb0: {
           StorageLive(_4);
-          _4 = [_1, _1, _1];
+          _4 = [copy _1, copy _1, copy _1];
           _3 = &_4;
-          _2 = _3 as &[T] (PointerCoercion(Unsize));
+          _2 = copy _3 as &[T] (PointerCoercion(Unsize));
           nop;
           nop;
           goto -> bb2;
diff --git a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
index f27be95338479..633e5c740a1a8 100644
--- a/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
+++ b/tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff
@@ -24,9 +24,9 @@
   
       bb0: {
           StorageLive(_4);
-          _4 = [_1, _1, _1];
+          _4 = [copy _1, copy _1, copy _1];
           _3 = &_4;
-          _2 = _3 as &[T] (PointerCoercion(Unsize));
+          _2 = copy _3 as &[T] (PointerCoercion(Unsize));
           nop;
           nop;
           goto -> bb2;
diff --git a/tests/mir-opt/issue_78192.f.InstSimplify-after-simplifycfg.diff b/tests/mir-opt/issue_78192.f.InstSimplify-after-simplifycfg.diff
index 53957bb3cb193..aae0570973df3 100644
--- a/tests/mir-opt/issue_78192.f.InstSimplify-after-simplifycfg.diff
+++ b/tests/mir-opt/issue_78192.f.InstSimplify-after-simplifycfg.diff
@@ -17,9 +17,9 @@
           StorageLive(_4);
           _4 = &raw const (*_1);
           _3 = &_4;
-          _2 = _3;
+          _2 = copy _3;
           StorageDead(_3);
-          _0 = (*_2);
+          _0 = copy (*_2);
           StorageDead(_4);
           StorageDead(_2);
           return;
diff --git a/tests/mir-opt/issue_91633.foo.built.after.mir b/tests/mir-opt/issue_91633.foo.built.after.mir
index a66769f0d112e..50fdf08375a00 100644
--- a/tests/mir-opt/issue_91633.foo.built.after.mir
+++ b/tests/mir-opt/issue_91633.foo.built.after.mir
@@ -18,8 +18,8 @@ fn foo(_1: Box<[T]>) -> T {
         StorageLive(_4);
         _4 = const 0_usize;
         _5 = Len((*_1));
-        _6 = Lt(_4, _5);
-        assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, _4) -> [success: bb1, unwind: bb5];
+        _6 = Lt(copy _4, copy _5);
+        assert(move _6, "index out of bounds: the length is {} but the index is {}", move _5, copy _4) -> [success: bb1, unwind: bb5];
     }
 
     bb1: {
diff --git a/tests/mir-opt/issue_91633.fun.built.after.mir b/tests/mir-opt/issue_91633.fun.built.after.mir
index 7175c9e800662..5b41b376719b2 100644
--- a/tests/mir-opt/issue_91633.fun.built.after.mir
+++ b/tests/mir-opt/issue_91633.fun.built.after.mir
@@ -16,8 +16,8 @@ fn fun(_1: &[T]) -> &T {
         StorageLive(_3);
         _3 = const 0_usize;
         _4 = Len((*_1));
-        _5 = Lt(_3, _4);
-        assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind: bb2];
+        _5 = Lt(copy _3, copy _4);
+        assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind: bb2];
     }
 
     bb1: {
diff --git a/tests/mir-opt/issue_99325.main.built.after.32bit.mir b/tests/mir-opt/issue_99325.main.built.after.32bit.mir
index 72e7f4794f980..161c73529f53c 100644
--- a/tests/mir-opt/issue_99325.main.built.after.32bit.mir
+++ b/tests/mir-opt/issue_99325.main.built.after.32bit.mir
@@ -83,9 +83,9 @@ fn main() -> () {
         StorageDead(_3);
         PlaceMention(_2);
         StorageLive(_8);
-        _8 = (_2.0: &&[u8]);
+        _8 = copy (_2.0: &&[u8]);
         StorageLive(_9);
-        _9 = (_2.1: &&[u8; 4]);
+        _9 = copy (_2.1: &&[u8; 4]);
         StorageLive(_10);
         StorageLive(_11);
         _11 = &(*_8);
@@ -187,9 +187,9 @@ fn main() -> () {
         StorageDead(_24);
         PlaceMention(_23);
         StorageLive(_28);
-        _28 = (_23.0: &&[u8]);
+        _28 = copy (_23.0: &&[u8]);
         StorageLive(_29);
-        _29 = (_23.1: &&[u8; 4]);
+        _29 = copy (_23.1: &&[u8; 4]);
         StorageLive(_30);
         StorageLive(_31);
         _31 = &(*_28);
diff --git a/tests/mir-opt/issue_99325.main.built.after.64bit.mir b/tests/mir-opt/issue_99325.main.built.after.64bit.mir
index 72e7f4794f980..161c73529f53c 100644
--- a/tests/mir-opt/issue_99325.main.built.after.64bit.mir
+++ b/tests/mir-opt/issue_99325.main.built.after.64bit.mir
@@ -83,9 +83,9 @@ fn main() -> () {
         StorageDead(_3);
         PlaceMention(_2);
         StorageLive(_8);
-        _8 = (_2.0: &&[u8]);
+        _8 = copy (_2.0: &&[u8]);
         StorageLive(_9);
-        _9 = (_2.1: &&[u8; 4]);
+        _9 = copy (_2.1: &&[u8; 4]);
         StorageLive(_10);
         StorageLive(_11);
         _11 = &(*_8);
@@ -187,9 +187,9 @@ fn main() -> () {
         StorageDead(_24);
         PlaceMention(_23);
         StorageLive(_28);
-        _28 = (_23.0: &&[u8]);
+        _28 = copy (_23.0: &&[u8]);
         StorageLive(_29);
-        _29 = (_23.1: &&[u8; 4]);
+        _29 = copy (_23.1: &&[u8; 4]);
         StorageLive(_30);
         StorageLive(_31);
         _31 = &(*_28);
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir
index 8da56d59aaa60..573c0a12bc1a7 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-abort.mir
@@ -19,7 +19,7 @@ fn num_to_digit(_1: char) -> u32 {
 
     bb0: {
         StorageLive(_2);
-        _2 = char::methods::<impl char>::to_digit(_1, const 8_u32) -> [return: bb1, unwind unreachable];
+        _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir
index 61bc09d901cbf..049803041d4e3 100644
--- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.panic-unwind.mir
@@ -19,7 +19,7 @@ fn num_to_digit(_1: char) -> u32 {
 
     bb0: {
         StorageLive(_2);
-        _2 = char::methods::<impl char>::to_digit(_1, const 8_u32) -> [return: bb1, unwind continue];
+        _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind continue];
     }
 
     bb1: {
diff --git a/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff b/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff
index 25ed1b4d0c764..1ab9be9665221 100644
--- a/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff
+++ b/tests/mir-opt/issues/issue_75439.foo.MatchBranchSimplification.diff
@@ -19,26 +19,26 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = move _3 as [u32; 4] (Transmute);
           StorageDead(_3);
-          switchInt(_2[0 of 4]) -> [0: bb1, otherwise: bb4];
+          switchInt(copy _2[0 of 4]) -> [0: bb1, otherwise: bb4];
       }
   
       bb1: {
-          switchInt(_2[1 of 4]) -> [0: bb2, otherwise: bb4];
+          switchInt(copy _2[1 of 4]) -> [0: bb2, otherwise: bb4];
       }
   
       bb2: {
-          switchInt(_2[2 of 4]) -> [0: bb3, 4294901760: bb3, otherwise: bb4];
+          switchInt(copy _2[2 of 4]) -> [0: bb3, 4294901760: bb3, otherwise: bb4];
       }
   
       bb3: {
           StorageLive(_4);
-          _4 = _2[3 of 4];
+          _4 = copy _2[3 of 4];
           StorageLive(_5);
           StorageLive(_6);
-          _6 = _4;
+          _6 = copy _4;
           _5 = move _6 as [u8; 4] (Transmute);
           StorageDead(_6);
           _0 = Option::<[u8; 4]>::Some(move _5);
diff --git a/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-abort.diff
index e955e66901437..a7551c3fb5b79 100644
--- a/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-abort.diff
@@ -18,13 +18,13 @@
           StorageLive(_4);
           _4 = const aggregate::FOO;
           StorageLive(_2);
-          _2 = (_4.0: u8);
+          _2 = copy (_4.0: u8);
           StorageLive(_3);
-          _3 = (_4.1: u8);
+          _3 = copy (_4.1: u8);
           StorageDead(_4);
           StorageLive(_5);
           StorageLive(_6);
-          _6 = _2;
+          _6 = copy _2;
           _5 = Eq(move _6, const 7_u8);
 -         switchInt(move _5) -> [0: bb2, otherwise: bb1];
 +         goto -> bb2;
@@ -32,13 +32,13 @@
   
       bb1: {
           StorageDead(_6);
-          _0 = _3;
+          _0 = copy _3;
           goto -> bb3;
       }
   
       bb2: {
           StorageDead(_6);
-          _0 = _2;
+          _0 = copy _2;
           goto -> bb3;
       }
   
diff --git a/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-unwind.diff
index e955e66901437..a7551c3fb5b79 100644
--- a/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.aggregate.JumpThreading.panic-unwind.diff
@@ -18,13 +18,13 @@
           StorageLive(_4);
           _4 = const aggregate::FOO;
           StorageLive(_2);
-          _2 = (_4.0: u8);
+          _2 = copy (_4.0: u8);
           StorageLive(_3);
-          _3 = (_4.1: u8);
+          _3 = copy (_4.1: u8);
           StorageDead(_4);
           StorageLive(_5);
           StorageLive(_6);
-          _6 = _2;
+          _6 = copy _2;
           _5 = Eq(move _6, const 7_u8);
 -         switchInt(move _5) -> [0: bb2, otherwise: bb1];
 +         goto -> bb2;
@@ -32,13 +32,13 @@
   
       bb1: {
           StorageDead(_6);
-          _0 = _3;
+          _0 = copy _3;
           goto -> bb3;
       }
   
       bb2: {
           StorageDead(_6);
-          _0 = _2;
+          _0 = copy _2;
           goto -> bb3;
       }
   
diff --git a/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-abort.diff
index 0c8e04a1e74dc..4d639d89f0d12 100644
--- a/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-abort.diff
@@ -22,12 +22,12 @@
           StorageLive(_1);
           _1 = const aggregate_copy::Foo;
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           StorageLive(_3);
-          _3 = (_2.1: u32);
+          _3 = copy (_2.1: u32);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _3;
+          _5 = copy _3;
           _4 = Eq(move _5, const 2_u32);
 -         switchInt(move _4) -> [0: bb2, otherwise: bb1];
 +         goto -> bb2;
@@ -35,7 +35,7 @@
   
       bb1: {
           StorageDead(_5);
-          _0 = (_2.0: u32);
+          _0 = copy (_2.0: u32);
           goto -> bb3;
       }
   
diff --git a/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-unwind.diff
index 0c8e04a1e74dc..4d639d89f0d12 100644
--- a/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.aggregate_copy.JumpThreading.panic-unwind.diff
@@ -22,12 +22,12 @@
           StorageLive(_1);
           _1 = const aggregate_copy::Foo;
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
           StorageLive(_3);
-          _3 = (_2.1: u32);
+          _3 = copy (_2.1: u32);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _3;
+          _5 = copy _3;
           _4 = Eq(move _5, const 2_u32);
 -         switchInt(move _4) -> [0: bb2, otherwise: bb1];
 +         goto -> bb2;
@@ -35,7 +35,7 @@
   
       bb1: {
           StorageDead(_5);
-          _0 = (_2.0: u32);
+          _0 = copy (_2.0: u32);
           goto -> bb3;
       }
   
diff --git a/tests/mir-opt/jump_threading.assume.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.assume.JumpThreading.panic-abort.diff
index f1f0106fdbce9..519cb0f0ab1df 100644
--- a/tests/mir-opt/jump_threading.assume.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.assume.JumpThreading.panic-abort.diff
@@ -5,11 +5,11 @@
       let mut _0: u8;
   
       bb0: {
-          switchInt(_1) -> [7: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [7: bb1, otherwise: bb2];
       }
   
       bb1: {
-          assume(_2);
+          assume(copy _2);
 -         goto -> bb3;
 +         goto -> bb6;
       }
@@ -19,7 +19,7 @@
       }
   
       bb3: {
-          switchInt(_2) -> [0: bb4, otherwise: bb5];
+          switchInt(copy _2) -> [0: bb4, otherwise: bb5];
       }
   
       bb4: {
diff --git a/tests/mir-opt/jump_threading.assume.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.assume.JumpThreading.panic-unwind.diff
index f1f0106fdbce9..519cb0f0ab1df 100644
--- a/tests/mir-opt/jump_threading.assume.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.assume.JumpThreading.panic-unwind.diff
@@ -5,11 +5,11 @@
       let mut _0: u8;
   
       bb0: {
-          switchInt(_1) -> [7: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [7: bb1, otherwise: bb2];
       }
   
       bb1: {
-          assume(_2);
+          assume(copy _2);
 -         goto -> bb3;
 +         goto -> bb6;
       }
@@ -19,7 +19,7 @@
       }
   
       bb3: {
-          switchInt(_2) -> [0: bb4, otherwise: bb5];
+          switchInt(copy _2) -> [0: bb4, otherwise: bb5];
       }
   
       bb4: {
diff --git a/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-abort.diff
index 462cc20778580..a86371794ebe9 100644
--- a/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-abort.diff
@@ -11,7 +11,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           switchInt(move _3) -> [0: bb2, otherwise: bb1];
       }
   
diff --git a/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-unwind.diff
index 462cc20778580..a86371794ebe9 100644
--- a/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.custom_discr.JumpThreading.panic-unwind.diff
@@ -11,7 +11,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           switchInt(move _3) -> [0: bb2, otherwise: bb1];
       }
   
diff --git a/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-abort.diff
index f290da84e5d88..d17f2752f58ec 100644
--- a/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-abort.diff
@@ -9,7 +9,7 @@
       bb0: {
           _2 = const true;
           _3 = const true;
-          switchInt(_1) -> [0: bb3, 1: bb3, 2: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [0: bb3, 1: bb3, 2: bb1, otherwise: bb2];
       }
   
       bb1: {
@@ -28,11 +28,11 @@
       }
   
       bb4: {
-          switchInt(_3) -> [0: bb5, otherwise: bb7];
+          switchInt(copy _3) -> [0: bb5, otherwise: bb7];
       }
   
       bb5: {
-          switchInt(_2) -> [0: bb6, otherwise: bb8];
+          switchInt(copy _2) -> [0: bb6, otherwise: bb8];
       }
   
       bb6: {
diff --git a/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-unwind.diff
index f290da84e5d88..d17f2752f58ec 100644
--- a/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.disappearing_bb.JumpThreading.panic-unwind.diff
@@ -9,7 +9,7 @@
       bb0: {
           _2 = const true;
           _3 = const true;
-          switchInt(_1) -> [0: bb3, 1: bb3, 2: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [0: bb3, 1: bb3, 2: bb1, otherwise: bb2];
       }
   
       bb1: {
@@ -28,11 +28,11 @@
       }
   
       bb4: {
-          switchInt(_3) -> [0: bb5, otherwise: bb7];
+          switchInt(copy _3) -> [0: bb5, otherwise: bb7];
       }
   
       bb5: {
-          switchInt(_2) -> [0: bb6, otherwise: bb8];
+          switchInt(copy _2) -> [0: bb6, otherwise: bb8];
       }
   
       bb6: {
diff --git a/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-abort.diff
index adcedfb366700..083a6e7487a05 100644
--- a/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-abort.diff
@@ -8,7 +8,7 @@
       let mut _4: i32;
   
       bb0: {
-          switchInt(_1) -> [1: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [1: bb1, otherwise: bb2];
       }
   
       bb1: {
@@ -28,7 +28,7 @@
   
       bb4: {
           _4 = const 15_i32;
--         switchInt(_2) -> [5: bb5, otherwise: bb6];
+-         switchInt(copy _2) -> [5: bb5, otherwise: bb6];
 +         goto -> bb5;
       }
   
diff --git a/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-unwind.diff
index adcedfb366700..083a6e7487a05 100644
--- a/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.duplicate_chain.JumpThreading.panic-unwind.diff
@@ -8,7 +8,7 @@
       let mut _4: i32;
   
       bb0: {
-          switchInt(_1) -> [1: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [1: bb1, otherwise: bb2];
       }
   
       bb1: {
@@ -28,7 +28,7 @@
   
       bb4: {
           _4 = const 15_i32;
--         switchInt(_2) -> [5: bb5, otherwise: bb6];
+-         switchInt(copy _2) -> [5: bb5, otherwise: bb6];
 +         goto -> bb5;
       }
   
diff --git a/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff
index 6ca37e96d297b..1192f7c23e15d 100644
--- a/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-abort.diff
@@ -33,7 +33,7 @@
           StorageDead(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           _3 = Eq(move _4, const 0f64);
           switchInt(move _3) -> [0: bb5, otherwise: bb4];
       }
diff --git a/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff
index 6ca37e96d297b..1192f7c23e15d 100644
--- a/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.floats.JumpThreading.panic-unwind.diff
@@ -33,7 +33,7 @@
           StorageDead(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           _3 = Eq(move _4, const 0f64);
           switchInt(move _3) -> [0: bb5, otherwise: bb4];
       }
diff --git a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff
index 65379ae8b890e..79599f856115d 100644
--- a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-abort.diff
@@ -45,7 +45,7 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_10);
           StorageLive(_11);
           StorageLive(_12);
@@ -59,8 +59,8 @@
   
       bb2: {
           StorageLive(_9);
-          _9 = ((_3 as Continue).0: i32);
-          _2 = _9;
+          _9 = copy ((_3 as Continue).0: i32);
+          _2 = copy _9;
           StorageDead(_9);
           _0 = Result::<i32, i32>::Ok(move _2);
           StorageDead(_2);
@@ -70,9 +70,9 @@
   
       bb3: {
           StorageLive(_6);
-          _6 = ((_3 as Break).0: std::result::Result<std::convert::Infallible, i32>);
+          _6 = copy ((_3 as Break).0: std::result::Result<std::convert::Infallible, i32>);
           StorageLive(_8);
-          _8 = _6;
+          _8 = copy _6;
           StorageLive(_14);
           _14 = move ((_8 as Err).0: i32);
           StorageLive(_15);
@@ -104,7 +104,7 @@
       bb6: {
           _12 = move ((_4 as Err).0: i32);
           StorageLive(_13);
-          _13 = Result::<Infallible, i32>::Err(_12);
+          _13 = Result::<Infallible, i32>::Err(copy _12);
           _3 = ControlFlow::<Result<Infallible, i32>, i32>::Break(move _13);
           StorageDead(_13);
 -         goto -> bb5;
@@ -113,7 +113,7 @@
   
       bb7: {
           _11 = move ((_4 as Ok).0: i32);
-          _3 = ControlFlow::<Result<Infallible, i32>, i32>::Continue(_11);
+          _3 = ControlFlow::<Result<Infallible, i32>, i32>::Continue(copy _11);
           goto -> bb5;
 +     }
 + 
diff --git a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff
index 65379ae8b890e..79599f856115d 100644
--- a/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.identity.JumpThreading.panic-unwind.diff
@@ -45,7 +45,7 @@
           StorageLive(_2);
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_10);
           StorageLive(_11);
           StorageLive(_12);
@@ -59,8 +59,8 @@
   
       bb2: {
           StorageLive(_9);
-          _9 = ((_3 as Continue).0: i32);
-          _2 = _9;
+          _9 = copy ((_3 as Continue).0: i32);
+          _2 = copy _9;
           StorageDead(_9);
           _0 = Result::<i32, i32>::Ok(move _2);
           StorageDead(_2);
@@ -70,9 +70,9 @@
   
       bb3: {
           StorageLive(_6);
-          _6 = ((_3 as Break).0: std::result::Result<std::convert::Infallible, i32>);
+          _6 = copy ((_3 as Break).0: std::result::Result<std::convert::Infallible, i32>);
           StorageLive(_8);
-          _8 = _6;
+          _8 = copy _6;
           StorageLive(_14);
           _14 = move ((_8 as Err).0: i32);
           StorageLive(_15);
@@ -104,7 +104,7 @@
       bb6: {
           _12 = move ((_4 as Err).0: i32);
           StorageLive(_13);
-          _13 = Result::<Infallible, i32>::Err(_12);
+          _13 = Result::<Infallible, i32>::Err(copy _12);
           _3 = ControlFlow::<Result<Infallible, i32>, i32>::Break(move _13);
           StorageDead(_13);
 -         goto -> bb5;
@@ -113,7 +113,7 @@
   
       bb7: {
           _11 = move ((_4 as Ok).0: i32);
-          _3 = ControlFlow::<Result<Infallible, i32>, i32>::Continue(_11);
+          _3 = ControlFlow::<Result<Infallible, i32>, i32>::Continue(copy _11);
           goto -> bb5;
 +     }
 + 
diff --git a/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-abort.diff
index 2ca03e439a0be..09c0ad6d48560 100644
--- a/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-abort.diff
@@ -7,18 +7,18 @@
       let mut _3: u8;
   
       bb0: {
-          switchInt(_1) -> [3: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [3: bb1, otherwise: bb2];
       }
   
       bb1: {
-          _2 = _1;
--         switchInt(_2) -> [3: bb3, otherwise: bb4];
+          _2 = copy _1;
+-         switchInt(copy _2) -> [3: bb3, otherwise: bb4];
 +         goto -> bb3;
       }
   
       bb2: {
-          _3 = _1;
--         switchInt(_3) -> [3: bb5, otherwise: bb6];
+          _3 = copy _1;
+-         switchInt(copy _3) -> [3: bb5, otherwise: bb6];
 +         goto -> bb6;
       }
   
@@ -38,7 +38,7 @@
       }
   
       bb6: {
-          switchInt(_3) -> [1: bb7, otherwise: bb8];
+          switchInt(copy _3) -> [1: bb7, otherwise: bb8];
       }
   
       bb7: {
diff --git a/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-unwind.diff
index 2ca03e439a0be..09c0ad6d48560 100644
--- a/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.multiple_match.JumpThreading.panic-unwind.diff
@@ -7,18 +7,18 @@
       let mut _3: u8;
   
       bb0: {
-          switchInt(_1) -> [3: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [3: bb1, otherwise: bb2];
       }
   
       bb1: {
-          _2 = _1;
--         switchInt(_2) -> [3: bb3, otherwise: bb4];
+          _2 = copy _1;
+-         switchInt(copy _2) -> [3: bb3, otherwise: bb4];
 +         goto -> bb3;
       }
   
       bb2: {
-          _3 = _1;
--         switchInt(_3) -> [3: bb5, otherwise: bb6];
+          _3 = copy _1;
+-         switchInt(copy _3) -> [3: bb5, otherwise: bb6];
 +         goto -> bb6;
       }
   
@@ -38,7 +38,7 @@
       }
   
       bb6: {
-          switchInt(_3) -> [1: bb7, otherwise: bb8];
+          switchInt(copy _3) -> [1: bb7, otherwise: bb8];
       }
   
       bb7: {
diff --git a/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-abort.diff
index e9d4352014f71..bb47f57b542a5 100644
--- a/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-abort.diff
@@ -27,7 +27,7 @@
           StorageDead(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           _4 = Eq(move _5, const 7_i32);
           switchInt(move _4) -> [0: bb2, otherwise: bb1];
       }
diff --git a/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-unwind.diff
index e9d4352014f71..bb47f57b542a5 100644
--- a/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.mutable_ref.JumpThreading.panic-unwind.diff
@@ -27,7 +27,7 @@
           StorageDead(_3);
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           _4 = Eq(move _5, const 7_i32);
           switchInt(move _4) -> [0: bb2, otherwise: bb1];
       }
diff --git a/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-abort.diff
index 8821b47c34576..7014146cb8624 100644
--- a/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-abort.diff
@@ -10,7 +10,7 @@
           discriminant(_1) = 1;
           (((_1 as variant#1).0: NonZeroUsize).0: usize) = const 0_usize;
           _2 = discriminant(_1);
-          switchInt(_2) -> [0: bb1, otherwise: bb2];
+          switchInt(copy _2) -> [0: bb1, otherwise: bb2];
       }
   
       bb1: {
diff --git a/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-unwind.diff
index 8821b47c34576..7014146cb8624 100644
--- a/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.mutate_discriminant.JumpThreading.panic-unwind.diff
@@ -10,7 +10,7 @@
           discriminant(_1) = 1;
           (((_1 as variant#1).0: NonZeroUsize).0: usize) = const 0_usize;
           _2 = discriminant(_1);
-          switchInt(_2) -> [0: bb1, otherwise: bb2];
+          switchInt(copy _2) -> [0: bb1, otherwise: bb2];
       }
   
       bb1: {
diff --git a/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-abort.diff
index 2d943a4bee219..9a8bdc8f4d952 100644
--- a/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-abort.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           _3 = const false;
-          switchInt(_1) -> [1: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [1: bb1, otherwise: bb2];
       }
   
       bb1: {
@@ -18,17 +18,17 @@
       }
   
       bb2: {
-          _2 = _1;
-          _3 = _1;
+          _2 = copy _1;
+          _3 = copy _1;
           goto -> bb3;
       }
   
       bb3: {
-          switchInt(_2) -> [0: bb4, otherwise: bb5];
+          switchInt(copy _2) -> [0: bb4, otherwise: bb5];
       }
   
       bb4: {
-          switchInt(_3) -> [0: bb6, otherwise: bb7];
+          switchInt(copy _3) -> [0: bb6, otherwise: bb7];
       }
   
       bb5: {
diff --git a/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-unwind.diff
index 2d943a4bee219..9a8bdc8f4d952 100644
--- a/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.renumbered_bb.JumpThreading.panic-unwind.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           _3 = const false;
-          switchInt(_1) -> [1: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [1: bb1, otherwise: bb2];
       }
   
       bb1: {
@@ -18,17 +18,17 @@
       }
   
       bb2: {
-          _2 = _1;
-          _3 = _1;
+          _2 = copy _1;
+          _3 = copy _1;
           goto -> bb3;
       }
   
       bb3: {
-          switchInt(_2) -> [0: bb4, otherwise: bb5];
+          switchInt(copy _2) -> [0: bb4, otherwise: bb5];
       }
   
       bb4: {
-          switchInt(_3) -> [0: bb6, otherwise: bb7];
+          switchInt(copy _3) -> [0: bb6, otherwise: bb7];
       }
   
       bb5: {
diff --git a/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-abort.diff b/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-abort.diff
index 365d9d6b32bde..7de359298922b 100644
--- a/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-abort.diff
+++ b/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-abort.diff
@@ -39,9 +39,9 @@
   
       bb2: {
           StorageLive(_6);
-          _6 = ((_1 as Err).0: usize);
+          _6 = copy ((_1 as Err).0: usize);
           StorageLive(_7);
-          _7 = _6;
+          _7 = copy _6;
           _2 = ControlFlow::<usize, i32>::Break(move _7);
           StorageDead(_7);
           StorageDead(_6);
@@ -51,9 +51,9 @@
   
       bb3: {
           StorageLive(_4);
-          _4 = ((_1 as Ok).0: i32);
+          _4 = copy ((_1 as Ok).0: i32);
           StorageLive(_5);
-          _5 = _4;
+          _5 = copy _4;
           _2 = ControlFlow::<usize, i32>::Continue(move _5);
           StorageDead(_5);
           StorageDead(_4);
@@ -68,7 +68,7 @@
   
       bb5: {
           StorageLive(_11);
-          _11 = ((_2 as Break).0: usize);
+          _11 = copy ((_2 as Break).0: usize);
           _0 = Option::<i32>::None;
           StorageDead(_11);
           goto -> bb7;
@@ -76,9 +76,9 @@
   
       bb6: {
           StorageLive(_9);
-          _9 = ((_2 as Continue).0: i32);
+          _9 = copy ((_2 as Continue).0: i32);
           StorageLive(_10);
-          _10 = _9;
+          _10 = copy _9;
           _0 = Option::<i32>::Some(move _10);
           StorageDead(_10);
           StorageDead(_9);
diff --git a/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-unwind.diff b/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-unwind.diff
index 365d9d6b32bde..7de359298922b 100644
--- a/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-unwind.diff
+++ b/tests/mir-opt/jump_threading.too_complex.JumpThreading.panic-unwind.diff
@@ -39,9 +39,9 @@
   
       bb2: {
           StorageLive(_6);
-          _6 = ((_1 as Err).0: usize);
+          _6 = copy ((_1 as Err).0: usize);
           StorageLive(_7);
-          _7 = _6;
+          _7 = copy _6;
           _2 = ControlFlow::<usize, i32>::Break(move _7);
           StorageDead(_7);
           StorageDead(_6);
@@ -51,9 +51,9 @@
   
       bb3: {
           StorageLive(_4);
-          _4 = ((_1 as Ok).0: i32);
+          _4 = copy ((_1 as Ok).0: i32);
           StorageLive(_5);
-          _5 = _4;
+          _5 = copy _4;
           _2 = ControlFlow::<usize, i32>::Continue(move _5);
           StorageDead(_5);
           StorageDead(_4);
@@ -68,7 +68,7 @@
   
       bb5: {
           StorageLive(_11);
-          _11 = ((_2 as Break).0: usize);
+          _11 = copy ((_2 as Break).0: usize);
           _0 = Option::<i32>::None;
           StorageDead(_11);
           goto -> bb7;
@@ -76,9 +76,9 @@
   
       bb6: {
           StorageLive(_9);
-          _9 = ((_2 as Continue).0: i32);
+          _9 = copy ((_2 as Continue).0: i32);
           StorageLive(_10);
-          _10 = _9;
+          _10 = copy _9;
           _0 = Option::<i32>::Some(move _10);
           StorageDead(_10);
           StorageDead(_9);
diff --git a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff
index 7aca2cb000701..8223cbbb41216 100644
--- a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff
+++ b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-abort.diff
@@ -18,7 +18,7 @@
 -         StorageLive(_3);
 +         nop;
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
@@ -35,8 +35,8 @@
           StorageDead(_6);
 -         _3 = Lt(move _4, move _5);
 -         switchInt(move _3) -> [0: bb4, otherwise: bb2];
-+         _3 = Lt(_1, const N);
-+         switchInt(_3) -> [0: bb4, otherwise: bb2];
++         _3 = Lt(copy _1, const N);
++         switchInt(copy _3) -> [0: bb4, otherwise: bb2];
       }
   
       bb2: {
@@ -44,18 +44,18 @@
 +         nop;
           StorageDead(_4);
           StorageLive(_8);
-          _8 = _1;
+          _8 = copy _1;
 -         _9 = Len((*_2));
--         _10 = Lt(_8, _9);
--         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind unreachable];
+-         _10 = Lt(copy _8, copy _9);
+-         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind unreachable];
 +         _9 = const N;
-+         _10 = _3;
-+         assert(_3, "index out of bounds: the length is {} but the index is {}", const N, _1) -> [success: bb3, unwind unreachable];
++         _10 = copy _3;
++         assert(copy _3, "index out of bounds: the length is {} but the index is {}", const N, copy _1) -> [success: bb3, unwind unreachable];
       }
   
       bb3: {
--         _0 = (*_2)[_8];
-+         _0 = (*_2)[_1];
+-         _0 = copy (*_2)[_8];
++         _0 = copy (*_2)[_1];
           StorageDead(_8);
           goto -> bb5;
       }
diff --git a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff
index ed39c11319af4..d8f33accbc005 100644
--- a/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff
+++ b/tests/mir-opt/lower_array_len.array_bound.GVN.panic-unwind.diff
@@ -18,7 +18,7 @@
 -         StorageLive(_3);
 +         nop;
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
@@ -35,8 +35,8 @@
           StorageDead(_6);
 -         _3 = Lt(move _4, move _5);
 -         switchInt(move _3) -> [0: bb4, otherwise: bb2];
-+         _3 = Lt(_1, const N);
-+         switchInt(_3) -> [0: bb4, otherwise: bb2];
++         _3 = Lt(copy _1, const N);
++         switchInt(copy _3) -> [0: bb4, otherwise: bb2];
       }
   
       bb2: {
@@ -44,18 +44,18 @@
 +         nop;
           StorageDead(_4);
           StorageLive(_8);
-          _8 = _1;
+          _8 = copy _1;
 -         _9 = Len((*_2));
--         _10 = Lt(_8, _9);
--         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind continue];
+-         _10 = Lt(copy _8, copy _9);
+-         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind continue];
 +         _9 = const N;
-+         _10 = _3;
-+         assert(_3, "index out of bounds: the length is {} but the index is {}", const N, _1) -> [success: bb3, unwind continue];
++         _10 = copy _3;
++         assert(copy _3, "index out of bounds: the length is {} but the index is {}", const N, copy _1) -> [success: bb3, unwind continue];
       }
   
       bb3: {
--         _0 = (*_2)[_8];
-+         _0 = (*_2)[_1];
+-         _0 = copy (*_2)[_8];
++         _0 = copy (*_2)[_1];
           StorageDead(_8);
           goto -> bb5;
       }
diff --git a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff
index 734d28e9546c1..1cb9963c00e94 100644
--- a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff
+++ b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-abort.diff
@@ -21,7 +21,7 @@
 -         StorageLive(_3);
 +         nop;
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
@@ -38,8 +38,8 @@
           StorageDead(_6);
 -         _3 = Lt(move _4, move _5);
 -         switchInt(move _3) -> [0: bb4, otherwise: bb2];
-+         _3 = Lt(_1, const N);
-+         switchInt(_3) -> [0: bb4, otherwise: bb2];
++         _3 = Lt(copy _1, const N);
++         switchInt(copy _3) -> [0: bb4, otherwise: bb2];
       }
   
       bb2: {
@@ -47,18 +47,18 @@
 +         nop;
           StorageDead(_4);
           StorageLive(_8);
-          _8 = _1;
+          _8 = copy _1;
 -         _9 = Len((*_2));
--         _10 = Lt(_8, _9);
--         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind unreachable];
+-         _10 = Lt(copy _8, copy _9);
+-         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind unreachable];
 +         _9 = const N;
-+         _10 = _3;
-+         assert(_3, "index out of bounds: the length is {} but the index is {}", const N, _1) -> [success: bb3, unwind unreachable];
++         _10 = copy _3;
++         assert(copy _3, "index out of bounds: the length is {} but the index is {}", const N, copy _1) -> [success: bb3, unwind unreachable];
       }
   
       bb3: {
--         _0 = (*_2)[_8];
-+         _0 = (*_2)[_1];
+-         _0 = copy (*_2)[_8];
++         _0 = copy (*_2)[_1];
           StorageDead(_8);
           goto -> bb6;
       }
@@ -70,8 +70,8 @@
           StorageLive(_11);
           _11 = const 0_usize;
 -         _12 = Len((*_2));
--         _13 = Lt(_11, _12);
--         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb5, unwind unreachable];
+-         _13 = Lt(copy _11, copy _12);
+-         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb5, unwind unreachable];
 +         _12 = const N;
 +         _13 = Lt(const 0_usize, const N);
 +         assert(move _13, "index out of bounds: the length is {} but the index is {}", const N, const 0_usize) -> [success: bb5, unwind unreachable];
diff --git a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff
index ec569ab504233..fa4e11ed20192 100644
--- a/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff
+++ b/tests/mir-opt/lower_array_len.array_bound_mut.GVN.panic-unwind.diff
@@ -21,7 +21,7 @@
 -         StorageLive(_3);
 +         nop;
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
 -         StorageLive(_5);
 +         nop;
           StorageLive(_6);
@@ -38,8 +38,8 @@
           StorageDead(_6);
 -         _3 = Lt(move _4, move _5);
 -         switchInt(move _3) -> [0: bb4, otherwise: bb2];
-+         _3 = Lt(_1, const N);
-+         switchInt(_3) -> [0: bb4, otherwise: bb2];
++         _3 = Lt(copy _1, const N);
++         switchInt(copy _3) -> [0: bb4, otherwise: bb2];
       }
   
       bb2: {
@@ -47,18 +47,18 @@
 +         nop;
           StorageDead(_4);
           StorageLive(_8);
-          _8 = _1;
+          _8 = copy _1;
 -         _9 = Len((*_2));
--         _10 = Lt(_8, _9);
--         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, _8) -> [success: bb3, unwind continue];
+-         _10 = Lt(copy _8, copy _9);
+-         assert(move _10, "index out of bounds: the length is {} but the index is {}", move _9, copy _8) -> [success: bb3, unwind continue];
 +         _9 = const N;
-+         _10 = _3;
-+         assert(_3, "index out of bounds: the length is {} but the index is {}", const N, _1) -> [success: bb3, unwind continue];
++         _10 = copy _3;
++         assert(copy _3, "index out of bounds: the length is {} but the index is {}", const N, copy _1) -> [success: bb3, unwind continue];
       }
   
       bb3: {
--         _0 = (*_2)[_8];
-+         _0 = (*_2)[_1];
+-         _0 = copy (*_2)[_8];
++         _0 = copy (*_2)[_1];
           StorageDead(_8);
           goto -> bb6;
       }
@@ -70,8 +70,8 @@
           StorageLive(_11);
           _11 = const 0_usize;
 -         _12 = Len((*_2));
--         _13 = Lt(_11, _12);
--         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, _11) -> [success: bb5, unwind continue];
+-         _13 = Lt(copy _11, copy _12);
+-         assert(move _13, "index out of bounds: the length is {} but the index is {}", move _12, copy _11) -> [success: bb5, unwind continue];
 +         _12 = const N;
 +         _13 = Lt(const 0_usize, const N);
 +         assert(move _13, "index out of bounds: the length is {} but the index is {}", const N, const 0_usize) -> [success: bb5, unwind continue];
diff --git a/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-abort.diff
index 96b66af66a2d2..7f325245bce63 100644
--- a/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-abort.diff
@@ -33,7 +33,7 @@
           StorageLive(_7);
           _7 = &_1;
           _6 = &raw const (*_7);
-          _5 = _6;
+          _5 = copy _6;
           _4 = move _5 as *const i32 (PtrToPtr);
           StorageDead(_5);
           StorageLive(_8);
@@ -42,7 +42,7 @@
           StorageLive(_11);
           _11 = &mut _2;
           _10 = &raw mut (*_11);
-          _9 = _10;
+          _9 = copy _10;
           _8 = move _9 as *mut i32 (PtrToPtr);
           StorageDead(_9);
 -         _3 = copy_nonoverlapping::<i32>(move _4, move _8, const 0_usize) -> [return: bb1, unwind unreachable];
diff --git a/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-unwind.diff
index 96b66af66a2d2..7f325245bce63 100644
--- a/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.f_copy_nonoverlapping.LowerIntrinsics.panic-unwind.diff
@@ -33,7 +33,7 @@
           StorageLive(_7);
           _7 = &_1;
           _6 = &raw const (*_7);
-          _5 = _6;
+          _5 = copy _6;
           _4 = move _5 as *const i32 (PtrToPtr);
           StorageDead(_5);
           StorageLive(_8);
@@ -42,7 +42,7 @@
           StorageLive(_11);
           _11 = &mut _2;
           _10 = &raw mut (*_11);
-          _9 = _10;
+          _9 = copy _10;
           _8 = move _9 as *mut i32 (PtrToPtr);
           StorageDead(_9);
 -         _3 = copy_nonoverlapping::<i32>(move _4, move _8, const 0_usize) -> [return: bb1, unwind unreachable];
diff --git a/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-abort.diff
index d256058c05ee6..f2cfce1b6e3f8 100644
--- a/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-abort.diff
@@ -25,7 +25,7 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = ptr_metadata::<i32, ()>(move _5) -> [return: bb1, unwind unreachable];
 +         _4 = PtrMetadata(move _5);
 +         goto -> bb1;
@@ -35,7 +35,7 @@
           StorageDead(_5);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _2;
+          _7 = copy _2;
 -         _6 = ptr_metadata::<[u8], usize>(move _7) -> [return: bb2, unwind unreachable];
 +         _6 = PtrMetadata(move _7);
 +         goto -> bb2;
@@ -45,7 +45,7 @@
           StorageDead(_7);
           StorageLive(_8);
           StorageLive(_9);
-          _9 = _3;
+          _9 = copy _3;
 -         _8 = ptr_metadata::<dyn Debug, DynMetadata<dyn Debug>>(move _9) -> [return: bb3, unwind unreachable];
 +         _8 = PtrMetadata(move _9);
 +         goto -> bb3;
diff --git a/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-unwind.diff
index d256058c05ee6..f2cfce1b6e3f8 100644
--- a/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.get_metadata.LowerIntrinsics.panic-unwind.diff
@@ -25,7 +25,7 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
 -         _4 = ptr_metadata::<i32, ()>(move _5) -> [return: bb1, unwind unreachable];
 +         _4 = PtrMetadata(move _5);
 +         goto -> bb1;
@@ -35,7 +35,7 @@
           StorageDead(_5);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _2;
+          _7 = copy _2;
 -         _6 = ptr_metadata::<[u8], usize>(move _7) -> [return: bb2, unwind unreachable];
 +         _6 = PtrMetadata(move _7);
 +         goto -> bb2;
@@ -45,7 +45,7 @@
           StorageDead(_7);
           StorageLive(_8);
           StorageLive(_9);
-          _9 = _3;
+          _9 = copy _3;
 -         _8 = ptr_metadata::<dyn Debug, DynMetadata<dyn Debug>>(move _9) -> [return: bb3, unwind unreachable];
 +         _8 = PtrMetadata(move _9);
 +         goto -> bb3;
diff --git a/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff
index 02934d4c01e6f..b282509c06861 100644
--- a/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-abort.diff
@@ -34,7 +34,7 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           StorageLive(_6);
           _6 = ();
 -         _4 = aggregate_raw_ptr::<*const i32, *const u8, ()>(move _5, move _6) -> [return: bb1, unwind unreachable];
@@ -47,7 +47,7 @@
           StorageDead(_5);
           StorageLive(_7);
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
           StorageLive(_9);
           _9 = ();
 -         _7 = aggregate_raw_ptr::<*mut u8, *mut (), ()>(move _8, move _9) -> [return: bb2, unwind unreachable];
@@ -60,9 +60,9 @@
           StorageDead(_8);
           StorageLive(_10);
           StorageLive(_11);
-          _11 = _1;
+          _11 = copy _1;
           StorageLive(_12);
-          _12 = _3;
+          _12 = copy _3;
 -         _10 = aggregate_raw_ptr::<*const [u16], *const u8, usize>(move _11, move _12) -> [return: bb3, unwind unreachable];
 +         _10 = *const [u16] from (move _11, move _12);
 +         goto -> bb3;
@@ -73,9 +73,9 @@
           StorageDead(_11);
           StorageLive(_13);
           StorageLive(_14);
-          _14 = _2;
+          _14 = copy _2;
           StorageLive(_15);
-          _15 = _3;
+          _15 = copy _3;
 -         _13 = aggregate_raw_ptr::<*mut [u64], *mut (), usize>(move _14, move _15) -> [return: bb4, unwind unreachable];
 +         _13 = *mut [u64] from (move _14, move _15);
 +         goto -> bb4;
diff --git a/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff
index 02934d4c01e6f..b282509c06861 100644
--- a/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.make_pointers.LowerIntrinsics.panic-unwind.diff
@@ -34,7 +34,7 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           StorageLive(_6);
           _6 = ();
 -         _4 = aggregate_raw_ptr::<*const i32, *const u8, ()>(move _5, move _6) -> [return: bb1, unwind unreachable];
@@ -47,7 +47,7 @@
           StorageDead(_5);
           StorageLive(_7);
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
           StorageLive(_9);
           _9 = ();
 -         _7 = aggregate_raw_ptr::<*mut u8, *mut (), ()>(move _8, move _9) -> [return: bb2, unwind unreachable];
@@ -60,9 +60,9 @@
           StorageDead(_8);
           StorageLive(_10);
           StorageLive(_11);
-          _11 = _1;
+          _11 = copy _1;
           StorageLive(_12);
-          _12 = _3;
+          _12 = copy _3;
 -         _10 = aggregate_raw_ptr::<*const [u16], *const u8, usize>(move _11, move _12) -> [return: bb3, unwind unreachable];
 +         _10 = *const [u16] from (move _11, move _12);
 +         goto -> bb3;
@@ -73,9 +73,9 @@
           StorageDead(_11);
           StorageLive(_13);
           StorageLive(_14);
-          _14 = _2;
+          _14 = copy _2;
           StorageLive(_15);
-          _15 = _3;
+          _15 = copy _3;
 -         _13 = aggregate_raw_ptr::<*mut [u64], *mut (), usize>(move _14, move _15) -> [return: bb4, unwind unreachable];
 +         _13 = *mut [u64] from (move _14, move _15);
 +         goto -> bb4;
diff --git a/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-abort.diff
index 069a82b95215d..5aa9869847680 100644
--- a/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-abort.diff
@@ -13,7 +13,7 @@
           StorageLive(_1);
           _1 = std::intrinsics::size_of::<T>;
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         _0 = move _2() -> [return: bb1, unwind unreachable];
 +         _0 = SizeOf(T);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-unwind.diff
index 069a82b95215d..5aa9869847680 100644
--- a/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.non_const.LowerIntrinsics.panic-unwind.diff
@@ -13,7 +13,7 @@
           StorageLive(_1);
           _1 = std::intrinsics::size_of::<T>;
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         _0 = move _2() -> [return: bb1, unwind unreachable];
 +         _0 = SizeOf(T);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-abort.diff
index 4f7ad0b6094f6..62cce84f69560 100644
--- a/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-abort.diff
@@ -10,9 +10,9 @@
   
       bb0: {
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _0 = offset::<*const i32, isize>(move _3, move _4) -> [return: bb1, unwind unreachable];
 +         _0 = Offset(move _3, move _4);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-unwind.diff
index 4f7ad0b6094f6..62cce84f69560 100644
--- a/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.ptr_offset.LowerIntrinsics.panic-unwind.diff
@@ -10,9 +10,9 @@
   
       bb0: {
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           StorageLive(_4);
-          _4 = _2;
+          _4 = copy _2;
 -         _0 = offset::<*const i32, isize>(move _3, move _4) -> [return: bb1, unwind unreachable];
 +         _0 = Offset(move _3, move _4);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-abort.diff
index 781104be290a6..95717d03b61f5 100644
--- a/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-abort.diff
@@ -10,7 +10,7 @@
           StorageLive(_2);
           _2 = &raw const (*_1);
 -         _0 = read_via_copy::<i32>(move _2) -> [return: bb1, unwind unreachable];
-+         _0 = (*_2);
++         _0 = copy (*_2);
 +         goto -> bb1;
       }
   
diff --git a/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-unwind.diff
index 781104be290a6..95717d03b61f5 100644
--- a/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.read_via_copy_primitive.LowerIntrinsics.panic-unwind.diff
@@ -10,7 +10,7 @@
           StorageLive(_2);
           _2 = &raw const (*_1);
 -         _0 = read_via_copy::<i32>(move _2) -> [return: bb1, unwind unreachable];
-+         _0 = (*_2);
++         _0 = copy (*_2);
 +         goto -> bb1;
       }
   
diff --git a/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-abort.diff
index 56c357b3776d9..8828549249e56 100644
--- a/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-abort.diff
@@ -10,7 +10,7 @@
           StorageLive(_2);
           _2 = &raw const (*_1);
 -         _0 = read_via_copy::<Never>(move _2) -> unwind unreachable;
-+         _0 = (*_2);
++         _0 = copy (*_2);
 +         unreachable;
       }
   }
diff --git a/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-unwind.diff
index 56c357b3776d9..8828549249e56 100644
--- a/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.read_via_copy_uninhabited.LowerIntrinsics.panic-unwind.diff
@@ -10,7 +10,7 @@
           StorageLive(_2);
           _2 = &raw const (*_1);
 -         _0 = read_via_copy::<Never>(move _2) -> unwind unreachable;
-+         _0 = (*_2);
++         _0 = copy (*_2);
 +         unreachable;
       }
   }
diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-abort.diff
index 816d620971588..f29bc5dfc6e4f 100644
--- a/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-abort.diff
@@ -15,9 +15,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = three_way_compare::<char>(move _4, move _5) -> [return: bb1, unwind unreachable];
 +         _3 = Cmp(move _4, move _5);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-unwind.diff
index 80b4bd7a2be75..596ad70b3bfad 100644
--- a/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.three_way_compare_char.LowerIntrinsics.panic-unwind.diff
@@ -15,9 +15,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = three_way_compare::<char>(move _4, move _5) -> [return: bb1, unwind continue];
 +         _3 = Cmp(move _4, move _5);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-abort.diff
index 05c20aaa09a27..654cb2503df58 100644
--- a/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-abort.diff
@@ -12,9 +12,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = three_way_compare::<i16>(move _4, move _5) -> [return: bb1, unwind unreachable];
 +         _3 = Cmp(move _4, move _5);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-unwind.diff
index 8a254d02a47b2..987c216669271 100644
--- a/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.three_way_compare_signed.LowerIntrinsics.panic-unwind.diff
@@ -12,9 +12,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = three_way_compare::<i16>(move _4, move _5) -> [return: bb1, unwind continue];
 +         _3 = Cmp(move _4, move _5);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-abort.diff
index 437614ec6738d..82c89b7ce549c 100644
--- a/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-abort.diff
@@ -15,9 +15,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = three_way_compare::<u32>(move _4, move _5) -> [return: bb1, unwind unreachable];
 +         _3 = Cmp(move _4, move _5);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-unwind.diff
index 7d6137979c81b..d7ec6dcfa2c3c 100644
--- a/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.three_way_compare_unsigned.LowerIntrinsics.panic-unwind.diff
@@ -15,9 +15,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = three_way_compare::<u32>(move _4, move _5) -> [return: bb1, unwind continue];
 +         _3 = Cmp(move _4, move _5);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff
index 6e542c4b5a7b7..71e84fdd8816e 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         _0 = transmute::<std::cmp::Ordering, i8>(move _2) -> [return: bb1, unwind unreachable];
 +         _0 = move _2 as i8 (Transmute);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff
index 6e542c4b5a7b7..71e84fdd8816e 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         _0 = transmute::<std::cmp::Ordering, i8>(move _2) -> [return: bb1, unwind unreachable];
 +         _0 = move _2 as i8 (Transmute);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff
index ab4646370f163..37232b826c129 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         _0 = transmute::<&T, *const T>(move _2) -> [return: bb1, unwind unreachable];
 +         _0 = move _2 as *const T (Transmute);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff
index ab4646370f163..37232b826c129 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         _0 = transmute::<&T, *const T>(move _2) -> [return: bb1, unwind unreachable];
 +         _0 = move _2 as *const T (Transmute);
 +         goto -> bb1;
diff --git a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff
index c4a3358ffa3ab..8ac70f99ad2f0 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff
@@ -17,7 +17,7 @@
       }
   
       bb1: {
-          _2 = (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
+          _2 = copy (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
           PlaceMention((*_2));
           unreachable;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff
index c4a3358ffa3ab..8ac70f99ad2f0 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff
@@ -17,7 +17,7 @@
       }
   
       bb1: {
-          _2 = (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
+          _2 = copy (((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>).0: *const Never);
           PlaceMention((*_2));
           unreachable;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff
index 6d3ad348988b3..eab969e9fe5bb 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         _0 = transmute::<(), Never>(move _2) -> unwind unreachable;
 +         _0 = move _2 as Never (Transmute);
 +         unreachable;
diff --git a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff
index 6d3ad348988b3..eab969e9fe5bb 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff
@@ -8,7 +8,7 @@
   
       bb0: {
           StorageLive(_2);
-          _2 = _1;
+          _2 = copy _1;
 -         _0 = transmute::<(), Never>(move _2) -> unwind unreachable;
 +         _0 = move _2 as Never (Transmute);
 +         unreachable;
diff --git a/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-abort.diff
index 3c9694d0370d8..d0d38462f8dd8 100644
--- a/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-abort.diff
@@ -64,9 +64,9 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           StorageLive(_6);
-          _6 = _2;
+          _6 = copy _2;
 -         _4 = unchecked_add::<i32>(move _5, move _6) -> [return: bb1, unwind unreachable];
 +         _4 = AddUnchecked(move _5, move _6);
 +         goto -> bb1;
@@ -77,9 +77,9 @@
           StorageDead(_5);
           StorageLive(_7);
           StorageLive(_8);
-          _8 = _1;
+          _8 = copy _1;
           StorageLive(_9);
-          _9 = _2;
+          _9 = copy _2;
 -         _7 = unchecked_sub::<i32>(move _8, move _9) -> [return: bb2, unwind unreachable];
 +         _7 = SubUnchecked(move _8, move _9);
 +         goto -> bb2;
@@ -90,9 +90,9 @@
           StorageDead(_8);
           StorageLive(_10);
           StorageLive(_11);
-          _11 = _1;
+          _11 = copy _1;
           StorageLive(_12);
-          _12 = _2;
+          _12 = copy _2;
 -         _10 = unchecked_mul::<i32>(move _11, move _12) -> [return: bb3, unwind unreachable];
 +         _10 = MulUnchecked(move _11, move _12);
 +         goto -> bb3;
@@ -103,9 +103,9 @@
           StorageDead(_11);
           StorageLive(_13);
           StorageLive(_14);
-          _14 = _1;
+          _14 = copy _1;
           StorageLive(_15);
-          _15 = _2;
+          _15 = copy _2;
 -         _13 = unchecked_div::<i32>(move _14, move _15) -> [return: bb4, unwind unreachable];
 +         _13 = Div(move _14, move _15);
 +         goto -> bb4;
@@ -116,9 +116,9 @@
           StorageDead(_14);
           StorageLive(_16);
           StorageLive(_17);
-          _17 = _1;
+          _17 = copy _1;
           StorageLive(_18);
-          _18 = _2;
+          _18 = copy _2;
 -         _16 = unchecked_rem::<i32>(move _17, move _18) -> [return: bb5, unwind unreachable];
 +         _16 = Rem(move _17, move _18);
 +         goto -> bb5;
@@ -129,9 +129,9 @@
           StorageDead(_17);
           StorageLive(_19);
           StorageLive(_20);
-          _20 = _1;
+          _20 = copy _1;
           StorageLive(_21);
-          _21 = _2;
+          _21 = copy _2;
 -         _19 = unchecked_shl::<i32, i32>(move _20, move _21) -> [return: bb6, unwind unreachable];
 +         _19 = ShlUnchecked(move _20, move _21);
 +         goto -> bb6;
@@ -142,9 +142,9 @@
           StorageDead(_20);
           StorageLive(_22);
           StorageLive(_23);
-          _23 = _1;
+          _23 = copy _1;
           StorageLive(_24);
-          _24 = _2;
+          _24 = copy _2;
 -         _22 = unchecked_shr::<i32, i32>(move _23, move _24) -> [return: bb7, unwind unreachable];
 +         _22 = ShrUnchecked(move _23, move _24);
 +         goto -> bb7;
@@ -155,9 +155,9 @@
           StorageDead(_23);
           StorageLive(_25);
           StorageLive(_26);
-          _26 = _1;
+          _26 = copy _1;
           StorageLive(_27);
-          _27 = _3;
+          _27 = copy _3;
 -         _25 = unchecked_shl::<i32, u32>(move _26, move _27) -> [return: bb8, unwind unreachable];
 +         _25 = ShlUnchecked(move _26, move _27);
 +         goto -> bb8;
@@ -168,9 +168,9 @@
           StorageDead(_26);
           StorageLive(_28);
           StorageLive(_29);
-          _29 = _1;
+          _29 = copy _1;
           StorageLive(_30);
-          _30 = _3;
+          _30 = copy _3;
 -         _28 = unchecked_shr::<i32, u32>(move _29, move _30) -> [return: bb9, unwind unreachable];
 +         _28 = ShrUnchecked(move _29, move _30);
 +         goto -> bb9;
diff --git a/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-unwind.diff
index 3c9694d0370d8..d0d38462f8dd8 100644
--- a/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.unchecked.LowerIntrinsics.panic-unwind.diff
@@ -64,9 +64,9 @@
       bb0: {
           StorageLive(_4);
           StorageLive(_5);
-          _5 = _1;
+          _5 = copy _1;
           StorageLive(_6);
-          _6 = _2;
+          _6 = copy _2;
 -         _4 = unchecked_add::<i32>(move _5, move _6) -> [return: bb1, unwind unreachable];
 +         _4 = AddUnchecked(move _5, move _6);
 +         goto -> bb1;
@@ -77,9 +77,9 @@
           StorageDead(_5);
           StorageLive(_7);
           StorageLive(_8);
-          _8 = _1;
+          _8 = copy _1;
           StorageLive(_9);
-          _9 = _2;
+          _9 = copy _2;
 -         _7 = unchecked_sub::<i32>(move _8, move _9) -> [return: bb2, unwind unreachable];
 +         _7 = SubUnchecked(move _8, move _9);
 +         goto -> bb2;
@@ -90,9 +90,9 @@
           StorageDead(_8);
           StorageLive(_10);
           StorageLive(_11);
-          _11 = _1;
+          _11 = copy _1;
           StorageLive(_12);
-          _12 = _2;
+          _12 = copy _2;
 -         _10 = unchecked_mul::<i32>(move _11, move _12) -> [return: bb3, unwind unreachable];
 +         _10 = MulUnchecked(move _11, move _12);
 +         goto -> bb3;
@@ -103,9 +103,9 @@
           StorageDead(_11);
           StorageLive(_13);
           StorageLive(_14);
-          _14 = _1;
+          _14 = copy _1;
           StorageLive(_15);
-          _15 = _2;
+          _15 = copy _2;
 -         _13 = unchecked_div::<i32>(move _14, move _15) -> [return: bb4, unwind unreachable];
 +         _13 = Div(move _14, move _15);
 +         goto -> bb4;
@@ -116,9 +116,9 @@
           StorageDead(_14);
           StorageLive(_16);
           StorageLive(_17);
-          _17 = _1;
+          _17 = copy _1;
           StorageLive(_18);
-          _18 = _2;
+          _18 = copy _2;
 -         _16 = unchecked_rem::<i32>(move _17, move _18) -> [return: bb5, unwind unreachable];
 +         _16 = Rem(move _17, move _18);
 +         goto -> bb5;
@@ -129,9 +129,9 @@
           StorageDead(_17);
           StorageLive(_19);
           StorageLive(_20);
-          _20 = _1;
+          _20 = copy _1;
           StorageLive(_21);
-          _21 = _2;
+          _21 = copy _2;
 -         _19 = unchecked_shl::<i32, i32>(move _20, move _21) -> [return: bb6, unwind unreachable];
 +         _19 = ShlUnchecked(move _20, move _21);
 +         goto -> bb6;
@@ -142,9 +142,9 @@
           StorageDead(_20);
           StorageLive(_22);
           StorageLive(_23);
-          _23 = _1;
+          _23 = copy _1;
           StorageLive(_24);
-          _24 = _2;
+          _24 = copy _2;
 -         _22 = unchecked_shr::<i32, i32>(move _23, move _24) -> [return: bb7, unwind unreachable];
 +         _22 = ShrUnchecked(move _23, move _24);
 +         goto -> bb7;
@@ -155,9 +155,9 @@
           StorageDead(_23);
           StorageLive(_25);
           StorageLive(_26);
-          _26 = _1;
+          _26 = copy _1;
           StorageLive(_27);
-          _27 = _3;
+          _27 = copy _3;
 -         _25 = unchecked_shl::<i32, u32>(move _26, move _27) -> [return: bb8, unwind unreachable];
 +         _25 = ShlUnchecked(move _26, move _27);
 +         goto -> bb8;
@@ -168,9 +168,9 @@
           StorageDead(_26);
           StorageLive(_28);
           StorageLive(_29);
-          _29 = _1;
+          _29 = copy _1;
           StorageLive(_30);
-          _30 = _3;
+          _30 = copy _3;
 -         _28 = unchecked_shr::<i32, u32>(move _29, move _30) -> [return: bb9, unwind unreachable];
 +         _28 = ShrUnchecked(move _29, move _30);
 +         goto -> bb9;
diff --git a/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-abort.diff
index efbbeeeac73da..a9bb5e7e3a443 100644
--- a/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-abort.diff
@@ -27,9 +27,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = add_with_overflow::<i32>(move _4, move _5) -> [return: bb1, unwind unreachable];
 +         _3 = AddWithOverflow(move _4, move _5);
 +         goto -> bb1;
@@ -40,9 +40,9 @@
           StorageDead(_4);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
 -         _6 = sub_with_overflow::<i32>(move _7, move _8) -> [return: bb2, unwind unreachable];
 +         _6 = SubWithOverflow(move _7, move _8);
 +         goto -> bb2;
@@ -53,9 +53,9 @@
           StorageDead(_7);
           StorageLive(_9);
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
           StorageLive(_11);
-          _11 = _2;
+          _11 = copy _2;
 -         _9 = mul_with_overflow::<i32>(move _10, move _11) -> [return: bb3, unwind unreachable];
 +         _9 = MulWithOverflow(move _10, move _11);
 +         goto -> bb3;
diff --git a/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-unwind.diff
index efbbeeeac73da..a9bb5e7e3a443 100644
--- a/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.with_overflow.LowerIntrinsics.panic-unwind.diff
@@ -27,9 +27,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = add_with_overflow::<i32>(move _4, move _5) -> [return: bb1, unwind unreachable];
 +         _3 = AddWithOverflow(move _4, move _5);
 +         goto -> bb1;
@@ -40,9 +40,9 @@
           StorageDead(_4);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
 -         _6 = sub_with_overflow::<i32>(move _7, move _8) -> [return: bb2, unwind unreachable];
 +         _6 = SubWithOverflow(move _7, move _8);
 +         goto -> bb2;
@@ -53,9 +53,9 @@
           StorageDead(_7);
           StorageLive(_9);
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
           StorageLive(_11);
-          _11 = _2;
+          _11 = copy _2;
 -         _9 = mul_with_overflow::<i32>(move _10, move _11) -> [return: bb3, unwind unreachable];
 +         _9 = MulWithOverflow(move _10, move _11);
 +         goto -> bb3;
diff --git a/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-abort.diff
index 2acb193e054d5..552b1a9a32b41 100644
--- a/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-abort.diff
@@ -27,9 +27,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = std::intrinsics::wrapping_add::<i32>(move _4, move _5) -> [return: bb1, unwind unreachable];
 +         _3 = Add(move _4, move _5);
 +         goto -> bb1;
@@ -40,9 +40,9 @@
           StorageDead(_4);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
 -         _6 = std::intrinsics::wrapping_sub::<i32>(move _7, move _8) -> [return: bb2, unwind unreachable];
 +         _6 = Sub(move _7, move _8);
 +         goto -> bb2;
@@ -53,9 +53,9 @@
           StorageDead(_7);
           StorageLive(_9);
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
           StorageLive(_11);
-          _11 = _2;
+          _11 = copy _2;
 -         _9 = wrapping_mul::<i32>(move _10, move _11) -> [return: bb3, unwind unreachable];
 +         _9 = Mul(move _10, move _11);
 +         goto -> bb3;
diff --git a/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-unwind.diff
index 2acb193e054d5..552b1a9a32b41 100644
--- a/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.wrapping.LowerIntrinsics.panic-unwind.diff
@@ -27,9 +27,9 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
-          _5 = _2;
+          _5 = copy _2;
 -         _3 = std::intrinsics::wrapping_add::<i32>(move _4, move _5) -> [return: bb1, unwind unreachable];
 +         _3 = Add(move _4, move _5);
 +         goto -> bb1;
@@ -40,9 +40,9 @@
           StorageDead(_4);
           StorageLive(_6);
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
 -         _6 = std::intrinsics::wrapping_sub::<i32>(move _7, move _8) -> [return: bb2, unwind unreachable];
 +         _6 = Sub(move _7, move _8);
 +         goto -> bb2;
@@ -53,9 +53,9 @@
           StorageDead(_7);
           StorageLive(_9);
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
           StorageLive(_11);
-          _11 = _2;
+          _11 = copy _2;
 -         _9 = wrapping_mul::<i32>(move _10, move _11) -> [return: bb3, unwind unreachable];
 +         _9 = Mul(move _10, move _11);
 +         goto -> bb3;
diff --git a/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-abort.diff b/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-abort.diff
index a212ee6788115..20001f1248ef5 100644
--- a/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-abort.diff
+++ b/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-abort.diff
@@ -16,7 +16,7 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
           StorageLive(_6);
           _6 = &(*_2);
@@ -35,14 +35,14 @@
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
           _8 = Len((*_2));
-          _9 = Lt(_7, _8);
-          assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb3, unwind unreachable];
+          _9 = Lt(copy _7, copy _8);
+          assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb3, unwind unreachable];
       }
   
       bb3: {
-          _0 = (*_2)[_7];
+          _0 = copy (*_2)[_7];
           StorageDead(_7);
           goto -> bb5;
       }
diff --git a/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-unwind.diff b/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-unwind.diff
index 38ec8a5b0c72e..ca8f92df5de0c 100644
--- a/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-unwind.diff
+++ b/tests/mir-opt/lower_slice_len.bound.LowerSliceLenCalls.panic-unwind.diff
@@ -16,7 +16,7 @@
       bb0: {
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
           StorageLive(_6);
           _6 = &(*_2);
@@ -35,14 +35,14 @@
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_7);
-          _7 = _1;
+          _7 = copy _1;
           _8 = Len((*_2));
-          _9 = Lt(_7, _8);
-          assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, _7) -> [success: bb3, unwind continue];
+          _9 = Lt(copy _7, copy _8);
+          assert(move _9, "index out of bounds: the length is {} but the index is {}", move _8, copy _7) -> [success: bb3, unwind continue];
       }
   
       bb3: {
-          _0 = (*_2)[_7];
+          _0 = copy (*_2)[_7];
           StorageDead(_7);
           goto -> bb5;
       }
diff --git a/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff b/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff
index 3c4a84bc24368..b3eb3e1f8b9d2 100644
--- a/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff
+++ b/tests/mir-opt/match_arm_scopes.complicated_match.panic-abort.SimplifyCfg-initial.after-ElaborateDrops.after.diff
@@ -32,22 +32,22 @@
   
       bb0: {
           PlaceMention(_2);
--         switchInt((_2.0: bool)) -> [0: bb2, otherwise: bb1];
-+         switchInt((_2.0: bool)) -> [0: bb6, otherwise: bb1];
+-         switchInt(copy (_2.0: bool)) -> [0: bb2, otherwise: bb1];
++         switchInt(copy (_2.0: bool)) -> [0: bb6, otherwise: bb1];
       }
   
       bb1: {
--         switchInt((_2.1: bool)) -> [0: bb4, otherwise: bb3];
-+         switchInt((_2.1: bool)) -> [0: bb5, otherwise: bb2];
+-         switchInt(copy (_2.1: bool)) -> [0: bb4, otherwise: bb3];
++         switchInt(copy (_2.1: bool)) -> [0: bb5, otherwise: bb2];
       }
   
       bb2: {
 -         falseEdge -> [real: bb9, imaginary: bb1];
-+         switchInt((_2.0: bool)) -> [0: bb3, otherwise: bb4];
++         switchInt(copy (_2.0: bool)) -> [0: bb3, otherwise: bb4];
       }
   
       bb3: {
--         switchInt((_2.0: bool)) -> [0: bb6, otherwise: bb5];
+-         switchInt(copy (_2.0: bool)) -> [0: bb6, otherwise: bb5];
 -     }
 - 
 -     bb4: {
@@ -60,7 +60,7 @@
 - 
 -     bb6: {
           StorageLive(_15);
-          _15 = (_2.1: bool);
+          _15 = copy (_2.1: bool);
           StorageLive(_16);
           _16 = move (_2.2: std::string::String);
 -         goto -> bb20;
@@ -70,7 +70,7 @@
 -     bb7: {
 +     bb4: {
           StorageLive(_15);
-          _15 = (_2.1: bool);
+          _15 = copy (_2.1: bool);
           StorageLive(_16);
           _16 = move (_2.2: std::string::String);
 -         goto -> bb20;
@@ -87,7 +87,7 @@
 -         _4 = &fake shallow (_2.1: bool);
           StorageLive(_12);
           StorageLive(_13);
-          _13 = _1;
+          _13 = copy _1;
 -         switchInt(move _13) -> [0: bb16, otherwise: bb15];
 +         switchInt(move _13) -> [0: bb13, otherwise: bb12];
       }
@@ -102,7 +102,7 @@
 -         _4 = &fake shallow (_2.1: bool);
           StorageLive(_9);
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
 -         switchInt(move _10) -> [0: bb12, otherwise: bb11];
 +         switchInt(move _10) -> [0: bb9, otherwise: bb8];
       }
@@ -125,7 +125,7 @@
   
 -     bb12: {
 +     bb9: {
-          _9 = (*_6);
+          _9 = copy (*_6);
 -         switchInt(move _9) -> [0: bb14, otherwise: bb13];
 +         switchInt(move _9) -> [0: bb11, otherwise: bb10];
       }
@@ -139,7 +139,7 @@
 -         FakeRead(ForGuardBinding, _6);
 -         FakeRead(ForGuardBinding, _8);
           StorageLive(_5);
-          _5 = (_2.1: bool);
+          _5 = copy (_2.1: bool);
           StorageLive(_7);
           _7 = move (_2.2: std::string::String);
 -         goto -> bb10;
@@ -167,7 +167,7 @@
   
 -     bb16: {
 +     bb13: {
-          _12 = (*_6);
+          _12 = copy (*_6);
 -         switchInt(move _12) -> [0: bb18, otherwise: bb17];
 +         switchInt(move _12) -> [0: bb15, otherwise: bb14];
       }
@@ -181,7 +181,7 @@
 -         FakeRead(ForGuardBinding, _6);
 -         FakeRead(ForGuardBinding, _8);
           StorageLive(_5);
-          _5 = (_2.0: bool);
+          _5 = copy (_2.0: bool);
           StorageLive(_7);
           _7 = move (_2.2: std::string::String);
 -         goto -> bb10;
diff --git a/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff b/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff
index 3c4a84bc24368..b3eb3e1f8b9d2 100644
--- a/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff
+++ b/tests/mir-opt/match_arm_scopes.complicated_match.panic-unwind.SimplifyCfg-initial.after-ElaborateDrops.after.diff
@@ -32,22 +32,22 @@
   
       bb0: {
           PlaceMention(_2);
--         switchInt((_2.0: bool)) -> [0: bb2, otherwise: bb1];
-+         switchInt((_2.0: bool)) -> [0: bb6, otherwise: bb1];
+-         switchInt(copy (_2.0: bool)) -> [0: bb2, otherwise: bb1];
++         switchInt(copy (_2.0: bool)) -> [0: bb6, otherwise: bb1];
       }
   
       bb1: {
--         switchInt((_2.1: bool)) -> [0: bb4, otherwise: bb3];
-+         switchInt((_2.1: bool)) -> [0: bb5, otherwise: bb2];
+-         switchInt(copy (_2.1: bool)) -> [0: bb4, otherwise: bb3];
++         switchInt(copy (_2.1: bool)) -> [0: bb5, otherwise: bb2];
       }
   
       bb2: {
 -         falseEdge -> [real: bb9, imaginary: bb1];
-+         switchInt((_2.0: bool)) -> [0: bb3, otherwise: bb4];
++         switchInt(copy (_2.0: bool)) -> [0: bb3, otherwise: bb4];
       }
   
       bb3: {
--         switchInt((_2.0: bool)) -> [0: bb6, otherwise: bb5];
+-         switchInt(copy (_2.0: bool)) -> [0: bb6, otherwise: bb5];
 -     }
 - 
 -     bb4: {
@@ -60,7 +60,7 @@
 - 
 -     bb6: {
           StorageLive(_15);
-          _15 = (_2.1: bool);
+          _15 = copy (_2.1: bool);
           StorageLive(_16);
           _16 = move (_2.2: std::string::String);
 -         goto -> bb20;
@@ -70,7 +70,7 @@
 -     bb7: {
 +     bb4: {
           StorageLive(_15);
-          _15 = (_2.1: bool);
+          _15 = copy (_2.1: bool);
           StorageLive(_16);
           _16 = move (_2.2: std::string::String);
 -         goto -> bb20;
@@ -87,7 +87,7 @@
 -         _4 = &fake shallow (_2.1: bool);
           StorageLive(_12);
           StorageLive(_13);
-          _13 = _1;
+          _13 = copy _1;
 -         switchInt(move _13) -> [0: bb16, otherwise: bb15];
 +         switchInt(move _13) -> [0: bb13, otherwise: bb12];
       }
@@ -102,7 +102,7 @@
 -         _4 = &fake shallow (_2.1: bool);
           StorageLive(_9);
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
 -         switchInt(move _10) -> [0: bb12, otherwise: bb11];
 +         switchInt(move _10) -> [0: bb9, otherwise: bb8];
       }
@@ -125,7 +125,7 @@
   
 -     bb12: {
 +     bb9: {
-          _9 = (*_6);
+          _9 = copy (*_6);
 -         switchInt(move _9) -> [0: bb14, otherwise: bb13];
 +         switchInt(move _9) -> [0: bb11, otherwise: bb10];
       }
@@ -139,7 +139,7 @@
 -         FakeRead(ForGuardBinding, _6);
 -         FakeRead(ForGuardBinding, _8);
           StorageLive(_5);
-          _5 = (_2.1: bool);
+          _5 = copy (_2.1: bool);
           StorageLive(_7);
           _7 = move (_2.2: std::string::String);
 -         goto -> bb10;
@@ -167,7 +167,7 @@
   
 -     bb16: {
 +     bb13: {
-          _12 = (*_6);
+          _12 = copy (*_6);
 -         switchInt(move _12) -> [0: bb18, otherwise: bb17];
 +         switchInt(move _12) -> [0: bb15, otherwise: bb14];
       }
@@ -181,7 +181,7 @@
 -         FakeRead(ForGuardBinding, _6);
 -         FakeRead(ForGuardBinding, _8);
           StorageLive(_5);
-          _5 = (_2.0: bool);
+          _5 = copy (_2.0: bool);
           StorageLive(_7);
           _7 = move (_2.2: std::string::String);
 -         goto -> bb10;
diff --git a/tests/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff
index 65da13eec50e3..597d93926f169 100644
--- a/tests/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.bar.MatchBranchSimplification.diff
@@ -33,16 +33,16 @@
           StorageLive(_4);
           StorageLive(_5);
           StorageLive(_6);
--         switchInt(_1) -> [7: bb2, otherwise: bb1];
+-         switchInt(copy _1) -> [7: bb2, otherwise: bb1];
 -     }
 - 
 -     bb1: {
 -         _2 = const true;
 -         _3 = const false;
 +         StorageLive(_11);
-+         _11 = _1;
-+         _2 = Ne(_11, const 7_i32);
-+         _3 = Eq(_11, const 7_i32);
++         _11 = copy _1;
++         _2 = Ne(copy _11, const 7_i32);
++         _3 = Eq(copy _11, const 7_i32);
           _4 = const false;
           _5 = const true;
           _6 = ();
@@ -62,13 +62,13 @@
 +         StorageDead(_11);
           StorageDead(_6);
           StorageLive(_7);
-          _7 = _2;
+          _7 = copy _2;
           StorageLive(_8);
-          _8 = _3;
+          _8 = copy _3;
           StorageLive(_9);
-          _9 = _4;
+          _9 = copy _4;
           StorageLive(_10);
-          _10 = _5;
+          _10 = copy _5;
           _0 = (move _7, move _8, move _9, move _10);
           StorageDead(_10);
           StorageDead(_9);
diff --git a/tests/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff
index 052e2e126643e..281f43b355dc0 100644
--- a/tests/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.foo.MatchBranchSimplification.diff
@@ -14,7 +14,7 @@
 -         switchInt(move _3) -> [0: bb2, otherwise: bb1];
 +         StorageLive(_4);
 +         _4 = move _3;
-+         _2 = Eq(_4, const 0_isize);
++         _2 = Eq(copy _4, const 0_isize);
 +         StorageDead(_4);
 +         switchInt(move _2) -> [0: bb2, otherwise: bb1];
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff
index fc34ce7125ec2..cc7e863d13546 100644
--- a/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff
@@ -39,7 +39,7 @@
 -     bb6: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as u128 (IntToInt);
++         _0 = copy _3 as u128 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_nested_if.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_nested_if.MatchBranchSimplification.diff
index 5a71bef93416d..e9143ef1636e6 100644
--- a/tests/mir-opt/matches_reduce_branches.match_nested_if.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_nested_if.MatchBranchSimplification.diff
@@ -46,7 +46,7 @@
 -     bb4: {
 +         StorageLive(_7);
 +         _7 = move _6;
-+         _5 = Ne(_7, const false);
++         _5 = Ne(copy _7, const false);
 +         StorageDead(_7);
 +         StorageLive(_8);
 +         _8 = move _5;
@@ -66,7 +66,7 @@
 -     }
 - 
 -     bb7: {
-+         _4 = Ne(_8, const false);
++         _4 = Ne(copy _8, const false);
 +         StorageDead(_8);
 +         StorageLive(_9);
 +         _9 = move _4;
@@ -86,7 +86,7 @@
 -     }
 - 
 -     bb10: {
-+         _3 = Ne(_9, const false);
++         _3 = Ne(copy _9, const false);
 +         StorageDead(_9);
 +         StorageLive(_10);
 +         _10 = move _3;
@@ -104,10 +104,10 @@
 -     }
 - 
 -     bb12: {
-+         _1 = Ne(_10, const false);
++         _1 = Ne(copy _10, const false);
 +         StorageDead(_10);
           StorageDead(_2);
-          _0 = _1;
+          _0 = copy _1;
           StorageDead(_1);
           return;
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_sext_i8_i16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_sext_i8_i16.MatchBranchSimplification.diff
index 7f8c2ab8d3748..dbd26adc20f93 100644
--- a/tests/mir-opt/matches_reduce_branches.match_sext_i8_i16.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_sext_i8_i16.MatchBranchSimplification.diff
@@ -44,7 +44,7 @@
 -     bb7: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as i16 (IntToInt);
++         _0 = copy _3 as i16 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_sext_i8_u16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_sext_i8_u16.MatchBranchSimplification.diff
index 86d0d0ba6cf57..f273d5388350e 100644
--- a/tests/mir-opt/matches_reduce_branches.match_sext_i8_u16.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_sext_i8_u16.MatchBranchSimplification.diff
@@ -44,7 +44,7 @@
 -     bb7: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as u16 (IntToInt);
++         _0 = copy _3 as u16 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_trunc_i16_i8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_trunc_i16_i8.MatchBranchSimplification.diff
index d3d27be207019..6170cf13c0021 100644
--- a/tests/mir-opt/matches_reduce_branches.match_trunc_i16_i8.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_trunc_i16_i8.MatchBranchSimplification.diff
@@ -69,7 +69,7 @@
 -     bb12: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as i8 (IntToInt);
++         _0 = copy _3 as i8 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_trunc_i16_u8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_trunc_i16_u8.MatchBranchSimplification.diff
index 5fe899148ebc5..c18719ebb55eb 100644
--- a/tests/mir-opt/matches_reduce_branches.match_trunc_i16_u8.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_trunc_i16_u8.MatchBranchSimplification.diff
@@ -69,7 +69,7 @@
 -     bb12: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as u8 (IntToInt);
++         _0 = copy _3 as u8 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_trunc_u16_i8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_trunc_u16_i8.MatchBranchSimplification.diff
index 85f97a13cac94..401049026f27b 100644
--- a/tests/mir-opt/matches_reduce_branches.match_trunc_u16_i8.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_trunc_u16_i8.MatchBranchSimplification.diff
@@ -59,7 +59,7 @@
 -     bb10: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as i8 (IntToInt);
++         _0 = copy _3 as i8 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_trunc_u16_u8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_trunc_u16_u8.MatchBranchSimplification.diff
index 768d838eaa6fc..d4dafbd886fcb 100644
--- a/tests/mir-opt/matches_reduce_branches.match_trunc_u16_u8.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_trunc_u16_u8.MatchBranchSimplification.diff
@@ -59,7 +59,7 @@
 -     bb10: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as u8 (IntToInt);
++         _0 = copy _3 as u8 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i8.MatchBranchSimplification.diff
index d63eed7c019a4..5ab6f5eac84aa 100644
--- a/tests/mir-opt/matches_reduce_branches.match_u8_i8.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_i8.MatchBranchSimplification.diff
@@ -39,7 +39,7 @@
 -     bb6: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as i8 (IntToInt);
++         _0 = copy _3 as i8 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i8_2.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i8_2.MatchBranchSimplification.diff
index 98dee1835a827..f14b3af9660aa 100644
--- a/tests/mir-opt/matches_reduce_branches.match_u8_i8_2.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_i8_2.MatchBranchSimplification.diff
@@ -35,8 +35,8 @@
 -         _3 = const -1_i8;
 +         StorageLive(_8);
 +         _8 = move _5;
-+         _2 = _8 as i8 (IntToInt);
-+         _3 = _8 as i8 (IntToInt);
++         _2 = copy _8 as i8 (IntToInt);
++         _3 = copy _8 as i8 (IntToInt);
           _4 = ();
 -         goto -> bb6;
 -     }
@@ -66,9 +66,9 @@
 +         StorageDead(_8);
           StorageDead(_4);
           StorageLive(_6);
-          _6 = _2;
+          _6 = copy _2;
           StorageLive(_7);
-          _7 = _3;
+          _7 = copy _3;
           _0 = (move _6, move _7);
           StorageDead(_7);
           StorageDead(_6);
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i8_2_failed.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i8_2_failed.MatchBranchSimplification.diff
index 901dda5861775..92e1a7dbc7d61 100644
--- a/tests/mir-opt/matches_reduce_branches.match_u8_i8_2_failed.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_i8_2_failed.MatchBranchSimplification.diff
@@ -60,9 +60,9 @@
       bb6: {
           StorageDead(_4);
           StorageLive(_6);
-          _6 = _2;
+          _6 = copy _2;
           StorageLive(_7);
-          _7 = _3;
+          _7 = copy _3;
           _0 = (move _6, move _7);
           StorageDead(_7);
           StorageDead(_6);
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_1.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_1.MatchBranchSimplification.diff
index 9ebf2cf27cbf7..a1d58424ecd1a 100644
--- a/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_1.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_1.MatchBranchSimplification.diff
@@ -7,7 +7,7 @@
   
       bb0: {
           _2 = discriminant(_1);
-          switchInt(_2) -> [0: bb1, 127: bb2, 128: bb3, 255: bb4, otherwise: bb5];
+          switchInt(copy _2) -> [0: bb1, 127: bb2, 128: bb3, 255: bb4, otherwise: bb5];
       }
   
       bb1: {
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_2.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_2.MatchBranchSimplification.diff
index 554856777eb6e..6c4ade1b6ca96 100644
--- a/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_2.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_i8_failed_len_2.MatchBranchSimplification.diff
@@ -7,7 +7,7 @@
   
       bb0: {
           _2 = discriminant(_1);
-          switchInt(_2) -> [0: bb1, 127: bb2, 128: bb3, 255: bb4, otherwise: bb5];
+          switchInt(copy _2) -> [0: bb1, 127: bb2, 128: bb3, 255: bb4, otherwise: bb5];
       }
   
       bb1: {
diff --git a/tests/mir-opt/matches_reduce_branches.match_zext_u8_i16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_zext_u8_i16.MatchBranchSimplification.diff
index e00a604fe25da..fdf83d91bbd38 100644
--- a/tests/mir-opt/matches_reduce_branches.match_zext_u8_i16.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_zext_u8_i16.MatchBranchSimplification.diff
@@ -39,7 +39,7 @@
 -     bb6: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as i16 (IntToInt);
++         _0 = copy _3 as i16 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_reduce_branches.match_zext_u8_u16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_zext_u8_u16.MatchBranchSimplification.diff
index befb9118907b4..a888d247275fd 100644
--- a/tests/mir-opt/matches_reduce_branches.match_zext_u8_u16.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_reduce_branches.match_zext_u8_u16.MatchBranchSimplification.diff
@@ -39,7 +39,7 @@
 -     bb6: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as u16 (IntToInt);
++         _0 = copy _3 as u16 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff b/tests/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff
index 11a18f58e3a1f..99985b28382f5 100644
--- a/tests/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_u8.exhaustive_match.MatchBranchSimplification.diff
@@ -29,7 +29,7 @@
 -     bb4: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as u8 (IntToInt);
++         _0 = copy _3 as u8 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff b/tests/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff
index 809badc41ba71..0fc5032691fed 100644
--- a/tests/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff
+++ b/tests/mir-opt/matches_u8.exhaustive_match_i8.MatchBranchSimplification.diff
@@ -29,7 +29,7 @@
 -     bb4: {
 +         StorageLive(_3);
 +         _3 = move _2;
-+         _0 = _3 as i8 (IntToInt);
++         _0 = copy _3 as i8 (IntToInt);
 +         StorageDead(_3);
           return;
       }
diff --git a/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.32bit.mir b/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.32bit.mir
index ad456600b0ab6..d09a422d4080e 100644
--- a/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.32bit.mir
+++ b/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.32bit.mir
@@ -50,15 +50,15 @@ fn main() -> () {
         StorageLive(_3);
         _3 = const ConstValue(Scalar(0x00000000): usize);
         _4 = Len(_1);
-        _5 = Lt(_3, _4);
-        assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind: bb7];
+        _5 = Lt(copy _3, copy _4);
+        assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind: bb7];
     }
 
     bb1: {
         _2 = &'?2 _1[_3];
         FakeRead(ForLet(None), _2);
         StorageLive(_6);
-        _6 = _2;
+        _6 = copy _2;
         FakeRead(ForLet(None), _6);
         StorageLive(_7);
         _7 = const ConstValue(Scalar(0x01): bool);
@@ -68,7 +68,7 @@ fn main() -> () {
     bb2: {
         StorageLive(_8);
         StorageLive(_9);
-        _9 = (*_6);
+        _9 = copy (*_6);
         _8 = ConstValue(ZeroSized: fn(usize) -> bool {use_x})(move _9) -> [return: bb3, unwind: bb7];
     }
 
diff --git a/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.64bit.mir b/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.64bit.mir
index a15d47cd66fef..4abb5b0b93b11 100644
--- a/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.64bit.mir
+++ b/tests/mir-opt/nll/region_subtyping_basic.main.nll.0.64bit.mir
@@ -50,15 +50,15 @@ fn main() -> () {
         StorageLive(_3);
         _3 = const ConstValue(Scalar(0x0000000000000000): usize);
         _4 = Len(_1);
-        _5 = Lt(_3, _4);
-        assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, _3) -> [success: bb1, unwind: bb7];
+        _5 = Lt(copy _3, copy _4);
+        assert(move _5, "index out of bounds: the length is {} but the index is {}", move _4, copy _3) -> [success: bb1, unwind: bb7];
     }
 
     bb1: {
         _2 = &'?2 _1[_3];
         FakeRead(ForLet(None), _2);
         StorageLive(_6);
-        _6 = _2;
+        _6 = copy _2;
         FakeRead(ForLet(None), _6);
         StorageLive(_7);
         _7 = const ConstValue(Scalar(0x01): bool);
@@ -68,7 +68,7 @@ fn main() -> () {
     bb2: {
         StorageLive(_8);
         StorageLive(_9);
-        _9 = (*_6);
+        _9 = copy (*_6);
         _8 = ConstValue(ZeroSized: fn(usize) -> bool {use_x})(move _9) -> [return: bb3, unwind: bb7];
     }
 
diff --git a/tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff b/tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff
index 260b472daa92a..d248c76f261b6 100644
--- a/tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff
+++ b/tests/mir-opt/nrvo_miscompile_111005.wrong.RenameReturnPlace.diff
@@ -6,10 +6,10 @@
       let mut _2: char;
   
       bb0: {
--         _2 = _1;
--         _0 = _2;
+-         _2 = copy _1;
+-         _0 = copy _2;
 -         _2 = const 'b';
-+         _0 = _1;
++         _0 = copy _1;
 +         _0 = const 'b';
           return;
       }
diff --git a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff b/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff
index f7bc5559ab7b4..6dce3ec5303d7 100644
--- a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff
+++ b/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-abort.diff
@@ -20,7 +20,7 @@
 +         _0 = [const 0_u8; 1024];
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
           StorageLive(_6);
 -         _6 = &mut _2;
@@ -34,7 +34,7 @@
           StorageDead(_4);
           StorageDead(_6);
           StorageDead(_3);
--         _0 = _2;
+-         _0 = copy _2;
 -         StorageDead(_2);
           return;
       }
diff --git a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff b/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff
index 3df8e567f1fe0..54cbe2871f15a 100644
--- a/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff
+++ b/tests/mir-opt/nrvo_simple.nrvo.RenameReturnPlace.panic-unwind.diff
@@ -20,7 +20,7 @@
 +         _0 = [const 0_u8; 1024];
           StorageLive(_3);
           StorageLive(_4);
-          _4 = _1;
+          _4 = copy _1;
           StorageLive(_5);
           StorageLive(_6);
 -         _6 = &mut _2;
@@ -34,7 +34,7 @@
           StorageDead(_4);
           StorageDead(_6);
           StorageDead(_3);
--         _0 = _2;
+-         _0 = copy _2;
 -         StorageDead(_2);
           return;
       }
diff --git a/tests/mir-opt/or_pattern.shortcut_second_or.SimplifyCfg-initial.after.mir b/tests/mir-opt/or_pattern.shortcut_second_or.SimplifyCfg-initial.after.mir
index 6c76a72b77577..c5d7a6a1d9965 100644
--- a/tests/mir-opt/or_pattern.shortcut_second_or.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/or_pattern.shortcut_second_or.SimplifyCfg-initial.after.mir
@@ -18,15 +18,15 @@ fn shortcut_second_or() -> () {
         _1 = (move _2, const 0_i32);
         StorageDead(_2);
         PlaceMention(_1);
-        switchInt(((_1.0: (i32, i32)).0: i32)) -> [0: bb2, otherwise: bb1];
+        switchInt(copy ((_1.0: (i32, i32)).0: i32)) -> [0: bb2, otherwise: bb1];
     }
 
     bb1: {
-        switchInt(((_1.0: (i32, i32)).1: i32)) -> [1: bb4, otherwise: bb3];
+        switchInt(copy ((_1.0: (i32, i32)).1: i32)) -> [1: bb4, otherwise: bb3];
     }
 
     bb2: {
-        switchInt((_1.1: i32)) -> [2: bb5, 3: bb6, otherwise: bb3];
+        switchInt(copy (_1.1: i32)) -> [2: bb5, 3: bb6, otherwise: bb3];
     }
 
     bb3: {
@@ -35,7 +35,7 @@ fn shortcut_second_or() -> () {
     }
 
     bb4: {
-        switchInt((_1.1: i32)) -> [2: bb7, 3: bb8, otherwise: bb3];
+        switchInt(copy (_1.1: i32)) -> [2: bb7, 3: bb8, otherwise: bb3];
     }
 
     bb5: {
@@ -56,33 +56,33 @@ fn shortcut_second_or() -> () {
 
     bb9: {
         StorageLive(_3);
-        _3 = (_1.0: (i32, i32));
+        _3 = copy (_1.0: (i32, i32));
         StorageLive(_4);
-        _4 = (_1.1: i32);
+        _4 = copy (_1.1: i32);
         goto -> bb13;
     }
 
     bb10: {
         StorageLive(_3);
-        _3 = (_1.0: (i32, i32));
+        _3 = copy (_1.0: (i32, i32));
         StorageLive(_4);
-        _4 = (_1.1: i32);
+        _4 = copy (_1.1: i32);
         goto -> bb13;
     }
 
     bb11: {
         StorageLive(_3);
-        _3 = (_1.0: (i32, i32));
+        _3 = copy (_1.0: (i32, i32));
         StorageLive(_4);
-        _4 = (_1.1: i32);
+        _4 = copy (_1.1: i32);
         goto -> bb13;
     }
 
     bb12: {
         StorageLive(_3);
-        _3 = (_1.0: (i32, i32));
+        _3 = copy (_1.0: (i32, i32));
         StorageLive(_4);
-        _4 = (_1.1: i32);
+        _4 = copy (_1.1: i32);
         goto -> bb13;
     }
 
diff --git a/tests/mir-opt/or_pattern.single_switchint.SimplifyCfg-initial.after.mir b/tests/mir-opt/or_pattern.single_switchint.SimplifyCfg-initial.after.mir
index 8b0ef7b29d7be..889ff6f9f5e2b 100644
--- a/tests/mir-opt/or_pattern.single_switchint.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/or_pattern.single_switchint.SimplifyCfg-initial.after.mir
@@ -10,15 +10,15 @@ fn single_switchint() -> () {
         StorageLive(_2);
         _2 = (const 1_i32, const true);
         PlaceMention(_2);
-        switchInt((_2.0: i32)) -> [1: bb2, 2: bb4, otherwise: bb1];
+        switchInt(copy (_2.0: i32)) -> [1: bb2, 2: bb4, otherwise: bb1];
     }
 
     bb1: {
-        switchInt((_2.0: i32)) -> [3: bb8, 4: bb8, otherwise: bb7];
+        switchInt(copy (_2.0: i32)) -> [3: bb8, 4: bb8, otherwise: bb7];
     }
 
     bb2: {
-        switchInt((_2.1: bool)) -> [0: bb6, otherwise: bb3];
+        switchInt(copy (_2.1: bool)) -> [0: bb6, otherwise: bb3];
     }
 
     bb3: {
@@ -26,7 +26,7 @@ fn single_switchint() -> () {
     }
 
     bb4: {
-        switchInt((_2.1: bool)) -> [0: bb5, otherwise: bb6];
+        switchInt(copy (_2.1: bool)) -> [0: bb5, otherwise: bb6];
     }
 
     bb5: {
diff --git a/tests/mir-opt/pre-codegen/chained_comparison.bitand.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/chained_comparison.bitand.PreCodegen.after.mir
index 99ca659c637b1..9b77bdb7cf616 100644
--- a/tests/mir-opt/pre-codegen/chained_comparison.bitand.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/chained_comparison.bitand.PreCodegen.after.mir
@@ -29,17 +29,17 @@ fn bitand(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageLive(_9);
         StorageLive(_5);
         StorageLive(_3);
-        _3 = ((*_1).0: u32);
+        _3 = copy ((*_1).0: u32);
         StorageLive(_4);
-        _4 = ((*_2).0: u32);
+        _4 = copy ((*_2).0: u32);
         _5 = Eq(move _3, move _4);
         StorageDead(_4);
         StorageDead(_3);
         StorageLive(_8);
         StorageLive(_6);
-        _6 = ((*_1).1: u32);
+        _6 = copy ((*_1).1: u32);
         StorageLive(_7);
-        _7 = ((*_2).1: u32);
+        _7 = copy ((*_2).1: u32);
         _8 = Eq(move _6, move _7);
         StorageDead(_7);
         StorageDead(_6);
@@ -48,9 +48,9 @@ fn bitand(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_5);
         StorageLive(_12);
         StorageLive(_10);
-        _10 = ((*_1).2: u32);
+        _10 = copy ((*_1).2: u32);
         StorageLive(_11);
-        _11 = ((*_2).2: u32);
+        _11 = copy ((*_2).2: u32);
         _12 = Eq(move _10, move _11);
         StorageDead(_11);
         StorageDead(_10);
@@ -59,9 +59,9 @@ fn bitand(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_9);
         StorageLive(_16);
         StorageLive(_14);
-        _14 = ((*_1).3: u32);
+        _14 = copy ((*_1).3: u32);
         StorageLive(_15);
-        _15 = ((*_2).3: u32);
+        _15 = copy ((*_2).3: u32);
         _16 = Eq(move _14, move _15);
         StorageDead(_15);
         StorageDead(_14);
@@ -70,9 +70,9 @@ fn bitand(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_13);
         StorageLive(_20);
         StorageLive(_18);
-        _18 = ((*_1).4: u32);
+        _18 = copy ((*_1).4: u32);
         StorageLive(_19);
-        _19 = ((*_2).4: u32);
+        _19 = copy ((*_2).4: u32);
         _20 = Eq(move _18, move _19);
         StorageDead(_19);
         StorageDead(_18);
diff --git a/tests/mir-opt/pre-codegen/chained_comparison.naive.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/chained_comparison.naive.PreCodegen.after.mir
index 838e30fa35ebb..9b3e28ab5b8ea 100644
--- a/tests/mir-opt/pre-codegen/chained_comparison.naive.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/chained_comparison.naive.PreCodegen.after.mir
@@ -22,9 +22,9 @@ fn naive(_1: &Blueprint, _2: &Blueprint) -> bool {
     bb0: {
         StorageLive(_5);
         StorageLive(_3);
-        _3 = ((*_1).0: u32);
+        _3 = copy ((*_1).0: u32);
         StorageLive(_4);
-        _4 = ((*_2).0: u32);
+        _4 = copy ((*_2).0: u32);
         _5 = Eq(move _3, move _4);
         switchInt(move _5) -> [0: bb1, otherwise: bb2];
     }
@@ -40,9 +40,9 @@ fn naive(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_3);
         StorageLive(_8);
         StorageLive(_6);
-        _6 = ((*_1).1: u32);
+        _6 = copy ((*_1).1: u32);
         StorageLive(_7);
-        _7 = ((*_2).1: u32);
+        _7 = copy ((*_2).1: u32);
         _8 = Eq(move _6, move _7);
         switchInt(move _8) -> [0: bb3, otherwise: bb4];
     }
@@ -58,9 +58,9 @@ fn naive(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_6);
         StorageLive(_11);
         StorageLive(_9);
-        _9 = ((*_1).2: u32);
+        _9 = copy ((*_1).2: u32);
         StorageLive(_10);
-        _10 = ((*_2).2: u32);
+        _10 = copy ((*_2).2: u32);
         _11 = Eq(move _9, move _10);
         switchInt(move _11) -> [0: bb5, otherwise: bb6];
     }
@@ -76,9 +76,9 @@ fn naive(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_9);
         StorageLive(_14);
         StorageLive(_12);
-        _12 = ((*_1).3: u32);
+        _12 = copy ((*_1).3: u32);
         StorageLive(_13);
-        _13 = ((*_2).3: u32);
+        _13 = copy ((*_2).3: u32);
         _14 = Eq(move _12, move _13);
         switchInt(move _14) -> [0: bb7, otherwise: bb9];
     }
@@ -98,9 +98,9 @@ fn naive(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_13);
         StorageDead(_12);
         StorageLive(_15);
-        _15 = ((*_1).4: u32);
+        _15 = copy ((*_1).4: u32);
         StorageLive(_16);
-        _16 = ((*_2).4: u32);
+        _16 = copy ((*_2).4: u32);
         _0 = Eq(move _15, move _16);
         StorageDead(_16);
         StorageDead(_15);
diff --git a/tests/mir-opt/pre-codegen/chained_comparison.returning.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/chained_comparison.returning.PreCodegen.after.mir
index 8452fa12f31de..72d52701d112d 100644
--- a/tests/mir-opt/pre-codegen/chained_comparison.returning.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/chained_comparison.returning.PreCodegen.after.mir
@@ -23,9 +23,9 @@ fn returning(_1: &Blueprint, _2: &Blueprint) -> bool {
     bb0: {
         StorageLive(_5);
         StorageLive(_3);
-        _3 = ((*_1).0: u32);
+        _3 = copy ((*_1).0: u32);
         StorageLive(_4);
-        _4 = ((*_2).0: u32);
+        _4 = copy ((*_2).0: u32);
         _5 = Ne(move _3, move _4);
         switchInt(move _5) -> [0: bb1, otherwise: bb10];
     }
@@ -36,9 +36,9 @@ fn returning(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_5);
         StorageLive(_8);
         StorageLive(_6);
-        _6 = ((*_1).1: u32);
+        _6 = copy ((*_1).1: u32);
         StorageLive(_7);
-        _7 = ((*_2).1: u32);
+        _7 = copy ((*_2).1: u32);
         _8 = Ne(move _6, move _7);
         switchInt(move _8) -> [0: bb2, otherwise: bb9];
     }
@@ -49,9 +49,9 @@ fn returning(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_8);
         StorageLive(_11);
         StorageLive(_9);
-        _9 = ((*_1).2: u32);
+        _9 = copy ((*_1).2: u32);
         StorageLive(_10);
-        _10 = ((*_2).2: u32);
+        _10 = copy ((*_2).2: u32);
         _11 = Ne(move _9, move _10);
         switchInt(move _11) -> [0: bb3, otherwise: bb8];
     }
@@ -62,9 +62,9 @@ fn returning(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_11);
         StorageLive(_14);
         StorageLive(_12);
-        _12 = ((*_1).3: u32);
+        _12 = copy ((*_1).3: u32);
         StorageLive(_13);
-        _13 = ((*_2).3: u32);
+        _13 = copy ((*_2).3: u32);
         _14 = Ne(move _12, move _13);
         switchInt(move _14) -> [0: bb4, otherwise: bb7];
     }
@@ -75,9 +75,9 @@ fn returning(_1: &Blueprint, _2: &Blueprint) -> bool {
         StorageDead(_14);
         StorageLive(_17);
         StorageLive(_15);
-        _15 = ((*_1).4: u32);
+        _15 = copy ((*_1).4: u32);
         StorageLive(_16);
-        _16 = ((*_2).4: u32);
+        _16 = copy ((*_2).4: u32);
         _17 = Ne(move _15, move _16);
         switchInt(move _17) -> [0: bb5, otherwise: bb6];
     }
diff --git a/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-abort.mir
index 4edf0d2c47c05..a9dd8886577dd 100644
--- a/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-abort.mir
@@ -17,7 +17,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option<u32> {
 
     bb0: {
         StorageLive(_3);
-        _3 = Lt(_2, const core::num::<impl u32>::BITS);
+        _3 = Lt(copy _2, const core::num::<impl u32>::BITS);
         switchInt(move _3) -> [0: bb1, otherwise: bb2];
     }
 
@@ -28,7 +28,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option<u32> {
 
     bb2: {
         StorageLive(_4);
-        _4 = ShlUnchecked(_1, _2);
+        _4 = ShlUnchecked(copy _1, copy _2);
         _0 = Option::<u32>::Some(move _4);
         StorageDead(_4);
         goto -> bb3;
diff --git a/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-unwind.mir
index 4edf0d2c47c05..a9dd8886577dd 100644
--- a/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/checked_ops.checked_shl.PreCodegen.after.panic-unwind.mir
@@ -17,7 +17,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option<u32> {
 
     bb0: {
         StorageLive(_3);
-        _3 = Lt(_2, const core::num::<impl u32>::BITS);
+        _3 = Lt(copy _2, const core::num::<impl u32>::BITS);
         switchInt(move _3) -> [0: bb1, otherwise: bb2];
     }
 
@@ -28,7 +28,7 @@ fn checked_shl(_1: u32, _2: u32) -> Option<u32> {
 
     bb2: {
         StorageLive(_4);
-        _4 = ShlUnchecked(_1, _2);
+        _4 = ShlUnchecked(copy _1, copy _2);
         _0 = Option::<u32>::Some(move _4);
         StorageDead(_4);
         goto -> bb3;
diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir
index 69c11ebcacced..935e67fc3c0a9 100644
--- a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-abort.mir
@@ -32,18 +32,18 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     bb0: {
         StorageLive(_4);
         StorageLive(_3);
-        _3 = Gt(_2, const 65535_usize);
+        _3 = Gt(copy _2, const 65535_usize);
         switchInt(move _3) -> [0: bb1, otherwise: bb5];
     }
 
     bb1: {
-        _4 = _2 as u16 (IntToInt);
+        _4 = copy _2 as u16 (IntToInt);
         StorageDead(_3);
         StorageLive(_7);
         StorageLive(_6);
         StorageLive(_5);
-        _5 = AddWithOverflow(_1, _4);
-        _6 = (_5.1: bool);
+        _5 = AddWithOverflow(copy _1, copy _4);
+        _6 = copy (_5.1: bool);
         _7 = unlikely(move _6) -> [return: bb2, unwind unreachable];
     }
 
@@ -76,8 +76,8 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
 
     bb7: {
         StorageLive(_8);
-        _8 = _2 as u16 (IntToInt);
-        _0 = Add(_1, _8);
+        _8 = copy _2 as u16 (IntToInt);
+        _0 = Add(copy _1, copy _8);
         StorageDead(_8);
         StorageDead(_4);
         return;
diff --git a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir
index e6ea6c510019c..bf1ffd1ef328d 100644
--- a/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/checked_ops.step_forward.PreCodegen.after.panic-unwind.mir
@@ -32,18 +32,18 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
     bb0: {
         StorageLive(_4);
         StorageLive(_3);
-        _3 = Gt(_2, const 65535_usize);
+        _3 = Gt(copy _2, const 65535_usize);
         switchInt(move _3) -> [0: bb1, otherwise: bb5];
     }
 
     bb1: {
-        _4 = _2 as u16 (IntToInt);
+        _4 = copy _2 as u16 (IntToInt);
         StorageDead(_3);
         StorageLive(_7);
         StorageLive(_6);
         StorageLive(_5);
-        _5 = AddWithOverflow(_1, _4);
-        _6 = (_5.1: bool);
+        _5 = AddWithOverflow(copy _1, copy _4);
+        _6 = copy (_5.1: bool);
         _7 = unlikely(move _6) -> [return: bb2, unwind unreachable];
     }
 
@@ -76,8 +76,8 @@ fn step_forward(_1: u16, _2: usize) -> u16 {
 
     bb7: {
         StorageLive(_8);
-        _8 = _2 as u16 (IntToInt);
-        _0 = Add(_1, _8);
+        _8 = copy _2 as u16 (IntToInt);
+        _0 = Add(copy _1, copy _8);
         StorageDead(_8);
         StorageDead(_4);
         return;
diff --git a/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir
index 47f10451b057c..5f4ec1de2701f 100644
--- a/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/derived_ord.{impl#0}-partial_cmp.PreCodegen.after.mir
@@ -22,13 +22,13 @@ fn <impl at $DIR/derived_ord.rs:6:10: 6:20>::partial_cmp(_1: &MultiField, _2: &M
 
     bb0: {
         StorageLive(_3);
-        _3 = ((*_1).0: char);
+        _3 = copy ((*_1).0: char);
         StorageLive(_4);
-        _4 = ((*_2).0: char);
+        _4 = copy ((*_2).0: char);
         _5 = Cmp(move _3, move _4);
         StorageDead(_4);
         StorageDead(_3);
-        _6 = Option::<std::cmp::Ordering>::Some(_5);
+        _6 = Option::<std::cmp::Ordering>::Some(copy _5);
         _7 = discriminant(_5);
         switchInt(move _7) -> [0: bb1, otherwise: bb2];
     }
@@ -36,9 +36,9 @@ fn <impl at $DIR/derived_ord.rs:6:10: 6:20>::partial_cmp(_1: &MultiField, _2: &M
     bb1: {
         StorageLive(_10);
         StorageLive(_8);
-        _8 = ((*_1).1: i16);
+        _8 = copy ((*_1).1: i16);
         StorageLive(_9);
-        _9 = ((*_2).1: i16);
+        _9 = copy ((*_2).1: i16);
         _10 = Cmp(move _8, move _9);
         StorageDead(_9);
         StorageDead(_8);
@@ -48,7 +48,7 @@ fn <impl at $DIR/derived_ord.rs:6:10: 6:20>::partial_cmp(_1: &MultiField, _2: &M
     }
 
     bb2: {
-        _0 = _6;
+        _0 = copy _6;
         goto -> bb3;
     }
 
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
index 30c122ddea03b..6cac8b109eea6 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-abort.diff
@@ -73,12 +73,12 @@
           StorageLive(_6);
           StorageLive(_7);
           _9 = const main::promoted[0];
-          _7 = _9;
+          _7 = copy _9;
           StorageLive(_8);
--         _8 = _1;
+-         _8 = copy _1;
 -         _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb4, unwind unreachable];
 +         _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }};
-+         _6 = std::alloc::Global::alloc_impl(_9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable];
++         _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
@@ -93,7 +93,7 @@
       bb5: {
           StorageLive(_15);
           _16 = &_13;
-          _15 = _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
+          _15 = copy _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
           _14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable;
       }
   
@@ -104,14 +104,14 @@
           StorageDead(_6);
 -         StorageLive(_17);
 +         nop;
-          _17 = (_5.0: *const [u8]);
+          _17 = copy (_5.0: *const [u8]);
 -         _4 = move _17 as *mut [u8] (PtrToPtr);
 -         StorageDead(_17);
-+         _4 = _17 as *mut [u8] (PtrToPtr);
++         _4 = copy _17 as *mut [u8] (PtrToPtr);
 +         nop;
           StorageDead(_5);
 -         _3 = move _4 as *mut u8 (PtrToPtr);
-+         _3 = _17 as *mut u8 (PtrToPtr);
++         _3 = copy _17 as *mut u8 (PtrToPtr);
           StorageDead(_4);
           StorageDead(_3);
 -         StorageDead(_1);
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff
index 93449462c3d08..5fcece2280d48 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.32bit.panic-unwind.diff
@@ -47,14 +47,14 @@
           StorageDead(_6);
 -         StorageLive(_12);
 +         nop;
-          _12 = (_5.0: *const [u8]);
+          _12 = copy (_5.0: *const [u8]);
 -         _4 = move _12 as *mut [u8] (PtrToPtr);
 -         StorageDead(_12);
-+         _4 = _12 as *mut [u8] (PtrToPtr);
++         _4 = copy _12 as *mut [u8] (PtrToPtr);
 +         nop;
           StorageDead(_5);
 -         _3 = move _4 as *mut u8 (PtrToPtr);
-+         _3 = _12 as *mut u8 (PtrToPtr);
++         _3 = copy _12 as *mut u8 (PtrToPtr);
           StorageDead(_4);
           StorageDead(_3);
 -         StorageDead(_1);
@@ -81,12 +81,12 @@
           StorageLive(_6);
           StorageLive(_7);
           _9 = const main::promoted[0];
-          _7 = _9;
+          _7 = copy _9;
           StorageLive(_8);
--         _8 = _1;
+-         _8 = copy _1;
 -         _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb5, unwind continue];
 +         _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }};
-+         _6 = std::alloc::Global::alloc_impl(_9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue];
++         _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(4 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x00000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue];
       }
   
       bb5: {
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
index 44435956ec418..10fde25e3178b 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-abort.diff
@@ -73,12 +73,12 @@
           StorageLive(_6);
           StorageLive(_7);
           _9 = const main::promoted[0];
-          _7 = _9;
+          _7 = copy _9;
           StorageLive(_8);
--         _8 = _1;
+-         _8 = copy _1;
 -         _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb4, unwind unreachable];
 +         _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }};
-+         _6 = std::alloc::Global::alloc_impl(_9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable];
++         _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb4, unwind unreachable];
       }
   
       bb4: {
@@ -93,7 +93,7 @@
       bb5: {
           StorageLive(_15);
           _16 = &_13;
-          _15 = _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
+          _15 = copy _16 as &dyn std::fmt::Debug (PointerCoercion(Unsize));
           _14 = result::unwrap_failed(const "called `Result::unwrap()` on an `Err` value", move _15) -> unwind unreachable;
       }
   
@@ -104,14 +104,14 @@
           StorageDead(_6);
 -         StorageLive(_17);
 +         nop;
-          _17 = (_5.0: *const [u8]);
+          _17 = copy (_5.0: *const [u8]);
 -         _4 = move _17 as *mut [u8] (PtrToPtr);
 -         StorageDead(_17);
-+         _4 = _17 as *mut [u8] (PtrToPtr);
++         _4 = copy _17 as *mut [u8] (PtrToPtr);
 +         nop;
           StorageDead(_5);
 -         _3 = move _4 as *mut u8 (PtrToPtr);
-+         _3 = _17 as *mut u8 (PtrToPtr);
++         _3 = copy _17 as *mut u8 (PtrToPtr);
           StorageDead(_4);
           StorageDead(_3);
 -         StorageDead(_1);
diff --git a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff
index c958480a9c71b..0821ea272bf50 100644
--- a/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/issue_117368_print_invalid_constant.main.GVN.64bit.panic-unwind.diff
@@ -47,14 +47,14 @@
           StorageDead(_6);
 -         StorageLive(_12);
 +         nop;
-          _12 = (_5.0: *const [u8]);
+          _12 = copy (_5.0: *const [u8]);
 -         _4 = move _12 as *mut [u8] (PtrToPtr);
 -         StorageDead(_12);
-+         _4 = _12 as *mut [u8] (PtrToPtr);
++         _4 = copy _12 as *mut [u8] (PtrToPtr);
 +         nop;
           StorageDead(_5);
 -         _3 = move _4 as *mut u8 (PtrToPtr);
-+         _3 = _12 as *mut u8 (PtrToPtr);
++         _3 = copy _12 as *mut u8 (PtrToPtr);
           StorageDead(_4);
           StorageDead(_3);
 -         StorageDead(_1);
@@ -81,12 +81,12 @@
           StorageLive(_6);
           StorageLive(_7);
           _9 = const main::promoted[0];
-          _7 = _9;
+          _7 = copy _9;
           StorageLive(_8);
--         _8 = _1;
+-         _8 = copy _1;
 -         _6 = std::alloc::Global::alloc_impl(move _7, move _8, const false) -> [return: bb5, unwind continue];
 +         _8 = const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }};
-+         _6 = std::alloc::Global::alloc_impl(_9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue];
++         _6 = std::alloc::Global::alloc_impl(copy _9, const Layout {{ size: Indirect { alloc_id: ALLOC0, offset: Size(8 bytes) }: usize, align: std::ptr::Alignment(Scalar(0x0000000000000000): std::ptr::alignment::AlignmentEnum) }}, const false) -> [return: bb5, unwind continue];
       }
   
       bb5: {
diff --git a/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir
index 8d182069adc99..75e8cb1d8618c 100644
--- a/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/loops.filter_mapped.PreCodegen.after.mir
@@ -32,7 +32,7 @@ fn filter_mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> Option<U>) -> ()
 
     bb1: {
         StorageLive(_4);
-        _4 = _3;
+        _4 = copy _3;
         goto -> bb2;
     }
 
diff --git a/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir
index cdb7eea74fba0..be69bbf10e77f 100644
--- a/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/loops.int_range.PreCodegen.after.mir
@@ -41,9 +41,9 @@ fn int_range(_1: usize, _2: usize) -> () {
     }
 
     bb0: {
-        _3 = std::ops::Range::<usize> { start: _1, end: _2 };
+        _3 = std::ops::Range::<usize> { start: copy _1, end: copy _2 };
         StorageLive(_4);
-        _4 = _3;
+        _4 = copy _3;
         goto -> bb1;
     }
 
@@ -57,9 +57,9 @@ fn int_range(_1: usize, _2: usize) -> () {
         StorageLive(_7);
         _7 = &(_4.1: usize);
         StorageLive(_8);
-        _8 = (_4.0: usize);
+        _8 = copy (_4.0: usize);
         StorageLive(_9);
-        _9 = (_4.1: usize);
+        _9 = copy (_4.1: usize);
         _10 = Lt(move _8, move _9);
         StorageDead(_9);
         StorageDead(_8);
@@ -79,18 +79,18 @@ fn int_range(_1: usize, _2: usize) -> () {
     bb3: {
         StorageDead(_7);
         StorageDead(_6);
-        _11 = (_4.0: usize);
+        _11 = copy (_4.0: usize);
         StorageLive(_12);
-        _12 = <usize as Step>::forward_unchecked(_11, const 1_usize) -> [return: bb4, unwind continue];
+        _12 = <usize as Step>::forward_unchecked(copy _11, const 1_usize) -> [return: bb4, unwind continue];
     }
 
     bb4: {
         (_4.0: usize) = move _12;
         StorageDead(_12);
-        _13 = Option::<usize>::Some(_11);
+        _13 = Option::<usize>::Some(copy _11);
         StorageDead(_10);
         StorageDead(_11);
-        _14 = ((_13 as Some).0: usize);
+        _14 = copy ((_13 as Some).0: usize);
         _15 = opaque::<usize>(move _14) -> [return: bb5, unwind continue];
     }
 
diff --git a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir
index 51d41e9ff051a..4977f39ccefe8 100644
--- a/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/loops.mapped.PreCodegen.after.mir
@@ -43,7 +43,7 @@ fn mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> U) -> () {
 
     bb1: {
         StorageLive(_4);
-        _4 = _3;
+        _4 = copy _3;
         goto -> bb2;
     }
 
@@ -84,7 +84,7 @@ fn mapped(_1: impl Iterator<Item = T>, _2: impl Fn(T) -> U) -> () {
         _10 = move ((_7 as Some).0: T);
         StorageLive(_12);
         StorageLive(_11);
-        _11 = (_10,);
+        _11 = (copy _10,);
         _12 = <&mut impl Fn(T) -> U as FnOnce<(T,)>>::call_once(move _8, move _11) -> [return: bb7, unwind: bb10];
     }
 
diff --git a/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-abort.mir
index 3ca24e152a4e0..c10f3c429627a 100644
--- a/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-abort.mir
@@ -9,8 +9,8 @@ fn manual_replace(_1: &mut u32, _2: u32) -> u32 {
     }
 
     bb0: {
-        _0 = (*_1);
-        (*_1) = _2;
+        _0 = copy (*_1);
+        (*_1) = copy _2;
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-unwind.mir
index 3ca24e152a4e0..c10f3c429627a 100644
--- a/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/mem_replace.manual_replace.PreCodegen.after.panic-unwind.mir
@@ -9,8 +9,8 @@ fn manual_replace(_1: &mut u32, _2: u32) -> u32 {
     }
 
     bb0: {
-        _0 = (*_1);
-        (*_1) = _2;
+        _0 = copy (*_1);
+        (*_1) = copy _2;
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-abort.mir
index a3dc54f73c8d0..ed494f6e74cf3 100644
--- a/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-abort.mir
@@ -14,8 +14,8 @@ fn mem_replace(_1: &mut u32, _2: u32) -> u32 {
     }
 
     bb0: {
-        _0 = (*_1);
-        (*_1) = _2;
+        _0 = copy (*_1);
+        (*_1) = copy _2;
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-unwind.mir
index a3dc54f73c8d0..ed494f6e74cf3 100644
--- a/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/mem_replace.mem_replace.PreCodegen.after.panic-unwind.mir
@@ -14,8 +14,8 @@ fn mem_replace(_1: &mut u32, _2: u32) -> u32 {
     }
 
     bb0: {
-        _0 = (*_1);
-        (*_1) = _2;
+        _0 = copy (*_1);
+        (*_1) = copy _2;
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/no_inlined_clone.{impl#0}-clone.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/no_inlined_clone.{impl#0}-clone.PreCodegen.after.mir
index 71898daa1bfa2..62a9cd9131f0b 100644
--- a/tests/mir-opt/pre-codegen/no_inlined_clone.{impl#0}-clone.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/no_inlined_clone.{impl#0}-clone.PreCodegen.after.mir
@@ -7,7 +7,7 @@ fn <impl at $DIR/no_inlined_clone.rs:9:10: 9:15>::clone(_1: &Foo) -> Foo {
 
     bb0: {
         StorageLive(_2);
-        _2 = ((*_1).0: i32);
+        _2 = copy ((*_1).0: i32);
         _0 = Foo { a: move _2 };
         StorageDead(_2);
         return;
diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-abort.diff
index 45b8d89c0f4fa..6575610727b99 100644
--- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-abort.diff
@@ -39,21 +39,21 @@
           StorageLive(_5);
           _5 = const 3_usize;
           _6 = const 6_usize;
--         _7 = Lt(_5, _6);
--         assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind unreachable];
+-         _7 = Lt(copy _5, copy _6);
+-         assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind unreachable];
 +         _7 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 6_usize, const 3_usize) -> [success: bb2, unwind unreachable];
       }
   
       bb2: {
--         _3 = _4[_5];
+-         _3 = copy _4[_5];
 +         _3 = const 3_i32;
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_8);
           StorageLive(_9);
           _9 = const 42_u32;
--         _8 = _9;
+-         _8 = copy _9;
 +         _8 = const 42_u32;
           StorageDead(_9);
           StorageDead(_8);
diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-unwind.diff
index e6ee1e6f9a348..1a4ed5767fece 100644
--- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.32bit.panic-unwind.diff
@@ -39,21 +39,21 @@
           StorageLive(_5);
           _5 = const 3_usize;
           _6 = const 6_usize;
--         _7 = Lt(_5, _6);
--         assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind continue];
+-         _7 = Lt(copy _5, copy _6);
+-         assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind continue];
 +         _7 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 6_usize, const 3_usize) -> [success: bb2, unwind continue];
       }
   
       bb2: {
--         _3 = _4[_5];
+-         _3 = copy _4[_5];
 +         _3 = const 3_i32;
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_8);
           StorageLive(_9);
           _9 = const 42_u32;
--         _8 = _9;
+-         _8 = copy _9;
 +         _8 = const 42_u32;
           StorageDead(_9);
           StorageDead(_8);
diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-abort.diff
index 45b8d89c0f4fa..6575610727b99 100644
--- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-abort.diff
@@ -39,21 +39,21 @@
           StorageLive(_5);
           _5 = const 3_usize;
           _6 = const 6_usize;
--         _7 = Lt(_5, _6);
--         assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind unreachable];
+-         _7 = Lt(copy _5, copy _6);
+-         assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind unreachable];
 +         _7 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 6_usize, const 3_usize) -> [success: bb2, unwind unreachable];
       }
   
       bb2: {
--         _3 = _4[_5];
+-         _3 = copy _4[_5];
 +         _3 = const 3_i32;
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_8);
           StorageLive(_9);
           _9 = const 42_u32;
--         _8 = _9;
+-         _8 = copy _9;
 +         _8 = const 42_u32;
           StorageDead(_9);
           StorageDead(_8);
diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-unwind.diff
index e6ee1e6f9a348..1a4ed5767fece 100644
--- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.GVN.64bit.panic-unwind.diff
@@ -39,21 +39,21 @@
           StorageLive(_5);
           _5 = const 3_usize;
           _6 = const 6_usize;
--         _7 = Lt(_5, _6);
--         assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind continue];
+-         _7 = Lt(copy _5, copy _6);
+-         assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind continue];
 +         _7 = const true;
 +         assert(const true, "index out of bounds: the length is {} but the index is {}", const 6_usize, const 3_usize) -> [success: bb2, unwind continue];
       }
   
       bb2: {
--         _3 = _4[_5];
+-         _3 = copy _4[_5];
 +         _3 = const 3_i32;
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_8);
           StorageLive(_9);
           _9 = const 42_u32;
--         _8 = _9;
+-         _8 = copy _9;
 +         _8 = const 42_u32;
           StorageDead(_9);
           StorageDead(_8);
diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-abort.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-abort.diff
index c01a12eaa4f2c..e2420a341e0ab 100644
--- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-abort.diff
@@ -38,18 +38,18 @@
           StorageLive(_5);
           _5 = const 3_usize;
           _6 = const 6_usize;
-          _7 = Lt(_5, _6);
-          assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind unreachable];
+          _7 = Lt(copy _5, copy _6);
+          assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind unreachable];
       }
   
       bb2: {
-          _3 = _4[_5];
+          _3 = copy _4[_5];
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_8);
 -         StorageLive(_9);
 -         _9 = Point { x: const 12_u32, y: const 42_u32 };
--         _8 = (_9.1: u32);
+-         _8 = copy (_9.1: u32);
 -         StorageDead(_9);
 +         StorageLive(_10);
 +         StorageLive(_11);
@@ -57,7 +57,7 @@
 +         _10 = const 12_u32;
 +         _11 = const 42_u32;
 +         nop;
-+         _8 = _11;
++         _8 = copy _11;
 +         StorageDead(_10);
 +         StorageDead(_11);
 +         nop;
diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-unwind.diff
index 64028e4437be3..a2fb3b979e622 100644
--- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.32bit.panic-unwind.diff
@@ -38,18 +38,18 @@
           StorageLive(_5);
           _5 = const 3_usize;
           _6 = const 6_usize;
-          _7 = Lt(_5, _6);
-          assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind continue];
+          _7 = Lt(copy _5, copy _6);
+          assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind continue];
       }
   
       bb2: {
-          _3 = _4[_5];
+          _3 = copy _4[_5];
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_8);
 -         StorageLive(_9);
 -         _9 = Point { x: const 12_u32, y: const 42_u32 };
--         _8 = (_9.1: u32);
+-         _8 = copy (_9.1: u32);
 -         StorageDead(_9);
 +         StorageLive(_10);
 +         StorageLive(_11);
@@ -57,7 +57,7 @@
 +         _10 = const 12_u32;
 +         _11 = const 42_u32;
 +         nop;
-+         _8 = _11;
++         _8 = copy _11;
 +         StorageDead(_10);
 +         StorageDead(_11);
 +         nop;
diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-abort.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-abort.diff
index c01a12eaa4f2c..e2420a341e0ab 100644
--- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-abort.diff
+++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-abort.diff
@@ -38,18 +38,18 @@
           StorageLive(_5);
           _5 = const 3_usize;
           _6 = const 6_usize;
-          _7 = Lt(_5, _6);
-          assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind unreachable];
+          _7 = Lt(copy _5, copy _6);
+          assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind unreachable];
       }
   
       bb2: {
-          _3 = _4[_5];
+          _3 = copy _4[_5];
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_8);
 -         StorageLive(_9);
 -         _9 = Point { x: const 12_u32, y: const 42_u32 };
--         _8 = (_9.1: u32);
+-         _8 = copy (_9.1: u32);
 -         StorageDead(_9);
 +         StorageLive(_10);
 +         StorageLive(_11);
@@ -57,7 +57,7 @@
 +         _10 = const 12_u32;
 +         _11 = const 42_u32;
 +         nop;
-+         _8 = _11;
++         _8 = copy _11;
 +         StorageDead(_10);
 +         StorageDead(_11);
 +         nop;
diff --git a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-unwind.diff b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-unwind.diff
index 64028e4437be3..a2fb3b979e622 100644
--- a/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-unwind.diff
+++ b/tests/mir-opt/pre-codegen/optimizes_into_variable.main.ScalarReplacementOfAggregates.64bit.panic-unwind.diff
@@ -38,18 +38,18 @@
           StorageLive(_5);
           _5 = const 3_usize;
           _6 = const 6_usize;
-          _7 = Lt(_5, _6);
-          assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, _5) -> [success: bb2, unwind continue];
+          _7 = Lt(copy _5, copy _6);
+          assert(move _7, "index out of bounds: the length is {} but the index is {}", move _6, copy _5) -> [success: bb2, unwind continue];
       }
   
       bb2: {
-          _3 = _4[_5];
+          _3 = copy _4[_5];
           StorageDead(_5);
           StorageDead(_4);
           StorageLive(_8);
 -         StorageLive(_9);
 -         _9 = Point { x: const 12_u32, y: const 42_u32 };
--         _8 = (_9.1: u32);
+-         _8 = copy (_9.1: u32);
 -         StorageDead(_9);
 +         StorageLive(_10);
 +         StorageLive(_11);
@@ -57,7 +57,7 @@
 +         _10 = const 12_u32;
 +         _11 = const 42_u32;
 +         nop;
-+         _8 = _11;
++         _8 = copy _11;
 +         StorageDead(_10);
 +         StorageDead(_11);
 +         nop;
diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir
index 2f6139712ffc1..5faa1e210cf4f 100644
--- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-abort.mir
@@ -23,12 +23,12 @@ fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] {
     bb0: {
         StorageLive(_4);
         StorageLive(_3);
-        _3 = _1 as *const u8 (PtrToPtr);
-        _4 = Offset(_3, _2);
+        _3 = copy _1 as *const u8 (PtrToPtr);
+        _4 = Offset(copy _3, copy _2);
         StorageDead(_3);
         StorageLive(_5);
-        _5 = PtrMetadata(_1);
-        _0 = *const [u32] from (_4, _5);
+        _5 = PtrMetadata(copy _1);
+        _0 = *const [u32] from (copy _4, copy _5);
         StorageDead(_5);
         StorageDead(_4);
         return;
diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir
index 2f6139712ffc1..5faa1e210cf4f 100644
--- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_fat.PreCodegen.after.panic-unwind.mir
@@ -23,12 +23,12 @@ fn demo_byte_add_fat(_1: *const [u32], _2: usize) -> *const [u32] {
     bb0: {
         StorageLive(_4);
         StorageLive(_3);
-        _3 = _1 as *const u8 (PtrToPtr);
-        _4 = Offset(_3, _2);
+        _3 = copy _1 as *const u8 (PtrToPtr);
+        _4 = Offset(copy _3, copy _2);
         StorageDead(_3);
         StorageLive(_5);
-        _5 = PtrMetadata(_1);
-        _0 = *const [u32] from (_4, _5);
+        _5 = PtrMetadata(copy _1);
+        _0 = *const [u32] from (copy _4, copy _5);
         StorageDead(_5);
         StorageDead(_4);
         return;
diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir
index 8d47e63eff2ac..9429785045a29 100644
--- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-abort.mir
@@ -22,10 +22,10 @@ fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 {
     bb0: {
         StorageLive(_4);
         StorageLive(_3);
-        _3 = _1 as *const u8 (PtrToPtr);
-        _4 = Offset(_3, _2);
+        _3 = copy _1 as *const u8 (PtrToPtr);
+        _4 = Offset(copy _3, copy _2);
         StorageDead(_3);
-        _0 = _4 as *const u32 (PtrToPtr);
+        _0 = copy _4 as *const u32 (PtrToPtr);
         StorageDead(_4);
         return;
     }
diff --git a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir
index 8d47e63eff2ac..9429785045a29 100644
--- a/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/ptr_offset.demo_byte_add_thin.PreCodegen.after.panic-unwind.mir
@@ -22,10 +22,10 @@ fn demo_byte_add_thin(_1: *const u32, _2: usize) -> *const u32 {
     bb0: {
         StorageLive(_4);
         StorageLive(_3);
-        _3 = _1 as *const u8 (PtrToPtr);
-        _4 = Offset(_3, _2);
+        _3 = copy _1 as *const u8 (PtrToPtr);
+        _4 = Offset(copy _3, copy _2);
         StorageDead(_3);
-        _0 = _4 as *const u32 (PtrToPtr);
+        _0 = copy _4 as *const u32 (PtrToPtr);
         StorageDead(_4);
         return;
     }
diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir
index 96b4962854de9..5d33c33d73fe9 100644
--- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-abort.mir
@@ -35,7 +35,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
 
     bb0: {
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         goto -> bb1;
     }
 
@@ -44,8 +44,8 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
         StorageLive(_7);
         StorageLive(_6);
         StorageLive(_5);
-        _5 = _4;
-        _6 = Lt(move _5, _2);
+        _5 = copy _4;
+        _6 = Lt(move _5, copy _2);
         StorageDead(_5);
         switchInt(move _6) -> [0: bb2, otherwise: bb4];
     }
@@ -63,22 +63,22 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb4: {
-        _7 = _4;
+        _7 = copy _4;
         StorageLive(_8);
-        _8 = <u32 as Step>::forward_unchecked(_7, const 1_usize) -> [return: bb5, unwind unreachable];
+        _8 = <u32 as Step>::forward_unchecked(copy _7, const 1_usize) -> [return: bb5, unwind unreachable];
     }
 
     bb5: {
         _4 = move _8;
         StorageDead(_8);
-        _9 = Option::<u32>::Some(_7);
+        _9 = Option::<u32>::Some(copy _7);
         StorageDead(_6);
         StorageDead(_7);
-        _10 = ((_9 as Some).0: u32);
+        _10 = copy ((_9 as Some).0: u32);
         StorageLive(_11);
         _11 = &_3;
         StorageLive(_12);
-        _12 = (_10,);
+        _12 = (copy _10,);
         _13 = <impl Fn(u32) as Fn<(u32,)>>::call(move _11, move _12) -> [return: bb6, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir
index ce8e2bd083ed4..ded30a1552035 100644
--- a/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/range_iter.forward_loop.PreCodegen.after.panic-unwind.mir
@@ -35,7 +35,7 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
 
     bb0: {
         StorageLive(_4);
-        _4 = _1;
+        _4 = copy _1;
         goto -> bb1;
     }
 
@@ -44,8 +44,8 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
         StorageLive(_7);
         StorageLive(_6);
         StorageLive(_5);
-        _5 = _4;
-        _6 = Lt(move _5, _2);
+        _5 = copy _4;
+        _6 = Lt(move _5, copy _2);
         StorageDead(_5);
         switchInt(move _6) -> [0: bb2, otherwise: bb4];
     }
@@ -63,22 +63,22 @@ fn forward_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb4: {
-        _7 = _4;
+        _7 = copy _4;
         StorageLive(_8);
-        _8 = <u32 as Step>::forward_unchecked(_7, const 1_usize) -> [return: bb5, unwind: bb7];
+        _8 = <u32 as Step>::forward_unchecked(copy _7, const 1_usize) -> [return: bb5, unwind: bb7];
     }
 
     bb5: {
         _4 = move _8;
         StorageDead(_8);
-        _9 = Option::<u32>::Some(_7);
+        _9 = Option::<u32>::Some(copy _7);
         StorageDead(_6);
         StorageDead(_7);
-        _10 = ((_9 as Some).0: u32);
+        _10 = copy ((_9 as Some).0: u32);
         StorageLive(_11);
         _11 = &_3;
         StorageLive(_12);
-        _12 = (_10,);
+        _12 = (copy _10,);
         _13 = <impl Fn(u32) as Fn<(u32,)>>::call(move _11, move _12) -> [return: bb6, unwind: bb7];
     }
 
diff --git a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir
index a7fe52d8390e9..60c0b8afa5343 100644
--- a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-abort.mir
@@ -28,9 +28,9 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb0: {
-        _4 = RangeInclusive::<u32> { start: _1, end: _2, exhausted: const false };
+        _4 = RangeInclusive::<u32> { start: copy _1, end: copy _2, exhausted: const false };
         StorageLive(_5);
-        _5 = _4;
+        _5 = copy _4;
         goto -> bb1;
     }
 
@@ -56,11 +56,11 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb5: {
-        _9 = ((_7 as Some).0: u32);
+        _9 = copy ((_7 as Some).0: u32);
         StorageLive(_10);
         _10 = &_3;
         StorageLive(_11);
-        _11 = (_9,);
+        _11 = (copy _9,);
         _12 = <impl Fn(u32) as Fn<(u32,)>>::call(move _10, move _11) -> [return: bb6, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir
index 3e2bbcd3c916f..7145da58ce18c 100644
--- a/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/range_iter.inclusive_loop.PreCodegen.after.panic-unwind.mir
@@ -28,9 +28,9 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb0: {
-        _4 = RangeInclusive::<u32> { start: _1, end: _2, exhausted: const false };
+        _4 = RangeInclusive::<u32> { start: copy _1, end: copy _2, exhausted: const false };
         StorageLive(_5);
-        _5 = _4;
+        _5 = copy _4;
         goto -> bb1;
     }
 
@@ -56,11 +56,11 @@ fn inclusive_loop(_1: u32, _2: u32, _3: impl Fn(u32)) -> () {
     }
 
     bb5: {
-        _9 = ((_7 as Some).0: u32);
+        _9 = copy ((_7 as Some).0: u32);
         StorageLive(_10);
         _10 = &_3;
         StorageLive(_11);
-        _11 = (_9,);
+        _11 = (copy _9,);
         _12 = <impl Fn(u32) as Fn<(u32,)>>::call(move _10, move _11) -> [return: bb6, unwind: bb8];
     }
 
diff --git a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir
index 2ac7e880ccb58..2621ec6753187 100644
--- a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-abort.mir
@@ -21,9 +21,9 @@ fn range_iter_next(_1: &mut std::ops::Range<u32>) -> Option<u32> {
         StorageLive(_5);
         StorageLive(_4);
         StorageLive(_2);
-        _2 = ((*_1).0: u32);
+        _2 = copy ((*_1).0: u32);
         StorageLive(_3);
-        _3 = ((*_1).1: u32);
+        _3 = copy ((*_1).1: u32);
         _4 = Lt(move _2, move _3);
         StorageDead(_3);
         StorageDead(_2);
@@ -36,15 +36,15 @@ fn range_iter_next(_1: &mut std::ops::Range<u32>) -> Option<u32> {
     }
 
     bb2: {
-        _5 = ((*_1).0: u32);
+        _5 = copy ((*_1).0: u32);
         StorageLive(_6);
-        _6 = <u32 as Step>::forward_unchecked(_5, const 1_usize) -> [return: bb3, unwind unreachable];
+        _6 = <u32 as Step>::forward_unchecked(copy _5, const 1_usize) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
         ((*_1).0: u32) = move _6;
         StorageDead(_6);
-        _0 = Option::<u32>::Some(_5);
+        _0 = Option::<u32>::Some(copy _5);
         goto -> bb4;
     }
 
diff --git a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir
index 60bf644fce6be..338fb4b952329 100644
--- a/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/range_iter.range_iter_next.PreCodegen.after.panic-unwind.mir
@@ -21,9 +21,9 @@ fn range_iter_next(_1: &mut std::ops::Range<u32>) -> Option<u32> {
         StorageLive(_5);
         StorageLive(_4);
         StorageLive(_2);
-        _2 = ((*_1).0: u32);
+        _2 = copy ((*_1).0: u32);
         StorageLive(_3);
-        _3 = ((*_1).1: u32);
+        _3 = copy ((*_1).1: u32);
         _4 = Lt(move _2, move _3);
         StorageDead(_3);
         StorageDead(_2);
@@ -36,15 +36,15 @@ fn range_iter_next(_1: &mut std::ops::Range<u32>) -> Option<u32> {
     }
 
     bb2: {
-        _5 = ((*_1).0: u32);
+        _5 = copy ((*_1).0: u32);
         StorageLive(_6);
-        _6 = <u32 as Step>::forward_unchecked(_5, const 1_usize) -> [return: bb3, unwind continue];
+        _6 = <u32 as Step>::forward_unchecked(copy _5, const 1_usize) -> [return: bb3, unwind continue];
     }
 
     bb3: {
         ((*_1).0: u32) = move _6;
         StorageDead(_6);
-        _0 = Option::<u32>::Some(_5);
+        _0 = Option::<u32>::Some(copy _5);
         goto -> bb4;
     }
 
diff --git a/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir
index 030f9c3b93e0c..cbfc58194cc1f 100644
--- a/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/simple_option_map.ezmap.PreCodegen.after.mir
@@ -25,9 +25,9 @@ fn ezmap(_1: Option<i32>) -> Option<i32> {
     }
 
     bb2: {
-        _3 = ((_1 as Some).0: i32);
+        _3 = copy ((_1 as Some).0: i32);
         StorageLive(_4);
-        _4 = Add(_3, const 1_i32);
+        _4 = Add(copy _3, const 1_i32);
         _0 = Option::<i32>::Some(move _4);
         StorageDead(_4);
         goto -> bb3;
diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir
index e382f744723eb..cbdd194afd3ab 100644
--- a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir
@@ -68,7 +68,7 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
     }
 
     bb0: {
-        _3 = (*_2);
+        _3 = copy (*_2);
         _4 = &((*_3).0: usize);
         _5 = &((*_3).1: usize);
         _6 = &((*_3).2: usize);
@@ -78,11 +78,11 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         _8 = &_4;
         StorageLive(_10);
         StorageLive(_9);
-        _9 = _6;
+        _9 = copy _6;
         _10 = &_9;
-        _11 = ((*_3).0: usize);
-        _12 = ((*_3).2: usize);
-        _13 = Le(_11, _12);
+        _11 = copy ((*_3).0: usize);
+        _12 = copy ((*_3).2: usize);
+        _13 = Le(copy _11, copy _12);
         switchInt(move _13) -> [0: bb1, otherwise: bb2];
     }
 
@@ -102,12 +102,12 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         _14 = &_7;
         StorageLive(_16);
         StorageLive(_15);
-        _15 = _5;
+        _15 = copy _5;
         _16 = &_15;
         StorageLive(_17);
-        _17 = ((*_3).3: usize);
+        _17 = copy ((*_3).3: usize);
         StorageLive(_18);
-        _18 = ((*_3).1: usize);
+        _18 = copy ((*_3).1: usize);
         _19 = Le(move _17, move _18);
         StorageDead(_18);
         StorageDead(_17);
@@ -127,9 +127,9 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         _20 = &_6;
         StorageLive(_22);
         StorageLive(_21);
-        _21 = _4;
+        _21 = copy _4;
         _22 = &_21;
-        _23 = Le(_12, _11);
+        _23 = Le(copy _12, copy _11);
         switchInt(move _23) -> [0: bb5, otherwise: bb6];
     }
 
@@ -149,12 +149,12 @@ fn variant_a::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:7:25: 7:39}, _2
         _24 = &_5;
         StorageLive(_26);
         StorageLive(_25);
-        _25 = _7;
+        _25 = copy _7;
         _26 = &_25;
         StorageLive(_27);
-        _27 = ((*_3).1: usize);
+        _27 = copy ((*_3).1: usize);
         StorageLive(_28);
-        _28 = ((*_3).3: usize);
+        _28 = copy ((*_3).3: usize);
         _0 = Le(move _27, move _28);
         StorageDead(_28);
         StorageDead(_27);
diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir
index d9e118d879a6a..bc7a31d52199b 100644
--- a/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir
@@ -18,25 +18,25 @@ fn variant_b::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:11:25: 11:41},
     }
 
     bb0: {
-        _3 = (*_2);
-        _4 = ((*_3).0: usize);
-        _5 = ((*_3).1: usize);
-        _6 = ((*_3).2: usize);
-        _7 = ((*_3).3: usize);
+        _3 = copy (*_2);
+        _4 = copy ((*_3).0: usize);
+        _5 = copy ((*_3).1: usize);
+        _6 = copy ((*_3).2: usize);
+        _7 = copy ((*_3).3: usize);
         StorageLive(_8);
-        _8 = Le(_4, _6);
+        _8 = Le(copy _4, copy _6);
         switchInt(move _8) -> [0: bb2, otherwise: bb1];
     }
 
     bb1: {
         StorageLive(_9);
-        _9 = Le(_7, _5);
+        _9 = Le(copy _7, copy _5);
         switchInt(move _9) -> [0: bb2, otherwise: bb6];
     }
 
     bb2: {
         StorageLive(_10);
-        _10 = Le(_6, _4);
+        _10 = Le(copy _6, copy _4);
         switchInt(move _10) -> [0: bb3, otherwise: bb4];
     }
 
@@ -46,7 +46,7 @@ fn variant_b::{closure#0}(_1: &mut {closure@$DIR/slice_filter.rs:11:25: 11:41},
     }
 
     bb4: {
-        _0 = Le(_5, _7);
+        _0 = Le(copy _5, copy _7);
         goto -> bb5;
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir
index 58e9b45a4a0f1..ec67193bc7948 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-abort.mir
@@ -23,8 +23,8 @@ fn slice_get_mut_usize(_1: &mut [u32], _2: usize) -> Option<&mut u32> {
         StorageLive(_8);
         StorageLive(_4);
         StorageLive(_3);
-        _3 = PtrMetadata(_1);
-        _4 = Lt(_2, move _3);
+        _3 = PtrMetadata(copy _1);
+        _4 = Lt(copy _2, move _3);
         switchInt(move _4) -> [0: bb1, otherwise: bb2];
     }
 
@@ -40,12 +40,12 @@ fn slice_get_mut_usize(_1: &mut [u32], _2: usize) -> Option<&mut u32> {
         StorageLive(_5);
         _5 = &raw mut (*_1);
         StorageLive(_6);
-        _6 = _5 as *mut u32 (PtrToPtr);
-        _7 = Offset(_6, _2);
+        _6 = copy _5 as *mut u32 (PtrToPtr);
+        _7 = Offset(copy _6, copy _2);
         StorageDead(_6);
         StorageDead(_5);
         _8 = &mut (*_7);
-        _0 = Option::<&mut u32>::Some(_8);
+        _0 = Option::<&mut u32>::Some(copy _8);
         StorageDead(_7);
         goto -> bb3;
     }
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir
index 58e9b45a4a0f1..ec67193bc7948 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_mut_usize.PreCodegen.after.panic-unwind.mir
@@ -23,8 +23,8 @@ fn slice_get_mut_usize(_1: &mut [u32], _2: usize) -> Option<&mut u32> {
         StorageLive(_8);
         StorageLive(_4);
         StorageLive(_3);
-        _3 = PtrMetadata(_1);
-        _4 = Lt(_2, move _3);
+        _3 = PtrMetadata(copy _1);
+        _4 = Lt(copy _2, move _3);
         switchInt(move _4) -> [0: bb1, otherwise: bb2];
     }
 
@@ -40,12 +40,12 @@ fn slice_get_mut_usize(_1: &mut [u32], _2: usize) -> Option<&mut u32> {
         StorageLive(_5);
         _5 = &raw mut (*_1);
         StorageLive(_6);
-        _6 = _5 as *mut u32 (PtrToPtr);
-        _7 = Offset(_6, _2);
+        _6 = copy _5 as *mut u32 (PtrToPtr);
+        _7 = Offset(copy _6, copy _2);
         StorageDead(_6);
         StorageDead(_5);
         _8 = &mut (*_7);
-        _0 = Option::<&mut u32>::Some(_8);
+        _0 = Option::<&mut u32>::Some(copy _8);
         StorageDead(_7);
         goto -> bb3;
     }
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir
index ee80726a675c8..220e881f86645 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-abort.mir
@@ -40,19 +40,19 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range<usize>) ->
         _5 = &raw mut (*_1);
         StorageLive(_8);
         StorageLive(_6);
-        _6 = PtrMetadata(_1);
-        _7 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(_3, _4, move _6) -> [return: bb1, unwind unreachable];
+        _6 = PtrMetadata(copy _1);
+        _7 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(copy _3, copy _4, move _6) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
         StorageDead(_6);
-        _8 = SubUnchecked(_4, _3);
+        _8 = SubUnchecked(copy _4, copy _3);
         StorageLive(_10);
         StorageLive(_9);
-        _9 = _5 as *mut u32 (PtrToPtr);
-        _10 = Offset(_9, _3);
+        _9 = copy _5 as *mut u32 (PtrToPtr);
+        _10 = Offset(copy _9, copy _3);
         StorageDead(_9);
-        _11 = *mut [u32] from (_10, _8);
+        _11 = *mut [u32] from (copy _10, copy _8);
         StorageDead(_10);
         StorageDead(_8);
         StorageDead(_5);
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir
index ee80726a675c8..220e881f86645 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_get_unchecked_mut_range.PreCodegen.after.panic-unwind.mir
@@ -40,19 +40,19 @@ fn slice_get_unchecked_mut_range(_1: &mut [u32], _2: std::ops::Range<usize>) ->
         _5 = &raw mut (*_1);
         StorageLive(_8);
         StorageLive(_6);
-        _6 = PtrMetadata(_1);
-        _7 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(_3, _4, move _6) -> [return: bb1, unwind unreachable];
+        _6 = PtrMetadata(copy _1);
+        _7 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked_mut::precondition_check(copy _3, copy _4, move _6) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
         StorageDead(_6);
-        _8 = SubUnchecked(_4, _3);
+        _8 = SubUnchecked(copy _4, copy _3);
         StorageLive(_10);
         StorageLive(_9);
-        _9 = _5 as *mut u32 (PtrToPtr);
-        _10 = Offset(_9, _3);
+        _9 = copy _5 as *mut u32 (PtrToPtr);
+        _10 = Offset(copy _9, copy _3);
         StorageDead(_9);
-        _11 = *mut [u32] from (_10, _8);
+        _11 = *mut [u32] from (copy _10, copy _8);
         StorageDead(_10);
         StorageDead(_8);
         StorageDead(_5);
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-abort.mir
index 210f9d6a12403..cc1034229fc39 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-abort.mir
@@ -9,12 +9,12 @@ fn slice_index_usize(_1: &[u32], _2: usize) -> u32 {
 
     bb0: {
         _3 = Len((*_1));
-        _4 = Lt(_2, _3);
-        assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, _2) -> [success: bb1, unwind unreachable];
+        _4 = Lt(copy _2, copy _3);
+        assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, copy _2) -> [success: bb1, unwind unreachable];
     }
 
     bb1: {
-        _0 = (*_1)[_2];
+        _0 = copy (*_1)[_2];
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-unwind.mir
index d576520a8d56b..358226fb5294d 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_index_usize.PreCodegen.after.panic-unwind.mir
@@ -9,12 +9,12 @@ fn slice_index_usize(_1: &[u32], _2: usize) -> u32 {
 
     bb0: {
         _3 = Len((*_1));
-        _4 = Lt(_2, _3);
-        assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, _2) -> [success: bb1, unwind continue];
+        _4 = Lt(copy _2, copy _3);
+        assert(move _4, "index out of bounds: the length is {} but the index is {}", move _3, copy _2) -> [success: bb1, unwind continue];
     }
 
     bb1: {
-        _0 = (*_1)[_2];
+        _0 = copy (*_1)[_2];
         return;
     }
 }
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir
index c61bebe6cc3c0..1e0df94b67fb1 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-abort.mir
@@ -35,19 +35,19 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range<usize>) -
         _4 = move (_2.1: usize);
         StorageLive(_7);
         StorageLive(_5);
-        _5 = PtrMetadata(_1);
-        _6 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked::precondition_check(_3, _4, move _5) -> [return: bb1, unwind unreachable];
+        _5 = PtrMetadata(copy _1);
+        _6 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked::precondition_check(copy _3, copy _4, move _5) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
         StorageDead(_5);
-        _7 = SubUnchecked(_4, _3);
+        _7 = SubUnchecked(copy _4, copy _3);
         StorageLive(_9);
         StorageLive(_8);
-        _8 = _1 as *const u32 (PtrToPtr);
-        _9 = Offset(_8, _3);
+        _8 = copy _1 as *const u32 (PtrToPtr);
+        _9 = Offset(copy _8, copy _3);
         StorageDead(_8);
-        _0 = *const [u32] from (_9, _7);
+        _0 = *const [u32] from (copy _9, copy _7);
         StorageDead(_9);
         StorageDead(_7);
         return;
diff --git a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir
index c61bebe6cc3c0..1e0df94b67fb1 100644
--- a/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_index.slice_ptr_get_unchecked_range.PreCodegen.after.panic-unwind.mir
@@ -35,19 +35,19 @@ fn slice_ptr_get_unchecked_range(_1: *const [u32], _2: std::ops::Range<usize>) -
         _4 = move (_2.1: usize);
         StorageLive(_7);
         StorageLive(_5);
-        _5 = PtrMetadata(_1);
-        _6 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked::precondition_check(_3, _4, move _5) -> [return: bb1, unwind unreachable];
+        _5 = PtrMetadata(copy _1);
+        _6 = <std::ops::Range<usize> as SliceIndex<[T]>>::get_unchecked::precondition_check(copy _3, copy _4, move _5) -> [return: bb1, unwind unreachable];
     }
 
     bb1: {
         StorageDead(_5);
-        _7 = SubUnchecked(_4, _3);
+        _7 = SubUnchecked(copy _4, copy _3);
         StorageLive(_9);
         StorageLive(_8);
-        _8 = _1 as *const u32 (PtrToPtr);
-        _9 = Offset(_8, _3);
+        _8 = copy _1 as *const u32 (PtrToPtr);
+        _9 = Offset(copy _8, copy _3);
         StorageDead(_8);
-        _0 = *const [u32] from (_9, _7);
+        _0 = *const [u32] from (copy _9, copy _7);
         StorageDead(_9);
         StorageDead(_7);
         return;
diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir
index 953e7550479da..3aa483ed1aefa 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir
@@ -31,7 +31,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
             }
             scope 19 {
                 scope 20 {
-                    scope 26 (inlined <Option<(usize, &T)> as FromResidual>::from_residual) {
+                    scope 26 (inlined <Option<(usize, &T)> as FromResidual<Option<Infallible>>>::from_residual) {
                     }
                 }
             }
@@ -90,10 +90,10 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = PtrMetadata(_1);
+        _3 = PtrMetadata(copy _1);
         _4 = &raw const (*_1);
-        _5 = _4 as *const T (PtrToPtr);
-        _6 = NonNull::<T> { pointer: _5 };
+        _5 = copy _4 as *const T (PtrToPtr);
+        _6 = NonNull::<T> { pointer: copy _5 };
         StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
@@ -101,8 +101,8 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     bb1: {
         StorageLive(_8);
         StorageLive(_7);
-        _7 = _4 as *mut T (PtrToPtr);
-        _8 = Offset(_7, _3);
+        _7 = copy _4 as *mut T (PtrToPtr);
+        _8 = Offset(copy _7, copy _3);
         StorageDead(_7);
         _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
@@ -110,24 +110,24 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb2: {
-        _9 = _3 as *const T (Transmute);
+        _9 = copy _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
         StorageLive(_10);
-        _10 = _9;
-        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
+        _10 = copy _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
         StorageDead(_9);
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
-        _12 = Enumerate::<std::slice::Iter<'_, T>> { iter: _11, count: const 0_usize };
+        _12 = Enumerate::<std::slice::Iter<'_, T>> { iter: copy _11, count: const 0_usize };
         StorageDead(_11);
         StorageLive(_13);
-        _13 = _12;
+        _13 = copy _12;
         goto -> bb4;
     }
 
@@ -166,25 +166,25 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         _17 = move ((_15 as Some).0: &T);
         StorageDead(_16);
         StorageDead(_15);
-        _18 = (_13.1: usize);
-        _19 = AddWithOverflow((_13.1: usize), const 1_usize);
-        assert(!move (_19.1: bool), "attempt to compute `{} + {}`, which would overflow", (_13.1: usize), const 1_usize) -> [success: bb9, unwind unreachable];
+        _18 = copy (_13.1: usize);
+        _19 = AddWithOverflow(copy (_13.1: usize), const 1_usize);
+        assert(!move (_19.1: bool), "attempt to compute `{} + {}`, which would overflow", copy (_13.1: usize), const 1_usize) -> [success: bb9, unwind unreachable];
     }
 
     bb9: {
         (_13.1: usize) = move (_19.0: usize);
         StorageLive(_20);
-        _20 = (_18, _17);
+        _20 = (copy _18, copy _17);
         _21 = Option::<(usize, &T)>::Some(move _20);
         StorageDead(_20);
         StorageDead(_19);
         StorageDead(_18);
-        _22 = (((_21 as Some).0: (usize, &T)).0: usize);
-        _23 = (((_21 as Some).0: (usize, &T)).1: &T);
+        _22 = copy (((_21 as Some).0: (usize, &T)).0: usize);
+        _23 = copy (((_21 as Some).0: (usize, &T)).1: &T);
         StorageLive(_24);
         _24 = &_2;
         StorageLive(_25);
-        _25 = (_22, _23);
+        _25 = (copy _22, copy _23);
         _26 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _24, move _25) -> [return: bb10, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir
index 4c766c6497a2e..4cc0aa0ed788d 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir
@@ -65,10 +65,10 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = PtrMetadata(_1);
+        _3 = PtrMetadata(copy _1);
         _4 = &raw const (*_1);
-        _5 = _4 as *const T (PtrToPtr);
-        _6 = NonNull::<T> { pointer: _5 };
+        _5 = copy _4 as *const T (PtrToPtr);
+        _6 = NonNull::<T> { pointer: copy _5 };
         StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
@@ -76,8 +76,8 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     bb1: {
         StorageLive(_8);
         StorageLive(_7);
-        _7 = _4 as *mut T (PtrToPtr);
-        _8 = Offset(_7, _3);
+        _7 = copy _4 as *mut T (PtrToPtr);
+        _8 = Offset(copy _7, copy _3);
         StorageDead(_7);
         _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
@@ -85,24 +85,24 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb2: {
-        _9 = _3 as *const T (Transmute);
+        _9 = copy _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
         StorageLive(_10);
-        _10 = _9;
-        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
+        _10 = copy _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
         StorageDead(_9);
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
-        _12 = Enumerate::<std::slice::Iter<'_, T>> { iter: _11, count: const 0_usize };
+        _12 = Enumerate::<std::slice::Iter<'_, T>> { iter: copy _11, count: const 0_usize };
         StorageDead(_11);
         StorageLive(_13);
-        _13 = _12;
+        _13 = copy _12;
         goto -> bb4;
     }
 
@@ -128,12 +128,12 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb8: {
-        _17 = (((_15 as Some).0: (usize, &T)).0: usize);
-        _18 = (((_15 as Some).0: (usize, &T)).1: &T);
+        _17 = copy (((_15 as Some).0: (usize, &T)).0: usize);
+        _18 = copy (((_15 as Some).0: (usize, &T)).1: &T);
         StorageLive(_19);
         _19 = &_2;
         StorageLive(_20);
-        _20 = (_17, _18);
+        _20 = (copy _17, copy _18);
         _21 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _19, move _20) -> [return: bb9, unwind: bb11];
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir
index 03de9fd938ec4..507afa63c6884 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir
@@ -57,10 +57,10 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = PtrMetadata(_1);
+        _3 = PtrMetadata(copy _1);
         _4 = &raw const (*_1);
-        _5 = _4 as *const T (PtrToPtr);
-        _6 = NonNull::<T> { pointer: _5 };
+        _5 = copy _4 as *const T (PtrToPtr);
+        _6 = NonNull::<T> { pointer: copy _5 };
         StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
@@ -68,8 +68,8 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     bb1: {
         StorageLive(_8);
         StorageLive(_7);
-        _7 = _4 as *mut T (PtrToPtr);
-        _8 = Offset(_7, _3);
+        _7 = copy _4 as *mut T (PtrToPtr);
+        _8 = Offset(copy _7, copy _3);
         StorageDead(_7);
         _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
@@ -77,14 +77,14 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb2: {
-        _9 = _3 as *const T (Transmute);
+        _9 = copy _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
         StorageLive(_10);
-        _10 = _9;
-        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
+        _10 = copy _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
         StorageDead(_9);
         StorageDead(_5);
@@ -92,7 +92,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageDead(_6);
         StorageDead(_3);
         StorageLive(_12);
-        _12 = _11;
+        _12 = copy _11;
         goto -> bb4;
     }
 
@@ -118,11 +118,11 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb8: {
-        _16 = ((_14 as Some).0: &T);
+        _16 = copy ((_14 as Some).0: &T);
         StorageLive(_17);
         _17 = &_2;
         StorageLive(_18);
-        _18 = (_16,);
+        _18 = (copy _16,);
         _19 = <impl Fn(&T) as Fn<(&T,)>>::call(move _17, move _18) -> [return: bb9, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir
index c7c722274f24e..a25f12edc28e9 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir
@@ -57,10 +57,10 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = PtrMetadata(_1);
+        _3 = PtrMetadata(copy _1);
         _4 = &raw const (*_1);
-        _5 = _4 as *const T (PtrToPtr);
-        _6 = NonNull::<T> { pointer: _5 };
+        _5 = copy _4 as *const T (PtrToPtr);
+        _6 = NonNull::<T> { pointer: copy _5 };
         StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
@@ -68,8 +68,8 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     bb1: {
         StorageLive(_8);
         StorageLive(_7);
-        _7 = _4 as *mut T (PtrToPtr);
-        _8 = Offset(_7, _3);
+        _7 = copy _4 as *mut T (PtrToPtr);
+        _8 = Offset(copy _7, copy _3);
         StorageDead(_7);
         _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
@@ -77,14 +77,14 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb2: {
-        _9 = _3 as *const T (Transmute);
+        _9 = copy _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
         StorageLive(_10);
-        _10 = _9;
-        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
+        _10 = copy _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
         StorageDead(_9);
         StorageDead(_5);
@@ -92,7 +92,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageDead(_6);
         StorageDead(_3);
         StorageLive(_12);
-        _12 = _11;
+        _12 = copy _11;
         goto -> bb4;
     }
 
@@ -118,11 +118,11 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb8: {
-        _16 = ((_14 as Some).0: &T);
+        _16 = copy ((_14 as Some).0: &T);
         StorageLive(_17);
         _17 = &_2;
         StorageLive(_18);
-        _18 = (_16,);
+        _18 = (copy _16,);
         _19 = <impl Fn(&T) as Fn<(&T,)>>::call(move _17, move _18) -> [return: bb9, unwind: bb11];
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir
index cea2fcbcdc0b2..ecac03ad0f9d9 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-abort.mir
@@ -40,7 +40,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb0: {
-        _3 = PtrMetadata(_1);
+        _3 = PtrMetadata(copy _1);
         StorageLive(_4);
         _4 = const 0_usize;
         goto -> bb1;
@@ -51,8 +51,8 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageLive(_7);
         StorageLive(_6);
         StorageLive(_5);
-        _5 = _4;
-        _6 = Lt(move _5, _3);
+        _5 = copy _4;
+        _6 = Lt(move _5, copy _3);
         StorageDead(_5);
         switchInt(move _6) -> [0: bb2, otherwise: bb4];
     }
@@ -70,21 +70,21 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb4: {
-        _7 = _4;
+        _7 = copy _4;
         StorageLive(_8);
-        _8 = <usize as Step>::forward_unchecked(_7, const 1_usize) -> [return: bb5, unwind unreachable];
+        _8 = <usize as Step>::forward_unchecked(copy _7, const 1_usize) -> [return: bb5, unwind unreachable];
     }
 
     bb5: {
         _4 = move _8;
         StorageDead(_8);
-        _9 = Option::<usize>::Some(_7);
+        _9 = Option::<usize>::Some(copy _7);
         StorageDead(_6);
         StorageDead(_7);
-        _10 = ((_9 as Some).0: usize);
+        _10 = copy ((_9 as Some).0: usize);
         _11 = Len((*_1));
-        _12 = Lt(_10, _11);
-        assert(move _12, "index out of bounds: the length is {} but the index is {}", move _11, _10) -> [success: bb6, unwind unreachable];
+        _12 = Lt(copy _10, copy _11);
+        assert(move _12, "index out of bounds: the length is {} but the index is {}", move _11, copy _10) -> [success: bb6, unwind unreachable];
     }
 
     bb6: {
@@ -92,7 +92,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageLive(_14);
         _14 = &_2;
         StorageLive(_15);
-        _15 = (_10, _13);
+        _15 = (copy _10, copy _13);
         _16 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _14, move _15) -> [return: bb7, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir
index bd658a770ea91..1032473b9b2a2 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.range_loop.PreCodegen.after.panic-unwind.mir
@@ -40,7 +40,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb0: {
-        _3 = PtrMetadata(_1);
+        _3 = PtrMetadata(copy _1);
         StorageLive(_4);
         _4 = const 0_usize;
         goto -> bb1;
@@ -51,8 +51,8 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageLive(_7);
         StorageLive(_6);
         StorageLive(_5);
-        _5 = _4;
-        _6 = Lt(move _5, _3);
+        _5 = copy _4;
+        _6 = Lt(move _5, copy _3);
         StorageDead(_5);
         switchInt(move _6) -> [0: bb2, otherwise: bb4];
     }
@@ -70,21 +70,21 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb4: {
-        _7 = _4;
+        _7 = copy _4;
         StorageLive(_8);
-        _8 = <usize as Step>::forward_unchecked(_7, const 1_usize) -> [return: bb5, unwind: bb8];
+        _8 = <usize as Step>::forward_unchecked(copy _7, const 1_usize) -> [return: bb5, unwind: bb8];
     }
 
     bb5: {
         _4 = move _8;
         StorageDead(_8);
-        _9 = Option::<usize>::Some(_7);
+        _9 = Option::<usize>::Some(copy _7);
         StorageDead(_6);
         StorageDead(_7);
-        _10 = ((_9 as Some).0: usize);
+        _10 = copy ((_9 as Some).0: usize);
         _11 = Len((*_1));
-        _12 = Lt(_10, _11);
-        assert(move _12, "index out of bounds: the length is {} but the index is {}", move _11, _10) -> [success: bb6, unwind: bb8];
+        _12 = Lt(copy _10, copy _11);
+        assert(move _12, "index out of bounds: the length is {} but the index is {}", move _11, copy _10) -> [success: bb6, unwind: bb8];
     }
 
     bb6: {
@@ -92,7 +92,7 @@ fn range_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageLive(_14);
         _14 = &_2;
         StorageLive(_15);
-        _15 = (_10, _13);
+        _15 = (copy _10, copy _13);
         _16 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _14, move _15) -> [return: bb7, unwind: bb8];
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir
index fbb887fe76a59..1b397a4e4cdde 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir
@@ -65,10 +65,10 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = PtrMetadata(_1);
+        _3 = PtrMetadata(copy _1);
         _4 = &raw const (*_1);
-        _5 = _4 as *const T (PtrToPtr);
-        _6 = NonNull::<T> { pointer: _5 };
+        _5 = copy _4 as *const T (PtrToPtr);
+        _6 = NonNull::<T> { pointer: copy _5 };
         StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
@@ -76,8 +76,8 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     bb1: {
         StorageLive(_8);
         StorageLive(_7);
-        _7 = _4 as *mut T (PtrToPtr);
-        _8 = Offset(_7, _3);
+        _7 = copy _4 as *mut T (PtrToPtr);
+        _8 = Offset(copy _7, copy _3);
         StorageDead(_7);
         _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
@@ -85,24 +85,24 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb2: {
-        _9 = _3 as *const T (Transmute);
+        _9 = copy _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
         StorageLive(_10);
-        _10 = _9;
-        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
+        _10 = copy _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
         StorageDead(_9);
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
-        _12 = Rev::<std::slice::Iter<'_, T>> { iter: _11 };
+        _12 = Rev::<std::slice::Iter<'_, T>> { iter: copy _11 };
         StorageDead(_11);
         StorageLive(_13);
-        _13 = _12;
+        _13 = copy _12;
         goto -> bb4;
     }
 
@@ -130,11 +130,11 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb8: {
-        _17 = ((_15 as Some).0: &T);
+        _17 = copy ((_15 as Some).0: &T);
         StorageLive(_18);
         _18 = &_2;
         StorageLive(_19);
-        _19 = (_17,);
+        _19 = (copy _17,);
         _20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind unreachable];
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir
index db9409f72ab1a..77689dd9b513e 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir
@@ -65,10 +65,10 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageLive(_6);
         StorageLive(_4);
         StorageLive(_5);
-        _3 = PtrMetadata(_1);
+        _3 = PtrMetadata(copy _1);
         _4 = &raw const (*_1);
-        _5 = _4 as *const T (PtrToPtr);
-        _6 = NonNull::<T> { pointer: _5 };
+        _5 = copy _4 as *const T (PtrToPtr);
+        _6 = NonNull::<T> { pointer: copy _5 };
         StorageLive(_9);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
@@ -76,8 +76,8 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     bb1: {
         StorageLive(_8);
         StorageLive(_7);
-        _7 = _4 as *mut T (PtrToPtr);
-        _8 = Offset(_7, _3);
+        _7 = copy _4 as *mut T (PtrToPtr);
+        _8 = Offset(copy _7, copy _3);
         StorageDead(_7);
         _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
@@ -85,24 +85,24 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb2: {
-        _9 = _3 as *const T (Transmute);
+        _9 = copy _3 as *const T (Transmute);
         goto -> bb3;
     }
 
     bb3: {
         StorageLive(_10);
-        _10 = _9;
-        _11 = std::slice::Iter::<'_, T> { ptr: _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
+        _10 = copy _9;
+        _11 = std::slice::Iter::<'_, T> { ptr: copy _6, end_or_len: move _10, _marker: const ZeroSized: PhantomData<&T> };
         StorageDead(_10);
         StorageDead(_9);
         StorageDead(_5);
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
-        _12 = Rev::<std::slice::Iter<'_, T>> { iter: _11 };
+        _12 = Rev::<std::slice::Iter<'_, T>> { iter: copy _11 };
         StorageDead(_11);
         StorageLive(_13);
-        _13 = _12;
+        _13 = copy _12;
         goto -> bb4;
     }
 
@@ -130,11 +130,11 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb8: {
-        _17 = ((_15 as Some).0: &T);
+        _17 = copy ((_15 as Some).0: &T);
         StorageLive(_18);
         _18 = &_2;
         StorageLive(_19);
-        _19 = (_17,);
+        _19 = (copy _17,);
         _20 = <impl Fn(&T) as Fn<(&T,)>>::call(move _18, move _19) -> [return: bb9, unwind: bb11];
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir
index 96e71c298e003..f8b0e749bfc03 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-abort.mir
@@ -43,27 +43,27 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
         StorageLive(_3);
         StorageLive(_2);
         _2 = &raw const ((*_1).1: *const T);
-        _3 = _2 as *const std::ptr::NonNull<T> (PtrToPtr);
+        _3 = copy _2 as *const std::ptr::NonNull<T> (PtrToPtr);
         StorageDead(_2);
-        _4 = (*_3);
+        _4 = copy (*_3);
         StorageDead(_3);
         StorageLive(_6);
         StorageLive(_7);
         StorageLive(_5);
-        _5 = ((*_1).0: std::ptr::NonNull<T>);
-        _6 = (_5.0: *const T);
+        _5 = copy ((*_1).0: std::ptr::NonNull<T>);
+        _6 = copy (_5.0: *const T);
         StorageDead(_5);
-        _7 = (_4.0: *const T);
-        _0 = Eq(_6, _7);
+        _7 = copy (_4.0: *const T);
+        _0 = Eq(copy _6, copy _7);
         StorageDead(_7);
         StorageDead(_6);
         goto -> bb3;
     }
 
     bb2: {
-        _8 = ((*_1).1: *const T);
-        _9 = _8 as usize (Transmute);
-        _0 = Eq(_9, const 0_usize);
+        _8 = copy ((*_1).1: *const T);
+        _9 = copy _8 as usize (Transmute);
+        _0 = Eq(copy _9, const 0_usize);
         goto -> bb3;
     }
 
diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-unwind.mir
index 96e71c298e003..f8b0e749bfc03 100644
--- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_generic_is_empty.PreCodegen.after.panic-unwind.mir
@@ -43,27 +43,27 @@ fn slice_iter_generic_is_empty(_1: &std::slice::Iter<'_, T>) -> bool {
         StorageLive(_3);
         StorageLive(_2);
         _2 = &raw const ((*_1).1: *const T);
-        _3 = _2 as *const std::ptr::NonNull<T> (PtrToPtr);
+        _3 = copy _2 as *const std::ptr::NonNull<T> (PtrToPtr);
         StorageDead(_2);
-        _4 = (*_3);
+        _4 = copy (*_3);
         StorageDead(_3);
         StorageLive(_6);
         StorageLive(_7);
         StorageLive(_5);
-        _5 = ((*_1).0: std::ptr::NonNull<T>);
-        _6 = (_5.0: *const T);
+        _5 = copy ((*_1).0: std::ptr::NonNull<T>);
+        _6 = copy (_5.0: *const T);
         StorageDead(_5);
-        _7 = (_4.0: *const T);
-        _0 = Eq(_6, _7);
+        _7 = copy (_4.0: *const T);
+        _0 = Eq(copy _6, copy _7);
         StorageDead(_7);
         StorageDead(_6);
         goto -> bb3;
     }
 
     bb2: {
-        _8 = ((*_1).1: *const T);
-        _9 = _8 as usize (Transmute);
-        _0 = Eq(_9, const 0_usize);
+        _8 = copy ((*_1).1: *const T);
+        _9 = copy _8 as usize (Transmute);
+        _0 = Eq(copy _9, const 0_usize);
         goto -> bb3;
     }
 
diff --git a/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-abort.mir
index c76e5315db9f6..fe4e2deab8706 100644
--- a/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-abort.mir
@@ -10,7 +10,7 @@ fn outer(_1: u8) -> u8 {
 
     bb0: {
         _2 = &_1;                        // scope 0 at $DIR/spans.rs:11:11: 11:13
-        _0 = _1;                         // scope 1 at $DIR/spans.rs:15:5: 15:7
+        _0 = copy _1;                    // scope 1 at $DIR/spans.rs:15:5: 15:7
         return;                          // scope 0 at $DIR/spans.rs:12:2: 12:2
     }
 }
diff --git a/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-unwind.mir
index c76e5315db9f6..fe4e2deab8706 100644
--- a/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/spans.outer.PreCodegen.after.panic-unwind.mir
@@ -10,7 +10,7 @@ fn outer(_1: u8) -> u8 {
 
     bb0: {
         _2 = &_1;                        // scope 0 at $DIR/spans.rs:11:11: 11:13
-        _0 = _1;                         // scope 1 at $DIR/spans.rs:15:5: 15:7
+        _0 = copy _1;                    // scope 1 at $DIR/spans.rs:15:5: 15:7
         return;                          // scope 0 at $DIR/spans.rs:12:2: 12:2
     }
 }
diff --git a/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir
index 16d6d9719b641..baa01e28a9410 100644
--- a/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/try_identity.new.PreCodegen.after.mir
@@ -30,18 +30,18 @@ fn new(_1: Result<T, E>) -> Result<T, E> {
 
     bb1: {
         _3 = move ((_1 as Ok).0: T);
-        _4 = ControlFlow::<E, T>::Continue(_3);
+        _4 = ControlFlow::<E, T>::Continue(copy _3);
         _5 = move ((_4 as Continue).0: T);
-        _0 = Result::<T, E>::Ok(_5);
+        _0 = Result::<T, E>::Ok(copy _5);
         StorageDead(_4);
         goto -> bb3;
     }
 
     bb2: {
         _6 = move ((_1 as Err).0: E);
-        _4 = ControlFlow::<E, T>::Break(_6);
+        _4 = ControlFlow::<E, T>::Break(copy _6);
         _7 = move ((_4 as Break).0: E);
-        _0 = Result::<T, E>::Err(_7);
+        _0 = Result::<T, E>::Err(copy _7);
         StorageDead(_4);
         goto -> bb3;
     }
diff --git a/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir
index d6883ac9fda08..ac485f485b1cc 100644
--- a/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir
+++ b/tests/mir-opt/pre-codegen/try_identity.old.PreCodegen.after.mir
@@ -20,13 +20,13 @@ fn old(_1: Result<T, E>) -> Result<T, E> {
 
     bb1: {
         _3 = move ((_1 as Ok).0: T);
-        _0 = Result::<T, E>::Ok(_3);
+        _0 = Result::<T, E>::Ok(copy _3);
         goto -> bb3;
     }
 
     bb2: {
         _4 = move ((_1 as Err).0: E);
-        _0 = Result::<T, E>::Err(_4);
+        _0 = Result::<T, E>::Err(copy _4);
         goto -> bb3;
     }
 
diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir
index 0fe4fd3707221..ce1e4a0abd61f 100644
--- a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir
+++ b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir
@@ -78,17 +78,17 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
         _3 = &(((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner);
         StorageLive(_6);
         StorageLive(_4);
-        _4 = (((((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
-        _5 = (_4.0: *const u8);
-        _6 = NonNull::<u8> { pointer: _5 };
+        _4 = copy (((((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
+        _5 = copy (_4.0: *const u8);
+        _6 = NonNull::<u8> { pointer: copy _5 };
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
         StorageDead(_2);
         StorageLive(_7);
-        _7 = ((*_1).1: usize);
+        _7 = copy ((*_1).1: usize);
         StorageLive(_8);
-        _8 = *const [u8] from (_5, _7);
+        _8 = *const [u8] from (copy _5, copy _7);
         _0 = &(*_8);
         StorageDead(_8);
         StorageDead(_7);
diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir
index 0fe4fd3707221..ce1e4a0abd61f 100644
--- a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir
+++ b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir
@@ -78,17 +78,17 @@ fn vec_deref_to_slice(_1: &Vec<u8>) -> &[u8] {
         _3 = &(((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner);
         StorageLive(_6);
         StorageLive(_4);
-        _4 = (((((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
-        _5 = (_4.0: *const u8);
-        _6 = NonNull::<u8> { pointer: _5 };
+        _4 = copy (((((*_1).0: alloc::raw_vec::RawVec<u8>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
+        _5 = copy (_4.0: *const u8);
+        _6 = NonNull::<u8> { pointer: copy _5 };
         StorageDead(_4);
         StorageDead(_6);
         StorageDead(_3);
         StorageDead(_2);
         StorageLive(_7);
-        _7 = ((*_1).1: usize);
+        _7 = copy ((*_1).1: usize);
         StorageLive(_8);
-        _8 = *const [u8] from (_5, _7);
+        _8 = *const [u8] from (copy _5, copy _7);
         _0 = &(*_8);
         StorageDead(_8);
         StorageDead(_7);
diff --git a/tests/mir-opt/reference_prop.dominate_storage.ReferencePropagation.diff b/tests/mir-opt/reference_prop.dominate_storage.ReferencePropagation.diff
index 012efa9693ec3..4715f5110ebb8 100644
--- a/tests/mir-opt/reference_prop.dominate_storage.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.dominate_storage.ReferencePropagation.diff
@@ -21,15 +21,15 @@
       }
   
       bb2: {
-          _5 = (*_2);
-          _0 = opaque::<i32>(_5) -> [return: bb3, unwind continue];
+          _5 = copy (*_2);
+          _0 = opaque::<i32>(copy _5) -> [return: bb3, unwind continue];
       }
   
       bb3: {
           StorageDead(_1);
           StorageLive(_1);
           _6 = const true;
-          switchInt(_6) -> [0: bb3, otherwise: bb1];
+          switchInt(copy _6) -> [0: bb3, otherwise: bb1];
       }
   }
   
diff --git a/tests/mir-opt/reference_prop.maybe_dead.ReferencePropagation.diff b/tests/mir-opt/reference_prop.maybe_dead.ReferencePropagation.diff
index c6bd6c2121092..b1de380d84d44 100644
--- a/tests/mir-opt/reference_prop.maybe_dead.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.maybe_dead.ReferencePropagation.diff
@@ -19,25 +19,25 @@
           _4 = &_2;
           _5 = &mut _3;
           (*_5) = const 7_i32;
--         _6 = (*_4);
-+         _6 = _2;
-          switchInt(_1) -> [1: bb1, otherwise: bb2];
+-         _6 = copy (*_4);
++         _6 = copy _2;
+          switchInt(copy _1) -> [1: bb1, otherwise: bb2];
       }
   
       bb1: {
           StorageDead(_2);
           StorageDead(_3);
-          _0 = opaque::<i32>(_6) -> [return: bb2, unwind continue];
+          _0 = opaque::<i32>(copy _6) -> [return: bb2, unwind continue];
       }
   
       bb2: {
-          _7 = (*_4);
-          _0 = opaque::<i32>(_7) -> [return: bb3, unwind continue];
+          _7 = copy (*_4);
+          _0 = opaque::<i32>(copy _7) -> [return: bb3, unwind continue];
       }
   
       bb3: {
-          _8 = (*_5);
-          _0 = opaque::<i32>(_8) -> [return: bb4, unwind continue];
+          _8 = copy (*_5);
+          _0 = opaque::<i32>(copy _8) -> [return: bb4, unwind continue];
       }
   
       bb4: {
diff --git a/tests/mir-opt/reference_prop.multiple_storage.ReferencePropagation.diff b/tests/mir-opt/reference_prop.multiple_storage.ReferencePropagation.diff
index 0fd74155aa30a..2368edea5bac4 100644
--- a/tests/mir-opt/reference_prop.multiple_storage.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.multiple_storage.ReferencePropagation.diff
@@ -13,8 +13,8 @@
           _2 = &_1;
           StorageDead(_1);
           StorageLive(_1);
-          _3 = (*_2);
-          _0 = opaque::<i32>(_3) -> [return: bb1, unwind continue];
+          _3 = copy (*_2);
+          _0 = opaque::<i32>(copy _3) -> [return: bb1, unwind continue];
       }
   
       bb1: {
diff --git a/tests/mir-opt/reference_prop.mut_raw_then_mut_shr.ReferencePropagation.diff b/tests/mir-opt/reference_prop.mut_raw_then_mut_shr.ReferencePropagation.diff
index 859097d3966a5..90fd91764cb94 100644
--- a/tests/mir-opt/reference_prop.mut_raw_then_mut_shr.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.mut_raw_then_mut_shr.ReferencePropagation.diff
@@ -41,23 +41,23 @@
 -         StorageLive(_5);
 -         _5 = &mut (*_2);
 -         _4 = &raw mut (*_5);
--         _3 = _4;
+-         _3 = copy _4;
 -         StorageDead(_5);
 -         StorageDead(_4);
 -         StorageLive(_6);
 -         _6 = &(*_2);
           StorageLive(_7);
--         _7 = (*_6);
+-         _7 = copy (*_6);
 -         StorageLive(_8);
 -         (*_3) = const 4_i32;
 -         _8 = const ();
 -         StorageDead(_8);
-+         _7 = _1;
++         _7 = copy _1;
 +         _1 = const 4_i32;
           StorageLive(_9);
-          _9 = _7;
+          _9 = copy _7;
           StorageLive(_10);
-          _10 = _1;
+          _10 = copy _1;
           _0 = (move _9, move _10);
           StorageDead(_10);
           StorageDead(_9);
diff --git a/tests/mir-opt/reference_prop.read_through_raw.ReferencePropagation.diff b/tests/mir-opt/reference_prop.read_through_raw.ReferencePropagation.diff
index 371b0e468b1db..064711925e020 100644
--- a/tests/mir-opt/reference_prop.read_through_raw.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.read_through_raw.ReferencePropagation.diff
@@ -13,10 +13,10 @@
 -         _3 = &mut (*_2);
 -         _4 = &raw mut (*_2);
 -         _5 = &raw mut (*_3);
--         _0 = (*_4);
--         _0 = (*_5);
-+         _0 = (*_1);
-+         _0 = (*_1);
+-         _0 = copy (*_4);
+-         _0 = copy (*_5);
++         _0 = copy (*_1);
++         _0 = copy (*_1);
           return;
       }
   }
diff --git a/tests/mir-opt/reference_prop.reference_propagation.ReferencePropagation.diff b/tests/mir-opt/reference_prop.reference_propagation.ReferencePropagation.diff
index 0dfe8781c186f..3c6a9a9614c32 100644
--- a/tests/mir-opt/reference_prop.reference_propagation.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.reference_propagation.ReferencePropagation.diff
@@ -191,8 +191,8 @@
           StorageLive(_5);
           _5 = &_4;
           StorageLive(_6);
--         _6 = (*_5);
-+         _6 = _4;
+-         _6 = copy (*_5);
++         _6 = copy _4;
           StorageLive(_7);
           StorageLive(_8);
           _8 = ();
@@ -223,7 +223,7 @@
           StorageDead(_13);
 -         StorageDead(_14);
           StorageLive(_15);
-          _15 = (*_12);
+          _15 = copy (*_12);
           StorageLive(_16);
           StorageLive(_17);
           _17 = ();
@@ -247,11 +247,11 @@
           StorageLive(_21);
           _21 = &_20;
           StorageLive(_22);
--         _22 = (*_20);
-+         _22 = _19;
+-         _22 = copy (*_20);
++         _22 = copy _19;
           StorageLive(_23);
           StorageLive(_24);
-          _24 = _21;
+          _24 = copy _21;
           _23 = opaque::<&&usize>(move _24) -> [return: bb3, unwind continue];
       }
   
@@ -272,10 +272,10 @@
           StorageLive(_28);
           _28 = &raw mut _27;
           StorageLive(_29);
-          _29 = (*_27);
+          _29 = copy (*_27);
           StorageLive(_30);
           StorageLive(_31);
-          _31 = _28;
+          _31 = copy _28;
           _30 = opaque::<*mut &usize>(move _31) -> [return: bb4, unwind continue];
       }
   
@@ -294,11 +294,11 @@
           StorageLive(_34);
           _34 = &_33;
           StorageLive(_35);
--         _35 = (*_34);
-+         _35 = _33;
+-         _35 = copy (*_34);
++         _35 = copy _33;
           StorageLive(_36);
           StorageLive(_37);
-          _37 = _34;
+          _37 = copy _34;
           _36 = opaque::<&usize>(move _37) -> [return: bb5, unwind continue];
       }
   
@@ -316,18 +316,18 @@
           StorageLive(_40);
           _40 = &_39;
           StorageLive(_41);
--         _41 = (*_40);
-+         _41 = _39;
+-         _41 = copy (*_40);
++         _41 = copy _39;
           StorageLive(_42);
-          _42 = _40;
+          _42 = copy _40;
           StorageLive(_43);
--         _43 = (*_42);
-+         _43 = _39;
+-         _43 = copy (*_42);
++         _43 = copy _39;
           StorageLive(_44);
-          _44 = _42;
+          _44 = copy _42;
           StorageLive(_45);
           StorageLive(_46);
-          _46 = _44;
+          _46 = copy _44;
           _45 = opaque::<&usize>(move _46) -> [return: bb6, unwind continue];
       }
   
@@ -346,8 +346,8 @@
 -         StorageLive(_48);
 -         _48 = &(*_1);
           StorageLive(_49);
--         _49 = (*_48);
-+         _49 = (*_1);
+-         _49 = copy (*_48);
++         _49 = copy (*_1);
           StorageLive(_50);
           StorageLive(_51);
           _51 = ();
@@ -373,7 +373,7 @@
           StorageDead(_54);
 -         StorageDead(_55);
           StorageLive(_56);
-          _56 = (*_53);
+          _56 = copy (*_53);
           StorageLive(_57);
           StorageLive(_58);
           _58 = ();
@@ -395,8 +395,8 @@
           StorageLive(_62);
           _62 = &_61;
           StorageLive(_63);
--         _63 = (*_61);
-+         _63 = _60;
+-         _63 = copy (*_61);
++         _63 = copy _60;
           StorageLive(_64);
           StorageLive(_65);
           _65 = ();
@@ -419,7 +419,7 @@
           StorageLive(_68);
           _68 = &mut _67;
           StorageLive(_69);
-          _69 = (*_67);
+          _69 = copy (*_67);
           StorageLive(_70);
           StorageLive(_71);
           _71 = ();
diff --git a/tests/mir-opt/reference_prop.reference_propagation_const_ptr.ReferencePropagation.diff b/tests/mir-opt/reference_prop.reference_propagation_const_ptr.ReferencePropagation.diff
index 21486a8616aab..75fe99de93810 100644
--- a/tests/mir-opt/reference_prop.reference_propagation_const_ptr.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.reference_propagation_const_ptr.ReferencePropagation.diff
@@ -208,8 +208,8 @@
           StorageLive(_5);
           _5 = &raw const _4;
           StorageLive(_6);
--         _6 = (*_5);
-+         _6 = _4;
+-         _6 = copy (*_5);
++         _6 = copy _4;
           StorageLive(_7);
           StorageLive(_8);
           _8 = ();
@@ -236,7 +236,7 @@
           _12 = move _13;
           StorageDead(_13);
           StorageLive(_14);
-          _14 = (*_12);
+          _14 = copy (*_12);
           StorageLive(_15);
           StorageLive(_16);
           _16 = ();
@@ -260,11 +260,11 @@
           StorageLive(_20);
           _20 = &_19;
           StorageLive(_21);
--         _21 = (*_19);
-+         _21 = _18;
+-         _21 = copy (*_19);
++         _21 = copy _18;
           StorageLive(_22);
           StorageLive(_23);
-          _23 = _20;
+          _23 = copy _20;
           _22 = opaque::<&*const usize>(move _23) -> [return: bb3, unwind continue];
       }
   
@@ -285,10 +285,10 @@
           StorageLive(_27);
           _27 = &raw mut _26;
           StorageLive(_28);
-          _28 = (*_26);
+          _28 = copy (*_26);
           StorageLive(_29);
           StorageLive(_30);
-          _30 = _27;
+          _30 = copy _27;
           _29 = opaque::<*mut *const usize>(move _30) -> [return: bb4, unwind continue];
       }
   
@@ -307,11 +307,11 @@
           StorageLive(_33);
           _33 = &raw const _32;
           StorageLive(_34);
--         _34 = (*_33);
-+         _34 = _32;
+-         _34 = copy (*_33);
++         _34 = copy _32;
           StorageLive(_35);
           StorageLive(_36);
-          _36 = _33;
+          _36 = copy _33;
           _35 = opaque::<*const usize>(move _36) -> [return: bb5, unwind continue];
       }
   
@@ -329,18 +329,18 @@
           StorageLive(_39);
           _39 = &raw const _38;
           StorageLive(_40);
--         _40 = (*_39);
-+         _40 = _38;
+-         _40 = copy (*_39);
++         _40 = copy _38;
           StorageLive(_41);
-          _41 = _39;
+          _41 = copy _39;
           StorageLive(_42);
--         _42 = (*_41);
-+         _42 = _38;
+-         _42 = copy (*_41);
++         _42 = copy _38;
           StorageLive(_43);
-          _43 = _41;
+          _43 = copy _41;
           StorageLive(_44);
           StorageLive(_45);
-          _45 = _43;
+          _45 = copy _43;
           _44 = opaque::<*const usize>(move _45) -> [return: bb6, unwind continue];
       }
   
@@ -359,8 +359,8 @@
 -         StorageLive(_47);
 -         _47 = &raw const (*_1);
           StorageLive(_48);
--         _48 = (*_47);
-+         _48 = (*_1);
+-         _48 = copy (*_47);
++         _48 = copy (*_1);
           StorageLive(_49);
           StorageLive(_50);
           _50 = ();
@@ -382,7 +382,7 @@
           _2 = move _53;
           StorageDead(_53);
           StorageLive(_54);
-          _54 = (*_52);
+          _54 = copy (*_52);
           StorageLive(_55);
           StorageLive(_56);
           _56 = ();
@@ -405,8 +405,8 @@
 -         _60 = &raw const (*_59);
 +         _60 = &raw const _58;
           StorageLive(_61);
--         _61 = (*_60);
-+         _61 = _58;
+-         _61 = copy (*_60);
++         _61 = copy _58;
           StorageLive(_62);
           StorageLive(_63);
           _63 = ();
@@ -430,8 +430,8 @@
           StorageLive(_67);
           _67 = &_66;
           StorageLive(_68);
--         _68 = (*_66);
-+         _68 = _65;
+-         _68 = copy (*_66);
++         _68 = copy _65;
           StorageLive(_69);
           StorageLive(_70);
           _70 = ();
@@ -454,7 +454,7 @@
           StorageLive(_73);
           _73 = &mut _72;
           StorageLive(_74);
-          _74 = (*_72);
+          _74 = copy (*_72);
           StorageLive(_75);
           StorageLive(_76);
           _76 = ();
diff --git a/tests/mir-opt/reference_prop.reference_propagation_mut.ReferencePropagation.diff b/tests/mir-opt/reference_prop.reference_propagation_mut.ReferencePropagation.diff
index 7c7f424bba2bd..f35b4974d6eba 100644
--- a/tests/mir-opt/reference_prop.reference_propagation_mut.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.reference_propagation_mut.ReferencePropagation.diff
@@ -191,8 +191,8 @@
           StorageLive(_5);
           _5 = &mut _4;
           StorageLive(_6);
--         _6 = (*_5);
-+         _6 = _4;
+-         _6 = copy (*_5);
++         _6 = copy _4;
           StorageLive(_7);
           StorageLive(_8);
           _8 = ();
@@ -223,7 +223,7 @@
           StorageDead(_13);
 -         StorageDead(_14);
           StorageLive(_15);
-          _15 = (*_12);
+          _15 = copy (*_12);
           StorageLive(_16);
           StorageLive(_17);
           _17 = ();
@@ -247,10 +247,10 @@
           StorageLive(_21);
           _21 = &_20;
           StorageLive(_22);
-          _22 = (*_20);
+          _22 = copy (*_20);
           StorageLive(_23);
           StorageLive(_24);
-          _24 = _21;
+          _24 = copy _21;
           _23 = opaque::<&&mut usize>(move _24) -> [return: bb3, unwind continue];
       }
   
@@ -271,10 +271,10 @@
           StorageLive(_28);
           _28 = &raw mut _27;
           StorageLive(_29);
-          _29 = (*_27);
+          _29 = copy (*_27);
           StorageLive(_30);
           StorageLive(_31);
-          _31 = _28;
+          _31 = copy _28;
           _30 = opaque::<*mut &mut usize>(move _31) -> [return: bb4, unwind continue];
       }
   
@@ -293,7 +293,7 @@
           StorageLive(_34);
           _34 = &mut _33;
           StorageLive(_35);
-          _35 = (*_34);
+          _35 = copy (*_34);
           StorageLive(_36);
           StorageLive(_37);
           _37 = move _34;
@@ -314,11 +314,11 @@
           StorageLive(_40);
           _40 = &mut _39;
           StorageLive(_41);
-          _41 = (*_40);
+          _41 = copy (*_40);
           StorageLive(_42);
           _42 = move _40;
           StorageLive(_43);
-          _43 = (*_42);
+          _43 = copy (*_42);
           StorageLive(_44);
           _44 = move _42;
           StorageLive(_45);
@@ -342,8 +342,8 @@
 -         StorageLive(_48);
 -         _48 = &mut (*_1);
           StorageLive(_49);
--         _49 = (*_48);
-+         _49 = (*_1);
+-         _49 = copy (*_48);
++         _49 = copy (*_1);
           StorageLive(_50);
           StorageLive(_51);
           _51 = ();
@@ -369,7 +369,7 @@
           StorageDead(_54);
 -         StorageDead(_55);
           StorageLive(_56);
-          _56 = (*_53);
+          _56 = copy (*_53);
           StorageLive(_57);
           StorageLive(_58);
           _58 = ();
@@ -391,7 +391,7 @@
           StorageLive(_62);
           _62 = &_61;
           StorageLive(_63);
-          _63 = (*_61);
+          _63 = copy (*_61);
           StorageLive(_64);
           StorageLive(_65);
           _65 = ();
@@ -414,7 +414,7 @@
           StorageLive(_68);
           _68 = &mut _67;
           StorageLive(_69);
-          _69 = (*_67);
+          _69 = copy (*_67);
           StorageLive(_70);
           StorageLive(_71);
           _71 = ();
diff --git a/tests/mir-opt/reference_prop.reference_propagation_mut_ptr.ReferencePropagation.diff b/tests/mir-opt/reference_prop.reference_propagation_mut_ptr.ReferencePropagation.diff
index 5629d04f1b192..21b322b721876 100644
--- a/tests/mir-opt/reference_prop.reference_propagation_mut_ptr.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.reference_propagation_mut_ptr.ReferencePropagation.diff
@@ -189,8 +189,8 @@
           StorageLive(_5);
           _5 = &raw mut _4;
           StorageLive(_6);
--         _6 = (*_5);
-+         _6 = _4;
+-         _6 = copy (*_5);
++         _6 = copy _4;
           StorageLive(_7);
           StorageLive(_8);
           _8 = ();
@@ -217,7 +217,7 @@
           _12 = move _13;
           StorageDead(_13);
           StorageLive(_14);
-          _14 = (*_12);
+          _14 = copy (*_12);
           StorageLive(_15);
           StorageLive(_16);
           _16 = ();
@@ -241,10 +241,10 @@
           StorageLive(_20);
           _20 = &_19;
           StorageLive(_21);
-          _21 = (*_19);
+          _21 = copy (*_19);
           StorageLive(_22);
           StorageLive(_23);
-          _23 = _20;
+          _23 = copy _20;
           _22 = opaque::<&*mut usize>(move _23) -> [return: bb3, unwind continue];
       }
   
@@ -265,10 +265,10 @@
           StorageLive(_27);
           _27 = &raw mut _26;
           StorageLive(_28);
-          _28 = (*_26);
+          _28 = copy (*_26);
           StorageLive(_29);
           StorageLive(_30);
-          _30 = _27;
+          _30 = copy _27;
           _29 = opaque::<*mut *mut usize>(move _30) -> [return: bb4, unwind continue];
       }
   
@@ -287,10 +287,10 @@
           StorageLive(_33);
           _33 = &raw mut _32;
           StorageLive(_34);
-          _34 = (*_33);
+          _34 = copy (*_33);
           StorageLive(_35);
           StorageLive(_36);
-          _36 = _33;
+          _36 = copy _33;
           _35 = opaque::<*mut usize>(move _36) -> [return: bb5, unwind continue];
       }
   
@@ -308,16 +308,16 @@
           StorageLive(_39);
           _39 = &raw mut _38;
           StorageLive(_40);
-          _40 = (*_39);
+          _40 = copy (*_39);
           StorageLive(_41);
-          _41 = _39;
+          _41 = copy _39;
           StorageLive(_42);
-          _42 = (*_41);
+          _42 = copy (*_41);
           StorageLive(_43);
-          _43 = _41;
+          _43 = copy _41;
           StorageLive(_44);
           StorageLive(_45);
-          _45 = _43;
+          _45 = copy _43;
           _44 = opaque::<*mut usize>(move _45) -> [return: bb6, unwind continue];
       }
   
@@ -336,8 +336,8 @@
 -         StorageLive(_47);
 -         _47 = &raw mut (*_1);
           StorageLive(_48);
--         _48 = (*_47);
-+         _48 = (*_1);
+-         _48 = copy (*_47);
++         _48 = copy (*_1);
           StorageLive(_49);
           StorageLive(_50);
           _50 = ();
@@ -359,7 +359,7 @@
           _2 = move _53;
           StorageDead(_53);
           StorageLive(_54);
-          _54 = (*_52);
+          _54 = copy (*_52);
           StorageLive(_55);
           StorageLive(_56);
           _56 = ();
@@ -381,7 +381,7 @@
           StorageLive(_60);
           _60 = &_59;
           StorageLive(_61);
-          _61 = (*_59);
+          _61 = copy (*_59);
           StorageLive(_62);
           StorageLive(_63);
           _63 = ();
@@ -404,7 +404,7 @@
           StorageLive(_66);
           _66 = &mut _65;
           StorageLive(_67);
-          _67 = (*_65);
+          _67 = copy (*_65);
           StorageLive(_68);
           StorageLive(_69);
           _69 = ();
diff --git a/tests/mir-opt/reference_prop.unique_with_copies.ReferencePropagation.diff b/tests/mir-opt/reference_prop.unique_with_copies.ReferencePropagation.diff
index a5427cea1f8e1..d2ba9db2b897b 100644
--- a/tests/mir-opt/reference_prop.unique_with_copies.ReferencePropagation.diff
+++ b/tests/mir-opt/reference_prop.unique_with_copies.ReferencePropagation.diff
@@ -29,20 +29,20 @@
           _3 = &raw mut _2;
           StorageLive(_4);
           StorageLive(_5);
-          _5 = (*_3);
+          _5 = copy (*_3);
           _4 = opaque::<i32>(move _5) -> [return: bb1, unwind continue];
       }
   
       bb1: {
           StorageDead(_5);
           StorageDead(_4);
--         _1 = _3;
+-         _1 = copy _3;
 -         StorageDead(_3);
           StorageDead(_2);
           StorageLive(_6);
           StorageLive(_7);
--         _7 = (*_1);
-+         _7 = (*_3);
+-         _7 = copy (*_1);
++         _7 = copy (*_3);
           _6 = opaque::<i32>(move _7) -> [return: bb2, unwind continue];
       }
   
diff --git a/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-abort.diff b/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-abort.diff
index d76d65a18a7b4..8c6c5e0d99349 100644
--- a/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-abort.diff
+++ b/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-abort.diff
@@ -24,7 +24,7 @@
       }
   
       bb2: {
-          switchInt((*(*((_1 as Some).0: &&i32)))) -> [0: bb3, otherwise: bb1];
+          switchInt(copy (*(*((_1 as Some).0: &&i32)))) -> [0: bb3, otherwise: bb1];
       }
   
       bb3: {
@@ -42,7 +42,7 @@
 +         nop;
 +         nop;
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
           switchInt(move _8) -> [0: bb6, otherwise: bb5];
       }
   
diff --git a/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-unwind.diff b/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-unwind.diff
index d76d65a18a7b4..8c6c5e0d99349 100644
--- a/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-unwind.diff
+++ b/tests/mir-opt/remove_fake_borrows.match_guard.CleanupPostBorrowck.panic-unwind.diff
@@ -24,7 +24,7 @@
       }
   
       bb2: {
-          switchInt((*(*((_1 as Some).0: &&i32)))) -> [0: bb3, otherwise: bb1];
+          switchInt(copy (*(*((_1 as Some).0: &&i32)))) -> [0: bb3, otherwise: bb1];
       }
   
       bb3: {
@@ -42,7 +42,7 @@
 +         nop;
 +         nop;
           StorageLive(_8);
-          _8 = _2;
+          _8 = copy _2;
           switchInt(move _8) -> [0: bb6, otherwise: bb5];
       }
   
diff --git a/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-abort.diff b/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-abort.diff
index 14762b9c40f46..38cdbf5684bf2 100644
--- a/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-abort.diff
+++ b/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-abort.diff
@@ -64,10 +64,10 @@
   
       bb5: {
 -         StorageLive(_12);
-          _12 = ((_7 as Some).0: i32);
+          _12 = copy ((_7 as Some).0: i32);
 -         StorageLive(_13);
-          _13 = _12;
-          _1 = Add(_1, move _13);
+          _13 = copy _12;
+          _1 = Add(copy _1, move _13);
 -         StorageDead(_13);
           _6 = const ();
 -         StorageDead(_12);
diff --git a/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-unwind.diff b/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-unwind.diff
index 24797424b5c8a..2b5aaa95fe1a4 100644
--- a/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-unwind.diff
+++ b/tests/mir-opt/remove_storage_markers.main.RemoveStorageMarkers.panic-unwind.diff
@@ -64,10 +64,10 @@
   
       bb5: {
 -         StorageLive(_12);
-          _12 = ((_7 as Some).0: i32);
+          _12 = copy ((_7 as Some).0: i32);
 -         StorageLive(_13);
-          _13 = _12;
-          _1 = Add(_1, move _13);
+          _13 = copy _12;
+          _1 = Add(copy _1, move _13);
 -         StorageDead(_13);
           _6 = const ();
 -         StorageDead(_12);
diff --git a/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-abort.diff b/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-abort.diff
index 5afeb8620a176..01eb6d4901f76 100644
--- a/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-abort.diff
+++ b/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-abort.diff
@@ -12,7 +12,7 @@
       bb0: {
 -         nop;
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         drop(_3) -> [return: bb1, unwind unreachable];
 -     }
 - 
diff --git a/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-unwind.diff b/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-unwind.diff
index b9919ddea568a..c2c3cb76e8328 100644
--- a/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-unwind.diff
+++ b/tests/mir-opt/remove_unneeded_drops.opt.RemoveUnneededDrops.panic-unwind.diff
@@ -12,7 +12,7 @@
       bb0: {
 -         nop;
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         drop(_3) -> [return: bb1, unwind continue];
 -     }
 - 
diff --git a/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-abort.diff b/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-abort.diff
index b89432dd6d626..a82ede6196ed3 100644
--- a/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-abort.diff
+++ b/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-abort.diff
@@ -12,7 +12,7 @@
       bb0: {
 -         nop;
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         drop(_3) -> [return: bb1, unwind unreachable];
 -     }
 - 
diff --git a/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-unwind.diff b/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-unwind.diff
index 48d0260533223..6e7c9ead740f0 100644
--- a/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-unwind.diff
+++ b/tests/mir-opt/remove_unneeded_drops.opt_generic_copy.RemoveUnneededDrops.panic-unwind.diff
@@ -12,7 +12,7 @@
       bb0: {
 -         nop;
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         drop(_3) -> [return: bb1, unwind continue];
 -     }
 - 
diff --git a/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-abort.mir
index 6dba667dd1557..ae7b2cc0b6fc7 100644
--- a/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-abort.mir
+++ b/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-abort.mir
@@ -70,7 +70,7 @@ fn array_casts() -> () {
         StorageLive(_5);
         StorageLive(_6);
         StorageLive(_7);
-        _7 = _2;
+        _7 = copy _2;
         _6 = std::ptr::mut_ptr::<impl *mut usize>::add(move _7, const 1_usize) -> [return: bb1, unwind unreachable];
     }
 
@@ -96,13 +96,13 @@ fn array_casts() -> () {
         StorageLive(_15);
         StorageLive(_16);
         StorageLive(_17);
-        _17 = _9;
+        _17 = copy _9;
         _16 = std::ptr::const_ptr::<impl *const usize>::add(move _17, const 1_usize) -> [return: bb2, unwind unreachable];
     }
 
     bb2: {
         StorageDead(_17);
-        _15 = (*_16);
+        _15 = copy (*_16);
         _14 = &_15;
         StorageLive(_18);
         _34 = const array_casts::promoted[0];
@@ -113,16 +113,16 @@ fn array_casts() -> () {
         StorageDead(_18);
         StorageDead(_14);
         StorageLive(_20);
-        _20 = (_13.0: &usize);
+        _20 = copy (_13.0: &usize);
         Retag(_20);
         StorageLive(_21);
-        _21 = (_13.1: &usize);
+        _21 = copy (_13.1: &usize);
         Retag(_21);
         StorageLive(_22);
         StorageLive(_23);
-        _23 = (*_20);
+        _23 = copy (*_20);
         StorageLive(_24);
-        _24 = (*_21);
+        _24 = copy (*_21);
         _22 = Eq(move _23, move _24);
         switchInt(move _22) -> [0: bb4, otherwise: bb3];
     }
diff --git a/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
index fa812002e26cb..789bc34263849 100644
--- a/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
+++ b/tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
@@ -70,7 +70,7 @@ fn array_casts() -> () {
         StorageLive(_5);
         StorageLive(_6);
         StorageLive(_7);
-        _7 = _2;
+        _7 = copy _2;
         _6 = std::ptr::mut_ptr::<impl *mut usize>::add(move _7, const 1_usize) -> [return: bb1, unwind continue];
     }
 
@@ -96,13 +96,13 @@ fn array_casts() -> () {
         StorageLive(_15);
         StorageLive(_16);
         StorageLive(_17);
-        _17 = _9;
+        _17 = copy _9;
         _16 = std::ptr::const_ptr::<impl *const usize>::add(move _17, const 1_usize) -> [return: bb2, unwind continue];
     }
 
     bb2: {
         StorageDead(_17);
-        _15 = (*_16);
+        _15 = copy (*_16);
         _14 = &_15;
         StorageLive(_18);
         _34 = const array_casts::promoted[0];
@@ -113,16 +113,16 @@ fn array_casts() -> () {
         StorageDead(_18);
         StorageDead(_14);
         StorageLive(_20);
-        _20 = (_13.0: &usize);
+        _20 = copy (_13.0: &usize);
         Retag(_20);
         StorageLive(_21);
-        _21 = (_13.1: &usize);
+        _21 = copy (_13.1: &usize);
         Retag(_21);
         StorageLive(_22);
         StorageLive(_23);
-        _23 = (*_20);
+        _23 = copy (*_20);
         StorageLive(_24);
-        _24 = (*_21);
+        _24 = copy (*_21);
         _22 = Eq(move _23, move _24);
         switchInt(move _22) -> [0: bb4, otherwise: bb3];
     }
diff --git a/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-abort.mir
index 0e568f6a5685f..ca02e7b49cccd 100644
--- a/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-abort.mir
+++ b/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-abort.mir
@@ -9,7 +9,7 @@ fn box_to_raw_mut(_1: &mut Box<i32>) -> *mut i32 {
     bb0: {
         Retag([fn entry] _1);
         _2 = deref_copy (*_1);
-        _3 = (((_2.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
+        _3 = copy (((_2.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
         _0 = &raw mut (*_3);
         Retag([raw] _0);
         return;
diff --git a/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
index 0e568f6a5685f..ca02e7b49cccd 100644
--- a/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
+++ b/tests/mir-opt/retag.box_to_raw_mut.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
@@ -9,7 +9,7 @@ fn box_to_raw_mut(_1: &mut Box<i32>) -> *mut i32 {
     bb0: {
         Retag([fn entry] _1);
         _2 = deref_copy (*_1);
-        _3 = (((_2.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
+        _3 = copy (((_2.0: std::ptr::Unique<i32>).0: std::ptr::NonNull<i32>).0: *const i32);
         _0 = &raw mut (*_3);
         Retag([raw] _0);
         return;
diff --git a/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-abort.mir
index 2620929e896be..63b32ceb5c059 100644
--- a/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-abort.mir
+++ b/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-abort.mir
@@ -12,7 +12,7 @@ fn main::{closure#0}(_1: &{closure@main::{closure#0}}, _2: &i32) -> &i32 {
         Retag([fn entry] _1);
         Retag([fn entry] _2);
         StorageLive(_3);
-        _3 = _2;
+        _3 = copy _2;
         Retag(_3);
         _0 = &(*_2);
         StorageDead(_3);
diff --git a/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
index 2620929e896be..63b32ceb5c059 100644
--- a/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
+++ b/tests/mir-opt/retag.main-{closure#0}.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
@@ -12,7 +12,7 @@ fn main::{closure#0}(_1: &{closure@main::{closure#0}}, _2: &i32) -> &i32 {
         Retag([fn entry] _1);
         Retag([fn entry] _2);
         StorageLive(_3);
-        _3 = _2;
+        _3 = copy _2;
         Retag(_3);
         _0 = &(*_2);
         StorageDead(_3);
diff --git a/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir
index a35af43cefd60..d0f454e456934 100644
--- a/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir
+++ b/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-abort.mir
@@ -93,7 +93,7 @@ fn main() -> () {
         StorageLive(_11);
         StorageLive(_12);
         _12 = &raw mut (*_10);
-        _11 = _12;
+        _11 = copy _12;
         StorageDead(_12);
         _2 = const ();
         StorageDead(_11);
@@ -109,7 +109,7 @@ fn main() -> () {
         StorageDead(_14);
         StorageLive(_15);
         StorageLive(_16);
-        _16 = _13;
+        _16 = copy _13;
         StorageLive(_17);
         StorageLive(_18);
         _18 = &_1;
@@ -150,7 +150,7 @@ fn main() -> () {
         StorageLive(_25);
         StorageLive(_26);
         _26 = &raw const (*_15);
-        _25 = _26;
+        _25 = copy _26;
         StorageDead(_26);
         StorageLive(_27);
         _27 = array_casts() -> [return: bb6, unwind unreachable];
diff --git a/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
index 2495719ec1c6c..685277d7a5328 100644
--- a/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
+++ b/tests/mir-opt/retag.main.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
@@ -93,7 +93,7 @@ fn main() -> () {
         StorageLive(_11);
         StorageLive(_12);
         _12 = &raw mut (*_10);
-        _11 = _12;
+        _11 = copy _12;
         StorageDead(_12);
         _2 = const ();
         StorageDead(_11);
@@ -109,7 +109,7 @@ fn main() -> () {
         StorageDead(_14);
         StorageLive(_15);
         StorageLive(_16);
-        _16 = _13;
+        _16 = copy _13;
         StorageLive(_17);
         StorageLive(_18);
         _18 = &_1;
@@ -150,7 +150,7 @@ fn main() -> () {
         StorageLive(_25);
         StorageLive(_26);
         _26 = &raw const (*_15);
-        _25 = _26;
+        _25 = copy _26;
         StorageDead(_26);
         StorageLive(_27);
         _27 = array_casts() -> [return: bb6, unwind continue];
diff --git a/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-abort.mir b/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-abort.mir
index 4f90413e38bfe..b873c5aabbfc3 100644
--- a/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-abort.mir
+++ b/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-abort.mir
@@ -8,7 +8,7 @@ fn <impl at $DIR/retag.rs:13:1: 13:10>::foo_shr(_1: &Test, _2: &i32) -> &i32 {
     bb0: {
         Retag([fn entry] _1);
         Retag([fn entry] _2);
-        _0 = _2;
+        _0 = copy _2;
         Retag(_0);
         return;
     }
diff --git a/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-unwind.mir b/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
index 4f90413e38bfe..b873c5aabbfc3 100644
--- a/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
+++ b/tests/mir-opt/retag.{impl#0}-foo_shr.SimplifyCfg-pre-optimizations.after.panic-unwind.mir
@@ -8,7 +8,7 @@ fn <impl at $DIR/retag.rs:13:1: 13:10>::foo_shr(_1: &Test, _2: &i32) -> &i32 {
     bb0: {
         Retag([fn entry] _1);
         Retag([fn entry] _2);
-        _0 = _2;
+        _0 = copy _2;
         Retag(_0);
         return;
     }
diff --git a/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff b/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff
index 8dd904c7d7b99..ce9d812701a8f 100644
--- a/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff
+++ b/tests/mir-opt/separate_const_switch.identity.JumpThreading.diff
@@ -50,16 +50,16 @@
       }
   
       bb2: {
-          _5 = ((_2 as Continue).0: i32);
-          _0 = Result::<i32, i32>::Ok(_5);
+          _5 = copy ((_2 as Continue).0: i32);
+          _0 = Result::<i32, i32>::Ok(copy _5);
           StorageDead(_2);
           return;
       }
   
       bb3: {
-          _4 = ((_2 as Break).0: std::result::Result<std::convert::Infallible, i32>);
-          _10 = ((_4 as Err).0: i32);
-          _0 = Result::<i32, i32>::Err(_10);
+          _4 = copy ((_2 as Break).0: std::result::Result<std::convert::Infallible, i32>);
+          _10 = copy ((_4 as Err).0: i32);
+          _0 = Result::<i32, i32>::Err(copy _10);
           StorageDead(_2);
           return;
       }
@@ -74,9 +74,9 @@
       }
   
       bb5: {
-          _8 = ((_1 as Err).0: i32);
+          _8 = copy ((_1 as Err).0: i32);
           StorageLive(_9);
-          _9 = Result::<Infallible, i32>::Err(_8);
+          _9 = Result::<Infallible, i32>::Err(copy _8);
           _2 = ControlFlow::<Result<Infallible, i32>, i32>::Break(move _9);
           StorageDead(_9);
 -         goto -> bb4;
@@ -84,8 +84,8 @@
       }
   
       bb6: {
-          _7 = ((_1 as Ok).0: i32);
-          _2 = ControlFlow::<Result<Infallible, i32>, i32>::Continue(_7);
+          _7 = copy ((_1 as Ok).0: i32);
+          _2 = ControlFlow::<Result<Infallible, i32>, i32>::Continue(copy _7);
           goto -> bb4;
 +     }
 + 
diff --git a/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff b/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff
index f749586299221..c88c63e0c1334 100644
--- a/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff
+++ b/tests/mir-opt/separate_const_switch.too_complex.JumpThreading.diff
@@ -35,15 +35,15 @@
       }
   
       bb2: {
-          _5 = ((_1 as Err).0: usize);
-          _2 = ControlFlow::<usize, i32>::Break(_5);
+          _5 = copy ((_1 as Err).0: usize);
+          _2 = ControlFlow::<usize, i32>::Break(copy _5);
 -         goto -> bb4;
 +         goto -> bb8;
       }
   
       bb3: {
-          _4 = ((_1 as Ok).0: i32);
-          _2 = ControlFlow::<usize, i32>::Continue(_4);
+          _4 = copy ((_1 as Ok).0: i32);
+          _2 = ControlFlow::<usize, i32>::Continue(copy _4);
           goto -> bb4;
       }
   
@@ -55,15 +55,15 @@
   
       bb5: {
           StorageLive(_8);
-          _8 = ((_2 as Break).0: usize);
+          _8 = copy ((_2 as Break).0: usize);
           _0 = const Option::<i32>::None;
           StorageDead(_8);
           goto -> bb7;
       }
   
       bb6: {
-          _7 = ((_2 as Continue).0: i32);
-          _0 = Option::<i32>::Some(_7);
+          _7 = copy ((_2 as Continue).0: i32);
+          _0 = Option::<i32>::Some(copy _7);
           goto -> bb7;
       }
   
diff --git a/tests/mir-opt/set_no_discriminant.f.JumpThreading.diff b/tests/mir-opt/set_no_discriminant.f.JumpThreading.diff
index bc28e81c9a88b..3d9852aef657e 100644
--- a/tests/mir-opt/set_no_discriminant.f.JumpThreading.diff
+++ b/tests/mir-opt/set_no_discriminant.f.JumpThreading.diff
@@ -10,7 +10,7 @@
           _2 = E::<char>::A;
           discriminant(_2) = 1;
           _1 = discriminant(_2);
-          switchInt(_1) -> [0: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [0: bb1, otherwise: bb2];
       }
   
       bb1: {
diff --git a/tests/mir-opt/set_no_discriminant.generic.JumpThreading.diff b/tests/mir-opt/set_no_discriminant.generic.JumpThreading.diff
index 78bfeef3c6492..c7af16383161e 100644
--- a/tests/mir-opt/set_no_discriminant.generic.JumpThreading.diff
+++ b/tests/mir-opt/set_no_discriminant.generic.JumpThreading.diff
@@ -10,7 +10,7 @@
           _2 = E::<T>::A;
           discriminant(_2) = 1;
           _1 = discriminant(_2);
-          switchInt(_1) -> [0: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [0: bb1, otherwise: bb2];
       }
   
       bb1: {
diff --git a/tests/mir-opt/simplify_dead_blocks.assert_nonzero_nonmax.SimplifyCfg-after-unreachable-enum-branching.diff b/tests/mir-opt/simplify_dead_blocks.assert_nonzero_nonmax.SimplifyCfg-after-unreachable-enum-branching.diff
index 4400cfaef810c..9c8efab5c8437 100644
--- a/tests/mir-opt/simplify_dead_blocks.assert_nonzero_nonmax.SimplifyCfg-after-unreachable-enum-branching.diff
+++ b/tests/mir-opt/simplify_dead_blocks.assert_nonzero_nonmax.SimplifyCfg-after-unreachable-enum-branching.diff
@@ -5,8 +5,8 @@
       let mut _0: u8;
   
       bb0: {
--         switchInt(_1) -> [0: bb3, 1: bb2, 255: bb3, otherwise: bb4];
-+         switchInt(_1) -> [0: bb2, 1: bb1, 255: bb2, otherwise: bb3];
+-         switchInt(copy _1) -> [0: bb3, 1: bb2, 255: bb3, otherwise: bb4];
++         switchInt(copy _1) -> [0: bb2, 1: bb1, 255: bb2, otherwise: bb3];
       }
   
       bb1: {
@@ -26,7 +26,7 @@
   
 -     bb4: {
 +     bb3: {
-          _0 = _1;
+          _0 = copy _1;
           return;
       }
   }
diff --git a/tests/mir-opt/simplify_locals.expose_provenance.SimplifyLocals-before-const-prop.diff b/tests/mir-opt/simplify_locals.expose_provenance.SimplifyLocals-before-const-prop.diff
index cc5c642407e9c..420fb4270b2b8 100644
--- a/tests/mir-opt/simplify_locals.expose_provenance.SimplifyLocals-before-const-prop.diff
+++ b/tests/mir-opt/simplify_locals.expose_provenance.SimplifyLocals-before-const-prop.diff
@@ -10,7 +10,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = move _3 as usize (PointerExposeProvenance);
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/simplify_locals.t1.SimplifyLocals-before-const-prop.diff b/tests/mir-opt/simplify_locals.t1.SimplifyLocals-before-const-prop.diff
index 526ff2f25cfc9..f05a3935d6584 100644
--- a/tests/mir-opt/simplify_locals.t1.SimplifyLocals-before-const-prop.diff
+++ b/tests/mir-opt/simplify_locals.t1.SimplifyLocals-before-const-prop.diff
@@ -10,7 +10,7 @@
 -         StorageLive(_1);
 -         StorageLive(_2);
 -         _2 = &/*tls*/ mut X;
--         _1 = (*_2);
+-         _1 = copy (*_2);
 -         StorageDead(_2);
 -         StorageDead(_1);
           _0 = const ();
diff --git a/tests/mir-opt/simplify_locals.t3.SimplifyLocals-before-const-prop.diff b/tests/mir-opt/simplify_locals.t3.SimplifyLocals-before-const-prop.diff
index 5d45d7ac78159..a57c136e64d34 100644
--- a/tests/mir-opt/simplify_locals.t3.SimplifyLocals-before-const-prop.diff
+++ b/tests/mir-opt/simplify_locals.t3.SimplifyLocals-before-const-prop.diff
@@ -13,7 +13,7 @@
 -         StorageLive(_3);
 -         _3 = &/*tls*/ mut X;
 -         _2 = &mut (*_3);
--         _1 = (*_2);
+-         _1 = copy (*_2);
 -         StorageDead(_3);
 -         StorageDead(_2);
 -         StorageDead(_1);
diff --git a/tests/mir-opt/simplify_locals.t4.SimplifyLocals-before-const-prop.diff b/tests/mir-opt/simplify_locals.t4.SimplifyLocals-before-const-prop.diff
index 4f4855dbaaf87..118193fd4fdef 100644
--- a/tests/mir-opt/simplify_locals.t4.SimplifyLocals-before-const-prop.diff
+++ b/tests/mir-opt/simplify_locals.t4.SimplifyLocals-before-const-prop.diff
@@ -10,7 +10,7 @@
           StorageLive(_1);
           StorageLive(_2);
           _2 = &/*tls*/ mut X;
-          _1 = (*_2);
+          _1 = copy (*_2);
           _0 = Add(move _1, const 1_u32);
           StorageDead(_1);
           StorageDead(_2);
diff --git a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff
index c520a159f47b2..c363dfcbf70bb 100644
--- a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff
+++ b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-abort.diff
@@ -33,7 +33,7 @@
   
       bb2: {
           StorageLive(_6);
-          _6 = (((_1.0: std::option::Option<u8>) as Some).0: u8);
+          _6 = copy (((_1.0: std::option::Option<u8>) as Some).0: u8);
           StorageDead(_6);
           goto -> bb3;
       }
diff --git a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff
index 686581591fc4e..895b0067d2e63 100644
--- a/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff
+++ b/tests/mir-opt/simplify_locals_fixedpoint.foo.SimplifyLocals-final.panic-unwind.diff
@@ -33,7 +33,7 @@
   
       bb2: {
           StorageLive(_6);
-          _6 = (((_1.0: std::option::Option<u8>) as Some).0: u8);
+          _6 = copy (((_1.0: std::option::Option<u8>) as Some).0: u8);
           StorageDead(_6);
           goto -> bb3;
       }
diff --git a/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-abort.diff b/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-abort.diff
index 54d254ee37463..58c265c5e6055 100644
--- a/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-abort.diff
+++ b/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-abort.diff
@@ -51,7 +51,7 @@
 -         _5 = (move _6, move _7);
 +         StorageLive(_8);
 +         _8 = Temp { x: const 40_u8 };
-+         _7 = (_8.0: u8);
++         _7 = copy (_8.0: u8);
 +         _6 = Add(move _7, const 2_u8);
           StorageDead(_7);
 -         StorageDead(_6);
@@ -67,7 +67,7 @@
 -         StorageLive(_10);
 -         StorageLive(_11);
 -         _11 = Temp { x: const 40_u8 };
--         _10 = (_11.0: u8);
+-         _10 = copy (_11.0: u8);
 -         _9 = Add(move _10, const 2_u8);
 -         StorageDead(_10);
 -         _8 = use_u8(move _9) -> [return: bb2, unwind unreachable];
diff --git a/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-unwind.diff b/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-unwind.diff
index a5d9bbc49af0a..748e1661c987b 100644
--- a/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-unwind.diff
+++ b/tests/mir-opt/simplify_locals_removes_unused_consts.main.SimplifyLocals-before-const-prop.panic-unwind.diff
@@ -51,7 +51,7 @@
 -         _5 = (move _6, move _7);
 +         StorageLive(_8);
 +         _8 = Temp { x: const 40_u8 };
-+         _7 = (_8.0: u8);
++         _7 = copy (_8.0: u8);
 +         _6 = Add(move _7, const 2_u8);
           StorageDead(_7);
 -         StorageDead(_6);
@@ -67,7 +67,7 @@
 -         StorageLive(_10);
 -         StorageLive(_11);
 -         _11 = Temp { x: const 40_u8 };
--         _10 = (_11.0: u8);
+-         _10 = copy (_11.0: u8);
 -         _9 = Add(move _10, const 2_u8);
 -         StorageDead(_10);
 -         _8 = use_u8(move _9) -> [return: bb2, unwind continue];
diff --git a/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff b/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff
index 33b36f660cb3a..9e798cbcac0c1 100644
--- a/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff
+++ b/tests/mir-opt/simplify_match.main.GVN.panic-abort.diff
@@ -14,9 +14,9 @@
 -         StorageLive(_2);
 +         nop;
           _2 = const false;
--         _1 = _2;
+-         _1 = copy _2;
 -         StorageDead(_2);
--         switchInt(_1) -> [0: bb2, otherwise: bb1];
+-         switchInt(copy _1) -> [0: bb2, otherwise: bb1];
 +         _1 = const false;
 +         nop;
 +         switchInt(const false) -> [0: bb2, otherwise: bb1];
diff --git a/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff b/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff
index e5c3adff62369..e243ff45ab0b2 100644
--- a/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff
+++ b/tests/mir-opt/simplify_match.main.GVN.panic-unwind.diff
@@ -14,9 +14,9 @@
 -         StorageLive(_2);
 +         nop;
           _2 = const false;
--         _1 = _2;
+-         _1 = copy _2;
 -         StorageDead(_2);
--         switchInt(_1) -> [0: bb2, otherwise: bb1];
+-         switchInt(copy _1) -> [0: bb2, otherwise: bb1];
 +         _1 = const false;
 +         nop;
 +         switchInt(const false) -> [0: bb2, otherwise: bb1];
diff --git a/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-abort.diff b/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-abort.diff
index ad1a2b300f2a9..0269c2cba202d 100644
--- a/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-abort.diff
+++ b/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-abort.diff
@@ -22,7 +22,7 @@
       bb1: {
           StorageDead(_2);
           StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 +         _3 = const <T as MyTrait>::ASSOC_BOOL;
           switchInt(move _3) -> [0: bb3, otherwise: bb2];
       }
diff --git a/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff b/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff
index 827a292e5d024..1285b8b33ba2d 100644
--- a/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff
+++ b/tests/mir-opt/single_use_consts.if_const_debug.SingleUseConsts.panic-unwind.diff
@@ -22,7 +22,7 @@
       bb1: {
           StorageDead(_2);
           StorageLive(_3);
--         _3 = _1;
+-         _3 = copy _1;
 +         _3 = const <T as MyTrait>::ASSOC_BOOL;
           switchInt(move _3) -> [0: bb3, otherwise: bb2];
       }
diff --git a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff
index 998b89919d1bd..354e0988a0060 100644
--- a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff
+++ b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-abort.diff
@@ -8,7 +8,7 @@
       bb0: {
           StorageLive(_1);
 -         _1 = const <T as MyTrait>::ASSOC_INT;
--         switchInt(_1) -> [7: bb3, 42: bb2, otherwise: bb1];
+-         switchInt(copy _1) -> [7: bb3, 42: bb2, otherwise: bb1];
 +         nop;
 +         switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb3, 42: bb2, otherwise: bb1];
       }
diff --git a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff
index 998b89919d1bd..354e0988a0060 100644
--- a/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff
+++ b/tests/mir-opt/single_use_consts.match_const.SingleUseConsts.panic-unwind.diff
@@ -8,7 +8,7 @@
       bb0: {
           StorageLive(_1);
 -         _1 = const <T as MyTrait>::ASSOC_INT;
--         switchInt(_1) -> [7: bb3, 42: bb2, otherwise: bb1];
+-         switchInt(copy _1) -> [7: bb3, 42: bb2, otherwise: bb1];
 +         nop;
 +         switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb3, 42: bb2, otherwise: bb1];
       }
diff --git a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff
index 30f66ef6b8237..5cf37dc97cbff 100644
--- a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff
+++ b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-abort.diff
@@ -20,7 +20,7 @@
   
       bb1: {
           StorageDead(_2);
--         switchInt(_1) -> [7: bb4, 42: bb3, otherwise: bb2];
+-         switchInt(copy _1) -> [7: bb4, 42: bb3, otherwise: bb2];
 +         switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb4, 42: bb3, otherwise: bb2];
       }
   
diff --git a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff
index ed12ad4b93e89..bdcf086e8d962 100644
--- a/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff
+++ b/tests/mir-opt/single_use_consts.match_const_debug.SingleUseConsts.panic-unwind.diff
@@ -20,7 +20,7 @@
   
       bb1: {
           StorageDead(_2);
--         switchInt(_1) -> [7: bb4, 42: bb3, otherwise: bb2];
+-         switchInt(copy _1) -> [7: bb4, 42: bb3, otherwise: bb2];
 +         switchInt(const <T as MyTrait>::ASSOC_INT) -> [7: bb4, 42: bb3, otherwise: bb2];
       }
   
diff --git a/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String].AddMovesForPackedDrops.before.mir b/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String].AddMovesForPackedDrops.before.mir
index 3a8b457a7a109..4d1eaa6ffe324 100644
--- a/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String].AddMovesForPackedDrops.before.mir
+++ b/tests/mir-opt/slice_drop_shim.core.ptr-drop_in_place.[String].AddMovesForPackedDrops.before.mir
@@ -28,7 +28,7 @@ fn std::ptr::drop_in_place(_1: *mut [String]) -> () {
     }
 
     bb4 (cleanup): {
-        _5 = Eq(_3, _2);
+        _5 = Eq(copy _3, copy _2);
         switchInt(move _5) -> [0: bb3, otherwise: bb2];
     }
 
@@ -39,7 +39,7 @@ fn std::ptr::drop_in_place(_1: *mut [String]) -> () {
     }
 
     bb6: {
-        _7 = Eq(_3, _2);
+        _7 = Eq(copy _3, copy _2);
         switchInt(move _7) -> [0: bb5, otherwise: bb1];
     }
 
diff --git a/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff
index 819f3f86d145f..478dacc327668 100644
--- a/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/lifetimes.foo.ScalarReplacementOfAggregates.diff
@@ -75,8 +75,8 @@
 -         _5 = move (_1.0: std::result::Result<std::boxed::Box<dyn std::fmt::Display>, <T as Err>::Err>);
 +         _5 = move _29;
           StorageLive(_6);
--         _6 = (_1.1: u32);
-+         _6 = _30;
+-         _6 = copy (_1.1: u32);
++         _6 = copy _30;
           _7 = discriminant(_5);
           switchInt(move _7) -> [0: bb2, otherwise: bb7];
       }
@@ -171,7 +171,7 @@
       }
   
       bb11: {
-          switchInt(_25) -> [0: bb10, otherwise: bb12];
+          switchInt(copy _25) -> [0: bb10, otherwise: bb12];
       }
   
       bb12: {
diff --git a/tests/mir-opt/sroa/structs.constant.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.constant.ScalarReplacementOfAggregates.diff
index 5d21e79398238..4da3eb0ed7617 100644
--- a/tests/mir-opt/sroa/structs.constant.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/structs.constant.ScalarReplacementOfAggregates.diff
@@ -29,11 +29,11 @@
 +         _4 = move (_1.0: usize);
 +         _5 = move (_1.1: u8);
           StorageLive(_2);
--         _2 = (_1.0: usize);
-+         _2 = _4;
+-         _2 = copy (_1.0: usize);
++         _2 = copy _4;
           StorageLive(_3);
--         _3 = (_1.1: u8);
-+         _3 = _5;
+-         _3 = copy (_1.1: u8);
++         _3 = copy _5;
           _0 = const ();
           StorageDead(_3);
           StorageDead(_2);
diff --git a/tests/mir-opt/sroa/structs.copies.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.copies.ScalarReplacementOfAggregates.diff
index 3621338635ed7..cfc086d65963f 100644
--- a/tests/mir-opt/sroa/structs.copies.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/structs.copies.ScalarReplacementOfAggregates.diff
@@ -43,38 +43,38 @@
   
       bb0: {
 -         StorageLive(_2);
--         _2 = _1;
+-         _2 = copy _1;
 +         StorageLive(_11);
 +         StorageLive(_12);
 +         StorageLive(_13);
 +         StorageLive(_14);
 +         nop;
-+         _11 = (_1.0: u8);
-+         _12 = (_1.1: ());
-+         _13 = (_1.2: &str);
-+         _14 = (_1.3: std::option::Option<isize>);
++         _11 = copy (_1.0: u8);
++         _12 = copy (_1.1: ());
++         _13 = copy (_1.2: &str);
++         _14 = copy (_1.3: std::option::Option<isize>);
 +         nop;
           StorageLive(_3);
--         _3 = (_2.0: u8);
-+         _3 = _11;
+-         _3 = copy (_2.0: u8);
++         _3 = copy _11;
           StorageLive(_4);
--         _4 = (_2.2: &str);
+-         _4 = copy (_2.2: &str);
 -         StorageLive(_5);
--         _5 = _2;
-+         _4 = _13;
+-         _5 = copy _2;
++         _4 = copy _13;
 +         StorageLive(_7);
 +         StorageLive(_8);
 +         StorageLive(_9);
 +         StorageLive(_10);
 +         nop;
-+         _7 = _11;
-+         _8 = _12;
-+         _9 = _13;
-+         _10 = _14;
++         _7 = copy _11;
++         _8 = copy _12;
++         _9 = copy _13;
++         _10 = copy _14;
 +         nop;
           StorageLive(_6);
--         _6 = (_5.1: ());
-+         _6 = _8;
+-         _6 = copy (_5.1: ());
++         _6 = copy _8;
           _0 = const ();
           StorageDead(_6);
 -         StorageDead(_5);
diff --git a/tests/mir-opt/sroa/structs.enums.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.enums.ScalarReplacementOfAggregates.diff
index b5e39e632476c..eda884de822a8 100644
--- a/tests/mir-opt/sroa/structs.enums.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/structs.enums.ScalarReplacementOfAggregates.diff
@@ -15,7 +15,7 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = Option::<usize>::Some(move _3);
           StorageDead(_3);
           _4 = discriminant(_2);
@@ -24,8 +24,8 @@
   
       bb1: {
           StorageLive(_5);
-          _5 = ((_2 as Some).0: usize);
-          _0 = _5;
+          _5 = copy ((_2 as Some).0: usize);
+          _0 = copy _5;
           StorageDead(_5);
           goto -> bb3;
       }
diff --git a/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff
index a84048365a4ba..77c7c1a901239 100644
--- a/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/structs.flat.ScalarReplacementOfAggregates.diff
@@ -49,18 +49,18 @@
           StorageDead(_7);
           StorageDead(_6);
           StorageLive(_1);
--         _1 = (_5.0: u8);
-+         _1 = _8;
+-         _1 = copy (_5.0: u8);
++         _1 = copy _8;
           StorageLive(_2);
--         _2 = (_5.1: ());
-+         _2 = _9;
+-         _2 = copy (_5.1: ());
++         _2 = copy _9;
           StorageLive(_3);
--         _3 = (_5.2: &str);
-+         _3 = _10;
+-         _3 = copy (_5.2: &str);
++         _3 = copy _10;
           StorageLive(_4);
--         _4 = (_5.3: std::option::Option<isize>);
+-         _4 = copy (_5.3: std::option::Option<isize>);
 -         StorageDead(_5);
-+         _4 = _11;
++         _4 = copy _11;
 +         StorageDead(_8);
 +         StorageDead(_9);
 +         StorageDead(_10);
diff --git a/tests/mir-opt/sroa/structs.ref_copies.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.ref_copies.ScalarReplacementOfAggregates.diff
index 304bf2fb1a765..abe7cd78878fe 100644
--- a/tests/mir-opt/sroa/structs.ref_copies.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/structs.ref_copies.ScalarReplacementOfAggregates.diff
@@ -27,23 +27,23 @@
   
       bb0: {
 -         StorageLive(_2);
--         _2 = (*_1);
+-         _2 = copy (*_1);
 +         StorageLive(_5);
 +         StorageLive(_6);
 +         StorageLive(_7);
 +         StorageLive(_8);
 +         nop;
-+         _5 = ((*_1).0: u8);
-+         _6 = ((*_1).1: ());
-+         _7 = ((*_1).2: &str);
-+         _8 = ((*_1).3: std::option::Option<isize>);
++         _5 = copy ((*_1).0: u8);
++         _6 = copy ((*_1).1: ());
++         _7 = copy ((*_1).2: &str);
++         _8 = copy ((*_1).3: std::option::Option<isize>);
 +         nop;
           StorageLive(_3);
--         _3 = (_2.0: u8);
-+         _3 = _5;
+-         _3 = copy (_2.0: u8);
++         _3 = copy _5;
           StorageLive(_4);
--         _4 = (_2.2: &str);
-+         _4 = _7;
+-         _4 = copy (_2.2: &str);
++         _4 = copy _7;
           _0 = const ();
           StorageDead(_4);
           StorageDead(_3);
diff --git a/tests/mir-opt/sroa/structs.structs.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.structs.ScalarReplacementOfAggregates.diff
index bf5c3e3bd0302..fe9deabe94078 100644
--- a/tests/mir-opt/sroa/structs.structs.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/structs.structs.ScalarReplacementOfAggregates.diff
@@ -15,15 +15,15 @@
 +         StorageLive(_5);
 +         nop;
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
 -         _2 = U { _foo: const 0_usize, a: move _3 };
 +         _4 = const 0_usize;
 +         _5 = move _3;
 +         nop;
           StorageDead(_3);
--         _0 = (_2.1: f32);
+-         _0 = copy (_2.1: f32);
 -         StorageDead(_2);
-+         _0 = _5;
++         _0 = copy _5;
 +         StorageDead(_4);
 +         StorageDead(_5);
 +         nop;
diff --git a/tests/mir-opt/sroa/structs.unions.ScalarReplacementOfAggregates.diff b/tests/mir-opt/sroa/structs.unions.ScalarReplacementOfAggregates.diff
index 2f8dfcc5d6345..115f163cda9ba 100644
--- a/tests/mir-opt/sroa/structs.unions.ScalarReplacementOfAggregates.diff
+++ b/tests/mir-opt/sroa/structs.unions.ScalarReplacementOfAggregates.diff
@@ -10,10 +10,10 @@
       bb0: {
           StorageLive(_2);
           StorageLive(_3);
-          _3 = _1;
+          _3 = copy _1;
           _2 = Repr { f: move _3 };
           StorageDead(_3);
-          _0 = (_2.1: u32);
+          _0 = copy (_2.1: u32);
           StorageDead(_2);
           return;
       }
diff --git a/tests/mir-opt/storage_ranges.main.nll.0.mir b/tests/mir-opt/storage_ranges.main.nll.0.mir
index 782efd5acc625..bc2dcfe0a6459 100644
--- a/tests/mir-opt/storage_ranges.main.nll.0.mir
+++ b/tests/mir-opt/storage_ranges.main.nll.0.mir
@@ -43,7 +43,7 @@ fn main() -> () {
         StorageLive(_3);
         StorageLive(_4);
         StorageLive(_5);
-        _5 = _1;
+        _5 = copy _1;
         _4 = Option::<i32>::Some(move _5);
         StorageDead(_5);
         _3 = &_4;
diff --git a/tests/mir-opt/switch_to_self.test.MatchBranchSimplification.diff b/tests/mir-opt/switch_to_self.test.MatchBranchSimplification.diff
index c0b599e060b28..fef708d9962e5 100644
--- a/tests/mir-opt/switch_to_self.test.MatchBranchSimplification.diff
+++ b/tests/mir-opt/switch_to_self.test.MatchBranchSimplification.diff
@@ -9,11 +9,11 @@
       }
   
       bb1: {
-          switchInt(_1) -> [0: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [0: bb1, otherwise: bb2];
       }
   
       bb2: {
-          switchInt(_1) -> [0: bb1, otherwise: bb2];
+          switchInt(copy _1) -> [0: bb1, otherwise: bb2];
       }
   }
   
diff --git a/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-abort.diff b/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-abort.diff
index 44673ea00a966..17c64d4baf0ef 100644
--- a/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-abort.diff
+++ b/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-abort.diff
@@ -102,7 +102,7 @@
 +     }
 + 
 +     bb14 (cleanup): {
-+         switchInt(_8) -> [0: bb11, otherwise: bb13];
++         switchInt(copy _8) -> [0: bb11, otherwise: bb13];
       }
   }
   
diff --git a/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-unwind.diff b/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-unwind.diff
index a6d33a2459543..58d8a87986d6b 100644
--- a/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-unwind.diff
+++ b/tests/mir-opt/tail_call_drops.f.ElaborateDrops.panic-unwind.diff
@@ -103,7 +103,7 @@
 +     }
 + 
 +     bb14 (cleanup): {
-+         switchInt(_8) -> [0: bb11, otherwise: bb13];
++         switchInt(copy _8) -> [0: bb11, otherwise: bb13];
       }
   }
   
diff --git a/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-abort.diff b/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-abort.diff
index c7df2bb2207fb..1a51601bc56f5 100644
--- a/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-abort.diff
+++ b/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-abort.diff
@@ -178,7 +178,7 @@
 +     }
 + 
 +     bb31 (cleanup): {
-+         switchInt(_12) -> [0: bb26, otherwise: bb30];
++         switchInt(copy _12) -> [0: bb26, otherwise: bb30];
       }
   }
   
diff --git a/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-unwind.diff b/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-unwind.diff
index c7df2bb2207fb..1a51601bc56f5 100644
--- a/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-unwind.diff
+++ b/tests/mir-opt/tail_call_drops.f_with_arg.ElaborateDrops.panic-unwind.diff
@@ -178,7 +178,7 @@
 +     }
 + 
 +     bb31 (cleanup): {
-+         switchInt(_12) -> [0: bb26, otherwise: bb30];
++         switchInt(copy _12) -> [0: bb26, otherwise: bb30];
       }
   }
   
diff --git a/tests/mir-opt/unnamed-fields/field_access.bar.SimplifyCfg-initial.after.mir b/tests/mir-opt/unnamed-fields/field_access.bar.SimplifyCfg-initial.after.mir
index f0311422c17b8..f1904e5d0f44e 100644
--- a/tests/mir-opt/unnamed-fields/field_access.bar.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/unnamed-fields/field_access.bar.SimplifyCfg-initial.after.mir
@@ -15,7 +15,7 @@ fn bar(_1: Bar) -> () {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = (_1.0: u8);
+        _3 = copy (_1.0: u8);
         _2 = access::<u8>(move _3) -> [return: bb1, unwind: bb5];
     }
 
@@ -24,7 +24,7 @@ fn bar(_1: Bar) -> () {
         StorageDead(_2);
         StorageLive(_4);
         StorageLive(_5);
-        _5 = ((_1.1: Bar::{anon_adt#0}).0: i8);
+        _5 = copy ((_1.1: Bar::{anon_adt#0}).0: i8);
         _4 = access::<i8>(move _5) -> [return: bb2, unwind: bb5];
     }
 
@@ -33,7 +33,7 @@ fn bar(_1: Bar) -> () {
         StorageDead(_4);
         StorageLive(_6);
         StorageLive(_7);
-        _7 = ((_1.1: Bar::{anon_adt#0}).1: bool);
+        _7 = copy ((_1.1: Bar::{anon_adt#0}).1: bool);
         _6 = access::<bool>(move _7) -> [return: bb3, unwind: bb5];
     }
 
@@ -42,7 +42,7 @@ fn bar(_1: Bar) -> () {
         StorageDead(_6);
         StorageLive(_8);
         StorageLive(_9);
-        _9 = (((_1.2: Bar::{anon_adt#1}).0: Bar::{anon_adt#1}::{anon_adt#0}).0: [u8; 1]);
+        _9 = copy (((_1.2: Bar::{anon_adt#1}).0: Bar::{anon_adt#1}::{anon_adt#0}).0: [u8; 1]);
         _8 = access::<[u8; 1]>(move _9) -> [return: bb4, unwind: bb5];
     }
 
diff --git a/tests/mir-opt/unnamed-fields/field_access.foo.SimplifyCfg-initial.after.mir b/tests/mir-opt/unnamed-fields/field_access.foo.SimplifyCfg-initial.after.mir
index d48a969f06ebd..c279f59001210 100644
--- a/tests/mir-opt/unnamed-fields/field_access.foo.SimplifyCfg-initial.after.mir
+++ b/tests/mir-opt/unnamed-fields/field_access.foo.SimplifyCfg-initial.after.mir
@@ -15,7 +15,7 @@ fn foo(_1: Foo) -> () {
     bb0: {
         StorageLive(_2);
         StorageLive(_3);
-        _3 = (_1.0: u8);
+        _3 = copy (_1.0: u8);
         _2 = access::<u8>(move _3) -> [return: bb1, unwind: bb5];
     }
 
@@ -24,7 +24,7 @@ fn foo(_1: Foo) -> () {
         StorageDead(_2);
         StorageLive(_4);
         StorageLive(_5);
-        _5 = ((_1.1: Foo::{anon_adt#0}).0: i8);
+        _5 = copy ((_1.1: Foo::{anon_adt#0}).0: i8);
         _4 = access::<i8>(move _5) -> [return: bb2, unwind: bb5];
     }
 
@@ -33,7 +33,7 @@ fn foo(_1: Foo) -> () {
         StorageDead(_4);
         StorageLive(_6);
         StorageLive(_7);
-        _7 = ((_1.1: Foo::{anon_adt#0}).1: bool);
+        _7 = copy ((_1.1: Foo::{anon_adt#0}).1: bool);
         _6 = access::<bool>(move _7) -> [return: bb3, unwind: bb5];
     }
 
@@ -42,7 +42,7 @@ fn foo(_1: Foo) -> () {
         StorageDead(_6);
         StorageLive(_8);
         StorageLive(_9);
-        _9 = (((_1.2: Foo::{anon_adt#1}).0: Foo::{anon_adt#1}::{anon_adt#0}).0: [u8; 1]);
+        _9 = copy (((_1.2: Foo::{anon_adt#1}).0: Foo::{anon_adt#1}::{anon_adt#0}).0: [u8; 1]);
         _8 = access::<[u8; 1]>(move _9) -> [return: bb4, unwind: bb5];
     }
 
diff --git a/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-abort.diff b/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-abort.diff
index 1e1ddfae0eb9e..17ddce0cdf8d4 100644
--- a/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-abort.diff
+++ b/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-abort.diff
@@ -20,7 +20,7 @@
       bb1: {
           _2 = discriminant(_1);
 -         switchInt(move _2) -> [1: bb3, otherwise: bb2];
-+         _5 = Ne(_2, const 1_isize);
++         _5 = Ne(copy _2, const 1_isize);
 +         assume(move _5);
 +         goto -> bb2;
       }
diff --git a/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-unwind.diff b/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-unwind.diff
index 809d24aa15a13..2f78092f5bd24 100644
--- a/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-unwind.diff
+++ b/tests/mir-opt/unreachable.as_match.UnreachablePropagation.panic-unwind.diff
@@ -20,7 +20,7 @@
       bb1: {
           _2 = discriminant(_1);
 -         switchInt(move _2) -> [1: bb3, otherwise: bb2];
-+         _5 = Ne(_2, const 1_isize);
++         _5 = Ne(copy _2, const 1_isize);
 +         assume(move _5);
 +         goto -> bb2;
       }
diff --git a/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-abort.diff b/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-abort.diff
index 61959732720e0..2ce37c4422b97 100644
--- a/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-abort.diff
+++ b/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-abort.diff
@@ -26,7 +26,7 @@
       bb1: {
           _2 = discriminant(_1);
 -         switchInt(move _2) -> [1: bb2, otherwise: bb6];
-+         _8 = Ne(_2, const 1_isize);
++         _8 = Ne(copy _2, const 1_isize);
 +         assume(move _8);
 +         goto -> bb6;
       }
diff --git a/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-unwind.diff b/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-unwind.diff
index 476e2f5599449..2dfba10c37df0 100644
--- a/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-unwind.diff
+++ b/tests/mir-opt/unreachable.if_let.UnreachablePropagation.panic-unwind.diff
@@ -26,7 +26,7 @@
       bb1: {
           _2 = discriminant(_1);
 -         switchInt(move _2) -> [1: bb2, otherwise: bb6];
-+         _8 = Ne(_2, const 1_isize);
++         _8 = Ne(copy _2, const 1_isize);
 +         assume(move _8);
 +         goto -> bb6;
       }
diff --git a/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-abort.diff b/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-abort.diff
index 11d7924e7360e..ba268832ca3cc 100644
--- a/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-abort.diff
+++ b/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-abort.diff
@@ -35,9 +35,9 @@
           _4 = move ((_2 as Some).0: Empty);
           StorageLive(_5);
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
 -         switchInt(move _6) -> [0: bb4, otherwise: bb3];
-+         _8 = Ne(_6, const false);
++         _8 = Ne(copy _6, const false);
 +         assume(move _8);
 +         goto -> bb3;
       }
diff --git a/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-unwind.diff b/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-unwind.diff
index df6f5609fbfa9..f057f7764704b 100644
--- a/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_diverging.main.UnreachablePropagation.panic-unwind.diff
@@ -35,9 +35,9 @@
           _4 = move ((_2 as Some).0: Empty);
           StorageLive(_5);
           StorageLive(_6);
-          _6 = _1;
+          _6 = copy _1;
 -         switchInt(move _6) -> [0: bb4, otherwise: bb3];
-+         _8 = Ne(_6, const false);
++         _8 = Ne(copy _6, const false);
 +         assume(move _8);
 +         goto -> bb3;
       }
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff
index 4cd6d3f56833e..17e01f38f4eb1 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-abort.diff
@@ -29,7 +29,7 @@
       }
   
       bb2: {
-          switchInt(((_2 as A).0: i32)) -> [1: bb6, 2: bb5, otherwise: bb1];
+          switchInt(copy ((_2 as A).0: i32)) -> [1: bb6, 2: bb5, otherwise: bb1];
       }
   
       bb3: {
diff --git a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff
index 4cd6d3f56833e..17e01f38f4eb1 100644
--- a/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff
+++ b/tests/mir-opt/unreachable_enum_branching.otherwise_t4_unreachable_default_2.UnreachableEnumBranching.panic-unwind.diff
@@ -29,7 +29,7 @@
       }
   
       bb2: {
-          switchInt(((_2 as A).0: i32)) -> [1: bb6, 2: bb5, otherwise: bb1];
+          switchInt(copy ((_2 as A).0: i32)) -> [1: bb6, 2: bb5, otherwise: bb1];
       }
   
       bb3: {

From b9cffa7de071e8deae2b0c6b4780bba25f8ec875 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Sun, 18 Aug 2024 16:09:03 -0700
Subject: [PATCH 428/685] Exclude the copy blessing from git blame

---
 .git-blame-ignore-revs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index 9fd8054a12e46..ec76a1a42ef09 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -25,3 +25,5 @@ b2d2184edea578109a48ec3d8decbee5948e8f35
 ec2cc761bc7067712ecc7734502f703fe3b024c8
 # format use declarations
 84ac80f1921afc243d71fd0caaa4f2838c294102
+# bless mir-opt tests to add `copy`
+99cb0c6bc399fb94a0ddde7e9b38e9c00d523bad

From b8eedfa3d217e19f806fd4f46a89b074f5e8659f Mon Sep 17 00:00:00 2001
From: Boxy <rust@boxyuwu.dev>
Date: Mon, 19 Aug 2024 01:14:09 +0100
Subject: [PATCH 429/685] Retroactively feature gate `ConstArgKind::Path`

---
 compiler/rustc_ast_lowering/src/asm.rs        |   4 +-
 compiler/rustc_ast_lowering/src/expr.rs       |   2 +-
 compiler/rustc_ast_lowering/src/lib.rs        |   7 +-
 compiler/rustc_feature/src/unstable.rs        |   2 +
 compiler/rustc_middle/src/ty/consts.rs        |  32 +++--
 compiler/rustc_resolve/src/def_collector.rs   |  16 ++-
 compiler/rustc_span/src/symbol.rs             |   1 +
 tests/crashes/127972.rs                       |   2 +-
 tests/crashes/128016.rs                       |  10 --
 .../ui-fulldeps/stable-mir/check_instance.rs  |  10 +-
 .../generic_const_type_mismatch.rs            |   2 +
 .../generic_const_type_mismatch.stderr        |  20 ++-
 .../ui/const-generics/bad-subst-const-kind.rs |   1 +
 .../bad-subst-const-kind.stderr               |  11 +-
 .../early/trivial-const-arg-macro-nested.rs   |  21 +++
 .../early/trivial-const-arg-macro-param.rs    |  13 ++
 .../trivial-const-arg-macro-res-error.rs      |  13 ++
 .../trivial-const-arg-macro-res-error.stderr  |  24 ++++
 .../early/trivial-const-arg-macro.rs          |  15 +++
 .../generic_const_exprs/type_mismatch.rs      |   1 +
 .../generic_const_exprs/type_mismatch.stderr  |  12 +-
 .../unevaluated-const-ice-119731.rs           |  10 +-
 .../unevaluated-const-ice-119731.stderr       |   4 +-
 tests/ui/const-generics/transmute-fail.rs     | 126 +++++++++---------
 tests/ui/const-generics/transmute-fail.stderr | 101 ++++++++------
 tests/ui/const-generics/type_mismatch.rs      |   2 +
 tests/ui/const-generics/type_mismatch.stderr  |  20 ++-
 tests/ui/consts/issue-36163.stderr            |   6 +-
 .../feature-gate-const-arg-path.rs            |   5 +
 tests/ui/lifetimes/issue-95023.rs             |   7 +-
 tests/ui/lifetimes/issue-95023.stderr         |  10 +-
 ...t-proj-ty-as-type-of-const-issue-125757.rs |   1 +
 ...oj-ty-as-type-of-const-issue-125757.stderr |  14 +-
 .../bad-const-wf-doesnt-specialize.rs         |   1 +
 .../bad-const-wf-doesnt-specialize.stderr     |  14 +-
 tests/ui/transmutability/issue-101739-1.rs    |   3 +-
 .../ui/transmutability/issue-101739-1.stderr  |  11 +-
 tests/ui/transmutability/issue-101739-2.rs    |  24 ++--
 .../ui/transmutability/issue-101739-2.stderr  |  25 ++--
 .../const-in-impl-fn-return-type.rs           |   8 +-
 .../const-in-impl-fn-return-type.stderr       |  20 ++-
 41 files changed, 425 insertions(+), 206 deletions(-)
 delete mode 100644 tests/crashes/128016.rs
 create mode 100644 tests/ui/const-generics/early/trivial-const-arg-macro-nested.rs
 create mode 100644 tests/ui/const-generics/early/trivial-const-arg-macro-param.rs
 create mode 100644 tests/ui/const-generics/early/trivial-const-arg-macro-res-error.rs
 create mode 100644 tests/ui/const-generics/early/trivial-const-arg-macro-res-error.stderr
 create mode 100644 tests/ui/const-generics/early/trivial-const-arg-macro.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-const-arg-path.rs

diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index 7d9d689e6d7e9..f20f376b278b7 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -221,7 +221,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             let parent_def_id = self.current_def_id_parent;
                             let node_id = self.next_node_id();
                             // HACK(min_generic_const_args): see lower_anon_const
-                            if !expr.is_potential_trivial_const_arg() {
+                            if !self.tcx.features().const_arg_path
+                                || !expr.is_potential_trivial_const_arg()
+                            {
                                 self.create_def(
                                     parent_def_id,
                                     node_id,
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index b5d8a547a8fb9..bb86e5c9325f9 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -387,7 +387,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let node_id = self.next_node_id();
 
                 // HACK(min_generic_const_args): see lower_anon_const
-                if !arg.is_potential_trivial_const_arg() {
+                if !self.tcx.features().const_arg_path || !arg.is_potential_trivial_const_arg() {
                     // Add a definition for the in-band const def.
                     self.create_def(parent_def_id, node_id, kw::Empty, DefKind::AnonConst, f.span);
                 }
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 81d17a9dec205..4b8c47ac4b411 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -2358,7 +2358,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         span: Span,
     ) -> &'hir hir::ConstArg<'hir> {
         let ct_kind = match res {
-            Res::Def(DefKind::ConstParam, _) => {
+            Res::Def(DefKind::ConstParam, _) if self.tcx.features().const_arg_path => {
                 let qpath = self.lower_qpath(
                     ty_id,
                     &None,
@@ -2433,7 +2433,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             self.resolver.get_partial_res(expr.id).and_then(|partial_res| partial_res.full_res());
         debug!("res={:?}", maybe_res);
         // FIXME(min_generic_const_args): for now we only lower params to ConstArgKind::Path
-        if let Some(res) = maybe_res
+        if self.tcx.features().const_arg_path
+            && let Some(res) = maybe_res
             && let Res::Def(DefKind::ConstParam, _) = res
             && let ExprKind::Path(qself, path) = &expr.kind
         {
@@ -2464,7 +2465,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     /// See [`hir::ConstArg`] for when to use this function vs
     /// [`Self::lower_anon_const_to_const_arg`].
     fn lower_anon_const_to_anon_const(&mut self, c: &AnonConst) -> &'hir hir::AnonConst {
-        if c.value.is_potential_trivial_const_arg() {
+        if self.tcx.features().const_arg_path && c.value.is_potential_trivial_const_arg() {
             // HACK(min_generic_const_args): see DefCollector::visit_anon_const
             // Over there, we guess if this is a bare param and only create a def if
             // we think it's not. However we may can guess wrong (see there for example)
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 459df9ea1b859..bcb084a1cd3d5 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -193,6 +193,8 @@ declare_features! (
     (unstable, anonymous_lifetime_in_impl_trait, "1.63.0", None),
     /// Allows identifying the `compiler_builtins` crate.
     (internal, compiler_builtins, "1.13.0", None),
+    /// Gating for a new desugaring of const arguments of usages of const parameters
+    (internal, const_arg_path, "1.81.0", None),
     /// Allows writing custom MIR
     (internal, custom_mir, "1.65.0", None),
     /// Outputs useful `assert!` messages
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index e373292741b90..362ff8e988d36 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -240,7 +240,7 @@ impl<'tcx> Const<'tcx> {
 
         let ty = tcx.type_of(def).no_bound_vars().expect("const parameter types cannot be generic");
 
-        match Self::try_from_lit(tcx, ty, expr) {
+        match Self::try_from_lit_or_param(tcx, ty, expr) {
             Some(v) => v,
             None => ty::Const::new_unevaluated(
                 tcx,
@@ -281,7 +281,11 @@ impl<'tcx> Const<'tcx> {
     }
 
     #[instrument(skip(tcx), level = "debug")]
-    fn try_from_lit(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, expr: &'tcx hir::Expr<'tcx>) -> Option<Self> {
+    fn try_from_lit_or_param(
+        tcx: TyCtxt<'tcx>,
+        ty: Ty<'tcx>,
+        expr: &'tcx hir::Expr<'tcx>,
+    ) -> Option<Self> {
         // Unwrap a block, so that e.g. `{ P }` is recognised as a parameter. Const arguments
         // currently have to be wrapped in curly brackets, so it's necessary to special-case.
         let expr = match &expr.kind {
@@ -291,6 +295,22 @@ impl<'tcx> Const<'tcx> {
             _ => expr,
         };
 
+        if let hir::ExprKind::Path(
+            qpath @ hir::QPath::Resolved(
+                _,
+                &hir::Path { res: Res::Def(DefKind::ConstParam, _), .. },
+            ),
+        ) = expr.kind
+        {
+            if tcx.features().const_arg_path {
+                span_bug!(
+                    expr.span,
+                    "try_from_lit: received const param which shouldn't be possible"
+                );
+            }
+            return Some(Const::from_param(tcx, qpath, expr.hir_id));
+        };
+
         let lit_input = match expr.kind {
             hir::ExprKind::Lit(lit) => Some(LitToConstInput { lit: &lit.node, ty, neg: false }),
             hir::ExprKind::Unary(hir::UnOp::Neg, expr) => match expr.kind {
@@ -318,14 +338,6 @@ impl<'tcx> Const<'tcx> {
             }
         }
 
-        if let hir::ExprKind::Path(hir::QPath::Resolved(
-            _,
-            &hir::Path { res: Res::Def(DefKind::ConstParam, _), .. },
-        )) = expr.kind
-        {
-            span_bug!(expr.span, "try_from_lit: received const param which shouldn't be possible")
-        }
-
         None
     }
 
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index ed23870dfdf8b..3595db78e9328 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -314,13 +314,15 @@ impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
     }
 
     fn visit_anon_const(&mut self, constant: &'a AnonConst) {
-        // HACK(min_generic_const_args): don't create defs for anon consts if we think they will
-        // later be turned into ConstArgKind::Path's. because this is before resolve is done, we
-        // may accidentally identify a construction of a unit struct as a param and not create a
-        // def. we'll then create a def later in ast lowering in this case. the parent of nested
-        // items will be messed up, but that's ok because there can't be any if we're just looking
-        // for bare idents.
-        if constant.value.is_potential_trivial_const_arg() {
+        if self.resolver.tcx.features().const_arg_path
+            && constant.value.is_potential_trivial_const_arg()
+        {
+            // HACK(min_generic_const_args): don't create defs for anon consts if we think they will
+            // later be turned into ConstArgKind::Path's. because this is before resolve is done, we
+            // may accidentally identify a construction of a unit struct as a param and not create a
+            // def. we'll then create a def later in ast lowering in this case. the parent of nested
+            // items will be messed up, but that's ok because there can't be any if we're just looking
+            // for bare idents.
             visit::walk_anon_const(self, constant)
         } else {
             let def =
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index a2e94492f8c23..942026cd7bf72 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -595,6 +595,7 @@ symbols! {
         conservative_impl_trait,
         console,
         const_allocate,
+        const_arg_path,
         const_async_blocks,
         const_closures,
         const_compare_raw_pointers,
diff --git a/tests/crashes/127972.rs b/tests/crashes/127972.rs
index d0764f875dbbb..797dd7e60209e 100644
--- a/tests/crashes/127972.rs
+++ b/tests/crashes/127972.rs
@@ -1,5 +1,5 @@
 //@ known-bug: #127962
-#![feature(generic_const_exprs)]
+#![feature(generic_const_exprs, const_arg_path)]
 
 fn zero_init<const usize: usize>() -> Substs1<{ (N) }> {
     Substs1([0; { (usize) }])
diff --git a/tests/crashes/128016.rs b/tests/crashes/128016.rs
deleted file mode 100644
index d23721ae14e3a..0000000000000
--- a/tests/crashes/128016.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-//@ known-bug: #128016
-macro_rules! len {
-    () => {
-        target
-    };
-}
-
-fn main() {
-    let val: [str; len!()] = [];
-}
diff --git a/tests/ui-fulldeps/stable-mir/check_instance.rs b/tests/ui-fulldeps/stable-mir/check_instance.rs
index 5e3f255756643..5449c09d35ab6 100644
--- a/tests/ui-fulldeps/stable-mir/check_instance.rs
+++ b/tests/ui-fulldeps/stable-mir/check_instance.rs
@@ -17,12 +17,14 @@ extern crate rustc_driver;
 extern crate rustc_interface;
 extern crate stable_mir;
 
-use mir::{mono::Instance, TerminatorKind::*};
+use std::io::Write;
+use std::ops::ControlFlow;
+
+use mir::mono::Instance;
+use mir::TerminatorKind::*;
 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";
 
@@ -33,7 +35,7 @@ fn test_stable_mir() -> ControlFlow<()> {
     // Get all items and split generic vs monomorphic items.
     let (generic, mono): (Vec<_>, Vec<_>) =
         items.into_iter().partition(|item| item.requires_monomorphization());
-    assert_eq!(mono.len(), 3, "Expected 3 mono functions");
+    assert_eq!(mono.len(), 4, "Expected 3 mono functions");
     assert_eq!(generic.len(), 2, "Expected 2 generic functions");
 
     // For all monomorphic items, get the correspondent instances.
diff --git a/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.rs b/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.rs
index e07fa78463c7d..cdfeb9c434e6c 100644
--- a/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.rs
+++ b/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.rs
@@ -5,7 +5,9 @@
 #![feature(with_negative_coherence)]
 trait Trait {}
 impl<const N: u8> Trait for [(); N] {}
+//~^ ERROR: mismatched types
 impl<const N: i8> Trait for [(); N] {}
 //~^ ERROR: conflicting implementations of trait `Trait`
+//~| ERROR: mismatched types
 
 fn main() {}
diff --git a/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.stderr b/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.stderr
index 2087be8e7115d..d65450845bc12 100644
--- a/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.stderr
+++ b/tests/ui/coherence/negative-coherence/generic_const_type_mismatch.stderr
@@ -1,11 +1,25 @@
 error[E0119]: conflicting implementations of trait `Trait` for type `[(); _]`
-  --> $DIR/generic_const_type_mismatch.rs:8:1
+  --> $DIR/generic_const_type_mismatch.rs:9:1
    |
 LL | impl<const N: u8> Trait for [(); N] {}
    | ----------------------------------- first implementation here
+LL |
 LL | impl<const N: i8> Trait for [(); N] {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `[(); _]`
 
-error: aborting due to 1 previous error
+error[E0308]: mismatched types
+  --> $DIR/generic_const_type_mismatch.rs:7:34
+   |
+LL | impl<const N: u8> Trait for [(); N] {}
+   |                                  ^ expected `usize`, found `u8`
+
+error[E0308]: mismatched types
+  --> $DIR/generic_const_type_mismatch.rs:9:34
+   |
+LL | impl<const N: i8> Trait for [(); N] {}
+   |                                  ^ expected `usize`, found `i8`
+
+error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0119`.
+Some errors have detailed explanations: E0119, E0308.
+For more information about an error, try `rustc --explain E0119`.
diff --git a/tests/ui/const-generics/bad-subst-const-kind.rs b/tests/ui/const-generics/bad-subst-const-kind.rs
index cc2ff9b8dea07..c4e74596e9fdc 100644
--- a/tests/ui/const-generics/bad-subst-const-kind.rs
+++ b/tests/ui/const-generics/bad-subst-const-kind.rs
@@ -7,6 +7,7 @@ trait Q {
 
 impl<const N: u64> Q for [u8; N] {
     //~^ ERROR: the constant `N` is not of type `usize`
+    //~| ERROR: mismatched types
     const ASSOC: usize = 1;
 }
 
diff --git a/tests/ui/const-generics/bad-subst-const-kind.stderr b/tests/ui/const-generics/bad-subst-const-kind.stderr
index 5c8d9c9036356..21ec8f0768cf1 100644
--- a/tests/ui/const-generics/bad-subst-const-kind.stderr
+++ b/tests/ui/const-generics/bad-subst-const-kind.stderr
@@ -5,7 +5,7 @@ LL | impl<const N: u64> Q for [u8; N] {
    |                          ^^^^^^^ expected `usize`, found `u64`
 
 error: the constant `13` is not of type `u64`
-  --> $DIR/bad-subst-const-kind.rs:13:24
+  --> $DIR/bad-subst-const-kind.rs:14:24
    |
 LL | pub fn test() -> [u8; <[u8; 13] as Q>::ASSOC] {
    |                        ^^^^^^^^ expected `u64`, found `usize`
@@ -18,5 +18,12 @@ LL | impl<const N: u64> Q for [u8; N] {
    |      |
    |      unsatisfied trait bound introduced here
 
-error: aborting due to 2 previous errors
+error[E0308]: mismatched types
+  --> $DIR/bad-subst-const-kind.rs:8:31
+   |
+LL | impl<const N: u64> Q for [u8; N] {
+   |                               ^ expected `usize`, found `u64`
+
+error: aborting due to 3 previous errors
 
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/early/trivial-const-arg-macro-nested.rs b/tests/ui/const-generics/early/trivial-const-arg-macro-nested.rs
new file mode 100644
index 0000000000000..f9730cf85661a
--- /dev/null
+++ b/tests/ui/const-generics/early/trivial-const-arg-macro-nested.rs
@@ -0,0 +1,21 @@
+//@ check-pass
+
+// This is a regression test for #128016.
+
+macro_rules! len_inner {
+    () => {
+        BAR
+    };
+}
+
+macro_rules! len {
+    () => {
+        len_inner!()
+    };
+}
+
+const BAR: usize = 0;
+
+fn main() {
+    let val: [bool; len!()] = [];
+}
diff --git a/tests/ui/const-generics/early/trivial-const-arg-macro-param.rs b/tests/ui/const-generics/early/trivial-const-arg-macro-param.rs
new file mode 100644
index 0000000000000..f123e55c028c3
--- /dev/null
+++ b/tests/ui/const-generics/early/trivial-const-arg-macro-param.rs
@@ -0,0 +1,13 @@
+//@ check-pass
+
+macro_rules! len {
+    ($x:ident) => {
+        $x
+    };
+}
+
+fn bar<const N: usize>() {
+    let val: [bool; len!(N)] = [true; N];
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.rs b/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.rs
new file mode 100644
index 0000000000000..f218caac0cf98
--- /dev/null
+++ b/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.rs
@@ -0,0 +1,13 @@
+// This is a regression test for #128016.
+
+macro_rules! len {
+    () => {
+        target
+        //~^ ERROR cannot find value `target`
+    };
+}
+
+fn main() {
+    let val: [str; len!()] = [];
+    //~^ ERROR the size for values
+}
diff --git a/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.stderr b/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.stderr
new file mode 100644
index 0000000000000..ab289e5a6b78f
--- /dev/null
+++ b/tests/ui/const-generics/early/trivial-const-arg-macro-res-error.stderr
@@ -0,0 +1,24 @@
+error[E0425]: cannot find value `target` in this scope
+  --> $DIR/trivial-const-arg-macro-res-error.rs:5:9
+   |
+LL |         target
+   |         ^^^^^^ not found in this scope
+...
+LL |     let val: [str; len!()] = [];
+   |                    ------ in this macro invocation
+   |
+   = note: this error originates in the macro `len` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the size for values of type `str` cannot be known at compilation time
+  --> $DIR/trivial-const-arg-macro-res-error.rs:11:14
+   |
+LL |     let val: [str; len!()] = [];
+   |              ^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `str`
+   = note: slice and array elements must have `Sized` type
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0277, E0425.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/const-generics/early/trivial-const-arg-macro.rs b/tests/ui/const-generics/early/trivial-const-arg-macro.rs
new file mode 100644
index 0000000000000..a19d9abfdcb05
--- /dev/null
+++ b/tests/ui/const-generics/early/trivial-const-arg-macro.rs
@@ -0,0 +1,15 @@
+//@ check-pass
+
+// This is a regression test for #128016.
+
+macro_rules! len {
+    () => {
+        BAR
+    };
+}
+
+const BAR: usize = 0;
+
+fn main() {
+    let val: [bool; len!()] = [];
+}
diff --git a/tests/ui/const-generics/generic_const_exprs/type_mismatch.rs b/tests/ui/const-generics/generic_const_exprs/type_mismatch.rs
index 8e5e23b233718..a45deabbb0f33 100644
--- a/tests/ui/const-generics/generic_const_exprs/type_mismatch.rs
+++ b/tests/ui/const-generics/generic_const_exprs/type_mismatch.rs
@@ -8,6 +8,7 @@ trait Q {
 impl<const N: u64> Q for [u8; N] {}
 //~^ ERROR not all trait items implemented
 //~| ERROR the constant `N` is not of type `usize`
+//~| ERROR mismatched types
 
 pub fn q_user() -> [u8; <[u8; 13] as Q>::ASSOC] {}
 //~^ ERROR the constant `13` is not of type `u64`
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 e03580ec007ca..68870a8d38da6 100644
--- a/tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/type_mismatch.stderr
@@ -14,7 +14,7 @@ LL | impl<const N: u64> Q for [u8; N] {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `ASSOC` in implementation
 
 error: the constant `13` is not of type `u64`
-  --> $DIR/type_mismatch.rs:12:26
+  --> $DIR/type_mismatch.rs:13:26
    |
 LL | pub fn q_user() -> [u8; <[u8; 13] as Q>::ASSOC] {}
    |                          ^^^^^^^^ expected `u64`, found `usize`
@@ -28,14 +28,20 @@ LL | impl<const N: u64> Q for [u8; N] {}
    |      unsatisfied trait bound introduced here
 
 error[E0308]: mismatched types
-  --> $DIR/type_mismatch.rs:12:20
+  --> $DIR/type_mismatch.rs:13:20
    |
 LL | pub fn q_user() -> [u8; <[u8; 13] as Q>::ASSOC] {}
    |        ------      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `[u8; <[u8; 13] as Q>::ASSOC]`, found `()`
    |        |
    |        implicitly returns `()` as its body has no tail or `return` expression
 
-error: aborting due to 4 previous errors
+error[E0308]: mismatched types
+  --> $DIR/type_mismatch.rs:8:31
+   |
+LL | impl<const N: u64> Q for [u8; N] {}
+   |                               ^ expected `usize`, found `u64`
+
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0046, E0308.
 For more information about an error, try `rustc --explain E0046`.
diff --git a/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.rs b/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.rs
index 8b7ee577569a6..05a3487ffca51 100644
--- a/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.rs
+++ b/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.rs
@@ -14,8 +14,8 @@ mod v20 {
     //~^ ERROR cannot find value `v8` in this scope
     //~| ERROR cannot find function `v6` in this scope
     pub struct v17<const v10: usize, const v7: v11> {
-    //~^ WARN type `v17` should have an upper camel case name
-    //~| ERROR `[[usize; v4]; v4]` is forbidden as the type of a const generic parameter
+        //~^ WARN type `v17` should have an upper camel case name
+        //~| ERROR `[[usize; v4]; v4]` is forbidden as the type of a const generic parameter
         _p: (),
     }
 
@@ -25,10 +25,10 @@ mod v20 {
     }
 
     impl<const v10: usize> v17<v10, v2> {
-    //~^ ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
-    //~| ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
+        //~^ ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
+        //~| ERROR maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
         pub const fn v21() -> v18 {
-        //~^ ERROR cannot find type `v18` in this scope
+            //~^ ERROR cannot find type `v18` in this scope
             v18 { _p: () }
             //~^ ERROR cannot find struct, variant or union type `v18` in this scope
         }
diff --git a/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.stderr b/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.stderr
index 15d3c47258525..39f022fbee9db 100644
--- a/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/unevaluated-const-ice-119731.stderr
@@ -72,13 +72,13 @@ help: add `#![feature(adt_const_params)]` to the crate attributes to enable more
 LL + #![feature(adt_const_params)]
    |
 
-error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
+error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
   --> $DIR/unevaluated-const-ice-119731.rs:27:37
    |
 LL |     impl<const v10: usize> v17<v10, v2> {
    |                                     ^^
 
-error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#0}
+error: maximum number of nodes exceeded in constant v20::v17::<v10, v2>::{constant#1}
   --> $DIR/unevaluated-const-ice-119731.rs:27:37
    |
 LL |     impl<const v10: usize> v17<v10, v2> {
diff --git a/tests/ui/const-generics/transmute-fail.rs b/tests/ui/const-generics/transmute-fail.rs
index 59b77c678e8ce..a9b297ffb62a2 100644
--- a/tests/ui/const-generics/transmute-fail.rs
+++ b/tests/ui/const-generics/transmute-fail.rs
@@ -2,108 +2,108 @@
 #![feature(generic_const_exprs)]
 #![allow(incomplete_features)]
 
-fn foo<const W: usize, const H: usize>(v: [[u32;H+1]; W]) -> [[u32; W+1]; H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR cannot transmute
-  }
+fn foo<const W: usize, const H: usize>(v: [[u32; H + 1]; W]) -> [[u32; W + 1]; H] {
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR cannot transmute
+    }
 }
 
 fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
-  //~^ ERROR the constant `W` is not of type `usize`
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR the constant `W` is not of type `usize`
-  }
+    //~^ ERROR: the constant `W` is not of type `usize`
+    //~| ERROR: mismatched types
+    //~| ERROR: mismatched types
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: the constant `W` is not of type `usize`
+    }
 }
 
 fn baz<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [u32; W * H * H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR cannot transmute
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR cannot transmute
+    }
 }
 
 fn overflow(v: [[[u32; 8888888]; 9999999]; 777777777]) -> [[[u32; 9999999]; 777777777]; 8888888] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR cannot transmute
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR cannot transmute
+    }
 }
 
-fn transpose<const W: usize, const H: usize>(v: [[u32;H]; W]) -> [[u32; W]; H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+fn transpose<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn ident<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [[u32; H]; W] {
-  unsafe {
-    std::mem::transmute(v)
-  }
+    unsafe { std::mem::transmute(v) }
 }
 
 fn flatten<const W: usize, const H: usize>(v: [[u32; H]; W]) -> [u32; W * H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
-fn coagulate<const W: usize, const H: usize>(v: [u32; H*W]) -> [[u32; W];H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+fn coagulate<const W: usize, const H: usize>(v: [u32; H * W]) -> [[u32; W]; H] {
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn flatten_3d<const W: usize, const H: usize, const D: usize>(
-  v: [[[u32; D]; H]; W]
+    v: [[[u32; D]; H]; W],
 ) -> [u32; D * W * H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn flatten_somewhat<const W: usize, const H: usize, const D: usize>(
-  v: [[[u32; D]; H]; W]
+    v: [[[u32; D]; H]; W],
 ) -> [[u32; D * W]; H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn known_size<const L: usize>(v: [u16; L]) -> [u8; L * 2] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn condense_bytes<const L: usize>(v: [u8; L * 2]) -> [u16; L] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
-fn singleton_each<const L: usize>(v: [u8; L]) -> [[u8;1]; L] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+fn singleton_each<const L: usize>(v: [u8; L]) -> [[u8; 1]; L] {
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn transpose_with_const<const W: usize, const H: usize>(
-  v: [[u32; 2 * H]; W + W]
+    v: [[u32; 2 * H]; W + W],
 ) -> [[u32; W + W]; 2 * H] {
-  unsafe {
-    std::mem::transmute(v)
-    //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
-  }
+    unsafe {
+        std::mem::transmute(v)
+        //~^ ERROR: cannot transmute between types of different sizes, or dependently-sized types
+    }
 }
 
 fn main() {}
diff --git a/tests/ui/const-generics/transmute-fail.stderr b/tests/ui/const-generics/transmute-fail.stderr
index b40fb23c33158..124fbee885057 100644
--- a/tests/ui/const-generics/transmute-fail.stderr
+++ b/tests/ui/const-generics/transmute-fail.stderr
@@ -5,119 +5,132 @@ LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
    |                                          ^^^^^^^^^^^^^ expected `usize`, found `bool`
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:7:5
+  --> $DIR/transmute-fail.rs:7:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
-   = note: source type: `[[u32; H+1]; W]` (size can vary because of [u32; H+1])
-   = note: target type: `[[u32; W+1]; H]` (size can vary because of [u32; W+1])
+   = note: source type: `[[u32; H + 1]; W]` (size can vary because of [u32; H + 1])
+   = note: target type: `[[u32; W + 1]; H]` (size can vary because of [u32; W + 1])
 
 error: the constant `W` is not of type `usize`
-  --> $DIR/transmute-fail.rs:15:5
+  --> $DIR/transmute-fail.rs:17:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^ expected `usize`, found `bool`
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:22:5
+  --> $DIR/transmute-fail.rs:24:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
    = note: target type: `[u32; W * H * H]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:29:5
+  --> $DIR/transmute-fail.rs:31:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         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]; 8888888]` (values of the type `[[u32; 9999999]; 777777777]` are too big for the current architecture)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:36:5
+  --> $DIR/transmute-fail.rs:38:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
    = note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:49:5
+  --> $DIR/transmute-fail.rs:49:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[u32; H]; W]` (size can vary because of [u32; H])
    = note: target type: `[u32; W * H]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:56:5
+  --> $DIR/transmute-fail.rs:56:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
-   = note: source type: `[u32; H*W]` (this type does not have a fixed size)
+   = note: source type: `[u32; H * W]` (this type does not have a fixed size)
    = note: target type: `[[u32; W]; H]` (size can vary because of [u32; W])
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:65:5
+  --> $DIR/transmute-fail.rs:65:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[[u32; D]; H]; W]` (size can vary because of [u32; D])
    = note: target type: `[u32; D * W * H]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:74:5
+  --> $DIR/transmute-fail.rs:74:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[[u32; D]; H]; W]` (size can vary because of [u32; D])
    = note: target type: `[[u32; D * W]; H]` (size can vary because of [u32; D * W])
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:81:5
+  --> $DIR/transmute-fail.rs:81:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[u16; L]` (this type does not have a fixed size)
    = note: target type: `[u8; L * 2]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:88:5
+  --> $DIR/transmute-fail.rs:88:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[u8; L * 2]` (this type does not have a fixed size)
    = note: target type: `[u16; L]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:95:5
+  --> $DIR/transmute-fail.rs:95:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[u8; L]` (this type does not have a fixed size)
    = note: target type: `[[u8; 1]; L]` (this type does not have a fixed size)
 
 error[E0512]: cannot transmute between types of different sizes, or dependently-sized types
-  --> $DIR/transmute-fail.rs:104:5
+  --> $DIR/transmute-fail.rs:104:9
    |
-LL |     std::mem::transmute(v)
-   |     ^^^^^^^^^^^^^^^^^^^
+LL |         std::mem::transmute(v)
+   |         ^^^^^^^^^^^^^^^^^^^
    |
    = note: source type: `[[u32; 2 * H]; W + W]` (size can vary because of [u32; 2 * H])
    = note: target type: `[[u32; W + W]; 2 * H]` (size can vary because of [u32; W + W])
 
-error: aborting due to 14 previous errors
+error[E0308]: mismatched types
+  --> $DIR/transmute-fail.rs:12:53
+   |
+LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
+   |                                                     ^ expected `usize`, found `bool`
+
+error[E0308]: mismatched types
+  --> $DIR/transmute-fail.rs:12:67
+   |
+LL | fn bar<const W: bool, const H: usize>(v: [[u32; H]; W]) -> [[u32; W]; H] {
+   |                                                                   ^ expected `usize`, found `bool`
+
+error: aborting due to 16 previous errors
 
-For more information about this error, try `rustc --explain E0512`.
+Some errors have detailed explanations: E0308, E0512.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/type_mismatch.rs b/tests/ui/const-generics/type_mismatch.rs
index 8187c785cd1c7..9c7217cd83eee 100644
--- a/tests/ui/const-generics/type_mismatch.rs
+++ b/tests/ui/const-generics/type_mismatch.rs
@@ -1,10 +1,12 @@
 fn foo<const N: usize>() -> [u8; N] {
     bar::<N>()
     //~^ ERROR the constant `N` is not of type `u8`
+    //~| ERROR: mismatched types
 }
 
 fn bar<const N: u8>() -> [u8; N] {}
 //~^ ERROR the constant `N` is not of type `usize`
+//~| ERROR: mismatched types
 //~| ERROR mismatched types
 
 fn main() {}
diff --git a/tests/ui/const-generics/type_mismatch.stderr b/tests/ui/const-generics/type_mismatch.stderr
index d1bb5c1242f02..77e9f5e2b445e 100644
--- a/tests/ui/const-generics/type_mismatch.stderr
+++ b/tests/ui/const-generics/type_mismatch.stderr
@@ -1,5 +1,5 @@
 error: the constant `N` is not of type `usize`
-  --> $DIR/type_mismatch.rs:6:26
+  --> $DIR/type_mismatch.rs:7:26
    |
 LL | fn bar<const N: u8>() -> [u8; N] {}
    |                          ^^^^^^^ expected `usize`, found `u8`
@@ -11,19 +11,31 @@ LL |     bar::<N>()
    |           ^ expected `u8`, found `usize`
    |
 note: required by a const generic parameter in `bar`
-  --> $DIR/type_mismatch.rs:6:8
+  --> $DIR/type_mismatch.rs:7:8
    |
 LL | fn bar<const N: u8>() -> [u8; N] {}
    |        ^^^^^^^^^^^ required by this const generic parameter in `bar`
 
 error[E0308]: mismatched types
-  --> $DIR/type_mismatch.rs:6:26
+  --> $DIR/type_mismatch.rs:7:26
    |
 LL | fn bar<const N: u8>() -> [u8; N] {}
    |    ---                   ^^^^^^^ expected `[u8; N]`, found `()`
    |    |
    |    implicitly returns `()` as its body has no tail or `return` expression
 
-error: aborting due to 3 previous errors
+error[E0308]: mismatched types
+  --> $DIR/type_mismatch.rs:2:11
+   |
+LL |     bar::<N>()
+   |           ^ expected `u8`, found `usize`
+
+error[E0308]: mismatched types
+  --> $DIR/type_mismatch.rs:7:31
+   |
+LL | fn bar<const N: u8>() -> [u8; N] {}
+   |                               ^ expected `usize`, found `u8`
+
+error: aborting due to 5 previous errors
 
 For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/consts/issue-36163.stderr b/tests/ui/consts/issue-36163.stderr
index 52d3e003f0ac9..8a7a0981f4154 100644
--- a/tests/ui/consts/issue-36163.stderr
+++ b/tests/ui/consts/issue-36163.stderr
@@ -1,10 +1,10 @@
-error[E0391]: cycle detected when simplifying constant for the type system `Foo::{constant#0}`
+error[E0391]: cycle detected when simplifying constant for the type system `Foo::B::{constant#0}`
   --> $DIR/issue-36163.rs:4:9
    |
 LL |     B = A,
    |         ^
    |
-note: ...which requires const-evaluating + checking `Foo::{constant#0}`...
+note: ...which requires const-evaluating + checking `Foo::B::{constant#0}`...
   --> $DIR/issue-36163.rs:4:9
    |
 LL |     B = A,
@@ -19,7 +19,7 @@ note: ...which requires const-evaluating + checking `A`...
    |
 LL | const A: isize = Foo::B as isize;
    |                  ^^^^^^^^^^^^^^^
-   = note: ...which again requires simplifying constant for the type system `Foo::{constant#0}`, completing the cycle
+   = note: ...which again requires simplifying constant for the type system `Foo::B::{constant#0}`, completing the cycle
 note: cycle used when checking that `Foo` is well-formed
   --> $DIR/issue-36163.rs:3:1
    |
diff --git a/tests/ui/feature-gates/feature-gate-const-arg-path.rs b/tests/ui/feature-gates/feature-gate-const-arg-path.rs
new file mode 100644
index 0000000000000..0938c5733a297
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-const-arg-path.rs
@@ -0,0 +1,5 @@
+//@ check-pass
+
+// this doesn't really have any user facing impact....
+
+fn main() {}
diff --git a/tests/ui/lifetimes/issue-95023.rs b/tests/ui/lifetimes/issue-95023.rs
index bcacd01474fbb..8461d92fc33e4 100644
--- a/tests/ui/lifetimes/issue-95023.rs
+++ b/tests/ui/lifetimes/issue-95023.rs
@@ -2,12 +2,13 @@ struct ErrorKind;
 struct Error(ErrorKind);
 impl Fn(&isize) for Error {
     //~^ ERROR manual implementations of `Fn` are experimental [E0183]
-    //~^^ ERROR associated item constraints are not allowed here [E0229]
+    //~| ERROR associated item constraints are not allowed here [E0229]
     //~| ERROR not all trait items implemented
     //~| ERROR expected a `FnMut(&isize)` closure, found `Error`
     fn foo<const N: usize>(&self) -> Self::B<{ N }>;
     //~^ ERROR associated function in `impl` without body
-    //~^^ ERROR method `foo` is not a member of trait `Fn` [E0407]
-    //~^^^ ERROR associated type `B` not found for `Self` [E0220]
+    //~| ERROR method `foo` is not a member of trait `Fn` [E0407]
+    //~| ERROR associated type `B` not found for `Self` [E0220]
+    //~| ERROR: associated type `B` not found for `Self`
 }
 fn main() {}
diff --git a/tests/ui/lifetimes/issue-95023.stderr b/tests/ui/lifetimes/issue-95023.stderr
index cbc0eeebee113..310dee5140603 100644
--- a/tests/ui/lifetimes/issue-95023.stderr
+++ b/tests/ui/lifetimes/issue-95023.stderr
@@ -56,7 +56,15 @@ error[E0220]: associated type `B` not found for `Self`
 LL |     fn foo<const N: usize>(&self) -> Self::B<{ N }>;
    |                                            ^ help: `Self` has the following associated type: `Output`
 
-error: aborting due to 7 previous errors
+error[E0220]: associated type `B` not found for `Self`
+  --> $DIR/issue-95023.rs:8:44
+   |
+LL |     fn foo<const N: usize>(&self) -> Self::B<{ N }>;
+   |                                            ^ help: `Self` has the following associated type: `Output`
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 8 previous errors
 
 Some errors have detailed explanations: E0046, E0183, E0220, E0229, E0277, E0407.
 For more information about an error, try `rustc --explain E0046`.
diff --git a/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.rs b/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.rs
index fb962ad24bf93..858fba2132aae 100644
--- a/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.rs
+++ b/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.rs
@@ -14,5 +14,6 @@ struct Wrapper<const C: <i32 as Trait>::Type> {}
 
 impl<const C: usize> Wrapper<C> {}
 //~^ ERROR the constant `C` is not of type `<i32 as Trait>::Type`
+//~| ERROR: mismatched types
 
 fn main() {}
diff --git a/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.stderr b/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.stderr
index 7094ee8c67ca0..71d4277275fee 100644
--- a/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.stderr
+++ b/tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.stderr
@@ -20,5 +20,17 @@ note: required by a const generic parameter in `Wrapper`
 LL | struct Wrapper<const C: <i32 as Trait>::Type> {}
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Wrapper`
 
-error: aborting due to 2 previous errors
+error[E0308]: mismatched types
+  --> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:15:30
+   |
+LL | impl<const C: usize> Wrapper<C> {}
+   |                              ^ expected associated type, found `usize`
+   |
+   = note: expected associated type `<i32 as Trait>::Type`
+                         found type `usize`
+   = help: consider constraining the associated type `<i32 as Trait>::Type` to `usize`
+   = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
+
+error: aborting due to 3 previous errors
 
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.rs b/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.rs
index a0ee771441772..f89a463bc5805 100644
--- a/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.rs
+++ b/tests/ui/specialization/min_specialization/bad-const-wf-doesnt-specialize.rs
@@ -6,6 +6,7 @@
 struct S<const L: usize>;
 
 impl<const N: i32> Copy for S<N> {}
+//~^ ERROR: mismatched types
 impl<const M: usize> Copy for S<M> {}
 //~^ ERROR: conflicting implementations of trait `Copy` for type `S<_>`
 
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 2953bc95917c9..1dac58e1f694e 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
@@ -1,11 +1,19 @@
 error[E0119]: conflicting implementations of trait `Copy` for type `S<_>`
-  --> $DIR/bad-const-wf-doesnt-specialize.rs:9:1
+  --> $DIR/bad-const-wf-doesnt-specialize.rs:10:1
    |
 LL | impl<const N: i32> Copy for S<N> {}
    | -------------------------------- first implementation here
+LL |
 LL | impl<const M: usize> Copy for S<M> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `S<_>`
 
-error: aborting due to 1 previous error
+error[E0308]: mismatched types
+  --> $DIR/bad-const-wf-doesnt-specialize.rs:8:31
+   |
+LL | impl<const N: i32> Copy for S<N> {}
+   |                               ^ expected `usize`, found `i32`
+
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0119`.
+Some errors have detailed explanations: E0119, E0308.
+For more information about an error, try `rustc --explain E0119`.
diff --git a/tests/ui/transmutability/issue-101739-1.rs b/tests/ui/transmutability/issue-101739-1.rs
index 20bd7917e5322..81a9038fdb536 100644
--- a/tests/ui/transmutability/issue-101739-1.rs
+++ b/tests/ui/transmutability/issue-101739-1.rs
@@ -6,7 +6,8 @@ mod assert {
     pub fn is_transmutable<Src, const ASSUME_ALIGNMENT: bool>()
     where
         Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>, //~ ERROR cannot find type `Dst` in this scope
-        //~^ the constant `ASSUME_ALIGNMENT` is not of type `Assume`
+                                                           //~| the constant `ASSUME_ALIGNMENT` is not of type `Assume`
+                                                           //~| ERROR: mismatched types
     {
     }
 }
diff --git a/tests/ui/transmutability/issue-101739-1.stderr b/tests/ui/transmutability/issue-101739-1.stderr
index ba18a980f4d0a..6f79bf7b42468 100644
--- a/tests/ui/transmutability/issue-101739-1.stderr
+++ b/tests/ui/transmutability/issue-101739-1.stderr
@@ -13,6 +13,13 @@ LL |         Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
 note: required by a const generic parameter in `BikeshedIntrinsicFrom`
   --> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
 
-error: aborting due to 2 previous errors
+error[E0308]: mismatched types
+  --> $DIR/issue-101739-1.rs:8:41
+   |
+LL |         Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
+   |                                         ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
+
+error: aborting due to 3 previous errors
 
-For more information about this error, try `rustc --explain E0412`.
+Some errors have detailed explanations: E0308, E0412.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/transmutability/issue-101739-2.rs b/tests/ui/transmutability/issue-101739-2.rs
index 8b36bf3dcb195..6dfde06d6b3c6 100644
--- a/tests/ui/transmutability/issue-101739-2.rs
+++ b/tests/ui/transmutability/issue-101739-2.rs
@@ -14,19 +14,23 @@ mod assert {
         const ASSUME_VISIBILITY: bool,
     >()
     where
-        Dst: BikeshedIntrinsicFrom< //~ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied
-            Src,
-            ASSUME_ALIGNMENT,
-            ASSUME_LIFETIMES,
-            ASSUME_VALIDITY,
-            ASSUME_VISIBILITY,
-        >,
-    {}
+        Dst: BikeshedIntrinsicFrom<
+                //~^ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied
+                Src,
+                ASSUME_ALIGNMENT, //~ ERROR: mismatched types
+                ASSUME_LIFETIMES,
+                ASSUME_VALIDITY,
+                ASSUME_VISIBILITY,
+            >,
+    {
+    }
 }
 
 fn via_const() {
-    #[repr(C)] struct Src;
-    #[repr(C)] struct Dst;
+    #[repr(C)]
+    struct Src;
+    #[repr(C)]
+    struct Dst;
 
     const FALSE: bool = false;
 
diff --git a/tests/ui/transmutability/issue-101739-2.stderr b/tests/ui/transmutability/issue-101739-2.stderr
index 6b0a36a414bfd..11e8fa1d8c5ae 100644
--- a/tests/ui/transmutability/issue-101739-2.stderr
+++ b/tests/ui/transmutability/issue-101739-2.stderr
@@ -3,14 +3,21 @@ error[E0107]: trait takes at most 2 generic arguments but 5 generic arguments we
    |
 LL |           Dst: BikeshedIntrinsicFrom<
    |                ^^^^^^^^^^^^^^^^^^^^^ expected at most 2 generic arguments
-LL |               Src,
-LL |               ASSUME_ALIGNMENT,
-   |  _____________________________-
-LL | |             ASSUME_LIFETIMES,
-LL | |             ASSUME_VALIDITY,
-LL | |             ASSUME_VISIBILITY,
-   | |_____________________________- help: remove the unnecessary generic arguments
+...
+LL |                   ASSUME_ALIGNMENT,
+   |  _________________________________-
+LL | |                 ASSUME_LIFETIMES,
+LL | |                 ASSUME_VALIDITY,
+LL | |                 ASSUME_VISIBILITY,
+   | |_________________________________- help: remove the unnecessary generic arguments
 
-error: aborting due to 1 previous error
+error[E0308]: mismatched types
+  --> $DIR/issue-101739-2.rs:20:17
+   |
+LL |                 ASSUME_ALIGNMENT,
+   |                 ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
+
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0107`.
+Some errors have detailed explanations: E0107, E0308.
+For more information about an error, try `rustc --explain E0107`.
diff --git a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs
index 9fc249198d03d..92c1999e1544b 100644
--- a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs
+++ b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.rs
@@ -3,16 +3,18 @@
 // of an impl fn produces a type mismatch error instead of triggering
 // a const eval cycle
 
-
 trait Trait {
-    fn func<const N: u32>() -> [ (); N ]; //~ ERROR the constant `N` is not of type `usize`
+    fn func<const N: u32>() -> [(); N];
+    //~^ ERROR: the constant `N` is not of type `usize`
+    //~| ERROR: mismatched types
 }
 
 struct S {}
 
 #[allow(unused_braces)]
 impl Trait for S {
-    fn func<const N: u32>() -> [ (); { () }] { //~ ERROR mismatched types
+    fn func<const N: u32>() -> [(); { () }] {
+        //~^ ERROR mismatched types
         N
     }
 }
diff --git a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr
index bff926a2081ab..bb8025d47a18f 100644
--- a/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr
+++ b/tests/ui/typeck/issue-114918/const-in-impl-fn-return-type.stderr
@@ -1,15 +1,21 @@
 error[E0308]: mismatched types
-  --> $DIR/const-in-impl-fn-return-type.rs:15:40
+  --> $DIR/const-in-impl-fn-return-type.rs:16:39
    |
-LL |     fn func<const N: u32>() -> [ (); { () }] {
-   |                                        ^^ expected `usize`, found `()`
+LL |     fn func<const N: u32>() -> [(); { () }] {
+   |                                       ^^ expected `usize`, found `()`
 
 error: the constant `N` is not of type `usize`
-  --> $DIR/const-in-impl-fn-return-type.rs:8:32
+  --> $DIR/const-in-impl-fn-return-type.rs:7:32
    |
-LL |     fn func<const N: u32>() -> [ (); N ];
-   |                                ^^^^^^^^^ expected `usize`, found `u32`
+LL |     fn func<const N: u32>() -> [(); N];
+   |                                ^^^^^^^ expected `usize`, found `u32`
 
-error: aborting due to 2 previous errors
+error[E0308]: mismatched types
+  --> $DIR/const-in-impl-fn-return-type.rs:7:37
+   |
+LL |     fn func<const N: u32>() -> [(); N];
+   |                                     ^ expected `usize`, found `u32`
+
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0308`.

From da7dd434c8086378a44ed2c379050dbe5c01a5d7 Mon Sep 17 00:00:00 2001
From: Wafarm <qinyy07@gmail.com>
Date: Sun, 18 Aug 2024 10:44:17 +0800
Subject: [PATCH 430/685] Fix wrong argument for `get_fn_decl`

---
 compiler/rustc_hir_typeck/src/coercion.rs     |  2 +-
 .../async-fn/recurse-ice-129215.rs            |  9 +++++
 .../async-fn/recurse-ice-129215.stderr        | 34 +++++++++++++++++++
 .../add_semicolon_non_block_closure.rs        |  1 +
 .../add_semicolon_non_block_closure.stderr    |  6 ++--
 5 files changed, 49 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/async-await/async-fn/recurse-ice-129215.rs
 create mode 100644 tests/ui/async-await/async-fn/recurse-ice-129215.stderr

diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index d53df251a153d..9b34c59f1f1b7 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -1859,7 +1859,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
         };
 
         // If this is due to an explicit `return`, suggest adding a return type.
-        if let Some((fn_id, fn_decl, can_suggest)) = fcx.get_fn_decl(parent_id)
+        if let Some((fn_id, fn_decl, can_suggest)) = fcx.get_fn_decl(block_or_return_id)
             && !due_to_block
         {
             fcx.suggest_missing_return_type(&mut err, fn_decl, expected, found, can_suggest, fn_id);
diff --git a/tests/ui/async-await/async-fn/recurse-ice-129215.rs b/tests/ui/async-await/async-fn/recurse-ice-129215.rs
new file mode 100644
index 0000000000000..06a2d7be9efb5
--- /dev/null
+++ b/tests/ui/async-await/async-fn/recurse-ice-129215.rs
@@ -0,0 +1,9 @@
+//@ edition: 2021
+
+async fn a() {
+    //~^ ERROR `()` is not a future
+    //~| ERROR mismatched types
+    a() //~ ERROR `()` is not a future
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/async-fn/recurse-ice-129215.stderr b/tests/ui/async-await/async-fn/recurse-ice-129215.stderr
new file mode 100644
index 0000000000000..98c7be2a5a3f2
--- /dev/null
+++ b/tests/ui/async-await/async-fn/recurse-ice-129215.stderr
@@ -0,0 +1,34 @@
+error[E0277]: `()` is not a future
+  --> $DIR/recurse-ice-129215.rs:6:5
+   |
+LL |     a()
+   |     ^^^ `()` is not a future
+   |
+   = help: the trait `Future` is not implemented for `()`
+
+error[E0277]: `()` is not a future
+  --> $DIR/recurse-ice-129215.rs:3:1
+   |
+LL | async fn a() {
+   | ^^^^^^^^^^^^ `()` is not a future
+   |
+   = help: the trait `Future` is not implemented for `()`
+
+error[E0308]: mismatched types
+  --> $DIR/recurse-ice-129215.rs:3:14
+   |
+LL |   async fn a() {
+   |  ______________^
+LL | |
+LL | |
+LL | |     a()
+LL | | }
+   | |_^ expected `()`, found `async` fn body
+   |
+   = note:    expected unit type `()`
+           found `async` fn body `{async fn body of a()}`
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0277, E0308.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/closures/add_semicolon_non_block_closure.rs b/tests/ui/closures/add_semicolon_non_block_closure.rs
index 3ae91be60c5a0..62c5e343cd345 100644
--- a/tests/ui/closures/add_semicolon_non_block_closure.rs
+++ b/tests/ui/closures/add_semicolon_non_block_closure.rs
@@ -8,4 +8,5 @@ fn main() {
     foo(|| bar())
     //~^ ERROR mismatched types [E0308]
     //~| HELP consider using a semicolon here
+    //~| HELP try adding a return type
 }
diff --git a/tests/ui/closures/add_semicolon_non_block_closure.stderr b/tests/ui/closures/add_semicolon_non_block_closure.stderr
index d095e59c7ebb0..7883db8f98ec5 100644
--- a/tests/ui/closures/add_semicolon_non_block_closure.stderr
+++ b/tests/ui/closures/add_semicolon_non_block_closure.stderr
@@ -1,8 +1,6 @@
 error[E0308]: mismatched types
   --> $DIR/add_semicolon_non_block_closure.rs:8:12
    |
-LL | fn main() {
-   |          - expected `()` because of default return type
 LL |     foo(|| bar())
    |            ^^^^^ expected `()`, found `i32`
    |
@@ -10,6 +8,10 @@ help: consider using a semicolon here
    |
 LL |     foo(|| { bar(); })
    |            +      +++
+help: try adding a return type
+   |
+LL |     foo(|| -> i32 bar())
+   |            ++++++
 
 error: aborting due to 1 previous error
 

From 1eb1e1816d3e42f3f31be75aae3c147302ae02a6 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Sun, 18 Aug 2024 22:51:04 -0500
Subject: [PATCH 431/685] Adjust expected errors for a `rustdoc` test

`pulldown-cmark` has slightly different behavior between 0.11.0 and
0.11.2, causing one of the `unportable-markdown` tests to no longer emit
an error. Per [1], remove the error annotation and bless the output.

[1]: https://github.com/rust-lang/rust/pull/128722#issuecomment-2295522292
---
 tests/rustdoc-ui/unportable-markdown.rs     |  1 -
 tests/rustdoc-ui/unportable-markdown.stderr | 26 ++++-----------------
 2 files changed, 5 insertions(+), 22 deletions(-)

diff --git a/tests/rustdoc-ui/unportable-markdown.rs b/tests/rustdoc-ui/unportable-markdown.rs
index 8035e680f3cf4..105fc1e59d53a 100644
--- a/tests/rustdoc-ui/unportable-markdown.rs
+++ b/tests/rustdoc-ui/unportable-markdown.rs
@@ -19,7 +19,6 @@ pub struct GfmFootnotes;
 /// <https://github.com/pulldown-cmark/pulldown-cmark/pull/773>
 ///
 /// test [^foo][^bar]
-//~^ ERROR unportable markdown
 ///
 /// [^foo]: test
 /// [^bar]: test2
diff --git a/tests/rustdoc-ui/unportable-markdown.stderr b/tests/rustdoc-ui/unportable-markdown.stderr
index b524aca25aef9..952ae4bb6eec6 100644
--- a/tests/rustdoc-ui/unportable-markdown.stderr
+++ b/tests/rustdoc-ui/unportable-markdown.stderr
@@ -1,31 +1,15 @@
 error: unportable markdown
-  --> $DIR/unportable-markdown.rs:21:10
+  --> $DIR/unportable-markdown.rs:48:5
    |
-LL | /// test [^foo][^bar]
-   |          ^^^^^^
+LL | /// >bar
+   |     ^
    |
-   = help: confusing footnote reference and link
+   = help: confusing block quote with no space after the `>` marker
 note: the lint level is defined here
   --> $DIR/unportable-markdown.rs:8:9
    |
 LL | #![deny(rustdoc::unportable_markdown)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-help: if it should not be a footnote, escape it
-   |
-LL | /// test \[^foo][^bar]
-   |          +
-help: if the footnote is intended, add a space
-   |
-LL | /// test [^foo] [^bar]
-   |                +
-
-error: unportable markdown
-  --> $DIR/unportable-markdown.rs:49:5
-   |
-LL | /// >bar
-   |     ^
-   |
-   = help: confusing block quote with no space after the `>` marker
 help: if the quote is intended, add a space
    |
 LL | /// > bar
@@ -35,5 +19,5 @@ help: if it should not be a quote, escape it
 LL | /// \>bar
    |     +
 
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 

From 370168787bd6f2ed26788a51af97166d868e0609 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Wed, 7 Aug 2024 02:11:05 -0500
Subject: [PATCH 432/685] Generate completions after version updates

Running `cargo update` changed completion output. Regenerate them here.
---
 src/etc/completions/x.py.fish | 1354 +++++++++++++--------------
 src/etc/completions/x.py.ps1  | 1438 ++++++++++++++---------------
 src/etc/completions/x.py.sh   | 1631 +++++++++++++++++++++++++++++++--
 src/etc/completions/x.py.zsh  |   36 +-
 4 files changed, 2988 insertions(+), 1471 deletions(-)

diff --git a/src/etc/completions/x.py.fish b/src/etc/completions/x.py.fish
index 297dc11cd6145..3a83c89280f90 100644
--- a/src/etc/completions/x.py.fish
+++ b/src/etc/completions/x.py.fish
@@ -1,664 +1,690 @@
-complete -c x.py -n "__fish_use_subcommand" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_use_subcommand" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_use_subcommand" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_use_subcommand" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_use_subcommand" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_use_subcommand" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_use_subcommand" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_use_subcommand" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_use_subcommand" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_use_subcommand" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_use_subcommand" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_use_subcommand" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_use_subcommand" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_use_subcommand" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_use_subcommand" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_use_subcommand" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_use_subcommand" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_use_subcommand" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_use_subcommand" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_use_subcommand" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_use_subcommand" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_use_subcommand" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_use_subcommand" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_use_subcommand" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_use_subcommand" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_use_subcommand" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_use_subcommand" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_use_subcommand" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_use_subcommand" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_use_subcommand" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_use_subcommand" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_use_subcommand" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_use_subcommand" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_use_subcommand" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_use_subcommand" -f -a "build" -d 'Compile either the compiler or libraries'
-complete -c x.py -n "__fish_use_subcommand" -f -a "check" -d 'Compile either the compiler or libraries, using cargo check'
-complete -c x.py -n "__fish_use_subcommand" -f -a "clippy" -d 'Run Clippy (uses rustup/cargo-installed clippy binary)'
-complete -c x.py -n "__fish_use_subcommand" -f -a "fix" -d 'Run cargo fix'
-complete -c x.py -n "__fish_use_subcommand" -f -a "fmt" -d 'Run rustfmt'
-complete -c x.py -n "__fish_use_subcommand" -f -a "doc" -d 'Build documentation'
-complete -c x.py -n "__fish_use_subcommand" -f -a "test" -d 'Build and run some test suites'
-complete -c x.py -n "__fish_use_subcommand" -f -a "miri" -d 'Build and run some test suites *in Miri*'
-complete -c x.py -n "__fish_use_subcommand" -f -a "bench" -d 'Build and run some benchmarks'
-complete -c x.py -n "__fish_use_subcommand" -f -a "clean" -d 'Clean out build directories'
-complete -c x.py -n "__fish_use_subcommand" -f -a "dist" -d 'Build distribution artifacts'
-complete -c x.py -n "__fish_use_subcommand" -f -a "install" -d 'Install distribution artifacts'
-complete -c x.py -n "__fish_use_subcommand" -f -a "run" -d 'Run tools contained in this repository'
-complete -c x.py -n "__fish_use_subcommand" -f -a "setup" -d 'Set up the environment for development'
-complete -c x.py -n "__fish_use_subcommand" -f -a "suggest" -d 'Suggest a subset of tests to run, based on modified files'
-complete -c x.py -n "__fish_use_subcommand" -f -a "vendor" -d 'Vendor dependencies'
-complete -c x.py -n "__fish_use_subcommand" -f -a "perf" -d 'Perform profiling and benchmarking of the compiler using the `rustc-perf-wrapper` tool'
-complete -c x.py -n "__fish_seen_subcommand_from build" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from build" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from build" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from build" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from build" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from build" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from build" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from build" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from build" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from build" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from build" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from build" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from build" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from build" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from build" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from build" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from build" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from build" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from build" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from build" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from build" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from build" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from build" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from build" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from build" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from build" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from build" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from build" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from build" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from build" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from build" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from build" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from build" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from build" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from check" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from check" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from check" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from check" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from check" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from check" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from check" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from check" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from check" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from check" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from check" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from check" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from check" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from check" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from check" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from check" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from check" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from check" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from check" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from check" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from check" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from check" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from check" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from check" -l all-targets -d 'Check all targets'
-complete -c x.py -n "__fish_seen_subcommand_from check" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from check" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from check" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from check" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from check" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from check" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from check" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from check" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from check" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from check" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from check" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -s A -d 'clippy lints to allow' -r
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -s D -d 'clippy lints to deny' -r
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -s W -d 'clippy lints to warn on' -r
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -s F -d 'clippy lints to forbid' -r
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l fix
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l allow-dirty
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l allow-staged
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from clippy" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from fix" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fix" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from fix" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l check -d 'check formatting instead of applying'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l all -d 'apply to all appropriate files, not just those that have been modified'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from fmt" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from doc" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l open -d 'open the docs in a browser'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l json -d 'render the documentation in JSON format in addition to the usual HTML format'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from doc" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r
-complete -c x.py -n "__fish_seen_subcommand_from test" -l compiletest-rustc-args -d 'extra options to pass the compiler when running compiletest tests' -r
-complete -c x.py -n "__fish_seen_subcommand_from test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell)' -r
-complete -c x.py -n "__fish_seen_subcommand_from test" -l compare-mode -d 'mode describing what file the actual ui output will be compared to' -r
-complete -c x.py -n "__fish_seen_subcommand_from test" -l pass -d 'force {check,build,run}-pass tests to this mode' -r
-complete -c x.py -n "__fish_seen_subcommand_from test" -l run -d 'whether to execute run-* tests' -r
-complete -c x.py -n "__fish_seen_subcommand_from test" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from test" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from test" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from test" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from test" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from test" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from test" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from test" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from test" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from test" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from test" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from test" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from test" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from test" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from test" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from test" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from test" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from test" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from test" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from test" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from test" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from test" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from test" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from test" -l no-fail-fast -d 'run all tests regardless of failure'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l no-doc -d 'do not run doc tests'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l doc -d 'only run doc tests'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l bless -d 'whether to automatically update stderr/stdout files'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l force-rerun -d 'rerun tests even if the inputs are unchanged'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l only-modified -d 'only run tests that result has been changed'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l rustfix-coverage -d 'enable this to generate a Rustfix coverage file, which is saved in `/<build_base>/rustfix_missing_coverage.txt`'
-complete -c x.py -n "__fish_seen_subcommand_from test" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from test" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from test" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from test" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from miri" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l no-fail-fast -d 'run all tests regardless of failure'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l no-doc -d 'do not run doc tests'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l doc -d 'only run doc tests'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from miri" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l test-args -r
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from bench" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from bench" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from bench" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l stage -d 'Clean a specific stage without touching other artifacts. By default, every stage is cleaned if this option is not used' -r
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from clean" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l all -d 'Clean the entire build directory (not used by default)'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from clean" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from dist" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from dist" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from dist" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from install" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from install" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from install" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from install" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from install" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from install" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from install" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from install" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from install" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from install" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from install" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from install" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from install" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from install" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from install" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from install" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from install" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from install" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from install" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from install" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from install" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from install" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from install" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from install" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from install" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from install" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from install" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from install" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from install" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from install" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from install" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from install" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from install" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from install" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from run" -l args -d 'arguments for the tool' -r
-complete -c x.py -n "__fish_seen_subcommand_from run" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from run" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from run" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from run" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from run" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from run" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from run" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from run" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from run" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from run" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from run" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from run" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from run" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from run" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from run" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from run" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from run" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from run" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from run" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from run" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from run" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from run" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from run" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from run" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from run" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from run" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from run" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from run" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from run" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from run" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from run" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from run" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from run" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from run" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from setup" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from setup" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from setup" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l run -d 'run suggested tests'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from suggest" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l sync -d 'Additional `Cargo.toml` to sync and vendor' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l versioned-dirs -d 'Always include version in subdir name'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from vendor" -s h -l help -d 'Print help (see more with \'--help\')'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l config -d 'TOML configuration file for build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l build -d 'build target of the stage0 compiler' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l host -d 'host targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l target -d 'target targets to build' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l exclude -d 'build paths to exclude' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l skip -d 'build paths to skip' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l rustc-error-format -r -f
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
-complete -c x.py -n "__fish_seen_subcommand_from perf" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny	'',warn	'',default	''}"
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l error-format -d 'rustc error format' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always	'',never	'',auto	''}"
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true	'',false	''}"
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l set -d 'override options in config.toml' -r -f
-complete -c x.py -n "__fish_seen_subcommand_from perf" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -s i -l incremental -d 'use incremental compilation'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l include-default-paths -d 'include default paths in addition to the provided ones'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l dry-run -d 'dry run; don\'t build anything'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l json-output -d 'use message-format=json'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l enable-bolt-settings -d 'Enable BOLT link flags'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
-complete -c x.py -n "__fish_seen_subcommand_from perf" -s h -l help -d 'Print help (see more with \'--help\')'
+# Print an optspec for argparse to handle cmd's options that are independent of any subcommand.
+function __fish_x.py_global_optspecs
+	string join \n v/verbose i/incremental config= build-dir= build= host= target= exclude= skip= include-default-paths rustc-error-format= on-fail= dry-run dump-bootstrap-shims stage= keep-stage= keep-stage-std= src= j/jobs= warnings= error-format= json-output color= bypass-bootstrap-lock llvm-skip-rebuild= rust-profile-generate= rust-profile-use= llvm-profile-use= llvm-profile-generate enable-bolt-settings skip-stage0-validation reproducible-artifact= set= h/help
+end
+
+function __fish_x.py_needs_command
+	# Figure out if the current invocation already has a command.
+	set -l cmd (commandline -opc)
+	set -e cmd[1]
+	argparse -s (__fish_x.py_global_optspecs) -- $cmd 2>/dev/null
+	or return
+	if set -q argv[1]
+		# Also print the command, so this can be used to figure out what it is.
+		echo $argv[1]
+		return 1
+	end
+	return 0
+end
+
+function __fish_x.py_using_subcommand
+	set -l cmd (__fish_x.py_needs_command)
+	test -z "$cmd"
+	and return 1
+	contains -- $cmd[1] $argv
+end
+
+complete -c x.py -n "__fish_x.py_needs_command" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_needs_command" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_needs_command" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_needs_command" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_needs_command" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_needs_command" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_needs_command" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_needs_command" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_needs_command" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_needs_command" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_needs_command" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_needs_command" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_needs_command" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_needs_command" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_needs_command" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_needs_command" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_needs_command" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_needs_command" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_needs_command" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_needs_command" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_needs_command" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_needs_command" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_needs_command" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_needs_command" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_needs_command" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_needs_command" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_needs_command" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_needs_command" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_needs_command" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_needs_command" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_needs_command" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_needs_command" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_needs_command" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_needs_command" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_needs_command" -a "build" -d 'Compile either the compiler or libraries'
+complete -c x.py -n "__fish_x.py_needs_command" -a "check" -d 'Compile either the compiler or libraries, using cargo check'
+complete -c x.py -n "__fish_x.py_needs_command" -a "clippy" -d 'Run Clippy (uses rustup/cargo-installed clippy binary)'
+complete -c x.py -n "__fish_x.py_needs_command" -a "fix" -d 'Run cargo fix'
+complete -c x.py -n "__fish_x.py_needs_command" -a "fmt" -d 'Run rustfmt'
+complete -c x.py -n "__fish_x.py_needs_command" -a "doc" -d 'Build documentation'
+complete -c x.py -n "__fish_x.py_needs_command" -a "test" -d 'Build and run some test suites'
+complete -c x.py -n "__fish_x.py_needs_command" -a "miri" -d 'Build and run some test suites *in Miri*'
+complete -c x.py -n "__fish_x.py_needs_command" -a "bench" -d 'Build and run some benchmarks'
+complete -c x.py -n "__fish_x.py_needs_command" -a "clean" -d 'Clean out build directories'
+complete -c x.py -n "__fish_x.py_needs_command" -a "dist" -d 'Build distribution artifacts'
+complete -c x.py -n "__fish_x.py_needs_command" -a "install" -d 'Install distribution artifacts'
+complete -c x.py -n "__fish_x.py_needs_command" -a "run" -d 'Run tools contained in this repository'
+complete -c x.py -n "__fish_x.py_needs_command" -a "setup" -d 'Set up the environment for development'
+complete -c x.py -n "__fish_x.py_needs_command" -a "suggest" -d 'Suggest a subset of tests to run, based on modified files'
+complete -c x.py -n "__fish_x.py_needs_command" -a "vendor" -d 'Vendor dependencies'
+complete -c x.py -n "__fish_x.py_needs_command" -a "perf" -d 'Perform profiling and benchmarking of the compiler using the `rustc-perf-wrapper` tool'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand build" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand build" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand build" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand check" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l all-targets -d 'Check all targets'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand check" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s A -d 'clippy lints to allow' -r
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s D -d 'clippy lints to deny' -r
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s W -d 'clippy lints to warn on' -r
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s F -d 'clippy lints to forbid' -r
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l fix
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l allow-dirty
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l allow-staged
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand clippy" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand fix" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l check -d 'check formatting instead of applying'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l all -d 'apply to all appropriate files, not just those that have been modified'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand fmt" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l open -d 'open the docs in a browser'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l json -d 'render the documentation in JSON format in addition to the usual HTML format'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand doc" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l compiletest-rustc-args -d 'extra options to pass the compiler when running compiletest tests' -r
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l extra-checks -d 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell)' -r
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l compare-mode -d 'mode describing what file the actual ui output will be compared to' -r
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l pass -d 'force {check,build,run}-pass tests to this mode' -r
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l run -d 'whether to execute run-* tests' -r
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand test" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l no-fail-fast -d 'run all tests regardless of failure'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l no-doc -d 'do not run doc tests'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l doc -d 'only run doc tests'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l bless -d 'whether to automatically update stderr/stdout files'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l force-rerun -d 'rerun tests even if the inputs are unchanged'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l only-modified -d 'only run tests that result has been changed'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l rustfix-coverage -d 'enable this to generate a Rustfix coverage file, which is saved in `/<build_base>/rustfix_missing_coverage.txt`'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand test" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l test-args -d 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)' -r
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l no-fail-fast -d 'run all tests regardless of failure'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l no-doc -d 'do not run doc tests'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l doc -d 'only run doc tests'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand miri" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l test-args -r
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand bench" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l stage -d 'Clean a specific stage without touching other artifacts. By default, every stage is cleaned if this option is not used' -r
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l all -d 'Clean the entire build directory (not used by default)'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand clean" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand dist" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand install" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand install" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand install" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l args -d 'arguments for the tool' -r
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand run" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand run" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand run" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand setup" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l run -d 'run suggested tests'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand suggest" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l sync -d 'Additional `Cargo.toml` to sync and vendor' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l versioned-dirs -d 'Always include version in subdir name'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand vendor" -s h -l help -d 'Print help (see more with \'--help\')'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l config -d 'TOML configuration file for build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l build-dir -d 'Build directory, overrides `build.build-dir` in `config.toml`' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l build -d 'build target of the stage0 compiler' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l host -d 'host targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l target -d 'target targets to build' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l exclude -d 'build paths to exclude' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l skip -d 'build paths to skip' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l rustc-error-format -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l on-fail -d 'command to run on failure' -r -f -a "(__fish_complete_command)"
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l stage -d 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l keep-stage -d 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l keep-stage-std -d 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l src -d 'path to the root of the rust checkout' -r -f -a "(__fish_complete_directories)"
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -s j -l jobs -d 'number of jobs to run in parallel' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l warnings -d 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour' -r -f -a "{deny\t'',warn\t'',default\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l error-format -d 'rustc error format' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l color -d 'whether to use color in cargo and rustc output' -r -f -a "{always\t'',never\t'',auto\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l llvm-skip-rebuild -d 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml' -r -f -a "{true\t'',false\t''}"
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l rust-profile-generate -d 'generate PGO profile with rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l rust-profile-use -d 'use PGO profile for rustc build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l llvm-profile-use -d 'use PGO profile for LLVM build' -r -F
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l reproducible-artifact -d 'Additional reproducible artifacts that should be added to the reproducible artifacts archive' -r
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l set -d 'override options in config.toml' -r -f
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -s v -l verbose -d 'use verbose output (-vv for very verbose)'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -s i -l incremental -d 'use incremental compilation'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l include-default-paths -d 'include default paths in addition to the provided ones'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l dry-run -d 'dry run; don\'t build anything'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l dump-bootstrap-shims -d 'Indicates whether to dump the work done from bootstrap shims'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l json-output -d 'use message-format=json'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l bypass-bootstrap-lock -d 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l llvm-profile-generate -d 'generate PGO profile with llvm built for rustc'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l enable-bolt-settings -d 'Enable BOLT link flags'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -l skip-stage0-validation -d 'Skip stage0 compiler validation'
+complete -c x.py -n "__fish_x.py_using_subcommand perf" -s h -l help -d 'Print help (see more with \'--help\')'
diff --git a/src/etc/completions/x.py.ps1 b/src/etc/completions/x.py.ps1
index 4b424471a2672..240de32451de1 100644
--- a/src/etc/completions/x.py.ps1
+++ b/src/etc/completions/x.py.ps1
@@ -21,44 +21,44 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
 
     $completions = @(switch ($command) {
         'x.py' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             [CompletionResult]::new('build', 'build', [CompletionResultType]::ParameterValue, 'Compile either the compiler or libraries')
             [CompletionResult]::new('check', 'check', [CompletionResultType]::ParameterValue, 'Compile either the compiler or libraries, using cargo check')
             [CompletionResult]::new('clippy', 'clippy', [CompletionResultType]::ParameterValue, 'Run Clippy (uses rustup/cargo-installed clippy binary)')
@@ -79,735 +79,735 @@ Register-ArgumentCompleter -Native -CommandName 'x.py' -ScriptBlock {
             break
         }
         'x.py;build' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;check' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('--all-targets', 'all-targets', [CompletionResultType]::ParameterName, 'Check all targets')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('--all-targets', '--all-targets', [CompletionResultType]::ParameterName, 'Check all targets')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;clippy' {
-            [CompletionResult]::new('-A', 'A ', [CompletionResultType]::ParameterName, 'clippy lints to allow')
-            [CompletionResult]::new('-D', 'D ', [CompletionResultType]::ParameterName, 'clippy lints to deny')
-            [CompletionResult]::new('-W', 'W ', [CompletionResultType]::ParameterName, 'clippy lints to warn on')
-            [CompletionResult]::new('-F', 'F ', [CompletionResultType]::ParameterName, 'clippy lints to forbid')
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('--fix', 'fix', [CompletionResultType]::ParameterName, 'fix')
-            [CompletionResult]::new('--allow-dirty', 'allow-dirty', [CompletionResultType]::ParameterName, 'allow-dirty')
-            [CompletionResult]::new('--allow-staged', 'allow-staged', [CompletionResultType]::ParameterName, 'allow-staged')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('-A', '-A ', [CompletionResultType]::ParameterName, 'clippy lints to allow')
+            [CompletionResult]::new('-D', '-D ', [CompletionResultType]::ParameterName, 'clippy lints to deny')
+            [CompletionResult]::new('-W', '-W ', [CompletionResultType]::ParameterName, 'clippy lints to warn on')
+            [CompletionResult]::new('-F', '-F ', [CompletionResultType]::ParameterName, 'clippy lints to forbid')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('--fix', '--fix', [CompletionResultType]::ParameterName, 'fix')
+            [CompletionResult]::new('--allow-dirty', '--allow-dirty', [CompletionResultType]::ParameterName, 'allow-dirty')
+            [CompletionResult]::new('--allow-staged', '--allow-staged', [CompletionResultType]::ParameterName, 'allow-staged')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;fix' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;fmt' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('--check', 'check', [CompletionResultType]::ParameterName, 'check formatting instead of applying')
-            [CompletionResult]::new('--all', 'all', [CompletionResultType]::ParameterName, 'apply to all appropriate files, not just those that have been modified')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('--check', '--check', [CompletionResultType]::ParameterName, 'check formatting instead of applying')
+            [CompletionResult]::new('--all', '--all', [CompletionResultType]::ParameterName, 'apply to all appropriate files, not just those that have been modified')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;doc' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('--open', 'open', [CompletionResultType]::ParameterName, 'open the docs in a browser')
-            [CompletionResult]::new('--json', 'json', [CompletionResultType]::ParameterName, 'render the documentation in JSON format in addition to the usual HTML format')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('--open', '--open', [CompletionResultType]::ParameterName, 'open the docs in a browser')
+            [CompletionResult]::new('--json', '--json', [CompletionResultType]::ParameterName, 'render the documentation in JSON format in addition to the usual HTML format')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;test' {
-            [CompletionResult]::new('--test-args', 'test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)')
-            [CompletionResult]::new('--compiletest-rustc-args', 'compiletest-rustc-args', [CompletionResultType]::ParameterName, 'extra options to pass the compiler when running compiletest tests')
-            [CompletionResult]::new('--extra-checks', 'extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell)')
-            [CompletionResult]::new('--compare-mode', 'compare-mode', [CompletionResultType]::ParameterName, 'mode describing what file the actual ui output will be compared to')
-            [CompletionResult]::new('--pass', 'pass', [CompletionResultType]::ParameterName, 'force {check,build,run}-pass tests to this mode')
-            [CompletionResult]::new('--run', 'run', [CompletionResultType]::ParameterName, 'whether to execute run-* tests')
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('--no-fail-fast', 'no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure')
-            [CompletionResult]::new('--no-doc', 'no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests')
-            [CompletionResult]::new('--doc', 'doc', [CompletionResultType]::ParameterName, 'only run doc tests')
-            [CompletionResult]::new('--bless', 'bless', [CompletionResultType]::ParameterName, 'whether to automatically update stderr/stdout files')
-            [CompletionResult]::new('--force-rerun', 'force-rerun', [CompletionResultType]::ParameterName, 'rerun tests even if the inputs are unchanged')
-            [CompletionResult]::new('--only-modified', 'only-modified', [CompletionResultType]::ParameterName, 'only run tests that result has been changed')
-            [CompletionResult]::new('--rustfix-coverage', 'rustfix-coverage', [CompletionResultType]::ParameterName, 'enable this to generate a Rustfix coverage file, which is saved in `/<build_base>/rustfix_missing_coverage.txt`')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)')
+            [CompletionResult]::new('--compiletest-rustc-args', '--compiletest-rustc-args', [CompletionResultType]::ParameterName, 'extra options to pass the compiler when running compiletest tests')
+            [CompletionResult]::new('--extra-checks', '--extra-checks', [CompletionResultType]::ParameterName, 'comma-separated list of other files types to check (accepts py, py:lint, py:fmt, shell)')
+            [CompletionResult]::new('--compare-mode', '--compare-mode', [CompletionResultType]::ParameterName, 'mode describing what file the actual ui output will be compared to')
+            [CompletionResult]::new('--pass', '--pass', [CompletionResultType]::ParameterName, 'force {check,build,run}-pass tests to this mode')
+            [CompletionResult]::new('--run', '--run', [CompletionResultType]::ParameterName, 'whether to execute run-* tests')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('--no-fail-fast', '--no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure')
+            [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests')
+            [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'only run doc tests')
+            [CompletionResult]::new('--bless', '--bless', [CompletionResultType]::ParameterName, 'whether to automatically update stderr/stdout files')
+            [CompletionResult]::new('--force-rerun', '--force-rerun', [CompletionResultType]::ParameterName, 'rerun tests even if the inputs are unchanged')
+            [CompletionResult]::new('--only-modified', '--only-modified', [CompletionResultType]::ParameterName, 'only run tests that result has been changed')
+            [CompletionResult]::new('--rustfix-coverage', '--rustfix-coverage', [CompletionResultType]::ParameterName, 'enable this to generate a Rustfix coverage file, which is saved in `/<build_base>/rustfix_missing_coverage.txt`')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;miri' {
-            [CompletionResult]::new('--test-args', 'test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)')
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('--no-fail-fast', 'no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure')
-            [CompletionResult]::new('--no-doc', 'no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests')
-            [CompletionResult]::new('--doc', 'doc', [CompletionResultType]::ParameterName, 'only run doc tests')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('--no-fail-fast', '--no-fail-fast', [CompletionResultType]::ParameterName, 'run all tests regardless of failure')
+            [CompletionResult]::new('--no-doc', '--no-doc', [CompletionResultType]::ParameterName, 'do not run doc tests')
+            [CompletionResult]::new('--doc', '--doc', [CompletionResultType]::ParameterName, 'only run doc tests')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;bench' {
-            [CompletionResult]::new('--test-args', 'test-args', [CompletionResultType]::ParameterName, 'test-args')
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--test-args', '--test-args', [CompletionResultType]::ParameterName, 'test-args')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;clean' {
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'Clean a specific stage without touching other artifacts. By default, every stage is cleaned if this option is not used')
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('--all', 'all', [CompletionResultType]::ParameterName, 'Clean the entire build directory (not used by default)')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'Clean a specific stage without touching other artifacts. By default, every stage is cleaned if this option is not used')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('--all', '--all', [CompletionResultType]::ParameterName, 'Clean the entire build directory (not used by default)')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;dist' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;install' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;run' {
-            [CompletionResult]::new('--args', 'args', [CompletionResultType]::ParameterName, 'arguments for the tool')
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--args', '--args', [CompletionResultType]::ParameterName, 'arguments for the tool')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;setup' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;suggest' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('--run', 'run', [CompletionResultType]::ParameterName, 'run suggested tests')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('--run', '--run', [CompletionResultType]::ParameterName, 'run suggested tests')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;vendor' {
-            [CompletionResult]::new('--sync', 'sync', [CompletionResultType]::ParameterName, 'Additional `Cargo.toml` to sync and vendor')
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('--versioned-dirs', 'versioned-dirs', [CompletionResultType]::ParameterName, 'Always include version in subdir name')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--sync', '--sync', [CompletionResultType]::ParameterName, 'Additional `Cargo.toml` to sync and vendor')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('--versioned-dirs', '--versioned-dirs', [CompletionResultType]::ParameterName, 'Always include version in subdir name')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
         'x.py;perf' {
-            [CompletionResult]::new('--config', 'config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
-            [CompletionResult]::new('--build-dir', 'build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
-            [CompletionResult]::new('--build', 'build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
-            [CompletionResult]::new('--host', 'host', [CompletionResultType]::ParameterName, 'host targets to build')
-            [CompletionResult]::new('--target', 'target', [CompletionResultType]::ParameterName, 'target targets to build')
-            [CompletionResult]::new('--exclude', 'exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
-            [CompletionResult]::new('--skip', 'skip', [CompletionResultType]::ParameterName, 'build paths to skip')
-            [CompletionResult]::new('--rustc-error-format', 'rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
-            [CompletionResult]::new('--on-fail', 'on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
-            [CompletionResult]::new('--stage', 'stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
-            [CompletionResult]::new('--keep-stage', 'keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--keep-stage-std', 'keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
-            [CompletionResult]::new('--src', 'src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
-            [CompletionResult]::new('-j', 'j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--jobs', 'jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
-            [CompletionResult]::new('--warnings', 'warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
-            [CompletionResult]::new('--error-format', 'error-format', [CompletionResultType]::ParameterName, 'rustc error format')
-            [CompletionResult]::new('--color', 'color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
-            [CompletionResult]::new('--llvm-skip-rebuild', 'llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
-            [CompletionResult]::new('--rust-profile-generate', 'rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
-            [CompletionResult]::new('--rust-profile-use', 'rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
-            [CompletionResult]::new('--llvm-profile-use', 'llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
-            [CompletionResult]::new('--reproducible-artifact', 'reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
-            [CompletionResult]::new('--set', 'set', [CompletionResultType]::ParameterName, 'override options in config.toml')
-            [CompletionResult]::new('-v', 'v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('--verbose', 'verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
-            [CompletionResult]::new('-i', 'i', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--incremental', 'incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
-            [CompletionResult]::new('--include-default-paths', 'include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
-            [CompletionResult]::new('--dry-run', 'dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
-            [CompletionResult]::new('--dump-bootstrap-shims', 'dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
-            [CompletionResult]::new('--json-output', 'json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
-            [CompletionResult]::new('--bypass-bootstrap-lock', 'bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
-            [CompletionResult]::new('--llvm-profile-generate', 'llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
-            [CompletionResult]::new('--enable-bolt-settings', 'enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
-            [CompletionResult]::new('--skip-stage0-validation', 'skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
-            [CompletionResult]::new('-h', 'h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
-            [CompletionResult]::new('--help', 'help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--config', '--config', [CompletionResultType]::ParameterName, 'TOML configuration file for build')
+            [CompletionResult]::new('--build-dir', '--build-dir', [CompletionResultType]::ParameterName, 'Build directory, overrides `build.build-dir` in `config.toml`')
+            [CompletionResult]::new('--build', '--build', [CompletionResultType]::ParameterName, 'build target of the stage0 compiler')
+            [CompletionResult]::new('--host', '--host', [CompletionResultType]::ParameterName, 'host targets to build')
+            [CompletionResult]::new('--target', '--target', [CompletionResultType]::ParameterName, 'target targets to build')
+            [CompletionResult]::new('--exclude', '--exclude', [CompletionResultType]::ParameterName, 'build paths to exclude')
+            [CompletionResult]::new('--skip', '--skip', [CompletionResultType]::ParameterName, 'build paths to skip')
+            [CompletionResult]::new('--rustc-error-format', '--rustc-error-format', [CompletionResultType]::ParameterName, 'rustc-error-format')
+            [CompletionResult]::new('--on-fail', '--on-fail', [CompletionResultType]::ParameterName, 'command to run on failure')
+            [CompletionResult]::new('--stage', '--stage', [CompletionResultType]::ParameterName, 'stage to build (indicates compiler to use/test, e.g., stage 0 uses the bootstrap compiler, stage 1 the stage 0 rustc artifacts, etc.)')
+            [CompletionResult]::new('--keep-stage', '--keep-stage', [CompletionResultType]::ParameterName, 'stage(s) to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--keep-stage-std', '--keep-stage-std', [CompletionResultType]::ParameterName, 'stage(s) of the standard library to keep without recompiling (pass multiple times to keep e.g., both stages 0 and 1)')
+            [CompletionResult]::new('--src', '--src', [CompletionResultType]::ParameterName, 'path to the root of the rust checkout')
+            [CompletionResult]::new('-j', '-j', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--jobs', '--jobs', [CompletionResultType]::ParameterName, 'number of jobs to run in parallel')
+            [CompletionResult]::new('--warnings', '--warnings', [CompletionResultType]::ParameterName, 'if value is deny, will deny warnings if value is warn, will emit warnings otherwise, use the default configured behaviour')
+            [CompletionResult]::new('--error-format', '--error-format', [CompletionResultType]::ParameterName, 'rustc error format')
+            [CompletionResult]::new('--color', '--color', [CompletionResultType]::ParameterName, 'whether to use color in cargo and rustc output')
+            [CompletionResult]::new('--llvm-skip-rebuild', '--llvm-skip-rebuild', [CompletionResultType]::ParameterName, 'whether rebuilding llvm should be skipped, overriding `skip-rebuld` in config.toml')
+            [CompletionResult]::new('--rust-profile-generate', '--rust-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with rustc build')
+            [CompletionResult]::new('--rust-profile-use', '--rust-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for rustc build')
+            [CompletionResult]::new('--llvm-profile-use', '--llvm-profile-use', [CompletionResultType]::ParameterName, 'use PGO profile for LLVM build')
+            [CompletionResult]::new('--reproducible-artifact', '--reproducible-artifact', [CompletionResultType]::ParameterName, 'Additional reproducible artifacts that should be added to the reproducible artifacts archive')
+            [CompletionResult]::new('--set', '--set', [CompletionResultType]::ParameterName, 'override options in config.toml')
+            [CompletionResult]::new('-v', '-v', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('--verbose', '--verbose', [CompletionResultType]::ParameterName, 'use verbose output (-vv for very verbose)')
+            [CompletionResult]::new('-i', '-i', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--incremental', '--incremental', [CompletionResultType]::ParameterName, 'use incremental compilation')
+            [CompletionResult]::new('--include-default-paths', '--include-default-paths', [CompletionResultType]::ParameterName, 'include default paths in addition to the provided ones')
+            [CompletionResult]::new('--dry-run', '--dry-run', [CompletionResultType]::ParameterName, 'dry run; don''t build anything')
+            [CompletionResult]::new('--dump-bootstrap-shims', '--dump-bootstrap-shims', [CompletionResultType]::ParameterName, 'Indicates whether to dump the work done from bootstrap shims')
+            [CompletionResult]::new('--json-output', '--json-output', [CompletionResultType]::ParameterName, 'use message-format=json')
+            [CompletionResult]::new('--bypass-bootstrap-lock', '--bypass-bootstrap-lock', [CompletionResultType]::ParameterName, 'Bootstrap uses this value to decide whether it should bypass locking the build process. This is rarely needed (e.g., compiling the std library for different targets in parallel)')
+            [CompletionResult]::new('--llvm-profile-generate', '--llvm-profile-generate', [CompletionResultType]::ParameterName, 'generate PGO profile with llvm built for rustc')
+            [CompletionResult]::new('--enable-bolt-settings', '--enable-bolt-settings', [CompletionResultType]::ParameterName, 'Enable BOLT link flags')
+            [CompletionResult]::new('--skip-stage0-validation', '--skip-stage0-validation', [CompletionResultType]::ParameterName, 'Skip stage0 compiler validation')
+            [CompletionResult]::new('-h', '-h', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
+            [CompletionResult]::new('--help', '--help', [CompletionResultType]::ParameterName, 'Print help (see more with ''--help'')')
             break
         }
     })
diff --git a/src/etc/completions/x.py.sh b/src/etc/completions/x.py.sh
index 60ba8d3ba7032..b1730e5c6d8e3 100644
--- a/src/etc/completions/x.py.sh
+++ b/src/etc/completions/x.py.sh
@@ -12,56 +12,56 @@ _x.py() {
             ",$1")
                 cmd="x.py"
                 ;;
-            bootstrap,bench)
-                cmd="bootstrap__bench"
+            x.py,bench)
+                cmd="x.py__bench"
                 ;;
-            bootstrap,build)
-                cmd="bootstrap__build"
+            x.py,build)
+                cmd="x.py__build"
                 ;;
-            bootstrap,check)
-                cmd="bootstrap__check"
+            x.py,check)
+                cmd="x.py__check"
                 ;;
-            bootstrap,clean)
-                cmd="bootstrap__clean"
+            x.py,clean)
+                cmd="x.py__clean"
                 ;;
-            bootstrap,clippy)
-                cmd="bootstrap__clippy"
+            x.py,clippy)
+                cmd="x.py__clippy"
                 ;;
-            bootstrap,dist)
-                cmd="bootstrap__dist"
+            x.py,dist)
+                cmd="x.py__dist"
                 ;;
-            bootstrap,doc)
-                cmd="bootstrap__doc"
+            x.py,doc)
+                cmd="x.py__doc"
                 ;;
-            bootstrap,fix)
-                cmd="bootstrap__fix"
+            x.py,fix)
+                cmd="x.py__fix"
                 ;;
-            bootstrap,fmt)
-                cmd="bootstrap__fmt"
+            x.py,fmt)
+                cmd="x.py__fmt"
                 ;;
-            bootstrap,install)
-                cmd="bootstrap__install"
+            x.py,install)
+                cmd="x.py__install"
                 ;;
-            bootstrap,miri)
-                cmd="bootstrap__miri"
+            x.py,miri)
+                cmd="x.py__miri"
                 ;;
-            bootstrap,perf)
-                cmd="bootstrap__perf"
+            x.py,perf)
+                cmd="x.py__perf"
                 ;;
-            bootstrap,run)
-                cmd="bootstrap__run"
+            x.py,run)
+                cmd="x.py__run"
                 ;;
-            bootstrap,setup)
-                cmd="bootstrap__setup"
+            x.py,setup)
+                cmd="x.py__setup"
                 ;;
-            bootstrap,suggest)
-                cmd="bootstrap__suggest"
+            x.py,suggest)
+                cmd="x.py__suggest"
                 ;;
-            bootstrap,test)
-                cmd="bootstrap__test"
+            x.py,test)
+                cmd="x.py__test"
                 ;;
-            bootstrap,vendor)
-                cmd="bootstrap__vendor"
+            x.py,vendor)
+                cmd="x.py__vendor"
                 ;;
             *)
                 ;;
@@ -77,23 +77,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -106,6 +129,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -114,26 +140,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -142,6 +186,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -153,15 +200,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -170,6 +250,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -191,23 +274,46 @@ _x.py() {
                     return 0
                     ;;
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -220,6 +326,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -228,26 +337,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -256,6 +383,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -267,15 +397,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -284,6 +447,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -301,23 +467,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -330,6 +519,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -338,26 +530,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -366,6 +576,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -377,15 +590,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -394,6 +640,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -411,23 +660,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -440,6 +712,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -448,26 +723,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -476,6 +769,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -487,15 +783,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -504,6 +833,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -525,23 +857,46 @@ _x.py() {
                     return 0
                     ;;
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -554,6 +909,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -562,22 +920,37 @@ _x.py() {
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -586,6 +959,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -597,15 +973,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -614,6 +1023,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -647,23 +1059,46 @@ _x.py() {
                     return 0
                     ;;
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -676,6 +1111,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -684,26 +1122,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -712,6 +1168,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -723,15 +1182,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -740,6 +1232,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -757,23 +1252,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -786,6 +1304,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -794,26 +1315,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -822,6 +1361,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -833,15 +1375,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -850,6 +1425,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -867,23 +1445,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -896,6 +1497,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -904,26 +1508,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -932,6 +1554,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -943,15 +1568,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -960,6 +1618,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -977,23 +1638,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -1006,6 +1690,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -1014,26 +1701,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -1042,6 +1747,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -1053,15 +1761,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -1070,6 +1811,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -1087,23 +1831,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -1116,6 +1883,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -1124,26 +1894,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -1152,6 +1940,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -1163,15 +1954,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -1180,6 +2004,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -1197,23 +2024,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -1226,6 +2076,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -1234,26 +2087,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -1262,6 +2133,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -1273,15 +2147,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -1290,6 +2197,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -1311,23 +2221,46 @@ _x.py() {
                     return 0
                     ;;
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -1340,6 +2273,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -1348,26 +2284,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -1376,6 +2330,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -1387,15 +2344,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -1404,6 +2394,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -1421,23 +2414,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -1450,6 +2466,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -1458,26 +2477,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -1486,6 +2523,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -1497,15 +2537,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -1514,6 +2587,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -1535,23 +2611,46 @@ _x.py() {
                     return 0
                     ;;
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -1564,6 +2663,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -1572,26 +2674,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -1600,6 +2720,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -1611,15 +2734,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -1628,6 +2784,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -1645,23 +2804,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -1674,6 +2856,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -1682,26 +2867,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -1710,6 +2913,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -1721,15 +2927,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -1738,6 +2977,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -1755,23 +2997,46 @@ _x.py() {
             fi
             case "${prev}" in
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -1784,6 +3049,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -1792,26 +3060,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -1820,6 +3106,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -1831,15 +3120,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -1848,6 +3170,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -1889,23 +3214,46 @@ _x.py() {
                     return 0
                     ;;
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -1918,6 +3266,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -1926,26 +3277,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -1954,6 +3323,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -1965,15 +3337,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -1982,6 +3387,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
@@ -2003,23 +3411,46 @@ _x.py() {
                     return 0
                     ;;
                 --config)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --build-dir)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --build)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --host)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --target)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --exclude)
@@ -2032,6 +3463,9 @@ _x.py() {
                     ;;
                 --rustc-error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --on-fail)
@@ -2040,26 +3474,44 @@ _x.py() {
                     ;;
                 --stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --keep-stage-std)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --src)
-                    COMPREPLY=($(compgen -f "${cur}"))
+                    COMPREPLY=()
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o plusdirs
+                    fi
                     return 0
                     ;;
                 --jobs)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 -j)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --warnings)
@@ -2068,6 +3520,9 @@ _x.py() {
                     ;;
                 --error-format)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 --color)
@@ -2079,15 +3534,48 @@ _x.py() {
                     return 0
                     ;;
                 --rust-profile-generate)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --rust-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --llvm-profile-use)
+                    local oldifs
+                    if [ -n "${IFS+x}" ]; then
+                        oldifs="$IFS"
+                    fi
+                    IFS=$'\n'
                     COMPREPLY=($(compgen -f "${cur}"))
+                    if [ -n "${oldifs+x}" ]; then
+                        IFS="$oldifs"
+                    fi
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o filenames
+                    fi
                     return 0
                     ;;
                 --reproducible-artifact)
@@ -2096,6 +3584,9 @@ _x.py() {
                     ;;
                 --set)
                     COMPREPLY=("${cur}")
+                    if [[ "${BASH_VERSINFO[0]}" -ge 4 ]]; then
+                        compopt -o nospace
+                    fi
                     return 0
                     ;;
                 *)
diff --git a/src/etc/completions/x.py.zsh b/src/etc/completions/x.py.zsh
index 688f692da2414..ae076b8834504 100644
--- a/src/etc/completions/x.py.zsh
+++ b/src/etc/completions/x.py.zsh
@@ -14,7 +14,7 @@ _x.py() {
     fi
 
     local context curcontext="$curcontext" state line
-    _arguments "${_arguments_options[@]}" \
+    _arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \
@@ -65,7 +65,7 @@ _x.py() {
         curcontext="${curcontext%:*:*}:x.py-command-$line[3]:"
         case $line[3] in
             (build)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \
@@ -108,7 +108,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (check)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \
@@ -152,7 +152,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (clippy)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '*-A+[clippy lints to allow]:LINT: ' \
 '*-D+[clippy lints to deny]:LINT: ' \
 '*-W+[clippy lints to warn on]:LINT: ' \
@@ -202,7 +202,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (fix)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \
@@ -245,7 +245,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (fmt)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \
@@ -290,7 +290,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (doc)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \
@@ -335,7 +335,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (test)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '*--test-args=[extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)]:ARGS: ' \
 '*--compiletest-rustc-args=[extra options to pass the compiler when running compiletest tests]:ARGS: ' \
 '--extra-checks=[comma-separated list of other files types to check (accepts py, py\:lint, py\:fmt, shell)]:EXTRA_CHECKS: ' \
@@ -391,7 +391,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (miri)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '*--test-args=[extra arguments to be passed for the test tool being used (e.g. libtest, compiletest or rustdoc)]:ARGS: ' \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
@@ -438,7 +438,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (bench)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '*--test-args=[]:TEST_ARGS: ' \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
@@ -482,7 +482,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (clean)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--stage=[Clean a specific stage without touching other artifacts. By default, every stage is cleaned if this option is not used]:N: ' \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
@@ -526,7 +526,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (dist)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \
@@ -569,7 +569,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (install)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \
@@ -612,7 +612,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (run)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '*--args=[arguments for the tool]:ARGS: ' \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
@@ -656,7 +656,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (setup)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \
@@ -700,7 +700,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (suggest)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \
@@ -744,7 +744,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (vendor)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '*--sync=[Additional \`Cargo.toml\` to sync and vendor]:SYNC:_files' \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
@@ -789,7 +789,7 @@ _arguments "${_arguments_options[@]}" \
 && ret=0
 ;;
 (perf)
-_arguments "${_arguments_options[@]}" \
+_arguments "${_arguments_options[@]}" : \
 '--config=[TOML configuration file for build]:FILE:_files' \
 '--build-dir=[Build directory, overrides \`build.build-dir\` in \`config.toml\`]:DIR:_files -/' \
 '--build=[build target of the stage0 compiler]:BUILD:( )' \

From 5365b05fc9160f55c2729c2bf32030bbe92adc3b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 19 Aug 2024 09:26:25 +0200
Subject: [PATCH 433/685] library: bump libc dependency

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

diff --git a/library/Cargo.lock b/library/Cargo.lock
index 815f5bb1385bf..30f5076e1e223 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -155,9 +155,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
 dependencies = [
  "rustc-std-workspace-core",
 ]

From 6a8ec81e1c894287bfee2a6263c8044a5ffc98a9 Mon Sep 17 00:00:00 2001
From: apiraino <apiraino@users.noreply.github.com>
Date: Mon, 19 Aug 2024 12:40:23 +0200
Subject: [PATCH 434/685] Add a missing compatibility note in the 1.80.0
 release notes

---
 RELEASES.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/RELEASES.md b/RELEASES.md
index 2c91ddf782674..a93aa432187cb 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -143,6 +143,7 @@ Compatibility Notes
 - [Turn `proc_macro_back_compat` lint into a hard error.](https://github.com/rust-lang/rust/pull/125596/)
 - [Detect unused structs even when implementing private traits](https://github.com/rust-lang/rust/pull/122382/)
 - [`std::sync::ReentrantLockGuard<T>` is no longer `Sync` if `T: !Sync`](https://github.com/rust-lang/rust/pull/125527) which means [`std::io::StdoutLock` and `std::io::StderrLock` are no longer Sync](https://github.com/rust-lang/rust/issues/127340)
+- [alloc: implement FromIterator for Box<str>](https://github.com/rust-lang/rust/pull/99969/)
 
 <a id="1.80-Internal-Changes"></a>
 

From cd7cc3f071a5b4bf7b621db3160bc960b5faeaa7 Mon Sep 17 00:00:00 2001
From: apiraino <apiraino@users.noreply.github.com>
Date: Mon, 19 Aug 2024 14:03:16 +0200
Subject: [PATCH 435/685] Update RELEASES.md

Co-authored-by: Mark Rousskov <mark.simulacrum@gmail.com>
---
 RELEASES.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/RELEASES.md b/RELEASES.md
index a93aa432187cb..7c15a3ccd1b74 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -143,7 +143,8 @@ Compatibility Notes
 - [Turn `proc_macro_back_compat` lint into a hard error.](https://github.com/rust-lang/rust/pull/125596/)
 - [Detect unused structs even when implementing private traits](https://github.com/rust-lang/rust/pull/122382/)
 - [`std::sync::ReentrantLockGuard<T>` is no longer `Sync` if `T: !Sync`](https://github.com/rust-lang/rust/pull/125527) which means [`std::io::StdoutLock` and `std::io::StderrLock` are no longer Sync](https://github.com/rust-lang/rust/issues/127340)
-- [alloc: implement FromIterator for Box<str>](https://github.com/rust-lang/rust/pull/99969/)
+- [Type inference will fail in some cases due to a new impl of FromIterator for Box<str>](https://github.com/rust-lang/rust/pull/99969/)
+  Notably this breaks versions of the `time` crate before 0.3.55, due to no longer inferring the right impl.
 
 <a id="1.80-Internal-Changes"></a>
 

From 35752cf058047262a9b6e970426db43ffa9ce206 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Mon, 19 Aug 2024 07:30:11 -0500
Subject: [PATCH 436/685] Update `library/Cargo.toml` in weekly job

Before the workspace split, the library was covered by the weekly `cargo
update` cron job. Now that the library has its own workspace, it doesn't
get these updates.

Add `library/Cargo.toml` to the job so updates happen again.
---
 .github/workflows/dependencies.yml | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/dependencies.yml b/.github/workflows/dependencies.yml
index 5e54ceea3d7f8..83b92b7fa092f 100644
--- a/.github/workflows/dependencies.yml
+++ b/.github/workflows/dependencies.yml
@@ -64,6 +64,10 @@ jobs:
       - name: cargo update
         # Remove first line that always just says "Updating crates.io index"
         run: cargo update 2>&1 | sed '/crates.io index/d' | tee -a cargo_update.log
+      - name: cargo update library
+        run: |
+          echo -e "\nlibrary dependencies:" >> cargo_update.log
+          cargo update --manifest-path library/Cargo.toml 2>&1 | sed '/crates.io index/d' | tee -a cargo_update.log
       - name: cargo update rustbook
         run: |
           echo -e "\nrustbook dependencies:" >> cargo_update.log
@@ -74,6 +78,7 @@ jobs:
           name: Cargo-lock
           path: |
             Cargo.lock
+            library/Cargo.lock
             src/tools/rustbook/Cargo.lock
           retention-days: 1
       - name: upload cargo-update log artifact for use in PR
@@ -119,7 +124,7 @@ jobs:
           git config user.name github-actions
           git config user.email github-actions@github.com
           git switch --force-create cargo_update
-          git add ./Cargo.lock ./src/tools/rustbook/Cargo.lock
+          git add ./Cargo.lock ./library/Cargo.lock ./src/tools/rustbook/Cargo.lock
           git commit --no-verify --file=commit.txt
 
       - name: push

From 7613eee55ea9fc0bdaff6bb482cc0650a5bf3e9a Mon Sep 17 00:00:00 2001
From: apiraino <apiraino@users.noreply.github.com>
Date: Mon, 19 Aug 2024 17:33:53 +0200
Subject: [PATCH 437/685] Update RELEASES.md

Co-authored-by: Jubilee <46493976+workingjubilee@users.noreply.github.com>
---
 RELEASES.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/RELEASES.md b/RELEASES.md
index 7c15a3ccd1b74..852af4389ea89 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -144,7 +144,7 @@ Compatibility Notes
 - [Detect unused structs even when implementing private traits](https://github.com/rust-lang/rust/pull/122382/)
 - [`std::sync::ReentrantLockGuard<T>` is no longer `Sync` if `T: !Sync`](https://github.com/rust-lang/rust/pull/125527) which means [`std::io::StdoutLock` and `std::io::StderrLock` are no longer Sync](https://github.com/rust-lang/rust/issues/127340)
 - [Type inference will fail in some cases due to a new impl of FromIterator for Box<str>](https://github.com/rust-lang/rust/pull/99969/)
-  Notably this breaks versions of the `time` crate before 0.3.55, due to no longer inferring the right impl.
+  Notably this breaks versions of the `time` crate before 0.3.36, due to no longer inferring the right impl.
 
 <a id="1.80-Internal-Changes"></a>
 

From d2d8fa499407d48877c939627914a999bc5ff458 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Mon, 19 Aug 2024 18:38:01 +0300
Subject: [PATCH 438/685] fix broken bootstrap documentation

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

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index 65d9c24b6c56f..ce23b7735f8bd 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -2515,7 +2515,7 @@ impl Config {
     ///
     /// This *does not* update the submodule if `config.toml` explicitly says
     /// not to, or if we're not in a git repository (like a plain source
-    /// tarball). Typically [`Build::require_submodule`] should be
+    /// tarball). Typically [`crate::Build::require_submodule`] should be
     /// used instead to provide a nice error to the user if the submodule is
     /// missing.
     pub(crate) fn update_submodule(&self, relative_path: &str) {

From 2bf24559252f9e4a186ea6227827c0c7c417471a Mon Sep 17 00:00:00 2001
From: Felix Rath <felixm.rath@gmail.com>
Date: Mon, 12 Aug 2024 03:16:39 +0200
Subject: [PATCH 439/685] Prevent double panic in query system, improve
 diagnostics

---
 compiler/rustc_query_impl/src/plumbing.rs         | 10 ++++++++--
 compiler/rustc_query_system/src/query/plumbing.rs | 11 +++++++++--
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
index b9e700c1938f2..c064b2bd6c16c 100644
--- a/compiler/rustc_query_impl/src/plumbing.rs
+++ b/compiler/rustc_query_impl/src/plumbing.rs
@@ -702,11 +702,17 @@ macro_rules! define_queries {
                     let name = stringify!($name);
                     $crate::plumbing::create_query_frame(tcx, rustc_middle::query::descs::$name, key, kind, name)
                 };
-                tcx.query_system.states.$name.try_collect_active_jobs(
+                let res = tcx.query_system.states.$name.try_collect_active_jobs(
                     tcx,
                     make_query,
                     qmap,
-                ).unwrap();
+                );
+                // this can be called during unwinding, and the function has a `try_`-prefix, so
+                // don't `unwrap()` here, just manually check for `None` and do best-effort error
+                // reporting.
+                if res.is_none() {
+                    tracing::warn!("Failed to collect active jobs for query with name `{}`!", stringify!($name));
+                }
             }
 
             pub fn alloc_self_profile_query_strings<'tcx>(tcx: TyCtxt<'tcx>, string_cache: &mut QueryKeyStringCache) {
diff --git a/compiler/rustc_query_system/src/query/plumbing.rs b/compiler/rustc_query_system/src/query/plumbing.rs
index 8ef680cdb6c8b..6dbd6e89fe98a 100644
--- a/compiler/rustc_query_system/src/query/plumbing.rs
+++ b/compiler/rustc_query_system/src/query/plumbing.rs
@@ -181,8 +181,15 @@ where
         cache.complete(key, result, dep_node_index);
 
         let job = {
-            let mut lock = state.active.lock_shard_by_value(&key);
-            lock.remove(&key).unwrap().expect_job()
+            let val = {
+                // don't keep the lock during the `unwrap()` of the retrieved value, or we taint the
+                // underlying shard.
+                // since unwinding also wants to look at this map, this can also prevent a double
+                // panic.
+                let mut lock = state.active.lock_shard_by_value(&key);
+                lock.remove(&key)
+            };
+            val.unwrap().expect_job()
         };
 
         job.signal_complete();

From 1958e1acd46e791382219429cb7c38c97bef677d Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Tue, 20 Aug 2024 01:51:32 +0900
Subject: [PATCH 440/685] fix false position in explicit_iter_loop with msrv

---
 clippy_config/src/msrvs.rs                   |  1 +
 clippy_lints/src/loops/explicit_iter_loop.rs | 12 ++++++++++--
 tests/ui/explicit_iter_loop.fixed            | 12 ++++++++++++
 tests/ui/explicit_iter_loop.rs               | 12 ++++++++++++
 4 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/clippy_config/src/msrvs.rs b/clippy_config/src/msrvs.rs
index 5b9707efd2634..0e8215aa8e3cd 100644
--- a/clippy_config/src/msrvs.rs
+++ b/clippy_config/src/msrvs.rs
@@ -18,6 +18,7 @@ macro_rules! msrv_aliases {
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
     1,81,0  { LINT_REASONS_STABILIZATION }
+    1,80,0 { BOX_INTO_ITER}
     1,77,0 { C_STR_LITERALS }
     1,76,0 { PTR_FROM_REF, OPTION_RESULT_INSPECT }
     1,71,0 { TUPLE_ARRAY_CONVERSIONS, BUILD_HASHER_HASH_ONE }
diff --git a/clippy_lints/src/loops/explicit_iter_loop.rs b/clippy_lints/src/loops/explicit_iter_loop.rs
index eea5f2a94ea60..b134af500f540 100644
--- a/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -3,7 +3,7 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::ty::{
-    implements_trait, implements_trait_with_env, is_copy, make_normalized_projection,
+    implements_trait, implements_trait_with_env, is_copy, is_type_lang_item, make_normalized_projection,
     make_normalized_projection_with_regions, normalize_with_regions,
 };
 use rustc_errors::Applicability;
@@ -20,9 +20,10 @@ pub(super) fn check(
     msrv: &Msrv,
     enforce_iter_loop_reborrow: bool,
 ) {
-    let Some((adjust, ty)) = is_ref_iterable(cx, self_arg, call_expr, enforce_iter_loop_reborrow) else {
+    let Some((adjust, ty)) = is_ref_iterable(cx, self_arg, call_expr, enforce_iter_loop_reborrow, msrv) else {
         return;
     };
+
     if let ty::Array(_, count) = *ty.peel_refs().kind() {
         if !ty.is_ref() {
             if !msrv.meets(msrvs::ARRAY_INTO_ITERATOR) {
@@ -109,6 +110,7 @@ fn is_ref_iterable<'tcx>(
     self_arg: &Expr<'_>,
     call_expr: &Expr<'_>,
     enforce_iter_loop_reborrow: bool,
+    msrv: &Msrv,
 ) -> Option<(AdjustKind, Ty<'tcx>)> {
     let typeck = cx.typeck_results();
     if let Some(trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
@@ -128,6 +130,12 @@ fn is_ref_iterable<'tcx>(
         let self_ty = typeck.expr_ty(self_arg);
         let self_is_copy = is_copy(cx, self_ty);
 
+        if !msrv.meets(msrvs::BOX_INTO_ITER)
+            && is_type_lang_item(cx, self_ty.peel_refs(), rustc_hir::LangItem::OwnedBox)
+        {
+            return None;
+        }
+
         if adjustments.is_empty() && self_is_copy {
             // Exact type match, already checked earlier
             return Some((AdjustKind::None, self_ty));
diff --git a/tests/ui/explicit_iter_loop.fixed b/tests/ui/explicit_iter_loop.fixed
index f38b34c5a7c47..1148f0f6c6a63 100644
--- a/tests/ui/explicit_iter_loop.fixed
+++ b/tests/ui/explicit_iter_loop.fixed
@@ -153,3 +153,15 @@ fn main() {
     let r = &x;
     for _ in r {}
 }
+
+#[clippy::msrv = "1.79"]
+pub fn issue_13184() {
+    // https://github.com/rust-lang/rust-clippy/issues/13184
+    // No need to fix, as IntoIterator for Box is valid starting from 1.80
+    let mut values: Box<[u32]> = Box::new([1, 2]);
+    for _ in values.iter() {}
+    for _ in values.iter_mut() {}
+
+    let rvalues = &values;
+    for _ in rvalues.iter() {}
+}
diff --git a/tests/ui/explicit_iter_loop.rs b/tests/ui/explicit_iter_loop.rs
index 2e701ada5ac6d..4dda2f13e5b83 100644
--- a/tests/ui/explicit_iter_loop.rs
+++ b/tests/ui/explicit_iter_loop.rs
@@ -153,3 +153,15 @@ fn main() {
     let r = &x;
     for _ in r.iter() {}
 }
+
+#[clippy::msrv = "1.79"]
+pub fn issue_13184() {
+    // https://github.com/rust-lang/rust-clippy/issues/13184
+    // No need to fix, as IntoIterator for Box is valid starting from 1.80
+    let mut values: Box<[u32]> = Box::new([1, 2]);
+    for _ in values.iter() {}
+    for _ in values.iter_mut() {}
+
+    let rvalues = &values;
+    for _ in rvalues.iter() {}
+}

From 7b7cf440cb5bc8733de38aeca8d42f3747bd45e1 Mon Sep 17 00:00:00 2001
From: Alexey Semenyuk <alexsemenyuk88@gmail.com>
Date: Sun, 18 Aug 2024 17:50:29 +0500
Subject: [PATCH 441/685] string_slice should detect on Cow

---
 clippy_lints/src/strings.rs  |  2 +-
 tests/ui/string_slice.rs     |  5 +++++
 tests/ui/string_slice.stderr | 14 ++++++++++----
 3 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/clippy_lints/src/strings.rs b/clippy_lints/src/strings.rs
index cfc387886dc01..6ca4ca000e9b4 100644
--- a/clippy_lints/src/strings.rs
+++ b/clippy_lints/src/strings.rs
@@ -190,7 +190,7 @@ impl<'tcx> LateLintPass<'tcx> for StringAdd {
                 }
             },
             ExprKind::Index(target, _idx, _) => {
-                let e_ty = cx.typeck_results().expr_ty(target).peel_refs();
+                let e_ty = cx.typeck_results().expr_ty_adjusted(target).peel_refs();
                 if e_ty.is_str() || is_type_lang_item(cx, e_ty, LangItem::String) {
                     span_lint(
                         cx,
diff --git a/tests/ui/string_slice.rs b/tests/ui/string_slice.rs
index 440a86b104a3d..1d1911aaa1d91 100644
--- a/tests/ui/string_slice.rs
+++ b/tests/ui/string_slice.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 #[warn(clippy::string_slice)]
 #[allow(clippy::no_effect)]
 
@@ -11,4 +13,7 @@ fn main() {
     let s = String::from(m);
     &s[0..2];
     //~^ ERROR: indexing into a string may panic if the index is within a UTF-8 character
+    let a = Cow::Borrowed("foo");
+    &a[0..3];
+    //~^ ERROR: indexing into a string may panic if the index is within a UTF-8 character
 }
diff --git a/tests/ui/string_slice.stderr b/tests/ui/string_slice.stderr
index 7a4596b5f2d25..bc0fcde34b826 100644
--- a/tests/ui/string_slice.stderr
+++ b/tests/ui/string_slice.stderr
@@ -1,5 +1,5 @@
 error: indexing into a string may panic if the index is within a UTF-8 character
-  --> tests/ui/string_slice.rs:5:6
+  --> tests/ui/string_slice.rs:7:6
    |
 LL |     &"Ölkanne"[1..];
    |      ^^^^^^^^^^^^^^
@@ -8,16 +8,22 @@ LL |     &"Ölkanne"[1..];
    = help: to override `-D warnings` add `#[allow(clippy::string_slice)]`
 
 error: indexing into a string may panic if the index is within a UTF-8 character
-  --> tests/ui/string_slice.rs:9:6
+  --> tests/ui/string_slice.rs:11:6
    |
 LL |     &m[2..5];
    |      ^^^^^^^
 
 error: indexing into a string may panic if the index is within a UTF-8 character
-  --> tests/ui/string_slice.rs:12:6
+  --> tests/ui/string_slice.rs:14:6
    |
 LL |     &s[0..2];
    |      ^^^^^^^
 
-error: aborting due to 3 previous errors
+error: indexing into a string may panic if the index is within a UTF-8 character
+  --> tests/ui/string_slice.rs:17:6
+   |
+LL |     &a[0..3];
+   |      ^^^^^^^
+
+error: aborting due to 4 previous errors
 

From 76fbf0af77d98d60bbc7c2598cb6563e9e1ef7e3 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Sun, 18 Aug 2024 22:45:34 +0000
Subject: [PATCH 442/685] Test wholearchive on rust staticlib

---
 tests/run-make/msvc-wholearchive/c.c       |  1 +
 tests/run-make/msvc-wholearchive/dll.def   |  4 ++
 tests/run-make/msvc-wholearchive/rmake.rs  | 52 ++++++++++++++++++++++
 tests/run-make/msvc-wholearchive/static.rs |  9 ++++
 4 files changed, 66 insertions(+)
 create mode 100644 tests/run-make/msvc-wholearchive/c.c
 create mode 100644 tests/run-make/msvc-wholearchive/dll.def
 create mode 100644 tests/run-make/msvc-wholearchive/rmake.rs
 create mode 100644 tests/run-make/msvc-wholearchive/static.rs

diff --git a/tests/run-make/msvc-wholearchive/c.c b/tests/run-make/msvc-wholearchive/c.c
new file mode 100644
index 0000000000000..d6847845c6846
--- /dev/null
+++ b/tests/run-make/msvc-wholearchive/c.c
@@ -0,0 +1 @@
+// This page is intentionally left blank
diff --git a/tests/run-make/msvc-wholearchive/dll.def b/tests/run-make/msvc-wholearchive/dll.def
new file mode 100644
index 0000000000000..d55819e0d5e9f
--- /dev/null
+++ b/tests/run-make/msvc-wholearchive/dll.def
@@ -0,0 +1,4 @@
+LIBRARY dll
+EXPORTS
+        hello
+        number
diff --git a/tests/run-make/msvc-wholearchive/rmake.rs b/tests/run-make/msvc-wholearchive/rmake.rs
new file mode 100644
index 0000000000000..98586fd8cc8bd
--- /dev/null
+++ b/tests/run-make/msvc-wholearchive/rmake.rs
@@ -0,0 +1,52 @@
+//! This is a regression test for #129020
+//! It ensures we can use `/WHOLEARCHIVE` to link a rust staticlib into DLL
+//! using the MSVC linker
+
+//@ only-msvc
+// Reason: this is testing the MSVC linker
+
+use std::path::PathBuf;
+
+use run_make_support::{cc, cmd, env_var, extra_c_flags, rustc};
+
+fn main() {
+    // Build the staticlib
+    rustc().crate_type("staticlib").input("static.rs").output("static.lib").run();
+    // Build an empty object to pass to the linker.
+    cc().input("c.c").output("c.obj").args(["-c"]).run();
+
+    // Find the C toolchain's linker.
+    let mut linker = PathBuf::from(env_var("CC"));
+    let linker_flavour = if linker.file_stem().is_some_and(|s| s == "cl") {
+        linker.set_file_name("link.exe");
+        "msvc"
+    } else if linker.file_stem().is_some_and(|s| s == "clang-cl") {
+        linker.set_file_name("lld-link.exe");
+        "llvm"
+    } else {
+        panic!("unknown C toolchain");
+    };
+
+    // As a sanity check, make sure this works without /WHOLEARCHIVE.
+    // Otherwise the actual test failure may be caused by something else.
+    cmd(&linker)
+        .args(["c.obj", "./static.lib", "-dll", "-def:dll.def", "-out:dll.dll"])
+        .args(extra_c_flags())
+        .run();
+
+    // FIXME(@ChrisDenton): this doesn't currently work with llvm's lld-link for other reasons.
+    // May need LLVM patches.
+    if linker_flavour == "msvc" {
+        // Link in the staticlib using `/WHOLEARCHIVE` and produce a DLL.
+        cmd(&linker)
+            .args([
+                "c.obj",
+                "-WHOLEARCHIVE:./static.lib",
+                "-dll",
+                "-def:dll.def",
+                "-out:dll_whole_archive.dll",
+            ])
+            .args(extra_c_flags())
+            .run();
+    }
+}
diff --git a/tests/run-make/msvc-wholearchive/static.rs b/tests/run-make/msvc-wholearchive/static.rs
new file mode 100644
index 0000000000000..881c88565737a
--- /dev/null
+++ b/tests/run-make/msvc-wholearchive/static.rs
@@ -0,0 +1,9 @@
+#[no_mangle]
+pub extern "C" fn hello() {
+    println!("Hello world!");
+}
+
+#[no_mangle]
+pub extern "C" fn number() -> u32 {
+    42
+}

From dbad7581348d71822573e906c165bd08c366f196 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Eduardo=20S=C3=A1nchez=20Mu=C3=B1oz?= <eduardosm-dev@e64.io>
Date: Mon, 19 Aug 2024 20:31:48 +0200
Subject: [PATCH 443/685] Stabilize feature `char_indices_offset`

---
 library/core/src/lib.rs      |  1 -
 library/core/src/str/iter.rs | 15 +++++++++++++--
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index e3640627c562a..bbfe412fbcf1b 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -110,7 +110,6 @@
 #![cfg_attr(bootstrap, feature(offset_of_nested))]
 #![feature(array_ptr_get)]
 #![feature(asm_experimental_arch)]
-#![feature(char_indices_offset)]
 #![feature(const_align_of_val)]
 #![feature(const_align_of_val_raw)]
 #![feature(const_align_offset)]
diff --git a/library/core/src/str/iter.rs b/library/core/src/str/iter.rs
index 06f796f9f3ad8..681ec79c0b7bf 100644
--- a/library/core/src/str/iter.rs
+++ b/library/core/src/str/iter.rs
@@ -241,24 +241,35 @@ impl<'a> CharIndices<'a> {
     /// Returns the byte position of the next character, or the length
     /// of the underlying string if there are no more characters.
     ///
+    /// This means that, when the iterator has not been fully consumed,
+    /// the returned value will match the index that will be returned
+    /// by the next call to [`next()`](Self::next).
+    ///
     /// # Examples
     ///
     /// ```
-    /// #![feature(char_indices_offset)]
     /// let mut chars = "a楽".char_indices();
     ///
+    /// // `next()` has not been called yet, so `offset()` returns the byte
+    /// // index of the first character of the string, which is always 0.
     /// assert_eq!(chars.offset(), 0);
+    /// // As expected, the first call to `next()` also returns 0 as index.
     /// assert_eq!(chars.next(), Some((0, 'a')));
     ///
+    /// // `next()` has been called once, so `offset()` returns the byte index
+    /// // of the second character ...
     /// assert_eq!(chars.offset(), 1);
+    /// // ... which matches the index returned by the next call to `next()`.
     /// assert_eq!(chars.next(), Some((1, '楽')));
     ///
+    /// // Once the iterator has been consumed, `offset()` returns the length
+    /// // in bytes of the string.
     /// assert_eq!(chars.offset(), 4);
     /// assert_eq!(chars.next(), None);
     /// ```
     #[inline]
     #[must_use]
-    #[unstable(feature = "char_indices_offset", issue = "83871")]
+    #[stable(feature = "char_indices_offset", since = "CURRENT_RUSTC_VERSION")]
     pub fn offset(&self) -> usize {
         self.front_offset
     }

From 25964b541e5671de044fd01d058a45bb92b75d1e Mon Sep 17 00:00:00 2001
From: Nadrieril <nadrieril+git@gmail.com>
Date: Mon, 19 Aug 2024 20:51:21 +0200
Subject: [PATCH 444/685] Reword the "unreachable pattern" explanations

---
 compiler/rustc_mir_build/messages.ftl         |   8 +-
 tests/ui/consts/packed_pattern.stderr         |   4 +-
 tests/ui/consts/packed_pattern2.stderr        |   4 +-
 tests/ui/error-codes/E0001.stderr             |   4 +-
 tests/ui/lint/issue-30302.stderr              |   2 +-
 .../exhaustiveness-unreachable-pattern.stderr | 136 +++++++++---------
 tests/ui/pattern/issue-14221.stderr           |   2 +-
 .../pattern/usefulness/consts-opaque.stderr   |  24 ++--
 ...tch-check-notes.exhaustive_patterns.stderr |   8 +-
 .../empty-match-check-notes.normal.stderr     |   8 +-
 .../empty-types.exhaustive_patterns.stderr    |  86 +++++------
 .../usefulness/empty-types.never_pats.stderr  |  86 +++++------
 .../usefulness/empty-types.normal.stderr      |  86 +++++------
 .../usefulness/explain-unreachable-pats.rs    |  30 ++--
 .../explain-unreachable-pats.stderr           |  30 ++--
 tests/ui/pattern/usefulness/floats.stderr     |  56 ++++----
 tests/ui/pattern/usefulness/impl-trait.stderr |  32 ++---
 .../integer-ranges/reachability.stderr        |  98 ++++++-------
 .../ui/pattern/usefulness/issue-12116.stderr  |   4 +-
 .../ui/pattern/usefulness/issue-12369.stderr  |   4 +-
 .../ui/pattern/usefulness/issue-13727.stderr  |   4 +-
 .../pattern/usefulness/issue-30240-b.stderr   |   4 +-
 .../ui/pattern/usefulness/issue-31221.stderr  |   8 +-
 .../ui/pattern/usefulness/issue-57472.stderr  |   8 +-
 .../usefulness/match-arm-statics.stderr       |  12 +-
 .../match-byte-array-patterns.stderr          |  32 ++---
 .../pattern/usefulness/match-ref-ice.stderr   |   4 +-
 .../pattern/usefulness/match-vec-fixed.stderr |   8 +-
 .../usefulness/match-vec-unreachable.stderr   |  12 +-
 .../usefulness/slice-pattern-const-2.stderr   |  16 +--
 .../usefulness/slice-pattern-const-3.stderr   |  16 +--
 .../usefulness/slice-pattern-const.stderr     |  36 ++---
 .../slice-patterns-reachability.stderr        |  24 ++--
 .../struct-pattern-match-useless.stderr       |   2 +-
 .../usefulness/top-level-alternation.stderr   |  44 +++---
 tests/ui/reachable/unreachable-arm.stderr     |   4 +-
 .../unreachable-loop-patterns.stderr          |   2 +-
 .../reachable/unreachable-try-pattern.stderr  |   4 +-
 .../unreachable.stderr                        |  12 +-
 .../enum_same_crate_empty_match.stderr        |   2 +-
 .../issue-65157-repeated-match-arm.stderr     |   4 +-
 .../uninhabited/patterns_same_crate.stderr    |  10 +-
 .../rfcs/rfc-2294-if-let-guard/warns.stderr   |   4 +-
 .../uninhabited/uninhabited-patterns.stderr   |   6 +-
 44 files changed, 495 insertions(+), 495 deletions(-)

diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index 7baf0256dd890..ae13485ce739b 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -330,11 +330,11 @@ mir_build_unreachable_making_this_unreachable = collectively making this unreach
 mir_build_unreachable_matches_same_values = matches some of the same values
 
 mir_build_unreachable_pattern = unreachable pattern
-    .label = unreachable pattern
-    .unreachable_matches_no_values = this pattern matches no values because `{$ty}` is uninhabited
+    .label = no value can reach this
+    .unreachable_matches_no_values = matches no values because `{$ty}` is uninhabited
     .unreachable_covered_by_catchall = matches any value
-    .unreachable_covered_by_one = matches all the values already
-    .unreachable_covered_by_many = these patterns collectively make the last one unreachable
+    .unreachable_covered_by_one = matches all the relevant values
+    .unreachable_covered_by_many = multiple earlier patterns match some of the same values
 
 mir_build_unsafe_fn_safe_body = an unsafe function restricts its caller, but its body is safe by default
 mir_build_unsafe_not_inherited = items do not inherit unsafety from separate enclosing items
diff --git a/tests/ui/consts/packed_pattern.stderr b/tests/ui/consts/packed_pattern.stderr
index a0b434b2d78ee..dc26078fb63ec 100644
--- a/tests/ui/consts/packed_pattern.stderr
+++ b/tests/ui/consts/packed_pattern.stderr
@@ -2,9 +2,9 @@ warning: unreachable pattern
   --> $DIR/packed_pattern.rs:16:9
    |
 LL |         Foo { field: (5, 6, 7, 8) } => {},
-   |         --------------------------- matches all the values already
+   |         --------------------------- matches all the relevant values
 LL |         FOO => unreachable!(),
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
    |
    = note: `#[warn(unreachable_patterns)]` on by default
 
diff --git a/tests/ui/consts/packed_pattern2.stderr b/tests/ui/consts/packed_pattern2.stderr
index 4785f4d029721..013f61f733c9e 100644
--- a/tests/ui/consts/packed_pattern2.stderr
+++ b/tests/ui/consts/packed_pattern2.stderr
@@ -2,9 +2,9 @@ warning: unreachable pattern
   --> $DIR/packed_pattern2.rs:24:9
    |
 LL |         Bar { a: Foo { field: (5, 6) } } => {},
-   |         -------------------------------- matches all the values already
+   |         -------------------------------- matches all the relevant values
 LL |         FOO => unreachable!(),
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
    |
    = note: `#[warn(unreachable_patterns)]` on by default
 
diff --git a/tests/ui/error-codes/E0001.stderr b/tests/ui/error-codes/E0001.stderr
index 40008230ec801..30d0df960f329 100644
--- a/tests/ui/error-codes/E0001.stderr
+++ b/tests/ui/error-codes/E0001.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/E0001.rs:8:9
    |
 LL |         _ => {/* ... */}
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/E0001.rs:8:9
    |
 LL |         Some(_) => {/* ... */}
diff --git a/tests/ui/lint/issue-30302.stderr b/tests/ui/lint/issue-30302.stderr
index baf6c0d7a59d8..317fefee466e9 100644
--- a/tests/ui/lint/issue-30302.stderr
+++ b/tests/ui/lint/issue-30302.stderr
@@ -13,7 +13,7 @@ LL |         Nil => true,
    |         --- matches any value
 LL |
 LL |         _ => false
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/issue-30302.rs:4:9
diff --git a/tests/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr b/tests/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr
index 5570390b21c28..6ddc059566539 100644
--- a/tests/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr
+++ b/tests/ui/or-patterns/exhaustiveness-unreachable-pattern.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:8:9
    |
 LL |         (1 | 2,) => {}
-   |         -------- matches all the values already
+   |         -------- matches all the relevant values
 LL |         (1,) => {}
-   |         ^^^^ unreachable pattern
+   |         ^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/exhaustiveness-unreachable-pattern.rs:1:9
@@ -16,17 +16,17 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:13:9
    |
 LL |         (1 | 2,) => {}
-   |         -------- matches all the values already
+   |         -------- matches all the relevant values
 LL |         (2,) => {}
-   |         ^^^^ unreachable pattern
+   |         ^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:19:9
    |
 LL |         (1 | 2,) => {}
-   |         ^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/exhaustiveness-unreachable-pattern.rs:19:9
    |
 LL |         (1,) => {}
@@ -40,44 +40,44 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:24:9
    |
 LL |         (1 | 2, 3 | 4) => {}
-   |         -------------- matches all the values already
+   |         -------------- matches all the relevant values
 LL |         (1, 3) => {}
-   |         ^^^^^^ unreachable pattern
+   |         ^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:25:9
    |
 LL |         (1 | 2, 3 | 4) => {}
-   |         -------------- matches all the values already
+   |         -------------- matches all the relevant values
 LL |         (1, 3) => {}
 LL |         (1, 4) => {}
-   |         ^^^^^^ unreachable pattern
+   |         ^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:26:9
    |
 LL |         (1 | 2, 3 | 4) => {}
-   |         -------------- matches all the values already
+   |         -------------- matches all the relevant values
 ...
 LL |         (2, 4) => {}
-   |         ^^^^^^ unreachable pattern
+   |         ^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:27:9
    |
 LL |         (1 | 2, 3 | 4) => {}
-   |         -------------- matches all the values already
+   |         -------------- matches all the relevant values
 ...
 LL |         (2 | 1, 4) => {}
-   |         ^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:29:9
    |
 LL |         (1, 4 | 5) => {}
-   |         ^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/exhaustiveness-unreachable-pattern.rs:29:9
    |
 LL |         (1 | 2, 3 | 4) => {}
@@ -92,107 +92,107 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:34:13
    |
 LL |         (0, 0, 0) => {}
-   |             - matches all the values already
+   |             - matches all the relevant values
 LL |         (0, 0 | 1, 0) => {}
-   |             ^ unreachable pattern
+   |             ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:42:9
    |
 LL |         (None | Some(1 | 2),) => {}
-   |         --------------------- matches all the values already
+   |         --------------------- matches all the relevant values
 LL |         (Some(1),) => {}
-   |         ^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:43:9
    |
 LL |         (None | Some(1 | 2),) => {}
-   |         --------------------- matches all the values already
+   |         --------------------- matches all the relevant values
 LL |         (Some(1),) => {}
 LL |         (None,) => {}
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:48:9
    |
 LL |         ((1 | 2,) | (3 | 4,),) => {}
-   |         ---------------------- matches all the values already
+   |         ---------------------- matches all the relevant values
 LL |         ((1..=4,),) => {}
-   |         ^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:53:14
    |
 LL |         (1 | 1,) => {}
-   |          -   ^ unreachable pattern
+   |          -   ^ no value can reach this
    |          |
-   |          matches all the values already
+   |          matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:57:19
    |
 LL |         (0 | 1) | 1 => {}
-   |              -    ^ unreachable pattern
+   |              -    ^ no value can reach this
    |              |
-   |              matches all the values already
+   |              matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:63:14
    |
 LL |         0 | (0 | 0) => {}
-   |         -    ^ unreachable pattern
+   |         -    ^ no value can reach this
    |         |
-   |         matches all the values already
+   |         matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:63:18
    |
 LL |         0 | (0 | 0) => {}
-   |         -        ^ unreachable pattern
+   |         -        ^ no value can reach this
    |         |
-   |         matches all the values already
+   |         matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:71:13
    |
 LL |           Some(0) |
-   |           ------- matches all the values already
+   |           ------- matches all the relevant values
 LL | /             Some(
 LL | |                 0 | 0) => {}
-   | |______________________^ unreachable pattern
+   | |______________________^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:77:15
    |
 LL |         [0
-   |          - matches all the values already
+   |          - matches all the relevant values
 LL |             | 0
-   |               ^ unreachable pattern
+   |               ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:79:15
    |
 LL |         , 0
-   |           - matches all the values already
+   |           - matches all the relevant values
 LL |             | 0] => {}
-   |               ^ unreachable pattern
+   |               ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:83:20
    |
 LL |         (true, 0 | 0) => {}
-   |                -   ^ unreachable pattern
+   |                -   ^ no value can reach this
    |                |
-   |                matches all the values already
+   |                matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:84:17
    |
 LL |         (_, 0 | 0) => {}
-   |                 ^ unreachable pattern
+   |                 ^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/exhaustiveness-unreachable-pattern.rs:84:17
    |
 LL |         (true, 0 | 0) => {}
@@ -206,25 +206,25 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:92:10
    |
 LL |         [1, ..] => {}
-   |          - matches all the values already
+   |          - matches all the relevant values
 LL |         [1
-   |          ^ unreachable pattern
+   |          ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:104:10
    |
 LL |         [true, ..] => {}
-   |          ---- matches all the values already
+   |          ---- matches all the relevant values
 LL |         [true
-   |          ^^^^ unreachable pattern
+   |          ^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:111:36
    |
 LL |         (true | false, None | Some(true
-   |                                    ^^^^ unreachable pattern
+   |                                    ^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/exhaustiveness-unreachable-pattern.rs:111:36
    |
 LL |         (true, Some(_)) => {}
@@ -238,12 +238,12 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:116:14
    |
 LL |             (true
-   |              ^^^^ unreachable pattern
+   |              ^^^^ no value can reach this
 ...
 LL |         (true | false, None | Some(t_or_f!())) => {}
    |                                    --------- in this macro invocation
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/exhaustiveness-unreachable-pattern.rs:116:14
    |
 LL |             (true
@@ -261,26 +261,26 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:127:14
    |
 LL |         Some(0) => {}
-   |              - matches all the values already
+   |              - matches all the relevant values
 LL |         Some(0
-   |              ^ unreachable pattern
+   |              ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:146:19
    |
 LL |         Some(false) => {}
-   |              ----- matches all the values already
+   |              ----- matches all the relevant values
 LL |         None | Some(true
 LL |                 | false) => {}
-   |                   ^^^^^ unreachable pattern
+   |                   ^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:154:15
    |
 LL |             | true) => {}
-   |               ^^^^ unreachable pattern
+   |               ^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/exhaustiveness-unreachable-pattern.rs:154:15
    |
 LL |         (false, true) => {}
@@ -295,9 +295,9 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:160:15
    |
 LL |             | true,
-   |               ^^^^ unreachable pattern
+   |               ^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/exhaustiveness-unreachable-pattern.rs:160:15
    |
 LL |         (true, false) => {}
@@ -314,13 +314,13 @@ error: unreachable pattern
 LL |         (x, y)
    |         ------ matches any value
 LL |             | (y, x) => {}
-   |               ^^^^^^ unreachable pattern
+   |               ^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:169:30
    |
 LL | fn unreachable_in_param((_ | (_, _)): (bool, bool)) {}
-   |                          -   ^^^^^^ unreachable pattern
+   |                          -   ^^^^^^ no value can reach this
    |                          |
    |                          matches any value
 
@@ -328,7 +328,7 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:176:14
    |
 LL |     let (_ | (_, _)) = bool_pair;
-   |          -   ^^^^^^ unreachable pattern
+   |          -   ^^^^^^ no value can reach this
    |          |
    |          matches any value
 
@@ -336,7 +336,7 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:178:14
    |
 LL |     for (_ | (_, _)) in [bool_pair] {}
-   |          -   ^^^^^^ unreachable pattern
+   |          -   ^^^^^^ no value can reach this
    |          |
    |          matches any value
 
@@ -344,25 +344,25 @@ error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:181:20
    |
 LL |     let (Some(_) | Some(true)) = bool_option else { return };
-   |          -------   ^^^^^^^^^^ unreachable pattern
+   |          -------   ^^^^^^^^^^ no value can reach this
    |          |
-   |          matches all the values already
+   |          matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:183:22
    |
 LL |     if let Some(_) | Some(true) = bool_option {}
-   |            -------   ^^^^^^^^^^ unreachable pattern
+   |            -------   ^^^^^^^^^^ no value can reach this
    |            |
-   |            matches all the values already
+   |            matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/exhaustiveness-unreachable-pattern.rs:185:25
    |
 LL |     while let Some(_) | Some(true) = bool_option {}
-   |               -------   ^^^^^^^^^^ unreachable pattern
+   |               -------   ^^^^^^^^^^ no value can reach this
    |               |
-   |               matches all the values already
+   |               matches all the relevant values
 
 error: aborting due to 36 previous errors
 
diff --git a/tests/ui/pattern/issue-14221.stderr b/tests/ui/pattern/issue-14221.stderr
index 7ea51b5f804c0..44b2923d60688 100644
--- a/tests/ui/pattern/issue-14221.stderr
+++ b/tests/ui/pattern/issue-14221.stderr
@@ -19,7 +19,7 @@ LL |             A => "A",
    |             - matches any value
 LL |
 LL |             B => "B",
-   |             ^ unreachable pattern
+   |             ^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/issue-14221.rs:1:9
diff --git a/tests/ui/pattern/usefulness/consts-opaque.stderr b/tests/ui/pattern/usefulness/consts-opaque.stderr
index 9d3a35321caf0..32d385eecb476 100644
--- a/tests/ui/pattern/usefulness/consts-opaque.stderr
+++ b/tests/ui/pattern/usefulness/consts-opaque.stderr
@@ -52,7 +52,7 @@ error: unreachable pattern
 LL |         Bar => {}
    |         --- matches any value
 LL |         BAR => {}
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/consts-opaque.rs:6:9
@@ -67,7 +67,7 @@ LL |         Bar => {}
    |         --- matches any value
 ...
 LL |         _ => {}
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/consts-opaque.rs:56:9
@@ -75,7 +75,7 @@ error: unreachable pattern
 LL |         BAR => {}
    |         --- matches any value
 LL |         Bar => {}
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/consts-opaque.rs:58:9
@@ -84,7 +84,7 @@ LL |         BAR => {}
    |         --- matches any value
 ...
 LL |         _ => {}
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/consts-opaque.rs:64:9
@@ -92,7 +92,7 @@ error: unreachable pattern
 LL |         BAR => {}
    |         --- matches any value
 LL |         BAR => {} // should not be emitting unreachable warning
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/consts-opaque.rs:66:9
@@ -101,31 +101,31 @@ LL |         BAR => {}
    |         --- matches any value
 ...
 LL |         _ => {} // should not be emitting unreachable warning
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/consts-opaque.rs:72:9
    |
 LL |         BAZ => {}
-   |         --- matches all the values already
+   |         --- matches all the relevant values
 LL |         Baz::Baz1 => {} // should not be emitting unreachable warning
-   |         ^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/consts-opaque.rs:79:9
    |
 LL |         Baz::Baz1 => {}
-   |         --------- matches all the values already
+   |         --------- matches all the relevant values
 LL |         BAZ => {}
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/consts-opaque.rs:87:9
    |
 LL |         _ => {} // should not be emitting unreachable warning
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/consts-opaque.rs:87:9
    |
 LL |         BAZ => {}
diff --git a/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr
index 1b65ff7aa5751..4cfa6182752ca 100644
--- a/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr
+++ b/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `EmptyEnum` is uninhabited
+   = note: matches no values because `EmptyEnum` is uninhabited
 note: the lint level is defined here
   --> $DIR/empty-match-check-notes.rs:7:9
    |
@@ -17,7 +17,7 @@ error: unreachable pattern
 LL |         _ if false => {}
    |         ^
    |
-   = note: this pattern matches no values because `EmptyEnum` is uninhabited
+   = note: matches no values because `EmptyEnum` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:29:9
@@ -25,7 +25,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `EmptyForeignEnum` is uninhabited
+   = note: matches no values because `EmptyForeignEnum` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:33:9
@@ -33,7 +33,7 @@ error: unreachable pattern
 LL |         _ if false => {}
    |         ^
    |
-   = note: this pattern matches no values because `EmptyForeignEnum` is uninhabited
+   = note: matches no values because `EmptyForeignEnum` is uninhabited
 
 error[E0005]: refutable pattern in local binding
   --> $DIR/empty-match-check-notes.rs:39:9
diff --git a/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr b/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr
index 1b65ff7aa5751..4cfa6182752ca 100644
--- a/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr
+++ b/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `EmptyEnum` is uninhabited
+   = note: matches no values because `EmptyEnum` is uninhabited
 note: the lint level is defined here
   --> $DIR/empty-match-check-notes.rs:7:9
    |
@@ -17,7 +17,7 @@ error: unreachable pattern
 LL |         _ if false => {}
    |         ^
    |
-   = note: this pattern matches no values because `EmptyEnum` is uninhabited
+   = note: matches no values because `EmptyEnum` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:29:9
@@ -25,7 +25,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `EmptyForeignEnum` is uninhabited
+   = note: matches no values because `EmptyForeignEnum` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:33:9
@@ -33,7 +33,7 @@ error: unreachable pattern
 LL |         _ if false => {}
    |         ^
    |
-   = note: this pattern matches no values because `EmptyForeignEnum` is uninhabited
+   = note: matches no values because `EmptyForeignEnum` is uninhabited
 
 error[E0005]: refutable pattern in local binding
   --> $DIR/empty-match-check-notes.rs:39:9
diff --git a/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
index f6f341d6f2f1e..74cf75f3b4026 100644
--- a/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 note: the lint level is defined here
   --> $DIR/empty-types.rs:15:9
    |
@@ -17,7 +17,7 @@ error: unreachable pattern
 LL |         _x => {}
    |         ^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
   --> $DIR/empty-types.rs:56:11
@@ -40,7 +40,7 @@ error: unreachable pattern
 LL |         (_, _) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `(u32, !)` is uninhabited
+   = note: matches no values because `(u32, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:76:9
@@ -48,7 +48,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `(!, !)` is uninhabited
+   = note: matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:79:9
@@ -56,7 +56,7 @@ error: unreachable pattern
 LL |         (_, _) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `(!, !)` is uninhabited
+   = note: matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:83:9
@@ -64,7 +64,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
   --> $DIR/empty-types.rs:87:11
@@ -91,7 +91,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:99:9
@@ -99,7 +99,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
   --> $DIR/empty-types.rs:96:11
@@ -139,7 +139,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:115:9
@@ -147,7 +147,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:118:9
@@ -155,7 +155,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:119:9
@@ -163,7 +163,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:122:9
@@ -171,7 +171,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:123:9
@@ -179,7 +179,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:132:13
@@ -187,7 +187,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:135:13
@@ -195,7 +195,7 @@ error: unreachable pattern
 LL |             _ if false => {}
    |             ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:143:13
@@ -203,15 +203,15 @@ error: unreachable pattern
 LL |             Some(_) => {}
    |             ^^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:147:13
    |
 LL |             None => {}
-   |             ---- matches all the values already
+   |             ---- matches all the relevant values
 LL |             _ => {}
-   |             ^ unreachable pattern
+   |             ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:199:13
@@ -219,7 +219,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:204:13
@@ -227,7 +227,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:209:13
@@ -235,7 +235,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:214:13
@@ -243,7 +243,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:220:13
@@ -251,7 +251,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:281:9
@@ -259,7 +259,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:284:9
@@ -267,7 +267,7 @@ error: unreachable pattern
 LL |         (_, _) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `(!, !)` is uninhabited
+   = note: matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:287:9
@@ -275,7 +275,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:288:9
@@ -283,7 +283,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
   --> $DIR/empty-types.rs:327:11
@@ -346,7 +346,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `[!; 3]` is uninhabited
+   = note: matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:371:9
@@ -354,7 +354,7 @@ error: unreachable pattern
 LL |         [_, _, _] => {}
    |         ^^^^^^^^^
    |
-   = note: this pattern matches no values because `[!; 3]` is uninhabited
+   = note: matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:374:9
@@ -362,7 +362,7 @@ error: unreachable pattern
 LL |         [_, ..] => {}
    |         ^^^^^^^
    |
-   = note: this pattern matches no values because `[!; 3]` is uninhabited
+   = note: matches no values because `[!; 3]` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
   --> $DIR/empty-types.rs:388:11
@@ -382,9 +382,9 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:395:9
    |
 LL |         [] => {}
-   |         -- matches all the values already
+   |         -- matches all the relevant values
 LL |         _ => {}
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error[E0004]: non-exhaustive patterns: `[]` not covered
   --> $DIR/empty-types.rs:397:11
@@ -406,7 +406,7 @@ error: unreachable pattern
 LL |         Some(_) => {}
    |         ^^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:421:9
@@ -414,25 +414,25 @@ error: unreachable pattern
 LL |         Some(_a) => {}
    |         ^^^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:426:9
    |
 LL |         None => {}
-   |         ---- matches all the values already
+   |         ---- matches all the relevant values
 LL |         // !useful, !reachable
 LL |         _ => {}
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:431:9
    |
 LL |         None => {}
-   |         ---- matches all the values already
+   |         ---- matches all the relevant values
 LL |         // !useful, !reachable
 LL |         _a => {}
-   |         ^^ unreachable pattern
+   |         ^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:603:9
@@ -440,7 +440,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:606:9
@@ -448,7 +448,7 @@ error: unreachable pattern
 LL |         _x => {}
    |         ^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:609:9
@@ -456,7 +456,7 @@ error: unreachable pattern
 LL |         _ if false => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:612:9
@@ -464,7 +464,7 @@ error: unreachable pattern
 LL |         _x if false => {}
    |         ^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: aborting due to 49 previous errors
 
diff --git a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
index 55a138c2d1cb2..e1a8458e5f8c8 100644
--- a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
@@ -13,7 +13,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 note: the lint level is defined here
   --> $DIR/empty-types.rs:15:9
    |
@@ -26,7 +26,7 @@ error: unreachable pattern
 LL |         _x => {}
    |         ^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
   --> $DIR/empty-types.rs:56:11
@@ -49,7 +49,7 @@ error: unreachable pattern
 LL |         (_, _) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `(u32, !)` is uninhabited
+   = note: matches no values because `(u32, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:76:9
@@ -57,7 +57,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `(!, !)` is uninhabited
+   = note: matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:79:9
@@ -65,7 +65,7 @@ error: unreachable pattern
 LL |         (_, _) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `(!, !)` is uninhabited
+   = note: matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:83:9
@@ -73,7 +73,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
   --> $DIR/empty-types.rs:87:11
@@ -100,7 +100,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:99:9
@@ -108,7 +108,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
   --> $DIR/empty-types.rs:96:11
@@ -162,7 +162,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:115:9
@@ -170,7 +170,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:118:9
@@ -178,7 +178,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:119:9
@@ -186,7 +186,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:122:9
@@ -194,7 +194,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:123:9
@@ -202,7 +202,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:132:13
@@ -210,7 +210,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:135:13
@@ -218,7 +218,7 @@ error: unreachable pattern
 LL |             _ if false => {}
    |             ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:143:13
@@ -226,15 +226,15 @@ error: unreachable pattern
 LL |             Some(_) => {}
    |             ^^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:147:13
    |
 LL |             None => {}
-   |             ---- matches all the values already
+   |             ---- matches all the relevant values
 LL |             _ => {}
-   |             ^ unreachable pattern
+   |             ^ no value can reach this
 
 error[E0004]: non-exhaustive patterns: `Some(!)` not covered
   --> $DIR/empty-types.rs:156:15
@@ -261,7 +261,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:204:13
@@ -269,7 +269,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:209:13
@@ -277,7 +277,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:214:13
@@ -285,7 +285,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:220:13
@@ -293,7 +293,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:281:9
@@ -301,7 +301,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:284:9
@@ -309,7 +309,7 @@ error: unreachable pattern
 LL |         (_, _) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `(!, !)` is uninhabited
+   = note: matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:287:9
@@ -317,7 +317,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:288:9
@@ -325,7 +325,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error[E0005]: refutable pattern in local binding
   --> $DIR/empty-types.rs:297:13
@@ -480,7 +480,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `[!; 3]` is uninhabited
+   = note: matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:371:9
@@ -488,7 +488,7 @@ error: unreachable pattern
 LL |         [_, _, _] => {}
    |         ^^^^^^^^^
    |
-   = note: this pattern matches no values because `[!; 3]` is uninhabited
+   = note: matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:374:9
@@ -496,7 +496,7 @@ error: unreachable pattern
 LL |         [_, ..] => {}
    |         ^^^^^^^
    |
-   = note: this pattern matches no values because `[!; 3]` is uninhabited
+   = note: matches no values because `[!; 3]` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
   --> $DIR/empty-types.rs:388:11
@@ -516,9 +516,9 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:395:9
    |
 LL |         [] => {}
-   |         -- matches all the values already
+   |         -- matches all the relevant values
 LL |         _ => {}
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error[E0004]: non-exhaustive patterns: `[]` not covered
   --> $DIR/empty-types.rs:397:11
@@ -540,7 +540,7 @@ error: unreachable pattern
 LL |         Some(_) => {}
    |         ^^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:421:9
@@ -548,25 +548,25 @@ error: unreachable pattern
 LL |         Some(_a) => {}
    |         ^^^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:426:9
    |
 LL |         None => {}
-   |         ---- matches all the values already
+   |         ---- matches all the relevant values
 LL |         // !useful, !reachable
 LL |         _ => {}
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:431:9
    |
 LL |         None => {}
-   |         ---- matches all the values already
+   |         ---- matches all the relevant values
 LL |         // !useful, !reachable
 LL |         _a => {}
-   |         ^^ unreachable pattern
+   |         ^^ no value can reach this
 
 error[E0004]: non-exhaustive patterns: `&Some(!)` not covered
   --> $DIR/empty-types.rs:451:11
@@ -664,7 +664,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:606:9
@@ -672,7 +672,7 @@ error: unreachable pattern
 LL |         _x => {}
    |         ^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:609:9
@@ -680,7 +680,7 @@ error: unreachable pattern
 LL |         _ if false => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:612:9
@@ -688,7 +688,7 @@ error: unreachable pattern
 LL |         _x if false => {}
    |         ^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: `&!` not covered
   --> $DIR/empty-types.rs:637:11
diff --git a/tests/ui/pattern/usefulness/empty-types.normal.stderr b/tests/ui/pattern/usefulness/empty-types.normal.stderr
index 83b3989ffdefb..c9bd25d5f9dee 100644
--- a/tests/ui/pattern/usefulness/empty-types.normal.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.normal.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 note: the lint level is defined here
   --> $DIR/empty-types.rs:15:9
    |
@@ -17,7 +17,7 @@ error: unreachable pattern
 LL |         _x => {}
    |         ^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
   --> $DIR/empty-types.rs:56:11
@@ -40,7 +40,7 @@ error: unreachable pattern
 LL |         (_, _) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `(u32, !)` is uninhabited
+   = note: matches no values because `(u32, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:76:9
@@ -48,7 +48,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `(!, !)` is uninhabited
+   = note: matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:79:9
@@ -56,7 +56,7 @@ error: unreachable pattern
 LL |         (_, _) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `(!, !)` is uninhabited
+   = note: matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:83:9
@@ -64,7 +64,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
   --> $DIR/empty-types.rs:87:11
@@ -91,7 +91,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:99:9
@@ -99,7 +99,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
   --> $DIR/empty-types.rs:96:11
@@ -153,7 +153,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:115:9
@@ -161,7 +161,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:118:9
@@ -169,7 +169,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:119:9
@@ -177,7 +177,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:122:9
@@ -185,7 +185,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:123:9
@@ -193,7 +193,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:132:13
@@ -201,7 +201,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:135:13
@@ -209,7 +209,7 @@ error: unreachable pattern
 LL |             _ if false => {}
    |             ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:143:13
@@ -217,15 +217,15 @@ error: unreachable pattern
 LL |             Some(_) => {}
    |             ^^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:147:13
    |
 LL |             None => {}
-   |             ---- matches all the values already
+   |             ---- matches all the relevant values
 LL |             _ => {}
-   |             ^ unreachable pattern
+   |             ^ no value can reach this
 
 error[E0004]: non-exhaustive patterns: `Some(_)` not covered
   --> $DIR/empty-types.rs:156:15
@@ -252,7 +252,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:204:13
@@ -260,7 +260,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:209:13
@@ -268,7 +268,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:214:13
@@ -276,7 +276,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:220:13
@@ -284,7 +284,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:281:9
@@ -292,7 +292,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:284:9
@@ -300,7 +300,7 @@ error: unreachable pattern
 LL |         (_, _) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `(!, !)` is uninhabited
+   = note: matches no values because `(!, !)` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:287:9
@@ -308,7 +308,7 @@ error: unreachable pattern
 LL |         Ok(_) => {}
    |         ^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:288:9
@@ -316,7 +316,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `Result<!, !>` is uninhabited
+   = note: matches no values because `Result<!, !>` is uninhabited
 
 error[E0005]: refutable pattern in local binding
   --> $DIR/empty-types.rs:297:13
@@ -471,7 +471,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `[!; 3]` is uninhabited
+   = note: matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:371:9
@@ -479,7 +479,7 @@ error: unreachable pattern
 LL |         [_, _, _] => {}
    |         ^^^^^^^^^
    |
-   = note: this pattern matches no values because `[!; 3]` is uninhabited
+   = note: matches no values because `[!; 3]` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:374:9
@@ -487,7 +487,7 @@ error: unreachable pattern
 LL |         [_, ..] => {}
    |         ^^^^^^^
    |
-   = note: this pattern matches no values because `[!; 3]` is uninhabited
+   = note: matches no values because `[!; 3]` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
   --> $DIR/empty-types.rs:388:11
@@ -507,9 +507,9 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:395:9
    |
 LL |         [] => {}
-   |         -- matches all the values already
+   |         -- matches all the relevant values
 LL |         _ => {}
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error[E0004]: non-exhaustive patterns: `[]` not covered
   --> $DIR/empty-types.rs:397:11
@@ -531,7 +531,7 @@ error: unreachable pattern
 LL |         Some(_) => {}
    |         ^^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:421:9
@@ -539,25 +539,25 @@ error: unreachable pattern
 LL |         Some(_a) => {}
    |         ^^^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:426:9
    |
 LL |         None => {}
-   |         ---- matches all the values already
+   |         ---- matches all the relevant values
 LL |         // !useful, !reachable
 LL |         _ => {}
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:431:9
    |
 LL |         None => {}
-   |         ---- matches all the values already
+   |         ---- matches all the relevant values
 LL |         // !useful, !reachable
 LL |         _a => {}
-   |         ^^ unreachable pattern
+   |         ^^ no value can reach this
 
 error[E0004]: non-exhaustive patterns: `&Some(_)` not covered
   --> $DIR/empty-types.rs:451:11
@@ -655,7 +655,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:606:9
@@ -663,7 +663,7 @@ error: unreachable pattern
 LL |         _x => {}
    |         ^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:609:9
@@ -671,7 +671,7 @@ error: unreachable pattern
 LL |         _ if false => {}
    |         ^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:612:9
@@ -679,7 +679,7 @@ error: unreachable pattern
 LL |         _x if false => {}
    |         ^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error[E0004]: non-exhaustive patterns: `&_` not covered
   --> $DIR/empty-types.rs:637:11
diff --git a/tests/ui/pattern/usefulness/explain-unreachable-pats.rs b/tests/ui/pattern/usefulness/explain-unreachable-pats.rs
index 44d194055d9bd..bc4abd343ad4f 100644
--- a/tests/ui/pattern/usefulness/explain-unreachable-pats.rs
+++ b/tests/ui/pattern/usefulness/explain-unreachable-pats.rs
@@ -6,10 +6,10 @@
 fn main() {
     match (0u8,) {
         (1 | 2,) => {}
-        //~^ NOTE matches all the values already
+        //~^ NOTE matches all the relevant values
         (2,) => {}
         //~^ ERROR unreachable pattern
-        //~| NOTE unreachable pattern
+        //~| NOTE no value can reach this
         _ => {}
     }
 
@@ -20,8 +20,8 @@ fn main() {
         //~^ NOTE matches some of the same values
         (1 | 2,) => {}
         //~^ ERROR unreachable pattern
-        //~| NOTE unreachable pattern
-        //~| NOTE these patterns collectively make the last one unreachable
+        //~| NOTE no value can reach this
+        //~| NOTE multiple earlier patterns match some of the same values
         //~| NOTE collectively making this unreachable
         _ => {}
     }
@@ -31,7 +31,7 @@ fn main() {
         Ok(_) => {}
         Err(_) => {}
         //~^ ERROR unreachable pattern
-        //~| NOTE this pattern matches no values because `!` is uninhabited
+        //~| NOTE matches no values because `!` is uninhabited
     }
 
     #[derive(Copy, Clone)]
@@ -44,22 +44,22 @@ fn main() {
     match (&res1, res2) {
         (Err(_), Err(_)) => {}
         //~^ ERROR unreachable pattern
-        //~| NOTE this pattern matches no values because `Void2` is uninhabited
+        //~| NOTE matches no values because `Void2` is uninhabited
         _ => {}
     }
     match (res1, &res2) {
         (Err(_), Err(_)) => {}
         //~^ ERROR unreachable pattern
-        //~| NOTE this pattern matches no values because `Void1` is uninhabited
+        //~| NOTE matches no values because `Void1` is uninhabited
         _ => {}
     }
 
 
     if let (0
-        //~^ NOTE matches all the values already
+        //~^ NOTE matches all the relevant values
         | 0, _) = (0, 0) {}
         //~^ ERROR unreachable pattern
-        //~| NOTE unreachable pattern
+        //~| NOTE no value can reach this
 
     match (true, true) {
         (_, true) if false => {} // Guarded patterns don't cover others
@@ -69,20 +69,20 @@ fn main() {
         //~^ NOTE matches some of the same values
         (_, true) => {}
         //~^ ERROR unreachable pattern
-        //~| NOTE unreachable pattern
-        //~| NOTE these patterns collectively make the last one unreachable
+        //~| NOTE no value can reach this
+        //~| NOTE multiple earlier patterns match some of the same values
         //~| NOTE collectively making this unreachable
     }
 
     match (true, true) {
         (true, _) => {}
-        //~^ NOTE matches all the values already
+        //~^ NOTE matches all the relevant values
         (false, _) => {}
         #[allow(unreachable_patterns)]
         (_, true) => {} // Doesn't cover below because it's already unreachable.
         (true, true) => {}
         //~^ ERROR unreachable pattern
-        //~| NOTE unreachable pattern
+        //~| NOTE no value can reach this
     }
 
     // Despite skipping some irrelevant cases, we still report a set of rows that covers the
@@ -90,11 +90,11 @@ fn main() {
     match (true, true, 0) {
         (true, _, _) => {}
         (_, true, 0..10) => {}
-        //~^ NOTE matches all the values already
+        //~^ NOTE matches all the relevant values
         (_, true, 10..) => {}
         (_, true, 3) => {}
         //~^ ERROR unreachable pattern
-        //~| NOTE unreachable pattern
+        //~| NOTE no value can reach this
         _ => {}
     }
 }
diff --git a/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr b/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
index 105d4f73f660a..da9bf30aa58cb 100644
--- a/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
+++ b/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
@@ -2,10 +2,10 @@ error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:10:9
    |
 LL |         (1 | 2,) => {}
-   |         -------- matches all the values already
+   |         -------- matches all the relevant values
 LL |
 LL |         (2,) => {}
-   |         ^^^^ unreachable pattern
+   |         ^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/explain-unreachable-pats.rs:2:9
@@ -17,9 +17,9 @@ error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:21:9
    |
 LL |         (1 | 2,) => {}
-   |         ^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/explain-unreachable-pats.rs:21:9
    |
 LL |         (1,) => {}
@@ -37,7 +37,7 @@ error: unreachable pattern
 LL |         Err(_) => {}
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:45:9
@@ -45,7 +45,7 @@ error: unreachable pattern
 LL |         (Err(_), Err(_)) => {}
    |         ^^^^^^^^^^^^^^^^
    |
-   = note: this pattern matches no values because `Void2` is uninhabited
+   = note: matches no values because `Void2` is uninhabited
 
 error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:51:9
@@ -53,24 +53,24 @@ error: unreachable pattern
 LL |         (Err(_), Err(_)) => {}
    |         ^^^^^^^^^^^^^^^^
    |
-   = note: this pattern matches no values because `Void1` is uninhabited
+   = note: matches no values because `Void1` is uninhabited
 
 error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:60:11
    |
 LL |     if let (0
-   |             - matches all the values already
+   |             - matches all the relevant values
 LL |
 LL |         | 0, _) = (0, 0) {}
-   |           ^ unreachable pattern
+   |           ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:70:9
    |
 LL |         (_, true) => {}
-   |         ^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/explain-unreachable-pats.rs:70:9
    |
 LL |         (true, _) => {}
@@ -86,19 +86,19 @@ error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:83:9
    |
 LL |         (true, _) => {}
-   |         --------- matches all the values already
+   |         --------- matches all the relevant values
 ...
 LL |         (true, true) => {}
-   |         ^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:95:9
    |
 LL |         (_, true, 0..10) => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 ...
 LL |         (_, true, 3) => {}
-   |         ^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^ no value can reach this
 
 error: aborting due to 9 previous errors
 
diff --git a/tests/ui/pattern/usefulness/floats.stderr b/tests/ui/pattern/usefulness/floats.stderr
index d0a8841d6a83a..61aaa2c7626f5 100644
--- a/tests/ui/pattern/usefulness/floats.stderr
+++ b/tests/ui/pattern/usefulness/floats.stderr
@@ -15,9 +15,9 @@ error: unreachable pattern
   --> $DIR/floats.rs:18:9
    |
 LL |         0.01f16..=6.5f16 => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 LL |         0.01f16 => {}
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/floats.rs:1:9
@@ -29,117 +29,117 @@ error: unreachable pattern
   --> $DIR/floats.rs:19:9
    |
 LL |         0.01f16..=6.5f16 => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 LL |         0.01f16 => {}
 LL |         0.02f16 => {}
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:20:9
    |
 LL |         0.01f16..=6.5f16 => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 ...
 LL |         6.5f16 => {}
-   |         ^^^^^^ unreachable pattern
+   |         ^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:31:9
    |
 LL |         0.01f32..=6.5f32 => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 LL |         0.01f32 => {}
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:32:9
    |
 LL |         0.01f32..=6.5f32 => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 LL |         0.01f32 => {}
 LL |         0.02f32 => {}
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:33:9
    |
 LL |         0.01f32..=6.5f32 => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 ...
 LL |         6.5f32 => {}
-   |         ^^^^^^ unreachable pattern
+   |         ^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:45:9
    |
 LL |         0.01f64..=6.5f64 => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 LL |         0.005f64 => {}
 LL |         0.01f64 => {}
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:46:9
    |
 LL |         0.01f64..=6.5f64 => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 ...
 LL |         0.02f64 => {}
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:47:9
    |
 LL |         0.01f64..=6.5f64 => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 ...
 LL |         6.5f64 => {}
-   |         ^^^^^^ unreachable pattern
+   |         ^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:49:9
    |
 LL |         0.01f64..=6.5f64 => {}
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 ...
 LL |         1.0f64..=4.0f64 => {}
-   |         ^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:62:9
    |
 LL |         0.01f128..=6.5f128 => {}
-   |         ------------------ matches all the values already
+   |         ------------------ matches all the relevant values
 LL |         0.005f128 => {}
 LL |         0.01f128 => {}
-   |         ^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:63:9
    |
 LL |         0.01f128..=6.5f128 => {}
-   |         ------------------ matches all the values already
+   |         ------------------ matches all the relevant values
 ...
 LL |         0.02f128 => {}
-   |         ^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:64:9
    |
 LL |         0.01f128..=6.5f128 => {}
-   |         ------------------ matches all the values already
+   |         ------------------ matches all the relevant values
 ...
 LL |         6.5f128 => {}
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/floats.rs:66:9
    |
 LL |         0.01f128..=6.5f128 => {}
-   |         ------------------ matches all the values already
+   |         ------------------ matches all the relevant values
 ...
 LL |         1.0f128..=4.0f128 => {}
-   |         ^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^ no value can reach this
 
 error: aborting due to 15 previous errors
 
diff --git a/tests/ui/pattern/usefulness/impl-trait.stderr b/tests/ui/pattern/usefulness/impl-trait.stderr
index 92932e4853881..04d6671bb9a61 100644
--- a/tests/ui/pattern/usefulness/impl-trait.stderr
+++ b/tests/ui/pattern/usefulness/impl-trait.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 note: the lint level is defined here
   --> $DIR/impl-trait.rs:4:9
    |
@@ -17,7 +17,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:44:13
@@ -25,15 +25,15 @@ error: unreachable pattern
 LL |             Some(_) => {}
    |             ^^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:48:13
    |
 LL |             None => {}
-   |             ---- matches all the values already
+   |             ---- matches all the relevant values
 LL |             _ => {}
-   |             ^ unreachable pattern
+   |             ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:58:13
@@ -41,15 +41,15 @@ error: unreachable pattern
 LL |             Some(_) => {}
    |             ^^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:62:13
    |
 LL |             None => {}
-   |             ---- matches all the values already
+   |             ---- matches all the relevant values
 LL |             _ => {}
-   |             ^ unreachable pattern
+   |             ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:75:9
@@ -57,7 +57,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:85:9
@@ -65,7 +65,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         - matches any value
 LL |         Some((a, b)) => {}
-   |         ^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:93:13
@@ -73,15 +73,15 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:104:9
    |
 LL |         Some((a, b)) => {}
-   |         ------------ matches all the values already
+   |         ------------ matches all the relevant values
 LL |         Some((mut x, mut y)) => {
-   |         ^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:123:13
@@ -89,7 +89,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             - matches any value
 LL |             Rec { n: 0, w: Some(Rec { n: 0, w: _ }) } => {}
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:137:13
@@ -97,7 +97,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `SecretelyVoid` is uninhabited
+   = note: matches no values because `SecretelyVoid` is uninhabited
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:150:13
@@ -105,7 +105,7 @@ error: unreachable pattern
 LL |             _ => {}
    |             ^
    |
-   = note: this pattern matches no values because `SecretelyDoubleVoid` is uninhabited
+   = note: matches no values because `SecretelyDoubleVoid` is uninhabited
 
 error[E0004]: non-exhaustive patterns: type `impl Copy` is non-empty
   --> $DIR/impl-trait.rs:22:11
diff --git a/tests/ui/pattern/usefulness/integer-ranges/reachability.stderr b/tests/ui/pattern/usefulness/integer-ranges/reachability.stderr
index 5d86007a853ec..0d495bcbec152 100644
--- a/tests/ui/pattern/usefulness/integer-ranges/reachability.stderr
+++ b/tests/ui/pattern/usefulness/integer-ranges/reachability.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/reachability.rs:18:17
    |
 LL |     m!(0u8, 42, 42);
-   |             --  ^^ unreachable pattern
+   |             --  ^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
    |
 note: the lint level is defined here
   --> $DIR/reachability.rs:3:9
@@ -16,129 +16,129 @@ error: unreachable pattern
   --> $DIR/reachability.rs:22:22
    |
 LL |     m!(0u8, 20..=30, 20);
-   |             -------  ^^ unreachable pattern
+   |             -------  ^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:23:22
    |
 LL |     m!(0u8, 20..=30, 21);
-   |             -------  ^^ unreachable pattern
+   |             -------  ^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:24:22
    |
 LL |     m!(0u8, 20..=30, 25);
-   |             -------  ^^ unreachable pattern
+   |             -------  ^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:25:22
    |
 LL |     m!(0u8, 20..=30, 29);
-   |             -------  ^^ unreachable pattern
+   |             -------  ^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:26:22
    |
 LL |     m!(0u8, 20..=30, 30);
-   |             -------  ^^ unreachable pattern
+   |             -------  ^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:29:21
    |
 LL |     m!(0u8, 20..30, 20);
-   |             ------  ^^ unreachable pattern
+   |             ------  ^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:30:21
    |
 LL |     m!(0u8, 20..30, 21);
-   |             ------  ^^ unreachable pattern
+   |             ------  ^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:31:21
    |
 LL |     m!(0u8, 20..30, 25);
-   |             ------  ^^ unreachable pattern
+   |             ------  ^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:32:21
    |
 LL |     m!(0u8, 20..30, 29);
-   |             ------  ^^ unreachable pattern
+   |             ------  ^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:36:22
    |
 LL |     m!(0u8, 20..=30, 20..=30);
-   |             -------  ^^^^^^^ unreachable pattern
+   |             -------  ^^^^^^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:37:22
    |
 LL |     m!(0u8, 20.. 30, 20.. 30);
-   |             -------  ^^^^^^^ unreachable pattern
+   |             -------  ^^^^^^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:38:22
    |
 LL |     m!(0u8, 20..=30, 20.. 30);
-   |             -------  ^^^^^^^ unreachable pattern
+   |             -------  ^^^^^^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:40:22
    |
 LL |     m!(0u8, 20..=30, 21..=30);
-   |             -------  ^^^^^^^ unreachable pattern
+   |             -------  ^^^^^^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:41:22
    |
 LL |     m!(0u8, 20..=30, 20..=29);
-   |             -------  ^^^^^^^ unreachable pattern
+   |             -------  ^^^^^^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:43:24
    |
 LL |     m!('a', 'A'..='z', 'a'..='z');
-   |             ---------  ^^^^^^^^^ unreachable pattern
+   |             ---------  ^^^^^^^^^ no value can reach this
    |             |
-   |             matches all the values already
+   |             matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/reachability.rs:50:9
    |
 LL |         5..=8 => {},
-   |         ^^^^^ unreachable pattern
+   |         ^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/reachability.rs:50:9
    |
 LL |         5 => {},
@@ -156,9 +156,9 @@ error: unreachable pattern
   --> $DIR/reachability.rs:56:9
    |
 LL |         5..15 => {},
-   |         ^^^^^ unreachable pattern
+   |         ^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/reachability.rs:56:9
    |
 LL |         0..10 => {},
@@ -172,9 +172,9 @@ error: unreachable pattern
   --> $DIR/reachability.rs:63:9
    |
 LL |         5..25 => {},
-   |         ^^^^^ unreachable pattern
+   |         ^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/reachability.rs:63:9
    |
 LL |         0..10 => {},
@@ -190,9 +190,9 @@ error: unreachable pattern
   --> $DIR/reachability.rs:71:9
    |
 LL |         5..25 => {},
-   |         ^^^^^ unreachable pattern
+   |         ^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/reachability.rs:71:9
    |
 LL |         0..10 => {},
@@ -210,9 +210,9 @@ error: unreachable pattern
   --> $DIR/reachability.rs:77:9
    |
 LL |         5..15 => {},
-   |         ^^^^^ unreachable pattern
+   |         ^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/reachability.rs:77:9
    |
 LL |         0..10 => {},
@@ -228,15 +228,15 @@ error: unreachable pattern
 LL |         _ => {},
    |         - matches any value
 LL |         '\u{D7FF}'..='\u{E000}' => {},
-   |         ^^^^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/reachability.rs:89:9
    |
 LL |         '\u{D7FF}'..='\u{E000}' => {},
-   |         ^^^^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/reachability.rs:89:9
    |
 LL |         '\u{0}'..='\u{D7FF}' => {},
@@ -250,18 +250,18 @@ error: unreachable pattern
   --> $DIR/reachability.rs:105:9
    |
 LL |         &42 => {}
-   |         --- matches all the values already
+   |         --- matches all the relevant values
 LL |         &FOO => {}
-   |         ^^^^ unreachable pattern
+   |         ^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/reachability.rs:106:9
    |
 LL |         &42 => {}
-   |         --- matches all the values already
+   |         --- matches all the relevant values
 LL |         &FOO => {}
 LL |         BAR => {}
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
 
 error: aborting due to 25 previous errors
 
diff --git a/tests/ui/pattern/usefulness/issue-12116.stderr b/tests/ui/pattern/usefulness/issue-12116.stderr
index b2c2be97563c7..5929b81f6c25e 100644
--- a/tests/ui/pattern/usefulness/issue-12116.stderr
+++ b/tests/ui/pattern/usefulness/issue-12116.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/issue-12116.rs:15:9
    |
 LL |         &IntList::Cons(val, box ref next_list) => tail(next_list),
-   |         -------------------------------------- matches all the values already
+   |         -------------------------------------- matches all the relevant values
 LL |         &IntList::Cons(val, box IntList::Nil)  => IntList::Cons(val, Box::new(IntList::Nil)),
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/issue-12116.rs:4:9
diff --git a/tests/ui/pattern/usefulness/issue-12369.stderr b/tests/ui/pattern/usefulness/issue-12369.stderr
index 7754cbc24843f..fb6f89379f828 100644
--- a/tests/ui/pattern/usefulness/issue-12369.stderr
+++ b/tests/ui/pattern/usefulness/issue-12369.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/issue-12369.rs:9:9
    |
 LL |         &[10,a, ref rest @ ..] => 10
-   |         ^^^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/issue-12369.rs:9:9
    |
 LL |         &[a,b,c] => 3,
diff --git a/tests/ui/pattern/usefulness/issue-13727.stderr b/tests/ui/pattern/usefulness/issue-13727.stderr
index ca8533b33a467..fdba8c870150a 100644
--- a/tests/ui/pattern/usefulness/issue-13727.stderr
+++ b/tests/ui/pattern/usefulness/issue-13727.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/issue-13727.rs:7:5
    |
 LL |     256 => print!("0b1110\n"),
-   |     --- matches all the values already
+   |     --- matches all the relevant values
 LL |     512 => print!("0b1111\n"),
-   |     ^^^ unreachable pattern
+   |     ^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/issue-13727.rs:2:9
diff --git a/tests/ui/pattern/usefulness/issue-30240-b.stderr b/tests/ui/pattern/usefulness/issue-30240-b.stderr
index 749515fc94b65..4805083c12997 100644
--- a/tests/ui/pattern/usefulness/issue-30240-b.stderr
+++ b/tests/ui/pattern/usefulness/issue-30240-b.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/issue-30240-b.rs:12:9
    |
 LL |         "hello" => {}
-   |         ------- matches all the values already
+   |         ------- matches all the relevant values
 LL |         "hello" => {}
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/issue-30240-b.rs:1:9
diff --git a/tests/ui/pattern/usefulness/issue-31221.stderr b/tests/ui/pattern/usefulness/issue-31221.stderr
index 596f4d8096d9a..e198a9397eed5 100644
--- a/tests/ui/pattern/usefulness/issue-31221.stderr
+++ b/tests/ui/pattern/usefulness/issue-31221.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |         Var3 => (),
    |         ---- matches any value
 LL |         Var2 => (),
-   |         ^^^^ unreachable pattern
+   |         ^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/issue-31221.rs:4:9
@@ -18,15 +18,15 @@ error: unreachable pattern
 LL |         &Var3 => (),
    |         ----- matches any value
 LL |         &Var2 => (),
-   |         ^^^^^ unreachable pattern
+   |         ^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/issue-31221.rs:31:9
    |
 LL |         anything => ()
-   |         ^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/issue-31221.rs:31:9
    |
 LL |         (Var1, b) => (),
diff --git a/tests/ui/pattern/usefulness/issue-57472.stderr b/tests/ui/pattern/usefulness/issue-57472.stderr
index 68b5b7cb7911a..5a35dbd7f93d6 100644
--- a/tests/ui/pattern/usefulness/issue-57472.stderr
+++ b/tests/ui/pattern/usefulness/issue-57472.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/issue-57472.rs:15:13
    |
 LL |             Punned { foo: [_], .. } => println!("foo"),
-   |             ----------------------- matches all the values already
+   |             ----------------------- matches all the relevant values
 LL |             Punned { bar: [_], .. } => println!("bar"),
-   |             ^^^^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/issue-57472.rs:2:9
@@ -16,9 +16,9 @@ error: unreachable pattern
   --> $DIR/issue-57472.rs:32:17
    |
 LL |                 Punned { foo: [_] } => println!("foo"),
-   |                 ------------------- matches all the values already
+   |                 ------------------- matches all the relevant values
 LL |                 Punned { bar: [_] } => println!("bar"),
-   |                 ^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |                 ^^^^^^^^^^^^^^^^^^^ no value can reach this
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/pattern/usefulness/match-arm-statics.stderr b/tests/ui/pattern/usefulness/match-arm-statics.stderr
index b6f2b47047dce..d5b8a4e6d7955 100644
--- a/tests/ui/pattern/usefulness/match-arm-statics.stderr
+++ b/tests/ui/pattern/usefulness/match-arm-statics.stderr
@@ -2,10 +2,10 @@ error: unreachable pattern
   --> $DIR/match-arm-statics.rs:25:9
    |
 LL |         TRUE_TRUE => (),
-   |         --------- matches all the values already
+   |         --------- matches all the relevant values
 ...
 LL |         (true, true) => ()
-   |         ^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/match-arm-statics.rs:2:9
@@ -17,18 +17,18 @@ error: unreachable pattern
   --> $DIR/match-arm-statics.rs:40:9
    |
 LL |         Some(Some(EAST)) => (),
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 ...
 LL |         Some(Some(East)) => (),
-   |         ^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/match-arm-statics.rs:60:9
    |
 LL |         Foo { bar: Some(EAST), baz: NewBool(false) } => ()
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/match-arm-statics.rs:60:9
    |
 LL |         Foo { bar: _, baz: NEW_FALSE } => (),
diff --git a/tests/ui/pattern/usefulness/match-byte-array-patterns.stderr b/tests/ui/pattern/usefulness/match-byte-array-patterns.stderr
index 39675e2bdd4bb..79a0fb9a8dd6c 100644
--- a/tests/ui/pattern/usefulness/match-byte-array-patterns.stderr
+++ b/tests/ui/pattern/usefulness/match-byte-array-patterns.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/match-byte-array-patterns.rs:8:9
    |
 LL |         b"AAAA" => {},
-   |         ------- matches all the values already
+   |         ------- matches all the relevant values
 LL |         &[0x41, 0x41, 0x41, 0x41] => {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/match-byte-array-patterns.rs:1:9
@@ -16,57 +16,57 @@ error: unreachable pattern
   --> $DIR/match-byte-array-patterns.rs:14:9
    |
 LL |         &[0x41, 0x41, 0x41, 0x41] => {}
-   |         ------------------------- matches all the values already
+   |         ------------------------- matches all the relevant values
 LL |         b"AAAA" => {},
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/match-byte-array-patterns.rs:20:9
    |
 LL |         &[_, 0x41, 0x41, 0x41] => {},
-   |         ---------------------- matches all the values already
+   |         ---------------------- matches all the relevant values
 LL |         b"AAAA" => {},
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/match-byte-array-patterns.rs:26:9
    |
 LL |         &[0x41, .., 0x41] => {}
-   |         ----------------- matches all the values already
+   |         ----------------- matches all the relevant values
 LL |         b"AAAA" => {},
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/match-byte-array-patterns.rs:34:9
    |
 LL |         b"AAAA" => {},
-   |         ------- matches all the values already
+   |         ------- matches all the relevant values
 LL |         &[0x41, 0x41, 0x41, 0x41] => {}
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/match-byte-array-patterns.rs:40:9
    |
 LL |         &[0x41, 0x41, 0x41, 0x41] => {}
-   |         ------------------------- matches all the values already
+   |         ------------------------- matches all the relevant values
 LL |         b"AAAA" => {},
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/match-byte-array-patterns.rs:46:9
    |
 LL |         &[_, 0x41, 0x41, 0x41] => {},
-   |         ---------------------- matches all the values already
+   |         ---------------------- matches all the relevant values
 LL |         b"AAAA" => {},
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/match-byte-array-patterns.rs:52:9
    |
 LL |         &[0x41, .., 0x41] => {}
-   |         ----------------- matches all the values already
+   |         ----------------- matches all the relevant values
 LL |         b"AAAA" => {},
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: aborting due to 8 previous errors
 
diff --git a/tests/ui/pattern/usefulness/match-ref-ice.stderr b/tests/ui/pattern/usefulness/match-ref-ice.stderr
index 9c5af47cc1eb5..c5f8a95b16bb3 100644
--- a/tests/ui/pattern/usefulness/match-ref-ice.stderr
+++ b/tests/ui/pattern/usefulness/match-ref-ice.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/match-ref-ice.rs:13:9
    |
 LL |         [1, ref _madoka, 3] => (),
-   |         ------------------- matches all the values already
+   |         ------------------- matches all the relevant values
 LL |         [1, 2, 3] => (),
-   |         ^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/match-ref-ice.rs:1:9
diff --git a/tests/ui/pattern/usefulness/match-vec-fixed.stderr b/tests/ui/pattern/usefulness/match-vec-fixed.stderr
index 04507a228564d..b0b8cdf887a54 100644
--- a/tests/ui/pattern/usefulness/match-vec-fixed.stderr
+++ b/tests/ui/pattern/usefulness/match-vec-fixed.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/match-vec-fixed.rs:7:9
    |
 LL |         [_, _, _] => {}
-   |         --------- matches all the values already
+   |         --------- matches all the relevant values
 LL |         [_, _, _] => {}
-   |         ^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/match-vec-fixed.rs:1:9
@@ -16,9 +16,9 @@ error: unreachable pattern
   --> $DIR/match-vec-fixed.rs:11:9
    |
 LL |         [_, 1, _] => {}
-   |         --------- matches all the values already
+   |         --------- matches all the relevant values
 LL |         [_, 1, _] => {}
-   |         ^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^ no value can reach this
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/pattern/usefulness/match-vec-unreachable.stderr b/tests/ui/pattern/usefulness/match-vec-unreachable.stderr
index 865f5b319a775..6ed8f0019fe76 100644
--- a/tests/ui/pattern/usefulness/match-vec-unreachable.stderr
+++ b/tests/ui/pattern/usefulness/match-vec-unreachable.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/match-vec-unreachable.rs:8:9
    |
 LL |         [a, (2, 3), _] => (),
-   |         -------------- matches all the values already
+   |         -------------- matches all the relevant values
 LL |         [(1, 2), (2, 3), b] => (),
-   |         ^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/match-vec-unreachable.rs:1:9
@@ -16,17 +16,17 @@ error: unreachable pattern
   --> $DIR/match-vec-unreachable.rs:18:9
    |
 LL |         [ref a, _, _, ..] => { println!("{}", a); }
-   |         ----------------- matches all the values already
+   |         ----------------- matches all the relevant values
 LL |         [_, _, _, _, _] => { }
-   |         ^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/match-vec-unreachable.rs:26:9
    |
 LL |         ['a', 'b', 'c', ref _tail @ ..] => {}
-   |         ------------------------------- matches all the values already
+   |         ------------------------------- matches all the relevant values
 LL |         ['a', 'b', 'c'] => {}
-   |         ^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^ no value can reach this
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/pattern/usefulness/slice-pattern-const-2.stderr b/tests/ui/pattern/usefulness/slice-pattern-const-2.stderr
index 12db48590a4d9..a6031eaa73010 100644
--- a/tests/ui/pattern/usefulness/slice-pattern-const-2.stderr
+++ b/tests/ui/pattern/usefulness/slice-pattern-const-2.stderr
@@ -2,10 +2,10 @@ error: unreachable pattern
   --> $DIR/slice-pattern-const-2.rs:9:9
    |
 LL |         MAGIC_TEST => (),
-   |         ---------- matches all the values already
+   |         ---------- matches all the relevant values
 LL |         [0x00, 0x00, 0x00, 0x00] => (),
 LL |         [4, 5, 6, 7] => (),
-   |         ^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/slice-pattern-const-2.rs:1:9
@@ -17,25 +17,25 @@ error: unreachable pattern
   --> $DIR/slice-pattern-const-2.rs:15:9
    |
 LL |         MAGIC_TEST => (),
-   |         ---------- matches all the values already
+   |         ---------- matches all the relevant values
 LL |         [4, 5, 6, 7] => (),
-   |         ^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const-2.rs:21:9
    |
 LL |         [4, 5, 6, 7] => (),
-   |         ------------ matches all the values already
+   |         ------------ matches all the relevant values
 LL |         MAGIC_TEST => (),
-   |         ^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const-2.rs:28:9
    |
 LL |         [4] => (),
-   |         --- matches all the values already
+   |         --- matches all the relevant values
 LL |         FOO => (),
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/pattern/usefulness/slice-pattern-const-3.stderr b/tests/ui/pattern/usefulness/slice-pattern-const-3.stderr
index 5a66799d9c97b..bbec9f23602a7 100644
--- a/tests/ui/pattern/usefulness/slice-pattern-const-3.stderr
+++ b/tests/ui/pattern/usefulness/slice-pattern-const-3.stderr
@@ -2,10 +2,10 @@ error: unreachable pattern
   --> $DIR/slice-pattern-const-3.rs:9:9
    |
 LL |         MAGIC_TEST => (),
-   |         ---------- matches all the values already
+   |         ---------- matches all the relevant values
 LL |         ["0x00", "0x00", "0x00", "0x00"] => (),
 LL |         ["4", "5", "6", "7"] => (),
-   |         ^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/slice-pattern-const-3.rs:1:9
@@ -17,25 +17,25 @@ error: unreachable pattern
   --> $DIR/slice-pattern-const-3.rs:15:9
    |
 LL |         MAGIC_TEST => (),
-   |         ---------- matches all the values already
+   |         ---------- matches all the relevant values
 LL |         ["4", "5", "6", "7"] => (),
-   |         ^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const-3.rs:21:9
    |
 LL |         ["4", "5", "6", "7"] => (),
-   |         -------------------- matches all the values already
+   |         -------------------- matches all the relevant values
 LL |         MAGIC_TEST => (),
-   |         ^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const-3.rs:28:9
    |
 LL |         ["boo"] => (),
-   |         ------- matches all the values already
+   |         ------- matches all the relevant values
 LL |         FOO => (),
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/pattern/usefulness/slice-pattern-const.stderr b/tests/ui/pattern/usefulness/slice-pattern-const.stderr
index 87a85acc4c535..09bbee73577ea 100644
--- a/tests/ui/pattern/usefulness/slice-pattern-const.stderr
+++ b/tests/ui/pattern/usefulness/slice-pattern-const.stderr
@@ -2,10 +2,10 @@ error: unreachable pattern
   --> $DIR/slice-pattern-const.rs:9:9
    |
 LL |         MAGIC_TEST => (),
-   |         ---------- matches all the values already
+   |         ---------- matches all the relevant values
 LL |         [0x00, 0x00, 0x00, 0x00] => (),
 LL |         [84, 69, 83, 84] => (),
-   |         ^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/slice-pattern-const.rs:1:9
@@ -17,67 +17,67 @@ error: unreachable pattern
   --> $DIR/slice-pattern-const.rs:15:9
    |
 LL |         MAGIC_TEST => (),
-   |         ---------- matches all the values already
+   |         ---------- matches all the relevant values
 LL |         [84, 69, 83, 84] => (),
-   |         ^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const.rs:21:9
    |
 LL |         [84, 69, 83, 84] => (),
-   |         ---------------- matches all the values already
+   |         ---------------- matches all the relevant values
 LL |         MAGIC_TEST => (),
-   |         ^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const.rs:28:9
    |
 LL |         [4] => (),
-   |         --- matches all the values already
+   |         --- matches all the relevant values
 LL |         FOO => (),
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const.rs:35:9
    |
 LL |         [4] => (),
-   |         --- matches all the values already
+   |         --- matches all the relevant values
 LL |         BAR => (),
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const.rs:43:9
    |
 LL |         [] => (),
-   |         -- matches all the values already
+   |         -- matches all the relevant values
 LL |         BOO => (),
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const.rs:44:9
    |
 LL |         [] => (),
-   |         -- matches all the values already
+   |         -- matches all the relevant values
 LL |         BOO => (),
 LL |         b"" => (),
-   |         ^^^ unreachable pattern
+   |         ^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const.rs:45:9
    |
 LL |         [] => (),
-   |         -- matches all the values already
+   |         -- matches all the relevant values
 ...
 LL |         _ => (),
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-pattern-const.rs:51:9
    |
 LL |         CONST1 => {}
-   |         ------ matches all the values already
+   |         ------ matches all the relevant values
 LL |         [true] => {}
-   |         ^^^^^^ unreachable pattern
+   |         ^^^^^^ no value can reach this
 
 error: aborting due to 9 previous errors
 
diff --git a/tests/ui/pattern/usefulness/slice-patterns-reachability.stderr b/tests/ui/pattern/usefulness/slice-patterns-reachability.stderr
index 40fbb00de1f2c..d45779f09a5fd 100644
--- a/tests/ui/pattern/usefulness/slice-patterns-reachability.stderr
+++ b/tests/ui/pattern/usefulness/slice-patterns-reachability.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/slice-patterns-reachability.rs:8:9
    |
 LL |         [true, ..] => {}
-   |         ---------- matches all the values already
+   |         ---------- matches all the relevant values
 LL |         [true, ..] => {}
-   |         ^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/slice-patterns-reachability.rs:1:9
@@ -16,44 +16,44 @@ error: unreachable pattern
   --> $DIR/slice-patterns-reachability.rs:9:9
    |
 LL |         [true, ..] => {}
-   |         ---------- matches all the values already
+   |         ---------- matches all the relevant values
 LL |         [true, ..] => {}
 LL |         [true] => {}
-   |         ^^^^^^ unreachable pattern
+   |         ^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-patterns-reachability.rs:14:9
    |
 LL |         [.., true] => {}
-   |         ---------- matches all the values already
+   |         ---------- matches all the relevant values
 LL |         [.., true] => {}
-   |         ^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-patterns-reachability.rs:15:9
    |
 LL |         [.., true] => {}
-   |         ---------- matches all the values already
+   |         ---------- matches all the relevant values
 LL |         [.., true] => {}
 LL |         [true] => {}
-   |         ^^^^^^ unreachable pattern
+   |         ^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-patterns-reachability.rs:20:9
    |
 LL |         [false, .., true] => {}
-   |         ----------------- matches all the values already
+   |         ----------------- matches all the relevant values
 LL |         [false, .., true] => {}
-   |         ^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/slice-patterns-reachability.rs:21:9
    |
 LL |         [false, .., true] => {}
-   |         ----------------- matches all the values already
+   |         ----------------- matches all the relevant values
 LL |         [false, .., true] => {}
 LL |         [false, true] => {}
-   |         ^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^ no value can reach this
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/pattern/usefulness/struct-pattern-match-useless.stderr b/tests/ui/pattern/usefulness/struct-pattern-match-useless.stderr
index cc29c42e4d689..502fa2deda9ab 100644
--- a/tests/ui/pattern/usefulness/struct-pattern-match-useless.stderr
+++ b/tests/ui/pattern/usefulness/struct-pattern-match-useless.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |         Foo { x: _x, y: _y } => (),
    |         -------------------- matches any value
 LL |         Foo { .. } => ()
-   |         ^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/struct-pattern-match-useless.rs:1:9
diff --git a/tests/ui/pattern/usefulness/top-level-alternation.stderr b/tests/ui/pattern/usefulness/top-level-alternation.stderr
index ad846f2315597..7fc03143bc372 100644
--- a/tests/ui/pattern/usefulness/top-level-alternation.stderr
+++ b/tests/ui/pattern/usefulness/top-level-alternation.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/top-level-alternation.rs:4:23
    |
 LL |     while let 0..=2 | 1 = 0 {}
-   |               -----   ^ unreachable pattern
+   |               -----   ^ no value can reach this
    |               |
-   |               matches all the values already
+   |               matches all the relevant values
    |
 note: the lint level is defined here
   --> $DIR/top-level-alternation.rs:1:9
@@ -16,66 +16,66 @@ error: unreachable pattern
   --> $DIR/top-level-alternation.rs:5:20
    |
 LL |     if let 0..=2 | 1 = 0 {}
-   |            -----   ^ unreachable pattern
+   |            -----   ^ no value can reach this
    |            |
-   |            matches all the values already
+   |            matches all the relevant values
 
 error: unreachable pattern
   --> $DIR/top-level-alternation.rs:9:15
    |
 LL |         0
-   |         - matches all the values already
+   |         - matches all the relevant values
 LL |             | 0 => {}
-   |               ^ unreachable pattern
+   |               ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/top-level-alternation.rs:14:15
    |
 LL |         Some(0)
-   |         ------- matches all the values already
+   |         ------- matches all the relevant values
 LL |             | Some(0) => {}
-   |               ^^^^^^^ unreachable pattern
+   |               ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/top-level-alternation.rs:19:9
    |
 LL |         (0, _) | (_, 0) => {}
-   |         --------------- matches all the values already
+   |         --------------- matches all the relevant values
 LL |         (0, 0) => {}
-   |         ^^^^^^ unreachable pattern
+   |         ^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/top-level-alternation.rs:39:9
    |
 LL |         None | Some(_) => {}
-   |         -------------- matches all the values already
+   |         -------------- matches all the relevant values
 LL |         _ => {}
-   |         ^ unreachable pattern
+   |         ^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/top-level-alternation.rs:43:9
    |
 LL |         None | Some(_) => {}
-   |         -------------- matches all the values already
+   |         -------------- matches all the relevant values
 LL |         Some(_) => {}
-   |         ^^^^^^^ unreachable pattern
+   |         ^^^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/top-level-alternation.rs:44:9
    |
 LL |         None | Some(_) => {}
-   |         -------------- matches all the values already
+   |         -------------- matches all the relevant values
 LL |         Some(_) => {}
 LL |         None => {}
-   |         ^^^^ unreachable pattern
+   |         ^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/top-level-alternation.rs:49:9
    |
 LL |         None | Some(_) => {}
-   |         ^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^ no value can reach this
    |
-note: these patterns collectively make the last one unreachable
+note: multiple earlier patterns match some of the same values
   --> $DIR/top-level-alternation.rs:49:9
    |
 LL |         Some(_) => {}
@@ -89,17 +89,17 @@ error: unreachable pattern
   --> $DIR/top-level-alternation.rs:53:9
    |
 LL |         1 | 2 => {},
-   |         ----- matches all the values already
+   |         ----- matches all the relevant values
 LL |         1..=2 => {},
-   |         ^^^^^ unreachable pattern
+   |         ^^^^^ no value can reach this
 
 error: unreachable pattern
   --> $DIR/top-level-alternation.rs:56:14
    |
 LL |     let (0 | 0) = 0 else { return };
-   |          -   ^ unreachable pattern
+   |          -   ^ no value can reach this
    |          |
-   |          matches all the values already
+   |          matches all the relevant values
 
 error: aborting due to 11 previous errors
 
diff --git a/tests/ui/reachable/unreachable-arm.stderr b/tests/ui/reachable/unreachable-arm.stderr
index 796274040302b..50c29b30c69cb 100644
--- a/tests/ui/reachable/unreachable-arm.stderr
+++ b/tests/ui/reachable/unreachable-arm.stderr
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/unreachable-arm.rs:11:9
    |
 LL |         Foo::B(_) | Foo::A(box _, 1) => { }
-   |         ---------------------------- matches all the values already
+   |         ---------------------------- matches all the relevant values
 LL |         Foo::A(_, 1) => { }
-   |         ^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/unreachable-arm.rs:4:9
diff --git a/tests/ui/reachable/unreachable-loop-patterns.stderr b/tests/ui/reachable/unreachable-loop-patterns.stderr
index 9b7c2ba4acdcc..9781a976686e9 100644
--- a/tests/ui/reachable/unreachable-loop-patterns.stderr
+++ b/tests/ui/reachable/unreachable-loop-patterns.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |     for _ in unimplemented!() as Void {}
    |         ^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 note: the lint level is defined here
   --> $DIR/unreachable-loop-patterns.rs:3:9
    |
diff --git a/tests/ui/reachable/unreachable-try-pattern.stderr b/tests/ui/reachable/unreachable-try-pattern.stderr
index bc1a6fffda648..83040d35c0f15 100644
--- a/tests/ui/reachable/unreachable-try-pattern.stderr
+++ b/tests/ui/reachable/unreachable-try-pattern.stderr
@@ -19,7 +19,7 @@ warning: unreachable pattern
 LL |     let y = (match x { Ok(n) => Ok(n as u32), Err(e) => Err(e) })?;
    |                        ^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 note: the lint level is defined here
   --> $DIR/unreachable-try-pattern.rs:4:9
    |
@@ -32,7 +32,7 @@ warning: unreachable pattern
 LL |     let y = (match x { Ok(n) => Ok(n), Err(e) => Err(e) })?;
    |                                        ^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 warning: 3 warnings emitted
 
diff --git a/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr b/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr
index 79b640d9f419f..be8b38f6942dc 100644
--- a/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr
+++ b/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |         Err(!),
    |         ^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 note: the lint level is defined here
   --> $DIR/unreachable.rs:4:9
    |
@@ -17,7 +17,7 @@ error: unreachable pattern
 LL |     let (Ok(_x) | Err(!)) = res_void;
    |                   ^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:19:12
@@ -25,7 +25,7 @@ error: unreachable pattern
 LL |     if let Err(!) = res_void {}
    |            ^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:21:24
@@ -33,7 +33,7 @@ error: unreachable pattern
 LL |     if let (Ok(true) | Err(!)) = res_void {}
    |                        ^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:23:23
@@ -41,7 +41,7 @@ error: unreachable pattern
 LL |     for (Ok(mut _x) | Err(!)) in [res_void] {}
    |                       ^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:27:18
@@ -49,7 +49,7 @@ error: unreachable pattern
 LL | fn foo((Ok(_x) | Err(!)): Result<bool, Void>) {}
    |                  ^^^^^^
    |
-   = note: this pattern matches no values because `Void` is uninhabited
+   = note: matches no values because `Void` is uninhabited
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr
index d5f58e436c5d8..06bc901ffdfdb 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |         _ => {}
    |         ^
    |
-   = note: this pattern matches no values because `EmptyNonExhaustiveEnum` is uninhabited
+   = note: matches no values because `EmptyNonExhaustiveEnum` is uninhabited
 note: the lint level is defined here
   --> $DIR/enum_same_crate_empty_match.rs:1:9
    |
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 4ec4ec9705a8b..956725fc10eb9 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
@@ -2,9 +2,9 @@ error: unreachable pattern
   --> $DIR/issue-65157-repeated-match-arm.rs:15:9
    |
 LL |         PartiallyInhabitedVariants::Struct { .. } => {},
-   |         ----------------------------------------- matches all the values already
+   |         ----------------------------------------- matches all the relevant values
 LL |         PartiallyInhabitedVariants::Struct { .. } => {},
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unreachable pattern
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no value can reach this
    |
 note: the lint level is defined here
   --> $DIR/issue-65157-repeated-match-arm.rs:2:9
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
index c399bb9083fb1..982129046b8b1 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |         Some(_x) => (),
    |         ^^^^^^^^
    |
-   = note: this pattern matches no values because `UninhabitedEnum` is uninhabited
+   = note: matches no values because `UninhabitedEnum` is uninhabited
 note: the lint level is defined here
   --> $DIR/patterns_same_crate.rs:1:9
    |
@@ -17,7 +17,7 @@ error: unreachable pattern
 LL |         Some(_x) => (),
    |         ^^^^^^^^
    |
-   = note: this pattern matches no values because `UninhabitedVariants` is uninhabited
+   = note: matches no values because `UninhabitedVariants` is uninhabited
 
 error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:60:15
@@ -25,7 +25,7 @@ error: unreachable pattern
 LL |     while let PartiallyInhabitedVariants::Struct { x } = partially_inhabited_variant() {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: this pattern matches no values because `!` is uninhabited
+   = note: matches no values because `!` is uninhabited
 
 error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:64:15
@@ -33,7 +33,7 @@ error: unreachable pattern
 LL |     while let Some(_x) = uninhabited_struct() {
    |               ^^^^^^^^
    |
-   = note: this pattern matches no values because `UninhabitedStruct` is uninhabited
+   = note: matches no values because `UninhabitedStruct` is uninhabited
 
 error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:67:15
@@ -41,7 +41,7 @@ error: unreachable pattern
 LL |     while let Some(_x) = uninhabited_tuple_struct() {
    |               ^^^^^^^^
    |
-   = note: this pattern matches no values because `UninhabitedTupleStruct` is uninhabited
+   = note: matches no values because `UninhabitedTupleStruct` is uninhabited
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/rfcs/rfc-2294-if-let-guard/warns.stderr b/tests/ui/rfcs/rfc-2294-if-let-guard/warns.stderr
index 8d0874fa9007e..693a06a229786 100644
--- a/tests/ui/rfcs/rfc-2294-if-let-guard/warns.stderr
+++ b/tests/ui/rfcs/rfc-2294-if-let-guard/warns.stderr
@@ -16,9 +16,9 @@ error: unreachable pattern
   --> $DIR/warns.rs:15:25
    |
 LL |         x if let None | None = x => {}
-   |                  ----   ^^^^ unreachable pattern
+   |                  ----   ^^^^ no value can reach this
    |                  |
-   |                  matches all the values already
+   |                  matches all the relevant values
    |
 note: the lint level is defined here
   --> $DIR/warns.rs:12:8
diff --git a/tests/ui/uninhabited/uninhabited-patterns.stderr b/tests/ui/uninhabited/uninhabited-patterns.stderr
index 4e4aaa93f8044..4bac1bc52f473 100644
--- a/tests/ui/uninhabited/uninhabited-patterns.stderr
+++ b/tests/ui/uninhabited/uninhabited-patterns.stderr
@@ -4,7 +4,7 @@ error: unreachable pattern
 LL |         Ok(box _) => (),
    |         ^^^^^^^^^
    |
-   = note: this pattern matches no values because `NotSoSecretlyEmpty` is uninhabited
+   = note: matches no values because `NotSoSecretlyEmpty` is uninhabited
 note: the lint level is defined here
   --> $DIR/uninhabited-patterns.rs:3:9
    |
@@ -17,7 +17,7 @@ error: unreachable pattern
 LL |         Err(Ok(_y)) => (),
    |         ^^^^^^^^^^^
    |
-   = note: this pattern matches no values because `NotSoSecretlyEmpty` is uninhabited
+   = note: matches no values because `NotSoSecretlyEmpty` is uninhabited
 
 error: unreachable pattern
   --> $DIR/uninhabited-patterns.rs:41:15
@@ -25,7 +25,7 @@ error: unreachable pattern
 LL |     while let Some(_y) = foo() {
    |               ^^^^^^^^
    |
-   = note: this pattern matches no values because `NotSoSecretlyEmpty` is uninhabited
+   = note: matches no values because `NotSoSecretlyEmpty` is uninhabited
 
 error: aborting due to 3 previous errors
 

From efb28bdd90cf7b4ef6d436edaca8f394724fb604 Mon Sep 17 00:00:00 2001
From: Nadrieril <nadrieril+git@gmail.com>
Date: Mon, 19 Aug 2024 21:08:18 +0200
Subject: [PATCH 445/685] Add a note with a link to explain empty types

---
 compiler/rustc_mir_build/messages.ftl         |  1 +
 compiler/rustc_mir_build/src/errors.rs        |  2 ++
 .../src/thir/pattern/check_match.rs           |  2 ++
 ...tch-check-notes.exhaustive_patterns.stderr | 14 +++++---
 .../empty-match-check-notes.normal.stderr     | 14 +++++---
 .../usefulness/empty-match-check-notes.rs     |  4 +++
 .../empty-types.exhaustive_patterns.stderr    | 35 +++++++++++++++++++
 .../usefulness/empty-types.never_pats.stderr  | 35 +++++++++++++++++++
 .../usefulness/empty-types.normal.stderr      | 35 +++++++++++++++++++
 .../usefulness/explain-unreachable-pats.rs    |  3 ++
 .../explain-unreachable-pats.stderr           | 17 +++++----
 tests/ui/pattern/usefulness/impl-trait.stderr |  8 +++++
 .../unreachable-loop-patterns.stderr          |  1 +
 .../reachable/unreachable-try-pattern.stderr  |  2 ++
 .../unreachable.stderr                        |  6 ++++
 .../enum_same_crate_empty_match.stderr        |  1 +
 .../uninhabited/patterns_same_crate.stderr    |  5 +++
 .../uninhabited/uninhabited-patterns.stderr   |  3 ++
 18 files changed, 171 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index ae13485ce739b..b6258045566b0 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -332,6 +332,7 @@ mir_build_unreachable_matches_same_values = matches some of the same values
 mir_build_unreachable_pattern = unreachable pattern
     .label = no value can reach this
     .unreachable_matches_no_values = matches no values because `{$ty}` is uninhabited
+    .unreachable_uninhabited_note = to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
     .unreachable_covered_by_catchall = matches any value
     .unreachable_covered_by_one = matches all the relevant values
     .unreachable_covered_by_many = multiple earlier patterns match some of the same values
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index 34577f102d1c5..a45a0311e32d4 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -588,6 +588,8 @@ pub(crate) struct UnreachablePattern<'tcx> {
     pub(crate) span: Option<Span>,
     #[subdiagnostic]
     pub(crate) matches_no_values: Option<UnreachableMatchesNoValues<'tcx>>,
+    #[note(mir_build_unreachable_uninhabited_note)]
+    pub(crate) uninhabited_note: Option<()>,
     #[label(mir_build_unreachable_covered_by_catchall)]
     pub(crate) covered_by_catchall: Option<Span>,
     #[label(mir_build_unreachable_covered_by_one)]
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index 85b9dacb1293c..a948e5d0c2168 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -921,6 +921,7 @@ fn report_unreachable_pattern<'p, 'tcx>(
     let mut lint = UnreachablePattern {
         span: Some(pat_span),
         matches_no_values: None,
+        uninhabited_note: None,
         covered_by_catchall: None,
         covered_by_one: None,
         covered_by_many: None,
@@ -929,6 +930,7 @@ fn report_unreachable_pattern<'p, 'tcx>(
         [] => {
             // Empty pattern; we report the uninhabited type that caused the emptiness.
             lint.span = None; // Don't label the pattern itself
+            lint.uninhabited_note = Some(()); // Give a link about empty types
             pat.walk(&mut |subpat| {
                 let ty = **subpat.ty();
                 if cx.is_uninhabited(ty) {
diff --git a/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr
index 4cfa6182752ca..5ec14a7597a54 100644
--- a/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr
+++ b/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr
@@ -5,6 +5,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `EmptyEnum` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/empty-match-check-notes.rs:7:9
    |
@@ -12,31 +13,34 @@ LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/empty-match-check-notes.rs:21:9
+  --> $DIR/empty-match-check-notes.rs:22:9
    |
 LL |         _ if false => {}
    |         ^
    |
    = note: matches no values because `EmptyEnum` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-match-check-notes.rs:29:9
+  --> $DIR/empty-match-check-notes.rs:31:9
    |
 LL |         _ => {}
    |         ^
    |
    = note: matches no values because `EmptyForeignEnum` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-match-check-notes.rs:33:9
+  --> $DIR/empty-match-check-notes.rs:36:9
    |
 LL |         _ if false => {}
    |         ^
    |
    = note: matches no values because `EmptyForeignEnum` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0005]: refutable pattern in local binding
-  --> $DIR/empty-match-check-notes.rs:39:9
+  --> $DIR/empty-match-check-notes.rs:43:9
    |
 LL |     let None = *x;
    |         ^^^^ pattern `Some(_)` not covered
@@ -51,7 +55,7 @@ LL |     if let None = *x { todo!() };
    |     ++               +++++++++++
 
 error[E0004]: non-exhaustive patterns: `0_u8..=u8::MAX` not covered
-  --> $DIR/empty-match-check-notes.rs:49:11
+  --> $DIR/empty-match-check-notes.rs:53:11
    |
 LL |     match 0u8 {
    |           ^^^ pattern `0_u8..=u8::MAX` not covered
diff --git a/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr b/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr
index 4cfa6182752ca..5ec14a7597a54 100644
--- a/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr
+++ b/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr
@@ -5,6 +5,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `EmptyEnum` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/empty-match-check-notes.rs:7:9
    |
@@ -12,31 +13,34 @@ LL | #![deny(unreachable_patterns)]
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error: unreachable pattern
-  --> $DIR/empty-match-check-notes.rs:21:9
+  --> $DIR/empty-match-check-notes.rs:22:9
    |
 LL |         _ if false => {}
    |         ^
    |
    = note: matches no values because `EmptyEnum` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-match-check-notes.rs:29:9
+  --> $DIR/empty-match-check-notes.rs:31:9
    |
 LL |         _ => {}
    |         ^
    |
    = note: matches no values because `EmptyForeignEnum` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/empty-match-check-notes.rs:33:9
+  --> $DIR/empty-match-check-notes.rs:36:9
    |
 LL |         _ if false => {}
    |         ^
    |
    = note: matches no values because `EmptyForeignEnum` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0005]: refutable pattern in local binding
-  --> $DIR/empty-match-check-notes.rs:39:9
+  --> $DIR/empty-match-check-notes.rs:43:9
    |
 LL |     let None = *x;
    |         ^^^^ pattern `Some(_)` not covered
@@ -51,7 +55,7 @@ LL |     if let None = *x { todo!() };
    |     ++               +++++++++++
 
 error[E0004]: non-exhaustive patterns: `0_u8..=u8::MAX` not covered
-  --> $DIR/empty-match-check-notes.rs:49:11
+  --> $DIR/empty-match-check-notes.rs:53:11
    |
 LL |     match 0u8 {
    |           ^^^ pattern `0_u8..=u8::MAX` not covered
diff --git a/tests/ui/pattern/usefulness/empty-match-check-notes.rs b/tests/ui/pattern/usefulness/empty-match-check-notes.rs
index 61a75e6c801f9..48d20fd2d5c1b 100644
--- a/tests/ui/pattern/usefulness/empty-match-check-notes.rs
+++ b/tests/ui/pattern/usefulness/empty-match-check-notes.rs
@@ -16,10 +16,12 @@ fn empty_enum(x: EmptyEnum) {
     match x {
         _ => {} //~ ERROR unreachable pattern
                 //~^ NOTE matches no values
+                //~| NOTE to learn more about uninhabited types, see
     }
     match x {
         _ if false => {} //~ ERROR unreachable pattern
                          //~^ NOTE matches no values
+                         //~| NOTE to learn more about uninhabited types, see
     }
 }
 
@@ -28,10 +30,12 @@ fn empty_foreign_enum(x: empty::EmptyForeignEnum) {
     match x {
         _ => {} //~ ERROR unreachable pattern
                 //~^ NOTE matches no values
+                //~| NOTE to learn more about uninhabited types, see
     }
     match x {
         _ if false => {} //~ ERROR unreachable pattern
                          //~^ NOTE matches no values
+                         //~| NOTE to learn more about uninhabited types, see
     }
 }
 
diff --git a/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
index 74cf75f3b4026..4e5f1d0ea8c21 100644
--- a/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
@@ -5,6 +5,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/empty-types.rs:15:9
    |
@@ -18,6 +19,7 @@ LL |         _x => {}
    |         ^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
   --> $DIR/empty-types.rs:56:11
@@ -41,6 +43,7 @@ LL |         (_, _) => {}
    |         ^^^^^^
    |
    = note: matches no values because `(u32, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:76:9
@@ -49,6 +52,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `(!, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:79:9
@@ -57,6 +61,7 @@ LL |         (_, _) => {}
    |         ^^^^^^
    |
    = note: matches no values because `(!, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:83:9
@@ -65,6 +70,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
   --> $DIR/empty-types.rs:87:11
@@ -92,6 +98,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:99:9
@@ -100,6 +107,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
   --> $DIR/empty-types.rs:96:11
@@ -140,6 +148,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:115:9
@@ -148,6 +157,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:118:9
@@ -156,6 +166,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:119:9
@@ -164,6 +175,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:122:9
@@ -172,6 +184,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:123:9
@@ -180,6 +193,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:132:13
@@ -188,6 +202,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:135:13
@@ -196,6 +211,7 @@ LL |             _ if false => {}
    |             ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:143:13
@@ -204,6 +220,7 @@ LL |             Some(_) => {}
    |             ^^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:147:13
@@ -220,6 +237,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:204:13
@@ -228,6 +246,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:209:13
@@ -236,6 +255,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:214:13
@@ -244,6 +264,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:220:13
@@ -252,6 +273,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:281:9
@@ -260,6 +282,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:284:9
@@ -268,6 +291,7 @@ LL |         (_, _) => {}
    |         ^^^^^^
    |
    = note: matches no values because `(!, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:287:9
@@ -276,6 +300,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:288:9
@@ -284,6 +309,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
   --> $DIR/empty-types.rs:327:11
@@ -347,6 +373,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `[!; 3]` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:371:9
@@ -355,6 +382,7 @@ LL |         [_, _, _] => {}
    |         ^^^^^^^^^
    |
    = note: matches no values because `[!; 3]` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:374:9
@@ -363,6 +391,7 @@ LL |         [_, ..] => {}
    |         ^^^^^^^
    |
    = note: matches no values because `[!; 3]` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
   --> $DIR/empty-types.rs:388:11
@@ -407,6 +436,7 @@ LL |         Some(_) => {}
    |         ^^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:421:9
@@ -415,6 +445,7 @@ LL |         Some(_a) => {}
    |         ^^^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:426:9
@@ -441,6 +472,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:606:9
@@ -449,6 +481,7 @@ LL |         _x => {}
    |         ^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:609:9
@@ -457,6 +490,7 @@ LL |         _ if false => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:612:9
@@ -465,6 +499,7 @@ LL |         _x if false => {}
    |         ^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: aborting due to 49 previous errors
 
diff --git a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
index e1a8458e5f8c8..3332eab8a776c 100644
--- a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
@@ -14,6 +14,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/empty-types.rs:15:9
    |
@@ -27,6 +28,7 @@ LL |         _x => {}
    |         ^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
   --> $DIR/empty-types.rs:56:11
@@ -50,6 +52,7 @@ LL |         (_, _) => {}
    |         ^^^^^^
    |
    = note: matches no values because `(u32, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:76:9
@@ -58,6 +61,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `(!, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:79:9
@@ -66,6 +70,7 @@ LL |         (_, _) => {}
    |         ^^^^^^
    |
    = note: matches no values because `(!, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:83:9
@@ -74,6 +79,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
   --> $DIR/empty-types.rs:87:11
@@ -101,6 +107,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:99:9
@@ -109,6 +116,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
   --> $DIR/empty-types.rs:96:11
@@ -163,6 +171,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:115:9
@@ -171,6 +180,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:118:9
@@ -179,6 +189,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:119:9
@@ -187,6 +198,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:122:9
@@ -195,6 +207,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:123:9
@@ -203,6 +216,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:132:13
@@ -211,6 +225,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:135:13
@@ -219,6 +234,7 @@ LL |             _ if false => {}
    |             ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:143:13
@@ -227,6 +243,7 @@ LL |             Some(_) => {}
    |             ^^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:147:13
@@ -262,6 +279,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:204:13
@@ -270,6 +288,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:209:13
@@ -278,6 +297,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:214:13
@@ -286,6 +306,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:220:13
@@ -294,6 +315,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:281:9
@@ -302,6 +324,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:284:9
@@ -310,6 +333,7 @@ LL |         (_, _) => {}
    |         ^^^^^^
    |
    = note: matches no values because `(!, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:287:9
@@ -318,6 +342,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:288:9
@@ -326,6 +351,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0005]: refutable pattern in local binding
   --> $DIR/empty-types.rs:297:13
@@ -481,6 +507,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `[!; 3]` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:371:9
@@ -489,6 +516,7 @@ LL |         [_, _, _] => {}
    |         ^^^^^^^^^
    |
    = note: matches no values because `[!; 3]` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:374:9
@@ -497,6 +525,7 @@ LL |         [_, ..] => {}
    |         ^^^^^^^
    |
    = note: matches no values because `[!; 3]` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
   --> $DIR/empty-types.rs:388:11
@@ -541,6 +570,7 @@ LL |         Some(_) => {}
    |         ^^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:421:9
@@ -549,6 +579,7 @@ LL |         Some(_a) => {}
    |         ^^^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:426:9
@@ -665,6 +696,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:606:9
@@ -673,6 +705,7 @@ LL |         _x => {}
    |         ^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:609:9
@@ -681,6 +714,7 @@ LL |         _ if false => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:612:9
@@ -689,6 +723,7 @@ LL |         _x if false => {}
    |         ^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `&!` not covered
   --> $DIR/empty-types.rs:637:11
diff --git a/tests/ui/pattern/usefulness/empty-types.normal.stderr b/tests/ui/pattern/usefulness/empty-types.normal.stderr
index c9bd25d5f9dee..89cf09f011e96 100644
--- a/tests/ui/pattern/usefulness/empty-types.normal.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.normal.stderr
@@ -5,6 +5,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/empty-types.rs:15:9
    |
@@ -18,6 +19,7 @@ LL |         _x => {}
    |         ^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
   --> $DIR/empty-types.rs:56:11
@@ -41,6 +43,7 @@ LL |         (_, _) => {}
    |         ^^^^^^
    |
    = note: matches no values because `(u32, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:76:9
@@ -49,6 +52,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `(!, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:79:9
@@ -57,6 +61,7 @@ LL |         (_, _) => {}
    |         ^^^^^^
    |
    = note: matches no values because `(!, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:83:9
@@ -65,6 +70,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
   --> $DIR/empty-types.rs:87:11
@@ -92,6 +98,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:99:9
@@ -100,6 +107,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
   --> $DIR/empty-types.rs:96:11
@@ -154,6 +162,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:115:9
@@ -162,6 +171,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:118:9
@@ -170,6 +180,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:119:9
@@ -178,6 +189,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:122:9
@@ -186,6 +198,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:123:9
@@ -194,6 +207,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:132:13
@@ -202,6 +216,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:135:13
@@ -210,6 +225,7 @@ LL |             _ if false => {}
    |             ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:143:13
@@ -218,6 +234,7 @@ LL |             Some(_) => {}
    |             ^^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:147:13
@@ -253,6 +270,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:204:13
@@ -261,6 +279,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:209:13
@@ -269,6 +288,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:214:13
@@ -277,6 +297,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:220:13
@@ -285,6 +306,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:281:9
@@ -293,6 +315,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:284:9
@@ -301,6 +324,7 @@ LL |         (_, _) => {}
    |         ^^^^^^
    |
    = note: matches no values because `(!, !)` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:287:9
@@ -309,6 +333,7 @@ LL |         Ok(_) => {}
    |         ^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:288:9
@@ -317,6 +342,7 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `Result<!, !>` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0005]: refutable pattern in local binding
   --> $DIR/empty-types.rs:297:13
@@ -472,6 +498,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `[!; 3]` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:371:9
@@ -480,6 +507,7 @@ LL |         [_, _, _] => {}
    |         ^^^^^^^^^
    |
    = note: matches no values because `[!; 3]` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:374:9
@@ -488,6 +516,7 @@ LL |         [_, ..] => {}
    |         ^^^^^^^
    |
    = note: matches no values because `[!; 3]` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
   --> $DIR/empty-types.rs:388:11
@@ -532,6 +561,7 @@ LL |         Some(_) => {}
    |         ^^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:421:9
@@ -540,6 +570,7 @@ LL |         Some(_a) => {}
    |         ^^^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:426:9
@@ -656,6 +687,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:606:9
@@ -664,6 +696,7 @@ LL |         _x => {}
    |         ^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:609:9
@@ -672,6 +705,7 @@ LL |         _ if false => {}
    |         ^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:612:9
@@ -680,6 +714,7 @@ LL |         _x if false => {}
    |         ^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `&_` not covered
   --> $DIR/empty-types.rs:637:11
diff --git a/tests/ui/pattern/usefulness/explain-unreachable-pats.rs b/tests/ui/pattern/usefulness/explain-unreachable-pats.rs
index bc4abd343ad4f..746343246c6ee 100644
--- a/tests/ui/pattern/usefulness/explain-unreachable-pats.rs
+++ b/tests/ui/pattern/usefulness/explain-unreachable-pats.rs
@@ -32,6 +32,7 @@ fn main() {
         Err(_) => {}
         //~^ ERROR unreachable pattern
         //~| NOTE matches no values because `!` is uninhabited
+        //~| NOTE to learn more about uninhabited types, see
     }
 
     #[derive(Copy, Clone)]
@@ -45,12 +46,14 @@ fn main() {
         (Err(_), Err(_)) => {}
         //~^ ERROR unreachable pattern
         //~| NOTE matches no values because `Void2` is uninhabited
+        //~| NOTE to learn more about uninhabited types, see
         _ => {}
     }
     match (res1, &res2) {
         (Err(_), Err(_)) => {}
         //~^ ERROR unreachable pattern
         //~| NOTE matches no values because `Void1` is uninhabited
+        //~| NOTE to learn more about uninhabited types, see
         _ => {}
     }
 
diff --git a/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr b/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
index da9bf30aa58cb..0dfd0980050f4 100644
--- a/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
+++ b/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
@@ -38,25 +38,28 @@ LL |         Err(_) => {}
    |         ^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:45:9
+  --> $DIR/explain-unreachable-pats.rs:46:9
    |
 LL |         (Err(_), Err(_)) => {}
    |         ^^^^^^^^^^^^^^^^
    |
    = note: matches no values because `Void2` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:51:9
+  --> $DIR/explain-unreachable-pats.rs:53:9
    |
 LL |         (Err(_), Err(_)) => {}
    |         ^^^^^^^^^^^^^^^^
    |
    = note: matches no values because `Void1` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:60:11
+  --> $DIR/explain-unreachable-pats.rs:63:11
    |
 LL |     if let (0
    |             - matches all the relevant values
@@ -65,13 +68,13 @@ LL |         | 0, _) = (0, 0) {}
    |           ^ no value can reach this
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:70:9
+  --> $DIR/explain-unreachable-pats.rs:73:9
    |
 LL |         (_, true) => {}
    |         ^^^^^^^^^ no value can reach this
    |
 note: multiple earlier patterns match some of the same values
-  --> $DIR/explain-unreachable-pats.rs:70:9
+  --> $DIR/explain-unreachable-pats.rs:73:9
    |
 LL |         (true, _) => {}
    |         --------- matches some of the same values
@@ -83,7 +86,7 @@ LL |         (_, true) => {}
    |         ^^^^^^^^^ collectively making this unreachable
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:83:9
+  --> $DIR/explain-unreachable-pats.rs:86:9
    |
 LL |         (true, _) => {}
    |         --------- matches all the relevant values
@@ -92,7 +95,7 @@ LL |         (true, true) => {}
    |         ^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:95:9
+  --> $DIR/explain-unreachable-pats.rs:98:9
    |
 LL |         (_, true, 0..10) => {}
    |         ---------------- matches all the relevant values
diff --git a/tests/ui/pattern/usefulness/impl-trait.stderr b/tests/ui/pattern/usefulness/impl-trait.stderr
index 04d6671bb9a61..0abfeb5b52907 100644
--- a/tests/ui/pattern/usefulness/impl-trait.stderr
+++ b/tests/ui/pattern/usefulness/impl-trait.stderr
@@ -5,6 +5,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/impl-trait.rs:4:9
    |
@@ -18,6 +19,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:44:13
@@ -26,6 +28,7 @@ LL |             Some(_) => {}
    |             ^^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:48:13
@@ -42,6 +45,7 @@ LL |             Some(_) => {}
    |             ^^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:62:13
@@ -58,6 +62,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:85:9
@@ -74,6 +79,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:104:9
@@ -98,6 +104,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `SecretelyVoid` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:150:13
@@ -106,6 +113,7 @@ LL |             _ => {}
    |             ^
    |
    = note: matches no values because `SecretelyDoubleVoid` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `impl Copy` is non-empty
   --> $DIR/impl-trait.rs:22:11
diff --git a/tests/ui/reachable/unreachable-loop-patterns.stderr b/tests/ui/reachable/unreachable-loop-patterns.stderr
index 9781a976686e9..f34ca3258ca51 100644
--- a/tests/ui/reachable/unreachable-loop-patterns.stderr
+++ b/tests/ui/reachable/unreachable-loop-patterns.stderr
@@ -5,6 +5,7 @@ LL |     for _ in unimplemented!() as Void {}
    |         ^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/unreachable-loop-patterns.rs:3:9
    |
diff --git a/tests/ui/reachable/unreachable-try-pattern.stderr b/tests/ui/reachable/unreachable-try-pattern.stderr
index 83040d35c0f15..2ead661a65886 100644
--- a/tests/ui/reachable/unreachable-try-pattern.stderr
+++ b/tests/ui/reachable/unreachable-try-pattern.stderr
@@ -20,6 +20,7 @@ LL |     let y = (match x { Ok(n) => Ok(n as u32), Err(e) => Err(e) })?;
    |                        ^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/unreachable-try-pattern.rs:4:9
    |
@@ -33,6 +34,7 @@ LL |     let y = (match x { Ok(n) => Ok(n), Err(e) => Err(e) })?;
    |                                        ^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 warning: 3 warnings emitted
 
diff --git a/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr b/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr
index be8b38f6942dc..b7a5f3e551390 100644
--- a/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr
+++ b/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr
@@ -5,6 +5,7 @@ LL |         Err(!),
    |         ^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/unreachable.rs:4:9
    |
@@ -18,6 +19,7 @@ LL |     let (Ok(_x) | Err(!)) = res_void;
    |                   ^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:19:12
@@ -26,6 +28,7 @@ LL |     if let Err(!) = res_void {}
    |            ^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:21:24
@@ -34,6 +37,7 @@ LL |     if let (Ok(true) | Err(!)) = res_void {}
    |                        ^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:23:23
@@ -42,6 +46,7 @@ LL |     for (Ok(mut _x) | Err(!)) in [res_void] {}
    |                       ^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:27:18
@@ -50,6 +55,7 @@ LL | fn foo((Ok(_x) | Err(!)): Result<bool, Void>) {}
    |                  ^^^^^^
    |
    = note: matches no values because `Void` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: aborting due to 6 previous errors
 
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr
index 06bc901ffdfdb..88fab333c74af 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr
@@ -5,6 +5,7 @@ LL |         _ => {}
    |         ^
    |
    = note: matches no values because `EmptyNonExhaustiveEnum` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/enum_same_crate_empty_match.rs:1:9
    |
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
index 982129046b8b1..5dbe7a2dc5ac5 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
@@ -5,6 +5,7 @@ LL |         Some(_x) => (),
    |         ^^^^^^^^
    |
    = note: matches no values because `UninhabitedEnum` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/patterns_same_crate.rs:1:9
    |
@@ -18,6 +19,7 @@ LL |         Some(_x) => (),
    |         ^^^^^^^^
    |
    = note: matches no values because `UninhabitedVariants` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:60:15
@@ -26,6 +28,7 @@ LL |     while let PartiallyInhabitedVariants::Struct { x } = partially_inhabite
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: matches no values because `!` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:64:15
@@ -34,6 +37,7 @@ LL |     while let Some(_x) = uninhabited_struct() {
    |               ^^^^^^^^
    |
    = note: matches no values because `UninhabitedStruct` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:67:15
@@ -42,6 +46,7 @@ LL |     while let Some(_x) = uninhabited_tuple_struct() {
    |               ^^^^^^^^
    |
    = note: matches no values because `UninhabitedTupleStruct` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/uninhabited/uninhabited-patterns.stderr b/tests/ui/uninhabited/uninhabited-patterns.stderr
index 4bac1bc52f473..c9b9242384d9a 100644
--- a/tests/ui/uninhabited/uninhabited-patterns.stderr
+++ b/tests/ui/uninhabited/uninhabited-patterns.stderr
@@ -5,6 +5,7 @@ LL |         Ok(box _) => (),
    |         ^^^^^^^^^
    |
    = note: matches no values because `NotSoSecretlyEmpty` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/uninhabited-patterns.rs:3:9
    |
@@ -18,6 +19,7 @@ LL |         Err(Ok(_y)) => (),
    |         ^^^^^^^^^^^
    |
    = note: matches no values because `NotSoSecretlyEmpty` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/uninhabited-patterns.rs:41:15
@@ -26,6 +28,7 @@ LL |     while let Some(_y) = foo() {
    |               ^^^^^^^^
    |
    = note: matches no values because `NotSoSecretlyEmpty` is uninhabited
+   = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: aborting due to 3 previous errors
 

From 36eced444e2c98aa7133cfeeeccaf6f2f36d6ff7 Mon Sep 17 00:00:00 2001
From: Nadrieril <nadrieril+git@gmail.com>
Date: Mon, 19 Aug 2024 21:26:32 +0200
Subject: [PATCH 446/685] Cap the number of patterns pointed to by the lint

---
 compiler/rustc_mir_build/messages.ftl         |  2 +
 compiler/rustc_mir_build/src/errors.rs        |  1 +
 .../src/thir/pattern/check_match.rs           | 20 +++++++--
 .../usefulness/explain-unreachable-pats.rs    | 19 +++++++++
 .../explain-unreachable-pats.stderr           | 42 +++++++++++++++----
 5 files changed, 72 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index b6258045566b0..15da430759b8e 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -327,6 +327,8 @@ mir_build_union_pattern = cannot use unions in constant patterns
 
 mir_build_unreachable_making_this_unreachable = collectively making this unreachable
 
+mir_build_unreachable_making_this_unreachable_n_more = ...and {$covered_by_many_n_more_count} other patterns collectively make this unreachable
+
 mir_build_unreachable_matches_same_values = matches some of the same values
 
 mir_build_unreachable_pattern = unreachable pattern
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index a45a0311e32d4..76b765ad4cd9b 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -596,6 +596,7 @@ pub(crate) struct UnreachablePattern<'tcx> {
     pub(crate) covered_by_one: Option<Span>,
     #[note(mir_build_unreachable_covered_by_many)]
     pub(crate) covered_by_many: Option<MultiSpan>,
+    pub(crate) covered_by_many_n_more_count: usize,
 }
 
 #[derive(Subdiagnostic)]
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index a948e5d0c2168..ca563e015698b 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -917,6 +917,7 @@ fn report_unreachable_pattern<'p, 'tcx>(
     pat: &DeconstructedPat<'p, 'tcx>,
     explanation: &RedundancyExplanation<'p, 'tcx>,
 ) {
+    static CAP_COVERED_BY_MANY: usize = 4;
     let pat_span = pat.data().span;
     let mut lint = UnreachablePattern {
         span: Some(pat_span),
@@ -925,6 +926,7 @@ fn report_unreachable_pattern<'p, 'tcx>(
         covered_by_catchall: None,
         covered_by_one: None,
         covered_by_many: None,
+        covered_by_many_n_more_count: 0,
     };
     match explanation.covered_by.as_slice() {
         [] => {
@@ -950,15 +952,27 @@ fn report_unreachable_pattern<'p, 'tcx>(
             lint.covered_by_one = Some(covering_pat.data().span);
         }
         covering_pats => {
+            let mut iter = covering_pats.iter();
             let mut multispan = MultiSpan::from_span(pat_span);
-            for p in covering_pats {
+            for p in iter.by_ref().take(CAP_COVERED_BY_MANY) {
                 multispan.push_span_label(
                     p.data().span,
                     fluent::mir_build_unreachable_matches_same_values,
                 );
             }
-            multispan
-                .push_span_label(pat_span, fluent::mir_build_unreachable_making_this_unreachable);
+            let remain = iter.count();
+            if remain == 0 {
+                multispan.push_span_label(
+                    pat_span,
+                    fluent::mir_build_unreachable_making_this_unreachable,
+                );
+            } else {
+                lint.covered_by_many_n_more_count = remain;
+                multispan.push_span_label(
+                    pat_span,
+                    fluent::mir_build_unreachable_making_this_unreachable_n_more,
+                );
+            }
             lint.covered_by_many = Some(multispan);
         }
     }
diff --git a/tests/ui/pattern/usefulness/explain-unreachable-pats.rs b/tests/ui/pattern/usefulness/explain-unreachable-pats.rs
index 746343246c6ee..1cfa5212414bb 100644
--- a/tests/ui/pattern/usefulness/explain-unreachable-pats.rs
+++ b/tests/ui/pattern/usefulness/explain-unreachable-pats.rs
@@ -26,6 +26,25 @@ fn main() {
         _ => {}
     }
 
+    match 0u8 {
+        1 => {}
+        //~^ NOTE matches some of the same values
+        2 => {}
+        //~^ NOTE matches some of the same values
+        3 => {}
+        //~^ NOTE matches some of the same values
+        4 => {}
+        //~^ NOTE matches some of the same values
+        5 => {}
+        6 => {}
+        1 ..= 6 => {}
+        //~^ ERROR unreachable pattern
+        //~| NOTE no value can reach this
+        //~| NOTE multiple earlier patterns match some of the same values
+        //~| NOTE ...and 2 other patterns
+        _ => {}
+    }
+
     let res: Result<(),!> = Ok(());
     match res {
         Ok(_) => {}
diff --git a/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr b/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
index 0dfd0980050f4..1378dce606358 100644
--- a/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
+++ b/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
@@ -32,7 +32,31 @@ LL |         (1 | 2,) => {}
    |         ^^^^^^^^ collectively making this unreachable
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:32:9
+  --> $DIR/explain-unreachable-pats.rs:40:9
+   |
+LL |         1 ..= 6 => {}
+   |         ^^^^^^^ no value can reach this
+   |
+note: multiple earlier patterns match some of the same values
+  --> $DIR/explain-unreachable-pats.rs:40:9
+   |
+LL |         1 => {}
+   |         - matches some of the same values
+LL |
+LL |         2 => {}
+   |         - matches some of the same values
+LL |
+LL |         3 => {}
+   |         - matches some of the same values
+LL |
+LL |         4 => {}
+   |         - matches some of the same values
+...
+LL |         1 ..= 6 => {}
+   |         ^^^^^^^ ...and 2 other patterns collectively make this unreachable
+
+error: unreachable pattern
+  --> $DIR/explain-unreachable-pats.rs:51:9
    |
 LL |         Err(_) => {}
    |         ^^^^^^
@@ -41,7 +65,7 @@ LL |         Err(_) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:46:9
+  --> $DIR/explain-unreachable-pats.rs:65:9
    |
 LL |         (Err(_), Err(_)) => {}
    |         ^^^^^^^^^^^^^^^^
@@ -50,7 +74,7 @@ LL |         (Err(_), Err(_)) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:53:9
+  --> $DIR/explain-unreachable-pats.rs:72:9
    |
 LL |         (Err(_), Err(_)) => {}
    |         ^^^^^^^^^^^^^^^^
@@ -59,7 +83,7 @@ LL |         (Err(_), Err(_)) => {}
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:63:11
+  --> $DIR/explain-unreachable-pats.rs:82:11
    |
 LL |     if let (0
    |             - matches all the relevant values
@@ -68,13 +92,13 @@ LL |         | 0, _) = (0, 0) {}
    |           ^ no value can reach this
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:73:9
+  --> $DIR/explain-unreachable-pats.rs:92:9
    |
 LL |         (_, true) => {}
    |         ^^^^^^^^^ no value can reach this
    |
 note: multiple earlier patterns match some of the same values
-  --> $DIR/explain-unreachable-pats.rs:73:9
+  --> $DIR/explain-unreachable-pats.rs:92:9
    |
 LL |         (true, _) => {}
    |         --------- matches some of the same values
@@ -86,7 +110,7 @@ LL |         (_, true) => {}
    |         ^^^^^^^^^ collectively making this unreachable
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:86:9
+  --> $DIR/explain-unreachable-pats.rs:105:9
    |
 LL |         (true, _) => {}
    |         --------- matches all the relevant values
@@ -95,7 +119,7 @@ LL |         (true, true) => {}
    |         ^^^^^^^^^^^^ no value can reach this
 
 error: unreachable pattern
-  --> $DIR/explain-unreachable-pats.rs:98:9
+  --> $DIR/explain-unreachable-pats.rs:117:9
    |
 LL |         (_, true, 0..10) => {}
    |         ---------------- matches all the relevant values
@@ -103,5 +127,5 @@ LL |         (_, true, 0..10) => {}
 LL |         (_, true, 3) => {}
    |         ^^^^^^^^^^^^ no value can reach this
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors
 

From c864238baf2d44e1634c754451d69e66ef56201b Mon Sep 17 00:00:00 2001
From: Xiretza <xiretza@xiretza.xyz>
Date: Mon, 19 Aug 2024 20:20:48 +0000
Subject: [PATCH 447/685] Update annotate-snippets to 0.11

---
 Cargo.lock                                    | 14 +---
 compiler/rustc_errors/Cargo.toml              |  2 +-
 .../src/annotate_snippet_emitter_writer.rs    | 69 ++++++++-----------
 compiler/rustc_fluent_macro/Cargo.toml        |  2 +-
 compiler/rustc_fluent_macro/src/fluent.rs     | 30 +++-----
 5 files changed, 42 insertions(+), 75 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ac347d02af700..a18219b56837e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -94,16 +94,6 @@ dependencies = [
  "yansi-term",
 ]
 
-[[package]]
-name = "annotate-snippets"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d9b665789884a7e8fb06c84b295e923b03ca51edbb7d08f91a6a50322ecbfe6"
-dependencies = [
- "anstyle",
- "unicode-width",
-]
-
 [[package]]
 name = "annotate-snippets"
 version = "0.11.4"
@@ -3642,7 +3632,7 @@ dependencies = [
 name = "rustc_errors"
 version = "0.0.0"
 dependencies = [
- "annotate-snippets 0.10.2",
+ "annotate-snippets 0.11.4",
  "derive_setters",
  "rustc_ast",
  "rustc_ast_pretty",
@@ -3702,7 +3692,7 @@ dependencies = [
 name = "rustc_fluent_macro"
 version = "0.0.0"
 dependencies = [
- "annotate-snippets 0.10.2",
+ "annotate-snippets 0.11.4",
  "fluent-bundle",
  "fluent-syntax",
  "proc-macro2",
diff --git a/compiler/rustc_errors/Cargo.toml b/compiler/rustc_errors/Cargo.toml
index 2fff9f2de50fb..59cf4e5f210b7 100644
--- a/compiler/rustc_errors/Cargo.toml
+++ b/compiler/rustc_errors/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 # tidy-alphabetical-start
-annotate-snippets = "0.10"
+annotate-snippets = "0.11"
 derive_setters = "0.1.6"
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
diff --git a/compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs b/compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs
index df4e9792f9538..d71ae9d210d5d 100644
--- a/compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs
+++ b/compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs
@@ -5,7 +5,7 @@
 //!
 //! [annotate_snippets]: https://docs.rs/crate/annotate-snippets/
 
-use annotate_snippets::{Annotation, AnnotationType, Renderer, Slice, Snippet, SourceAnnotation};
+use annotate_snippets::{Renderer, Snippet};
 use rustc_data_structures::sync::Lrc;
 use rustc_error_messages::FluentArgs;
 use rustc_span::source_map::SourceMap;
@@ -83,15 +83,17 @@ fn source_string(file: Lrc<SourceFile>, line: &Line) -> String {
     file.get_line(line.line_index - 1).map(|a| a.to_string()).unwrap_or_default()
 }
 
-/// Maps `diagnostic::Level` to `snippet::AnnotationType`
-fn annotation_type_for_level(level: Level) -> AnnotationType {
+/// Maps [`crate::Level`] to [`annotate_snippets::Level`]
+fn annotation_level_for_level(level: Level) -> annotate_snippets::Level {
     match level {
-        Level::Bug | Level::Fatal | Level::Error | Level::DelayedBug => AnnotationType::Error,
-        Level::ForceWarning(_) | Level::Warning => AnnotationType::Warning,
-        Level::Note | Level::OnceNote => AnnotationType::Note,
-        Level::Help | Level::OnceHelp => AnnotationType::Help,
+        Level::Bug | Level::Fatal | Level::Error | Level::DelayedBug => {
+            annotate_snippets::Level::Error
+        }
+        Level::ForceWarning(_) | Level::Warning => annotate_snippets::Level::Warning,
+        Level::Note | Level::OnceNote => annotate_snippets::Level::Note,
+        Level::Help | Level::OnceHelp => annotate_snippets::Level::Help,
         // FIXME(#59346): Not sure how to map this level
-        Level::FailureNote => AnnotationType::Error,
+        Level::FailureNote => annotate_snippets::Level::Error,
         Level::Allow => panic!("Should not call with Allow"),
         Level::Expect(_) => panic!("Should not call with Expect"),
     }
@@ -180,42 +182,29 @@ impl AnnotateSnippetEmitter {
                 })
                 .collect();
             let code = code.map(|code| code.to_string());
-            let snippet = Snippet {
-                title: Some(Annotation {
-                    label: Some(&message),
-                    id: code.as_deref(),
-                    annotation_type: annotation_type_for_level(*level),
-                }),
-                footer: vec![],
-                slices: annotated_files
-                    .iter()
-                    .map(|(file_name, source, line_index, annotations)| {
-                        Slice {
-                            source,
-                            line_start: *line_index,
-                            origin: Some(file_name),
-                            // FIXME(#59346): Not really sure when `fold` should be true or false
-                            fold: false,
-                            annotations: annotations
-                                .iter()
-                                .map(|annotation| SourceAnnotation {
-                                    range: (
-                                        annotation.start_col.display,
-                                        annotation.end_col.display,
-                                    ),
-                                    label: annotation.label.as_deref().unwrap_or_default(),
-                                    annotation_type: annotation_type_for_level(*level),
-                                })
-                                .collect(),
-                        }
-                    })
-                    .collect(),
-            };
+
+            let snippets =
+                annotated_files.iter().map(|(file_name, source, line_index, annotations)| {
+                    Snippet::source(source)
+                        .line_start(*line_index)
+                        .origin(file_name)
+                        // FIXME(#59346): Not really sure when `fold` should be true or false
+                        .fold(false)
+                        .annotations(annotations.iter().map(|annotation| {
+                            annotation_level_for_level(*level)
+                                .span(annotation.start_col.display..annotation.end_col.display)
+                                .label(annotation.label.as_deref().unwrap_or_default())
+                        }))
+                });
+            let mut message = annotation_level_for_level(*level).title(&message).snippets(snippets);
+            if let Some(code) = code.as_deref() {
+                message = message.id(code)
+            }
             // FIXME(#59346): Figure out if we can _always_ print to stderr or not.
             // `emitter.rs` has the `Destination` enum that lists various possible output
             // destinations.
             let renderer = Renderer::plain().anonymized_line_numbers(self.ui_testing);
-            eprintln!("{}", renderer.render(snippet))
+            eprintln!("{}", renderer.render(message))
         }
         // FIXME(#59346): Is it ok to return None if there's no source_map?
     }
diff --git a/compiler/rustc_fluent_macro/Cargo.toml b/compiler/rustc_fluent_macro/Cargo.toml
index c5a53ae831355..eeceaa4691a2a 100644
--- a/compiler/rustc_fluent_macro/Cargo.toml
+++ b/compiler/rustc_fluent_macro/Cargo.toml
@@ -8,7 +8,7 @@ proc-macro = true
 
 [dependencies]
 # tidy-alphabetical-start
-annotate-snippets = "0.10"
+annotate-snippets = "0.11"
 fluent-bundle = "0.15.2"
 fluent-syntax = "0.11"
 proc-macro2 = "1"
diff --git a/compiler/rustc_fluent_macro/src/fluent.rs b/compiler/rustc_fluent_macro/src/fluent.rs
index 23795a96b923c..ca8bace28f3d1 100644
--- a/compiler/rustc_fluent_macro/src/fluent.rs
+++ b/compiler/rustc_fluent_macro/src/fluent.rs
@@ -2,7 +2,7 @@ use std::collections::{HashMap, HashSet};
 use std::fs::read_to_string;
 use std::path::{Path, PathBuf};
 
-use annotate_snippets::{Annotation, AnnotationType, Renderer, Slice, Snippet, SourceAnnotation};
+use annotate_snippets::{Renderer, Snippet};
 use fluent_bundle::{FluentBundle, FluentError, FluentResource};
 use fluent_syntax::ast::{
     Attribute, Entry, Expression, Identifier, InlineExpression, Message, Pattern, PatternElement,
@@ -154,27 +154,15 @@ pub(crate) fn fluent_messages(input: proc_macro::TokenStream) -> proc_macro::Tok
                     .unwrap()
                     .0;
 
-                let snippet = Snippet {
-                    title: Some(Annotation {
-                        label: Some(&err),
-                        id: None,
-                        annotation_type: AnnotationType::Error,
-                    }),
-                    footer: vec![],
-                    slices: vec![Slice {
-                        source: this.source(),
-                        line_start,
-                        origin: Some(&relative_ftl_path),
-                        fold: true,
-                        annotations: vec![SourceAnnotation {
-                            label: "",
-                            annotation_type: AnnotationType::Error,
-                            range: (pos.start, pos.end - 1),
-                        }],
-                    }],
-                };
+                let message = annotate_snippets::Level::Error.title(&err).snippet(
+                    Snippet::source(this.source())
+                        .line_start(line_start)
+                        .origin(&relative_ftl_path)
+                        .fold(true)
+                        .annotation(annotate_snippets::Level::Error.span(pos.start..pos.end - 1)),
+                );
                 let renderer = Renderer::plain();
-                eprintln!("{}\n", renderer.render(snippet));
+                eprintln!("{}\n", renderer.render(message));
             }
 
             return failed(&crate_name);

From 7f5d282185674cac26f9f916f0f1ae8ec04e3482 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 16 Jun 2024 12:58:08 -0400
Subject: [PATCH 448/685] Add a precondition check for
 Layout::from_size_align_unchecked

---
 library/core/src/alloc/layout.rs | 32 +++++++++++++++++++++++++++-----
 library/core/src/result.rs       |  2 --
 2 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/library/core/src/alloc/layout.rs b/library/core/src/alloc/layout.rs
index 549a4bc6727fc..c2521ffe9cc96 100644
--- a/library/core/src/alloc/layout.rs
+++ b/library/core/src/alloc/layout.rs
@@ -6,7 +6,7 @@
 
 use crate::error::Error;
 use crate::ptr::{Alignment, NonNull};
-use crate::{cmp, fmt, mem};
+use crate::{assert_unsafe_precondition, cmp, fmt, mem};
 
 // While this function is used in one place and its implementation
 // could be inlined, the previous attempts to do so made rustc
@@ -66,12 +66,25 @@ impl Layout {
     #[inline]
     #[rustc_allow_const_fn_unstable(ptr_alignment_type)]
     pub const fn from_size_align(size: usize, align: usize) -> Result<Self, LayoutError> {
-        if !align.is_power_of_two() {
-            return Err(LayoutError);
+        if Layout::is_size_align_valid(size, align) {
+            // SAFETY: Layout::is_size_align_valid checks the preconditions for this call.
+            let layout = unsafe { Layout::from_size_align_unchecked(size, align) };
+            Ok(layout)
+        } else {
+            Err(LayoutError)
         }
+    }
 
-        // SAFETY: just checked that align is a power of two.
-        Layout::from_size_alignment(size, unsafe { Alignment::new_unchecked(align) })
+    const fn is_size_align_valid(size: usize, align: usize) -> bool {
+        if !align.is_power_of_two() {
+            return false;
+        }
+        // SAFETY: Precondition checked directly above.
+        let align = unsafe { Alignment::new_unchecked(align) };
+        if size > Self::max_size_for_align(align) {
+            return false;
+        }
+        true
     }
 
     #[inline(always)]
@@ -116,6 +129,15 @@ impl Layout {
     #[inline]
     #[rustc_allow_const_fn_unstable(ptr_alignment_type)]
     pub const unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Self {
+        assert_unsafe_precondition!(
+            check_library_ub,
+            "Layout::from_size_align_unchecked requires that align is a power of 2 \
+            and the rounded-up allocation size does not exceed isize::MAX",
+            (
+                size: usize = size,
+                align: usize = align,
+            ) => Layout::is_size_align_valid(size, align)
+        );
         // SAFETY: the caller is required to uphold the preconditions.
         unsafe { Layout { size, align: Alignment::new_unchecked(align) } }
     }
diff --git a/library/core/src/result.rs b/library/core/src/result.rs
index 7f278296b7b88..73b11f803d929 100644
--- a/library/core/src/result.rs
+++ b/library/core/src/result.rs
@@ -1481,7 +1481,6 @@ impl<T, E> Result<T, E> {
     #[track_caller]
     #[stable(feature = "option_result_unwrap_unchecked", since = "1.58.0")]
     pub unsafe fn unwrap_unchecked(self) -> T {
-        debug_assert!(self.is_ok());
         match self {
             Ok(t) => t,
             // SAFETY: the safety contract must be upheld by the caller.
@@ -1513,7 +1512,6 @@ impl<T, E> Result<T, E> {
     #[track_caller]
     #[stable(feature = "option_result_unwrap_unchecked", since = "1.58.0")]
     pub unsafe fn unwrap_err_unchecked(self) -> E {
-        debug_assert!(self.is_err());
         match self {
             // SAFETY: the safety contract must be upheld by the caller.
             Ok(_) => unsafe { hint::unreachable_unchecked() },

From 78d0e08504a30e5ff8b8e0ba88126af95a16a398 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 19 Aug 2024 10:57:03 -0400
Subject: [PATCH 449/685] Don't consider RibKind::Module's bindings when
 checking generics shadowing

---
 compiler/rustc_resolve/src/late.rs              | 6 +++---
 tests/ui/resolve/local-shadows-inner-generic.rs | 8 ++++++++
 2 files changed, 11 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/resolve/local-shadows-inner-generic.rs

diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 4a70fc0f30847..40fdb01a72c0e 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -2677,14 +2677,14 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
             // We also can't shadow bindings from associated parent items.
             for ns in [ValueNS, TypeNS] {
                 for parent_rib in self.ribs[ns].iter().rev() {
-                    seen_bindings
-                        .extend(parent_rib.bindings.keys().map(|ident| (*ident, ident.span)));
-
                     // Break at mod level, to account for nested items which are
                     // allowed to shadow generic param names.
                     if matches!(parent_rib.kind, RibKind::Module(..)) {
                         break;
                     }
+
+                    seen_bindings
+                        .extend(parent_rib.bindings.keys().map(|ident| (*ident, ident.span)));
                 }
             }
 
diff --git a/tests/ui/resolve/local-shadows-inner-generic.rs b/tests/ui/resolve/local-shadows-inner-generic.rs
new file mode 100644
index 0000000000000..d9145b9fe2c86
--- /dev/null
+++ b/tests/ui/resolve/local-shadows-inner-generic.rs
@@ -0,0 +1,8 @@
+//@ check-pass
+
+#![allow(non_camel_case_types)]
+
+pub fn main() {
+    let a = 1;
+    struct Foo<a> { field: a, };
+}

From 3c735a00f70c8c3df737eb18494e9eb9c6196971 Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Mon, 19 Aug 2024 17:10:37 -0700
Subject: [PATCH 450/685] Add a test.

---
 tests/debuginfo/dummy_span.rs | 45 +++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 tests/debuginfo/dummy_span.rs

diff --git a/tests/debuginfo/dummy_span.rs b/tests/debuginfo/dummy_span.rs
new file mode 100644
index 0000000000000..d02eead470fa1
--- /dev/null
+++ b/tests/debuginfo/dummy_span.rs
@@ -0,0 +1,45 @@
+//@ min-lldb-version: 310
+
+//@ compile-flags:-g
+
+// === GDB TESTS ===================================================================================
+
+// gdb-command:run 7
+
+// gdb-command:next
+// gdb-command:next
+// gdb-check:[...]#loc1[...]
+// gdb-command:next
+// gdb-check:[...]#loc2[...]
+
+// === LLDB TESTS ==================================================================================
+
+// lldb-command:run 7
+
+// lldb-command:next
+// lldb-command:next
+// lldb-command:frame select
+// lldb-check:[...]#loc1[...]
+// lldb-command:next
+// lldb-command:frame select
+// lldb-check:[...]#loc2[...]
+
+use std::env;
+use std::num::ParseIntError;
+
+fn main() -> Result<(), ParseIntError> {
+    let args = env::args();
+    let number_str = args.skip(1).next().unwrap();
+    let number = number_str.parse::<i32>()?;
+    zzz(); // #break
+    if number % 7 == 0 {
+        // This generates code with a dummy span for
+        // some reason. If that ever changes this
+        // test will not test what it wants to test.
+        return Ok(()); // #loc1
+    }
+    println!("{}", number);
+    Ok(())
+} // #loc2
+
+fn zzz() { () }

From 4e9725cd2f5327f65f881c59d6bcbae46308318e Mon Sep 17 00:00:00 2001
From: Kyle Huey <khuey@kylehuey.com>
Date: Mon, 19 Aug 2024 17:13:30 -0700
Subject: [PATCH 451/685] Add a comment.

---
 compiler/rustc_codegen_llvm/src/debuginfo/mod.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index 66dd653bb2166..3fbaebe28aaec 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -570,6 +570,11 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         inlined_at: Option<&'ll DILocation>,
         span: Span,
     ) -> &'ll DILocation {
+        // When emitting debugging information, DWARF (i.e. everything but MSVC)
+        // treats line 0 as a magic value meaning that the code could not be
+        // attributed to any line in the source. That's also exactly what dummy
+        // spans are. Make that equivalence here, rather than passing dummy spans
+        // to lookup_debug_loc, which will return line 1 for them.
         let (line, col) = if span.is_dummy() && !self.sess().target.is_like_msvc {
             (0, 0)
         } else {

From 9d7574f9b0925a5b681e19e81f96ad8d5f2a5be2 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Mon, 19 Aug 2024 16:16:34 -0700
Subject: [PATCH 452/685] rustdoc: animate the `:target` highlight

This approach is, roughly, based on how Discourse does it.
It came up while discussing some other possible sidebar changes,
as a design that made rapid scanning easier while avoiding the
inherent trade-offs in summarizing.
---
 src/librustdoc/html/static/css/rustdoc.css | 13 +++++++++++++
 tests/rustdoc-gui/target.goml              |  2 +-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index eb5a5d935e202..28df8d3f011fe 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -1547,10 +1547,23 @@ instead, we check that it's not a "finger" cursor.
 	margin-left: 24px;
 }
 
+@keyframes targetfadein {
+	from {
+		background-color: var(--main-background-color);
+	}
+	10% {
+		background-color: var(--target-border-color);
+	}
+	to {
+		background-color: var(--target-background-color);
+	}
+}
+
 :target {
 	padding-right: 3px;
 	background-color: var(--target-background-color);
 	border-right: 3px solid var(--target-border-color);
+	animation: 0.65s cubic-bezier(0, 0, 0.1, 1.0) 0.1s targetfadein;
 }
 
 .code-header a.tooltip {
diff --git a/tests/rustdoc-gui/target.goml b/tests/rustdoc-gui/target.goml
index 82bd34ed2746e..92846f8e01d27 100644
--- a/tests/rustdoc-gui/target.goml
+++ b/tests/rustdoc-gui/target.goml
@@ -11,7 +11,7 @@ define-function: (
     [theme, background, border],
     block {
         call-function: ("switch-theme", {"theme": |theme|})
-        assert-css: ("#method\.a_method:target", {
+        wait-for-css: ("#method\.a_method:target", {
             "background-color": |background|,
             "border-right": "3px solid " + |border|,
         })

From a97b41f1880f3aef9f4669ba56cf2e4d830825bc Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 19 Aug 2024 21:26:10 -0400
Subject: [PATCH 453/685] Use subtyping for UnsafeFnPointer coercion, too

---
 compiler/rustc_borrowck/src/type_check/mod.rs      |  4 ++--
 .../coercion/cast-higher-ranked-unsafe-fn-ptr.rs   | 14 ++++++++++++++
 2 files changed, 16 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/coercion/cast-higher-ranked-unsafe-fn-ptr.rs

diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 6983cda6ddf3b..3b3898ccd4da1 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -2043,9 +2043,9 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
                         let ty_fn_ptr_from = tcx.safe_to_unsafe_fn_ty(fn_sig);
 
-                        if let Err(terr) = self.eq_types(
-                            *ty,
+                        if let Err(terr) = self.sub_types(
                             ty_fn_ptr_from,
+                            *ty,
                             location.to_locations(),
                             ConstraintCategory::Cast { unsize_to: None },
                         ) {
diff --git a/tests/ui/coercion/cast-higher-ranked-unsafe-fn-ptr.rs b/tests/ui/coercion/cast-higher-ranked-unsafe-fn-ptr.rs
new file mode 100644
index 0000000000000..19723bee4d46e
--- /dev/null
+++ b/tests/ui/coercion/cast-higher-ranked-unsafe-fn-ptr.rs
@@ -0,0 +1,14 @@
+//@ check-pass
+
+fn higher_ranked_fndef(ctx: &mut ()) {}
+
+fn test(higher_ranked_fnptr: fn(&mut ())) {
+    fn as_unsafe<T>(_: unsafe fn(T)) {}
+
+    // Make sure that we can cast higher-ranked fn items and pointers to
+    // a non-higher-ranked target.
+    as_unsafe(higher_ranked_fndef);
+    as_unsafe(higher_ranked_fnptr);
+}
+
+fn main() {}

From a5f6c15571216703bf94e5a657d96bc9df54fb17 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Mon, 19 Aug 2024 22:22:08 -0400
Subject: [PATCH 454/685] Pin `cc` to 1.0.105

`cc` 1.0.106 removes support for Visual Studio 12. Pin to 1.0.105 so we
don't drop support yet.

Fixes: https://github.com/rust-lang/rust/pull/128722#issuecomment-2297605573
---
 Cargo.lock                            | 7 ++-----
 compiler/rustc_codegen_ssa/Cargo.toml | 2 +-
 compiler/rustc_llvm/Cargo.toml        | 2 +-
 3 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ac347d02af700..cf9221eb2aef9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -420,12 +420,9 @@ version = "0.1.0"
 
 [[package]]
 name = "cc"
-version = "1.1.13"
+version = "1.0.105"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72db2f7947ecee9b03b510377e8bb9077afa27176fdbff55c51027e976fdcc48"
-dependencies = [
- "shlex",
-]
+checksum = "5208975e568d83b6b05cc0a063c8e7e9acc2b43bee6da15616a5b73e109d7437"
 
 [[package]]
 name = "cfg-if"
diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml
index e3033b332caee..e621eafd48423 100644
--- a/compiler/rustc_codegen_ssa/Cargo.toml
+++ b/compiler/rustc_codegen_ssa/Cargo.toml
@@ -8,7 +8,7 @@ edition = "2021"
 ar_archive_writer = "0.4.0"
 arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
-cc = "1.0.90"
+cc = "=1.0.105" # FIXME(cc): pinned to keep support for VS2013
 either = "1.5.0"
 itertools = "0.12"
 jobserver = "0.1.28"
diff --git a/compiler/rustc_llvm/Cargo.toml b/compiler/rustc_llvm/Cargo.toml
index 83fda7ef07c49..1f74aaf9965a7 100644
--- a/compiler/rustc_llvm/Cargo.toml
+++ b/compiler/rustc_llvm/Cargo.toml
@@ -10,5 +10,5 @@ libc = "0.2.73"
 
 [build-dependencies]
 # tidy-alphabetical-start
-cc = "1.0.97"
+cc = "=1.0.105" # FIXME(cc): pinned to keep support for VS2013
 # tidy-alphabetical-end

From e5072f0e51fc9dcaf59e9902fdc11ef3cb1f6c67 Mon Sep 17 00:00:00 2001
From: The Miri Cronjob Bot <miri@cron.bot>
Date: Tue, 20 Aug 2024 05:00:55 +0000
Subject: [PATCH 455/685] 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 c3f4f4b5d8220..1eca86baeaa21 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-f24a6ba06f4190d8ec4f22d1baa800e64b1900cb
+fdf61d499c8a8421ecf98e7924bb87caf43a9938

From dfea11d6206be57feca5283c67c17b9c3ee12960 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Mon, 19 Aug 2024 22:39:04 -0700
Subject: [PATCH 456/685] Stabilize `iter::repeat_n`

---
 library/alloc/src/lib.rs                  |  1 -
 library/core/src/iter/mod.rs              |  2 +-
 library/core/src/iter/sources.rs          |  2 +-
 library/core/src/iter/sources/repeat_n.rs | 18 ++++++++----------
 library/core/tests/lib.rs                 |  1 -
 5 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 3e44adf73f045..5e4b08df6cb55 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -131,7 +131,6 @@
 #![feature(inplace_iteration)]
 #![feature(iter_advance_by)]
 #![feature(iter_next_chunk)]
-#![feature(iter_repeat_n)]
 #![feature(layout_for_ptr)]
 #![feature(local_waker)]
 #![feature(maybe_uninit_slice)]
diff --git a/library/core/src/iter/mod.rs b/library/core/src/iter/mod.rs
index 1f2bf49d2b729..5dad9e1a75ed6 100644
--- a/library/core/src/iter/mod.rs
+++ b/library/core/src/iter/mod.rs
@@ -436,7 +436,7 @@ pub use self::sources::{once, Once};
 pub use self::sources::{once_with, OnceWith};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::sources::{repeat, Repeat};
-#[unstable(feature = "iter_repeat_n", issue = "104434")]
+#[stable(feature = "iter_repeat_n", since = "CURRENT_RUSTC_VERSION")]
 pub use self::sources::{repeat_n, RepeatN};
 #[stable(feature = "iterator_repeat_with", since = "1.28.0")]
 pub use self::sources::{repeat_with, RepeatWith};
diff --git a/library/core/src/iter/sources.rs b/library/core/src/iter/sources.rs
index 6a94051b7c7b8..55901e1e50b42 100644
--- a/library/core/src/iter/sources.rs
+++ b/library/core/src/iter/sources.rs
@@ -24,7 +24,7 @@ pub use self::once::{once, Once};
 pub use self::once_with::{once_with, OnceWith};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::repeat::{repeat, Repeat};
-#[unstable(feature = "iter_repeat_n", issue = "104434")]
+#[stable(feature = "iter_repeat_n", since = "CURRENT_RUSTC_VERSION")]
 pub use self::repeat_n::{repeat_n, RepeatN};
 #[stable(feature = "iterator_repeat_with", since = "1.28.0")]
 pub use self::repeat_with::{repeat_with, RepeatWith};
diff --git a/library/core/src/iter/sources/repeat_n.rs b/library/core/src/iter/sources/repeat_n.rs
index 4c4ae39f836ca..2e247a34075c4 100644
--- a/library/core/src/iter/sources/repeat_n.rs
+++ b/library/core/src/iter/sources/repeat_n.rs
@@ -18,7 +18,6 @@ use crate::num::NonZero;
 /// Basic usage:
 ///
 /// ```
-/// #![feature(iter_repeat_n)]
 /// use std::iter;
 ///
 /// // four of the number four:
@@ -36,7 +35,6 @@ use crate::num::NonZero;
 /// For non-`Copy` types,
 ///
 /// ```
-/// #![feature(iter_repeat_n)]
 /// use std::iter;
 ///
 /// let v: Vec<i32> = Vec::with_capacity(123);
@@ -58,7 +56,7 @@ use crate::num::NonZero;
 /// assert_eq!(None, it.next());
 /// ```
 #[inline]
-#[unstable(feature = "iter_repeat_n", issue = "104434")]
+#[stable(feature = "iter_repeat_n", since = "CURRENT_RUSTC_VERSION")]
 pub fn repeat_n<T: Clone>(element: T, count: usize) -> RepeatN<T> {
     let mut element = ManuallyDrop::new(element);
 
@@ -77,7 +75,7 @@ pub fn repeat_n<T: Clone>(element: T, count: usize) -> RepeatN<T> {
 /// This `struct` is created by the [`repeat_n()`] function.
 /// See its documentation for more.
 #[derive(Clone, Debug)]
-#[unstable(feature = "iter_repeat_n", issue = "104434")]
+#[stable(feature = "iter_repeat_n", since = "CURRENT_RUSTC_VERSION")]
 pub struct RepeatN<A> {
     count: usize,
     // Invariant: has been dropped iff count == 0.
@@ -101,14 +99,14 @@ impl<A> RepeatN<A> {
     }
 }
 
-#[unstable(feature = "iter_repeat_n", issue = "104434")]
+#[stable(feature = "iter_repeat_n", since = "CURRENT_RUSTC_VERSION")]
 impl<A> Drop for RepeatN<A> {
     fn drop(&mut self) {
         self.take_element();
     }
 }
 
-#[unstable(feature = "iter_repeat_n", issue = "104434")]
+#[stable(feature = "iter_repeat_n", since = "CURRENT_RUSTC_VERSION")]
 impl<A: Clone> Iterator for RepeatN<A> {
     type Item = A;
 
@@ -156,14 +154,14 @@ impl<A: Clone> Iterator for RepeatN<A> {
     }
 }
 
-#[unstable(feature = "iter_repeat_n", issue = "104434")]
+#[stable(feature = "iter_repeat_n", since = "CURRENT_RUSTC_VERSION")]
 impl<A: Clone> ExactSizeIterator for RepeatN<A> {
     fn len(&self) -> usize {
         self.count
     }
 }
 
-#[unstable(feature = "iter_repeat_n", issue = "104434")]
+#[stable(feature = "iter_repeat_n", since = "CURRENT_RUSTC_VERSION")]
 impl<A: Clone> DoubleEndedIterator for RepeatN<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
@@ -181,12 +179,12 @@ impl<A: Clone> DoubleEndedIterator for RepeatN<A> {
     }
 }
 
-#[unstable(feature = "iter_repeat_n", issue = "104434")]
+#[stable(feature = "iter_repeat_n", since = "CURRENT_RUSTC_VERSION")]
 impl<A: Clone> FusedIterator for RepeatN<A> {}
 
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<A: Clone> TrustedLen for RepeatN<A> {}
-#[unstable(feature = "trusted_len_next_unchecked", issue = "37572")]
+#[stable(feature = "iter_repeat_n", since = "CURRENT_RUSTC_VERSION")]
 impl<A: Clone> UncheckedIterator for RepeatN<A> {
     #[inline]
     unsafe fn next_unchecked(&mut self) -> Self::Item {
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index 8872b4cbfd5ba..2f0d03abed3cd 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -73,7 +73,6 @@
 #![feature(iter_next_chunk)]
 #![feature(iter_order_by)]
 #![feature(iter_partition_in_place)]
-#![feature(iter_repeat_n)]
 #![feature(iterator_try_collect)]
 #![feature(iterator_try_reduce)]
 #![feature(layout_for_ptr)]

From 75ed08972703798888fceff12b3217408ca6a4b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?=
 <39484203+jieyouxu@users.noreply.github.com>
Date: Tue, 20 Aug 2024 17:24:56 +0800
Subject: [PATCH 457/685] compiletest: use `std::fs::remove_dir_all` now that
 it is available

---
 src/tools/compiletest/src/runtest.rs | 27 ++-------------------------
 1 file changed, 2 insertions(+), 25 deletions(-)

diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index eca21e559896a..6d45040345ad4 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -3265,7 +3265,7 @@ impl<'test> TestCx<'test> {
 
         let tmpdir = cwd.join(self.output_base_name());
         if tmpdir.exists() {
-            self.aggressive_rm_rf(&tmpdir).unwrap();
+            fs::remove_dir_all(&tmpdir).unwrap();
         }
         create_dir_all(&tmpdir).unwrap();
 
@@ -3404,29 +3404,6 @@ impl<'test> TestCx<'test> {
         }
     }
 
-    fn aggressive_rm_rf(&self, path: &Path) -> io::Result<()> {
-        for e in path.read_dir()? {
-            let entry = e?;
-            let path = entry.path();
-            if entry.file_type()?.is_dir() {
-                self.aggressive_rm_rf(&path)?;
-            } else {
-                // Remove readonly files as well on windows (by default we can't)
-                fs::remove_file(&path).or_else(|e| {
-                    if cfg!(windows) && e.kind() == io::ErrorKind::PermissionDenied {
-                        let mut meta = entry.metadata()?.permissions();
-                        meta.set_readonly(false);
-                        fs::set_permissions(&path, meta)?;
-                        fs::remove_file(&path)
-                    } else {
-                        Err(e)
-                    }
-                })?;
-            }
-        }
-        fs::remove_dir(path)
-    }
-
     fn run_rmake_v2_test(&self) {
         // For `run-make` V2, we need to perform 2 steps to build and run a `run-make` V2 recipe
         // (`rmake.rs`) to run the actual tests. The support library is already built as a tool rust
@@ -3475,7 +3452,7 @@ impl<'test> TestCx<'test> {
         // This setup intentionally diverges from legacy Makefile run-make tests.
         let base_dir = self.output_base_name();
         if base_dir.exists() {
-            self.aggressive_rm_rf(&base_dir).unwrap();
+            fs::remove_dir_all(&base_dir).unwrap();
         }
         let rmake_out_dir = base_dir.join("rmake_out");
         create_dir_all(&rmake_out_dir).unwrap();

From 16fd4601577b3bae77955a6889766e9cfccda3dd Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 19 Aug 2024 22:30:03 +0200
Subject: [PATCH 458/685] Remove duplicated usage of `-Zunstable-options` in
 bootstrap

---
 src/bootstrap/src/bin/rustdoc.rs          |  2 --
 src/bootstrap/src/core/build_steps/doc.rs | 19 +++++++------------
 src/bootstrap/src/core/builder.rs         | 13 +------------
 3 files changed, 8 insertions(+), 26 deletions(-)

diff --git a/src/bootstrap/src/bin/rustdoc.rs b/src/bootstrap/src/bin/rustdoc.rs
index ba6b0c2dbdad7..a338b9c808013 100644
--- a/src/bootstrap/src/bin/rustdoc.rs
+++ b/src/bootstrap/src/bin/rustdoc.rs
@@ -59,8 +59,6 @@ fn main() {
     if stage == "0" {
         cmd.arg("--cfg=bootstrap");
     }
-    cmd.arg("-Zunstable-options");
-    cmd.arg("--check-cfg=cfg(bootstrap)");
 
     maybe_dump(format!("stage{stage}-rustdoc"), &cmd);
 
diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index 301633559fe71..ffb617c642baf 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -303,10 +303,11 @@ fn invoke_rustdoc(
         .arg(&out)
         .arg(&path)
         .arg("--markdown-css")
-        .arg("../rust.css");
+        .arg("../rust.css")
+        .arg("-Zunstable-options");
 
     if !builder.config.docs_minification {
-        cmd.arg("-Z").arg("unstable-options").arg("--disable-minification");
+        cmd.arg("--disable-minification");
     }
 
     cmd.run(builder);
@@ -376,8 +377,6 @@ impl Step for Standalone {
             }
 
             let mut cmd = builder.rustdoc_cmd(compiler);
-            // Needed for --index-page flag
-            cmd.arg("-Z").arg("unstable-options");
 
             cmd.arg("--html-after-content")
                 .arg(&footer)
@@ -386,6 +385,7 @@ impl Step for Standalone {
                 .arg("--html-in-header")
                 .arg(&favicon)
                 .arg("--markdown-no-toc")
+                .arg("-Zunstable-options")
                 .arg("--index-page")
                 .arg(builder.src.join("src/doc/index.md"))
                 .arg("--markdown-playground-url")
@@ -478,9 +478,6 @@ impl Step for Releases {
             mem::drop(tmpfile);
             let mut cmd = builder.rustdoc_cmd(compiler);
 
-            // Needed for --index-page flag
-            cmd.arg("-Z").arg("unstable-options");
-
             cmd.arg("--html-after-content")
                 .arg(&footer)
                 .arg("--html-before-content")
@@ -490,6 +487,7 @@ impl Step for Releases {
                 .arg("--markdown-no-toc")
                 .arg("--markdown-css")
                 .arg("rust.css")
+                .arg("-Zunstable-options")
                 .arg("--index-page")
                 .arg(builder.src.join("src/doc/index.md"))
                 .arg("--markdown-playground-url")
@@ -636,6 +634,8 @@ impl Step for Std {
         if !builder.config.docs_minification {
             extra_args.push("--disable-minification");
         }
+        // For `--index-page` and `--output-format=json`.
+        extra_args.push("-Zunstable-options");
 
         doc_std(builder, self.format, stage, target, &out, &extra_args, &crates);
 
@@ -715,8 +715,6 @@ fn doc_std(
         .arg("--target-dir")
         .arg(&*target_dir.to_string_lossy())
         .arg("-Zskip-rustdoc-fingerprint")
-        .rustdocflag("-Z")
-        .rustdocflag("unstable-options")
         .rustdocflag("--resource-suffix")
         .rustdocflag(&builder.version);
     for arg in extra_args {
@@ -822,7 +820,6 @@ impl Step for Rustc {
         // Since we always pass --document-private-items, there's no need to warn about linking to private items.
         cargo.rustdocflag("-Arustdoc::private-intra-doc-links");
         cargo.rustdocflag("--enable-index-page");
-        cargo.rustdocflag("-Zunstable-options");
         cargo.rustdocflag("-Znormalize-docs");
         cargo.rustdocflag("--show-type-layout");
         // FIXME: `--generate-link-to-definition` tries to resolve cfged out code
@@ -830,7 +827,6 @@ impl Step for Rustc {
         // cargo.rustdocflag("--generate-link-to-definition");
 
         compile::rustc_cargo(builder, &mut cargo, target, &compiler);
-        cargo.arg("-Zunstable-options");
         cargo.arg("-Zskip-rustdoc-fingerprint");
 
         // Only include compiler crates, no dependencies of those, such as `libc`.
@@ -986,7 +982,6 @@ macro_rules! tool_doc {
                 cargo.rustdocflag("-Arustdoc::private-intra-doc-links");
                 cargo.rustdocflag("--enable-index-page");
                 cargo.rustdocflag("--show-type-layout");
-                cargo.rustdocflag("-Zunstable-options");
                 // FIXME: `--generate-link-to-definition` tries to resolve cfged out code
                 // see https://github.com/rust-lang/rust/pull/122066#issuecomment-1983049222
                 // cargo.rustdocflag("--generate-link-to-definition");
diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs
index 454cc20d15538..56e06f3e83ef9 100644
--- a/src/bootstrap/src/core/builder.rs
+++ b/src/bootstrap/src/core/builder.rs
@@ -1616,7 +1616,6 @@ impl<'a> Builder<'a> {
             rustflags.arg("-Csymbol-mangling-version=v0");
         } else {
             rustflags.arg("-Csymbol-mangling-version=legacy");
-            rustflags.arg("-Zunstable-options");
         }
 
         // Enable compile-time checking of `cfg` names, values and Cargo `features`.
@@ -1864,16 +1863,7 @@ impl<'a> Builder<'a> {
             },
         );
 
-        let split_debuginfo = self.config.split_debuginfo(target);
-        let split_debuginfo_is_stable = target.contains("linux")
-            || target.contains("apple")
-            || (target.is_msvc() && split_debuginfo == SplitDebuginfo::Packed)
-            || (target.is_windows() && split_debuginfo == SplitDebuginfo::Off);
-
-        if !split_debuginfo_is_stable {
-            rustflags.arg("-Zunstable-options");
-        }
-        match split_debuginfo {
+        match self.config.split_debuginfo(target) {
             SplitDebuginfo::Packed => rustflags.arg("-Csplit-debuginfo=packed"),
             SplitDebuginfo::Unpacked => rustflags.arg("-Csplit-debuginfo=unpacked"),
             SplitDebuginfo::Off => rustflags.arg("-Csplit-debuginfo=off"),
@@ -2050,7 +2040,6 @@ impl<'a> Builder<'a> {
         }
 
         if mode == Mode::Rustc {
-            rustflags.arg("-Zunstable-options");
             rustflags.arg("-Wrustc::internal");
             // FIXME(edition_2024): Change this to `-Wrust_2024_idioms` when all
             // of the individual lints are satisfied.

From 3f5c222b68b619c2ac083e9b3d96d424c88d4af9 Mon Sep 17 00:00:00 2001
From: Nikita Popov <npopov@redhat.com>
Date: Tue, 20 Aug 2024 11:50:47 +0200
Subject: [PATCH 459/685] Update to LLVM 19 rc 3

---
 src/llvm-project | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/llvm-project b/src/llvm-project
index ccf4c38bdd73f..2b259b3c201f9 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit ccf4c38bdd73f1a37ec266c73bdaef80e39f8cf6
+Subproject commit 2b259b3c201f939f2ed8d2fb0a0e9b37dd2d1321

From fc8a025f171a4cf8e5839c2bd5fa33c25357e2a0 Mon Sep 17 00:00:00 2001
From: Milo Moisson <milomoisson@gmail.com>
Date: Tue, 20 Aug 2024 12:04:28 +0200
Subject: [PATCH 460/685] fix(cfg_not_test): lint description typo

---
 clippy_lints/src/cfg_not_test.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clippy_lints/src/cfg_not_test.rs b/clippy_lints/src/cfg_not_test.rs
index b54f392bf2fad..d820c1e0720b8 100644
--- a/clippy_lints/src/cfg_not_test.rs
+++ b/clippy_lints/src/cfg_not_test.rs
@@ -5,7 +5,7 @@ use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Checks for usage of `cfg` that excludes code from `test` builds. (i.e., `#{cfg(not(test))]`)
+    /// Checks for usage of `cfg` that excludes code from `test` builds. (i.e., `#[cfg(not(test))]`)
     ///
     /// ### Why is this bad?
     /// This may give the false impression that a codebase has 100% coverage, yet actually has untested code.

From 221932fc4dc443fd741822d08a65705d60e8773b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 18 Aug 2024 10:38:34 +0200
Subject: [PATCH 461/685] readdir_r shim: assume FreeBSD v12+

needs a libc version bump
---
 src/tools/miri/src/shims/unix/fs.rs         | 16 ++++++++--------
 src/tools/miri/test_dependencies/Cargo.lock |  4 ++--
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index 80f4b89bf34d3..e00758bb98de6 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -1204,14 +1204,14 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                         )?;
                     }
                     "freebsd" => {
-                        this.write_int(ino, &this.project_field_named(&entry_place, "d_fileno")?)?;
-                        // `d_off` only exists on FreeBSD 12+, but we support v11 as well.
-                        // `libc` uses a build script to determine which version of the API to use,
-                        // and cross-builds always end up using v11.
-                        // To support both v11 and v12+, we dynamically check whether the field exists.
-                        if this.projectable_has_field(&entry_place, "d_off") {
-                            this.write_int(0, &this.project_field_named(&entry_place, "d_off")?)?;
-                        }
+                        #[rustfmt::skip]
+                        this.write_int_fields_named(
+                            &[
+                                ("d_fileno", ino.into()),
+                                ("d_off", 0),
+                            ],
+                            &entry_place,
+                        )?;
                     }
                     _ => unreachable!(),
                 }
diff --git a/src/tools/miri/test_dependencies/Cargo.lock b/src/tools/miri/test_dependencies/Cargo.lock
index e94bef529521e..bbead8782233c 100644
--- a/src/tools/miri/test_dependencies/Cargo.lock
+++ b/src/tools/miri/test_dependencies/Cargo.lock
@@ -119,9 +119,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.158"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
 
 [[package]]
 name = "linux-raw-sys"

From df019a9f46d58fcb1b32ee69022a294a93e1a0a7 Mon Sep 17 00:00:00 2001
From: bohan <bohan-zhang@foxmail.com>
Date: Fri, 16 Aug 2024 23:58:19 +0800
Subject: [PATCH 462/685] skip updating when external binding is existed

---
 .../rustc_resolve/src/build_reduced_graph.rs  | 18 ++++++++----
 src/tools/tidy/src/issues.txt                 |  3 +-
 .../{issue-85992-extern-2.rs => empty.rs}     |  0
 ...5992-extern-1.rs => issue-85992-extern.rs} |  2 +-
 tests/ui/imports/issue-85992.rs               | 12 ++++----
 tests/ui/imports/issue-85992.stderr           |  6 ++--
 .../multiple-extern-by-macro-for-buitlin.rs   | 18 ++++++++++++
 ...ultiple-extern-by-macro-for-buitlin.stderr | 22 ++++++++++++++
 .../multiple-extern-by-macro-for-custom.rs    | 19 ++++++++++++
 ...multiple-extern-by-macro-for-custom.stderr | 22 ++++++++++++++
 .../multiple-extern-by-macro-for-inexist.rs   | 19 ++++++++++++
 ...ultiple-extern-by-macro-for-inexist.stderr | 29 +++++++++++++++++++
 ...multiple-extern-by-macro-for-underscore.rs | 18 ++++++++++++
 ...iple-extern-by-macro-for-underscore.stderr |  8 +++++
 14 files changed, 179 insertions(+), 17 deletions(-)
 rename tests/ui/imports/auxiliary/{issue-85992-extern-2.rs => empty.rs} (100%)
 rename tests/ui/imports/auxiliary/{issue-85992-extern-1.rs => issue-85992-extern.rs} (54%)
 create mode 100644 tests/ui/imports/multiple-extern-by-macro-for-buitlin.rs
 create mode 100644 tests/ui/imports/multiple-extern-by-macro-for-buitlin.stderr
 create mode 100644 tests/ui/imports/multiple-extern-by-macro-for-custom.rs
 create mode 100644 tests/ui/imports/multiple-extern-by-macro-for-custom.stderr
 create mode 100644 tests/ui/imports/multiple-extern-by-macro-for-inexist.rs
 create mode 100644 tests/ui/imports/multiple-extern-by-macro-for-inexist.stderr
 create mode 100644 tests/ui/imports/multiple-extern-by-macro-for-underscore.rs
 create mode 100644 tests/ui/imports/multiple-extern-by-macro-for-underscore.stderr

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index d57dabdd78d91..3a27f96dde869 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -896,7 +896,8 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
         self.r.potentially_unused_imports.push(import);
         let imported_binding = self.r.import(binding, import);
         if parent == self.r.graph_root {
-            if let Some(entry) = self.r.extern_prelude.get(&ident.normalize_to_macros_2_0()) {
+            let ident = ident.normalize_to_macros_2_0();
+            if let Some(entry) = self.r.extern_prelude.get(&ident) {
                 if expansion != LocalExpnId::ROOT && orig_name.is_some() && !entry.is_import() {
                     self.r.dcx().emit_err(
                         errors::MacroExpandedExternCrateCannotShadowExternArguments {
@@ -913,14 +914,21 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
             let entry = self
                 .r
                 .extern_prelude
-                .entry(ident.normalize_to_macros_2_0())
+                .entry(ident)
                 .or_insert(ExternPreludeEntry { binding: None, introduced_by_item: true });
-            // Binding from `extern crate` item in source code can replace
-            // a binding from `--extern` on command line here.
-            entry.binding = Some(imported_binding);
             if orig_name.is_some() {
                 entry.introduced_by_item = true;
             }
+            // Binding from `extern crate` item in source code can replace
+            // a binding from `--extern` on command line here.
+            if !entry.is_import() {
+                entry.binding = Some(imported_binding)
+            } else if ident.name != kw::Underscore {
+                self.r.dcx().span_delayed_bug(
+                    item.span,
+                    format!("it had been define the external module '{ident}' multiple times"),
+                );
+            }
         }
         self.r.define(parent, ident, TypeNS, imported_binding);
     }
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 5731097770481..5205fa1429435 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -1289,8 +1289,7 @@ ui/imports/auxiliary/issue-52891.rs
 ui/imports/auxiliary/issue-55811.rs
 ui/imports/auxiliary/issue-56125.rs
 ui/imports/auxiliary/issue-59764.rs
-ui/imports/auxiliary/issue-85992-extern-1.rs
-ui/imports/auxiliary/issue-85992-extern-2.rs
+ui/imports/auxiliary/issue-85992-extern.rs
 ui/imports/issue-109148.rs
 ui/imports/issue-109343.rs
 ui/imports/issue-113953.rs
diff --git a/tests/ui/imports/auxiliary/issue-85992-extern-2.rs b/tests/ui/imports/auxiliary/empty.rs
similarity index 100%
rename from tests/ui/imports/auxiliary/issue-85992-extern-2.rs
rename to tests/ui/imports/auxiliary/empty.rs
diff --git a/tests/ui/imports/auxiliary/issue-85992-extern-1.rs b/tests/ui/imports/auxiliary/issue-85992-extern.rs
similarity index 54%
rename from tests/ui/imports/auxiliary/issue-85992-extern-1.rs
rename to tests/ui/imports/auxiliary/issue-85992-extern.rs
index a2d0e20606570..076d60451909a 100644
--- a/tests/ui/imports/auxiliary/issue-85992-extern-1.rs
+++ b/tests/ui/imports/auxiliary/issue-85992-extern.rs
@@ -1,6 +1,6 @@
 #[macro_export]
 macro_rules! m {
    () => {
-        use issue_85992_extern_2::Outcome;
+        use empty::Outcome;
    }
 }
diff --git a/tests/ui/imports/issue-85992.rs b/tests/ui/imports/issue-85992.rs
index 321c3a9218d67..38cf03845010b 100644
--- a/tests/ui/imports/issue-85992.rs
+++ b/tests/ui/imports/issue-85992.rs
@@ -1,11 +1,11 @@
 //@ edition: 2021
-//@ compile-flags: --extern issue_85992_extern_1 --extern issue_85992_extern_2
-//@ aux-build: issue-85992-extern-1.rs
-//@ aux-build: issue-85992-extern-2.rs
+//@ compile-flags: --extern issue_85992_extern --extern empty
+//@ aux-build: issue-85992-extern.rs
+//@ aux-build: empty.rs
 
-issue_85992_extern_1::m!();
+issue_85992_extern::m!();
 
-use crate::issue_85992_extern_2;
-//~^ ERROR unresolved import `crate::issue_85992_extern_2`
+use crate::empty;
+//~^ ERROR unresolved import `crate::empty`
 
 fn main() {}
diff --git a/tests/ui/imports/issue-85992.stderr b/tests/ui/imports/issue-85992.stderr
index 6c75b45d926c0..490b2d4d88b00 100644
--- a/tests/ui/imports/issue-85992.stderr
+++ b/tests/ui/imports/issue-85992.stderr
@@ -1,8 +1,8 @@
-error[E0432]: unresolved import `crate::issue_85992_extern_2`
+error[E0432]: unresolved import `crate::empty`
   --> $DIR/issue-85992.rs:8:5
    |
-LL | use crate::issue_85992_extern_2;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ no `issue_85992_extern_2` in the root
+LL | use crate::empty;
+   |     ^^^^^^^^^^^^ no `empty` in the root
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/multiple-extern-by-macro-for-buitlin.rs b/tests/ui/imports/multiple-extern-by-macro-for-buitlin.rs
new file mode 100644
index 0000000000000..f0e5e4b4325c1
--- /dev/null
+++ b/tests/ui/imports/multiple-extern-by-macro-for-buitlin.rs
@@ -0,0 +1,18 @@
+//@ edition: 2021
+
+// issue#128813
+
+extern crate core;
+
+macro_rules! m {
+    () => {
+        extern crate std as core;
+        //~^ ERROR: the name `core` is defined multiple times
+    };
+}
+
+m!();
+
+fn main() {
+    use ::core;
+}
diff --git a/tests/ui/imports/multiple-extern-by-macro-for-buitlin.stderr b/tests/ui/imports/multiple-extern-by-macro-for-buitlin.stderr
new file mode 100644
index 0000000000000..a84a6c42aa8d1
--- /dev/null
+++ b/tests/ui/imports/multiple-extern-by-macro-for-buitlin.stderr
@@ -0,0 +1,22 @@
+error[E0259]: the name `core` is defined multiple times
+  --> $DIR/multiple-extern-by-macro-for-buitlin.rs:9:9
+   |
+LL | extern crate core;
+   | ------------------ previous import of the extern crate `core` here
+...
+LL |         extern crate std as core;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ `core` reimported here
+...
+LL | m!();
+   | ---- in this macro invocation
+   |
+   = note: `core` must be defined only once in the type namespace of this module
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you can use `as` to change the binding name of the import
+   |
+LL |         extern crate std as other_core;
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0259`.
diff --git a/tests/ui/imports/multiple-extern-by-macro-for-custom.rs b/tests/ui/imports/multiple-extern-by-macro-for-custom.rs
new file mode 100644
index 0000000000000..6bf544566e301
--- /dev/null
+++ b/tests/ui/imports/multiple-extern-by-macro-for-custom.rs
@@ -0,0 +1,19 @@
+//@ edition: 2021
+//@ aux-build: empty.rs
+
+// issue#128813
+
+extern crate empty;
+
+macro_rules! m {
+    () => {
+        extern crate std as empty;
+        //~^ ERROR: the name `empty` is defined multiple times
+    };
+}
+
+m!();
+
+fn main() {
+    use ::empty;
+}
diff --git a/tests/ui/imports/multiple-extern-by-macro-for-custom.stderr b/tests/ui/imports/multiple-extern-by-macro-for-custom.stderr
new file mode 100644
index 0000000000000..556d75a4dbb5f
--- /dev/null
+++ b/tests/ui/imports/multiple-extern-by-macro-for-custom.stderr
@@ -0,0 +1,22 @@
+error[E0259]: the name `empty` is defined multiple times
+  --> $DIR/multiple-extern-by-macro-for-custom.rs:10:9
+   |
+LL | extern crate empty;
+   | ------------------- previous import of the extern crate `empty` here
+...
+LL |         extern crate std as empty;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ `empty` reimported here
+...
+LL | m!();
+   | ---- in this macro invocation
+   |
+   = note: `empty` must be defined only once in the type namespace of this module
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you can use `as` to change the binding name of the import
+   |
+LL |         extern crate std as other_empty;
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0259`.
diff --git a/tests/ui/imports/multiple-extern-by-macro-for-inexist.rs b/tests/ui/imports/multiple-extern-by-macro-for-inexist.rs
new file mode 100644
index 0000000000000..c23f275b9ff9f
--- /dev/null
+++ b/tests/ui/imports/multiple-extern-by-macro-for-inexist.rs
@@ -0,0 +1,19 @@
+//@ edition: 2021
+
+// issue#128813
+
+extern crate non_existent;
+//~^ ERROR: can't find crate for `non_existent`
+
+macro_rules! m {
+    () => {
+        extern crate std as non_existent;
+        //~^ ERROR: the name `non_existent` is defined multiple times
+    };
+}
+
+m!();
+
+fn main() {
+    use ::non_existent;
+}
diff --git a/tests/ui/imports/multiple-extern-by-macro-for-inexist.stderr b/tests/ui/imports/multiple-extern-by-macro-for-inexist.stderr
new file mode 100644
index 0000000000000..ec34489f2323d
--- /dev/null
+++ b/tests/ui/imports/multiple-extern-by-macro-for-inexist.stderr
@@ -0,0 +1,29 @@
+error[E0463]: can't find crate for `non_existent`
+  --> $DIR/multiple-extern-by-macro-for-inexist.rs:5:1
+   |
+LL | extern crate non_existent;
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ can't find crate
+
+error[E0259]: the name `non_existent` is defined multiple times
+  --> $DIR/multiple-extern-by-macro-for-inexist.rs:10:9
+   |
+LL | extern crate non_existent;
+   | -------------------------- previous import of the extern crate `non_existent` here
+...
+LL |         extern crate std as non_existent;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `non_existent` reimported here
+...
+LL | m!();
+   | ---- in this macro invocation
+   |
+   = note: `non_existent` must be defined only once in the type namespace of this module
+   = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: you can use `as` to change the binding name of the import
+   |
+LL |         extern crate std as other_non_existent;
+   |
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0259, E0463.
+For more information about an error, try `rustc --explain E0259`.
diff --git a/tests/ui/imports/multiple-extern-by-macro-for-underscore.rs b/tests/ui/imports/multiple-extern-by-macro-for-underscore.rs
new file mode 100644
index 0000000000000..ddf735d894753
--- /dev/null
+++ b/tests/ui/imports/multiple-extern-by-macro-for-underscore.rs
@@ -0,0 +1,18 @@
+//@ edition: 2021
+
+// issue#128813
+
+extern crate core as _;
+
+macro_rules! m {
+    () => {
+        extern crate std as _;
+    };
+}
+
+m!();
+
+fn main() {
+    use ::_;
+    //~^ ERROR: expected identifier, found reserved identifier `_`
+}
diff --git a/tests/ui/imports/multiple-extern-by-macro-for-underscore.stderr b/tests/ui/imports/multiple-extern-by-macro-for-underscore.stderr
new file mode 100644
index 0000000000000..1da5aa8707043
--- /dev/null
+++ b/tests/ui/imports/multiple-extern-by-macro-for-underscore.stderr
@@ -0,0 +1,8 @@
+error: expected identifier, found reserved identifier `_`
+  --> $DIR/multiple-extern-by-macro-for-underscore.rs:16:11
+   |
+LL |     use ::_;
+   |           ^ expected identifier, found reserved identifier
+
+error: aborting due to 1 previous error
+

From 257519615227104e57b1d69bf637e0278281806c Mon Sep 17 00:00:00 2001
From: c8ef <c8ef@outlook.com>
Date: Tue, 20 Aug 2024 20:50:32 +0800
Subject: [PATCH 463/685] fix: simple typo in compiler directory

---
 compiler/rustc_mir_build/src/build/scope.rs             | 2 +-
 compiler/rustc_query_system/src/dep_graph/serialized.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_mir_build/src/build/scope.rs b/compiler/rustc_mir_build/src/build/scope.rs
index 8546a2539d725..693037d03e017 100644
--- a/compiler/rustc_mir_build/src/build/scope.rs
+++ b/compiler/rustc_mir_build/src/build/scope.rs
@@ -748,7 +748,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         self.cfg.terminate(block, source_info, TerminatorKind::UnwindResume);
     }
 
-    /// Sets up the drops for explict tail calls.
+    /// Sets up the drops for explicit tail calls.
     ///
     /// Unlike other kinds of early exits, tail calls do not go through the drop tree.
     /// Instead, all scheduled drops are immediately added to the CFG.
diff --git a/compiler/rustc_query_system/src/dep_graph/serialized.rs b/compiler/rustc_query_system/src/dep_graph/serialized.rs
index ff1c3431b7c52..ab4a8be0fbfb5 100644
--- a/compiler/rustc_query_system/src/dep_graph/serialized.rs
+++ b/compiler/rustc_query_system/src/dep_graph/serialized.rs
@@ -547,7 +547,7 @@ impl<D: Deps> EncoderState<D> {
     /// Encodes a node that was promoted from the previous graph. It reads the information directly from
     /// the previous dep graph for performance reasons.
     ///
-    /// This differs from `encode_node` where you have to explictly provide the relevant `NodeInfo`.
+    /// This differs from `encode_node` where you have to explicitly provide the relevant `NodeInfo`.
     ///
     /// It expects all edges to already have a new dep node index assigned.
     #[inline]

From 38af7b068f506019a3aaa7c107e22bc1395f7b27 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 20 Aug 2024 14:58:10 +0200
Subject: [PATCH 464/685] ctfe: make CompileTimeInterpCx type alias public

---
 compiler/rustc_const_eval/src/const_eval/machine.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index a075bdc191181..c3d94ca0e596b 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -40,7 +40,10 @@ const TINY_LINT_TERMINATOR_LIMIT: usize = 20;
 /// power of two of interpreted terminators.
 const PROGRESS_INDICATOR_START: usize = 4_000_000;
 
-/// Extra machine state for CTFE, and the Machine instance
+/// Extra machine state for CTFE, and the Machine instance.
+//
+// Should be public because out-of-tree rustc consumers need this
+// if they want to interact with constant values.
 pub struct CompileTimeMachine<'tcx> {
     /// The number of terminators that have been evaluated.
     ///
@@ -160,7 +163,7 @@ impl<K: Hash + Eq, V> interpret::AllocMap<K, V> for FxIndexMap<K, V> {
     }
 }
 
-pub(crate) type CompileTimeInterpCx<'tcx> = InterpCx<'tcx, CompileTimeMachine<'tcx>>;
+pub type CompileTimeInterpCx<'tcx> = InterpCx<'tcx, CompileTimeMachine<'tcx>>;
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum MemoryKind {

From 728876ea98ccebddd56df16c8df0635a4f0bd5a6 Mon Sep 17 00:00:00 2001
From: Martin Habovstiak <martin.habovstiak@gmail.com>
Date: Wed, 17 Jul 2024 16:11:32 +0200
Subject: [PATCH 465/685] Implement SHA256 SIMD intrinsics on x86

It'd be useful to be able to verify code implementing SHA256 using SIMD
since such code is a bit more complicated and at some points requires
use of pointers. Until now `miri` didn't support x86 SHA256 intrinsics.
This commit implements them.
---
 src/tools/miri/src/shims/x86/mod.rs           |   6 +
 src/tools/miri/src/shims/x86/sha.rs           | 221 ++++++++++++++
 .../tests/pass/shims/x86/intrinsics-sha.rs    | 270 ++++++++++++++++++
 3 files changed, 497 insertions(+)
 create mode 100644 src/tools/miri/src/shims/x86/sha.rs
 create mode 100644 src/tools/miri/tests/pass/shims/x86/intrinsics-sha.rs

diff --git a/src/tools/miri/src/shims/x86/mod.rs b/src/tools/miri/src/shims/x86/mod.rs
index 0bbf2a8e13e9a..f6f21ee5de8aa 100644
--- a/src/tools/miri/src/shims/x86/mod.rs
+++ b/src/tools/miri/src/shims/x86/mod.rs
@@ -15,6 +15,7 @@ mod aesni;
 mod avx;
 mod avx2;
 mod bmi;
+mod sha;
 mod sse;
 mod sse2;
 mod sse3;
@@ -105,6 +106,11 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this, link_name, abi, args, dest,
                 );
             }
+            name if name.starts_with("sha") => {
+                return sha::EvalContextExt::emulate_x86_sha_intrinsic(
+                    this, link_name, abi, args, dest,
+                );
+            }
             name if name.starts_with("sse.") => {
                 return sse::EvalContextExt::emulate_x86_sse_intrinsic(
                     this, link_name, abi, args, dest,
diff --git a/src/tools/miri/src/shims/x86/sha.rs b/src/tools/miri/src/shims/x86/sha.rs
new file mode 100644
index 0000000000000..e9cc28be34cff
--- /dev/null
+++ b/src/tools/miri/src/shims/x86/sha.rs
@@ -0,0 +1,221 @@
+//! Implements sha256 SIMD instructions of x86 targets
+//!
+//! The functions that actually compute SHA256 were copied from [RustCrypto's sha256 module].
+//!
+//! [RustCrypto's sha256 module]: https://github.com/RustCrypto/hashes/blob/6be8466247e936c415d8aafb848697f39894a386/sha2/src/sha256/soft.rs
+
+use rustc_span::Symbol;
+use rustc_target::spec::abi::Abi;
+
+use crate::*;
+
+impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
+pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
+    fn emulate_x86_sha_intrinsic(
+        &mut self,
+        link_name: Symbol,
+        abi: Abi,
+        args: &[OpTy<'tcx>],
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx, EmulateItemResult> {
+        let this = self.eval_context_mut();
+        this.expect_target_feature_for_intrinsic(link_name, "sha")?;
+        // Prefix should have already been checked.
+        let unprefixed_name = link_name.as_str().strip_prefix("llvm.x86.sha").unwrap();
+
+        fn read<'c>(this: &mut MiriInterpCx<'c>, reg: &MPlaceTy<'c>) -> InterpResult<'c, [u32; 4]> {
+            let mut res = [0; 4];
+            // We reverse the order because x86 is little endian but the copied implementation uses
+            // big endian.
+            for (i, dst) in res.iter_mut().rev().enumerate() {
+                let projected = &this.project_index(reg, i.try_into().unwrap())?;
+                *dst = this.read_scalar(projected)?.to_u32()?
+            }
+            Ok(res)
+        }
+
+        fn write<'c>(
+            this: &mut MiriInterpCx<'c>,
+            dest: &MPlaceTy<'c>,
+            val: [u32; 4],
+        ) -> InterpResult<'c, ()> {
+            // We reverse the order because x86 is little endian but the copied implementation uses
+            // big endian.
+            for (i, part) in val.into_iter().rev().enumerate() {
+                let projected = &this.project_index(dest, i.try_into().unwrap())?;
+                this.write_scalar(Scalar::from_u32(part), projected)?;
+            }
+            Ok(())
+        }
+
+        match unprefixed_name {
+            // Used to implement the _mm_sha256rnds2_epu32 function.
+            "256rnds2" => {
+                let [a, b, k] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
+
+                let (a_reg, a_len) = this.operand_to_simd(a)?;
+                let (b_reg, b_len) = this.operand_to_simd(b)?;
+                let (k_reg, k_len) = this.operand_to_simd(k)?;
+                let (dest, dest_len) = this.mplace_to_simd(dest)?;
+
+                assert_eq!(a_len, 4);
+                assert_eq!(b_len, 4);
+                assert_eq!(k_len, 4);
+                assert_eq!(dest_len, 4);
+
+                let a = read(this, &a_reg)?;
+                let b = read(this, &b_reg)?;
+                let k = read(this, &k_reg)?;
+
+                let result = sha256_digest_round_x2(a, b, k);
+                write(this, &dest, result)?;
+            }
+            // Used to implement the _mm_sha256msg1_epu32 function.
+            "256msg1" => {
+                let [a, b] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
+
+                let (a_reg, a_len) = this.operand_to_simd(a)?;
+                let (b_reg, b_len) = this.operand_to_simd(b)?;
+                let (dest, dest_len) = this.mplace_to_simd(dest)?;
+
+                assert_eq!(a_len, 4);
+                assert_eq!(b_len, 4);
+                assert_eq!(dest_len, 4);
+
+                let a = read(this, &a_reg)?;
+                let b = read(this, &b_reg)?;
+
+                let result = sha256msg1(a, b);
+                write(this, &dest, result)?;
+            }
+            // Used to implement the _mm_sha256msg2_epu32 function.
+            "256msg2" => {
+                let [a, b] = this.check_shim(abi, Abi::C { unwind: false }, link_name, args)?;
+
+                let (a_reg, a_len) = this.operand_to_simd(a)?;
+                let (b_reg, b_len) = this.operand_to_simd(b)?;
+                let (dest, dest_len) = this.mplace_to_simd(dest)?;
+
+                assert_eq!(a_len, 4);
+                assert_eq!(b_len, 4);
+                assert_eq!(dest_len, 4);
+
+                let a = read(this, &a_reg)?;
+                let b = read(this, &b_reg)?;
+
+                let result = sha256msg2(a, b);
+                write(this, &dest, result)?;
+            }
+            _ => return Ok(EmulateItemResult::NotSupported),
+        }
+        Ok(EmulateItemResult::NeedsReturn)
+    }
+}
+
+#[inline(always)]
+fn shr(v: [u32; 4], o: u32) -> [u32; 4] {
+    [v[0] >> o, v[1] >> o, v[2] >> o, v[3] >> o]
+}
+
+#[inline(always)]
+fn shl(v: [u32; 4], o: u32) -> [u32; 4] {
+    [v[0] << o, v[1] << o, v[2] << o, v[3] << o]
+}
+
+#[inline(always)]
+fn or(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
+    [a[0] | b[0], a[1] | b[1], a[2] | b[2], a[3] | b[3]]
+}
+
+#[inline(always)]
+fn xor(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
+    [a[0] ^ b[0], a[1] ^ b[1], a[2] ^ b[2], a[3] ^ b[3]]
+}
+
+#[inline(always)]
+fn add(a: [u32; 4], b: [u32; 4]) -> [u32; 4] {
+    [
+        a[0].wrapping_add(b[0]),
+        a[1].wrapping_add(b[1]),
+        a[2].wrapping_add(b[2]),
+        a[3].wrapping_add(b[3]),
+    ]
+}
+
+fn sha256load(v2: [u32; 4], v3: [u32; 4]) -> [u32; 4] {
+    [v3[3], v2[0], v2[1], v2[2]]
+}
+
+fn sha256_digest_round_x2(cdgh: [u32; 4], abef: [u32; 4], wk: [u32; 4]) -> [u32; 4] {
+    macro_rules! big_sigma0 {
+        ($a:expr) => {
+            ($a.rotate_right(2) ^ $a.rotate_right(13) ^ $a.rotate_right(22))
+        };
+    }
+    macro_rules! big_sigma1 {
+        ($a:expr) => {
+            ($a.rotate_right(6) ^ $a.rotate_right(11) ^ $a.rotate_right(25))
+        };
+    }
+    macro_rules! bool3ary_202 {
+        ($a:expr, $b:expr, $c:expr) => {
+            $c ^ ($a & ($b ^ $c))
+        };
+    } // Choose, MD5F, SHA1C
+    macro_rules! bool3ary_232 {
+        ($a:expr, $b:expr, $c:expr) => {
+            ($a & $b) ^ ($a & $c) ^ ($b & $c)
+        };
+    } // Majority, SHA1M
+
+    let [_, _, wk1, wk0] = wk;
+    let [a0, b0, e0, f0] = abef;
+    let [c0, d0, g0, h0] = cdgh;
+
+    // a round
+    let x0 =
+        big_sigma1!(e0).wrapping_add(bool3ary_202!(e0, f0, g0)).wrapping_add(wk0).wrapping_add(h0);
+    let y0 = big_sigma0!(a0).wrapping_add(bool3ary_232!(a0, b0, c0));
+    let (a1, b1, c1, d1, e1, f1, g1, h1) =
+        (x0.wrapping_add(y0), a0, b0, c0, x0.wrapping_add(d0), e0, f0, g0);
+
+    // a round
+    let x1 =
+        big_sigma1!(e1).wrapping_add(bool3ary_202!(e1, f1, g1)).wrapping_add(wk1).wrapping_add(h1);
+    let y1 = big_sigma0!(a1).wrapping_add(bool3ary_232!(a1, b1, c1));
+    let (a2, b2, _, _, e2, f2, _, _) =
+        (x1.wrapping_add(y1), a1, b1, c1, x1.wrapping_add(d1), e1, f1, g1);
+
+    [a2, b2, e2, f2]
+}
+
+fn sha256msg1(v0: [u32; 4], v1: [u32; 4]) -> [u32; 4] {
+    // sigma 0 on vectors
+    #[inline]
+    fn sigma0x4(x: [u32; 4]) -> [u32; 4] {
+        let t1 = or(shr(x, 7), shl(x, 25));
+        let t2 = or(shr(x, 18), shl(x, 14));
+        let t3 = shr(x, 3);
+        xor(xor(t1, t2), t3)
+    }
+
+    add(v0, sigma0x4(sha256load(v0, v1)))
+}
+
+fn sha256msg2(v4: [u32; 4], v3: [u32; 4]) -> [u32; 4] {
+    macro_rules! sigma1 {
+        ($a:expr) => {
+            $a.rotate_right(17) ^ $a.rotate_right(19) ^ ($a >> 10)
+        };
+    }
+
+    let [x3, x2, x1, x0] = v4;
+    let [w15, w14, _, _] = v3;
+
+    let w16 = x0.wrapping_add(sigma1!(w14));
+    let w17 = x1.wrapping_add(sigma1!(w15));
+    let w18 = x2.wrapping_add(sigma1!(w16));
+    let w19 = x3.wrapping_add(sigma1!(w17));
+
+    [w19, w18, w17, w16]
+}
diff --git a/src/tools/miri/tests/pass/shims/x86/intrinsics-sha.rs b/src/tools/miri/tests/pass/shims/x86/intrinsics-sha.rs
new file mode 100644
index 0000000000000..e65fdc3fbed68
--- /dev/null
+++ b/src/tools/miri/tests/pass/shims/x86/intrinsics-sha.rs
@@ -0,0 +1,270 @@
+// Ignore everything except x86 and x86_64
+// Any new targets that are added to CI should be ignored here.
+// (We cannot use `cfg`-based tricks here since the `target-feature` flags below only work on x86.)
+//@ignore-target-aarch64
+//@ignore-target-arm
+//@ignore-target-avr
+//@ignore-target-s390x
+//@ignore-target-thumbv7em
+//@ignore-target-wasm32
+//@compile-flags: -C target-feature=+sha,+sse2,+ssse3,+sse4.1
+
+#[cfg(target_arch = "x86")]
+use std::arch::x86::*;
+#[cfg(target_arch = "x86_64")]
+use std::arch::x86_64::*;
+
+macro_rules! rounds4 {
+    ($abef:ident, $cdgh:ident, $rest:expr, $i:expr) => {{
+        let k = K32X4[$i];
+        let kv = _mm_set_epi32(k[0] as i32, k[1] as i32, k[2] as i32, k[3] as i32);
+        let t1 = _mm_add_epi32($rest, kv);
+        $cdgh = _mm_sha256rnds2_epu32($cdgh, $abef, t1);
+        let t2 = _mm_shuffle_epi32(t1, 0x0E);
+        $abef = _mm_sha256rnds2_epu32($abef, $cdgh, t2);
+    }};
+}
+
+macro_rules! schedule_rounds4 {
+    (
+        $abef:ident, $cdgh:ident,
+        $w0:expr, $w1:expr, $w2:expr, $w3:expr, $w4:expr,
+        $i: expr
+    ) => {{
+        $w4 = schedule($w0, $w1, $w2, $w3);
+        rounds4!($abef, $cdgh, $w4, $i);
+    }};
+}
+
+fn main() {
+    assert!(is_x86_feature_detected!("sha"));
+    assert!(is_x86_feature_detected!("sse2"));
+    assert!(is_x86_feature_detected!("ssse3"));
+    assert!(is_x86_feature_detected!("sse4.1"));
+
+    unsafe {
+        test_sha256rnds2();
+        test_sha256msg1();
+        test_sha256msg2();
+        test_sha256();
+    }
+}
+
+#[target_feature(enable = "sha,sse2,ssse3,sse4.1")]
+unsafe fn test_sha256rnds2() {
+    let test_vectors = [
+        (
+            [0x3c6ef372, 0xa54ff53a, 0x1f83d9ab, 0x5be0cd19],
+            [0x6a09e667, 0xbb67ae85, 0x510e527f, 0x9b05688c],
+            [0x592340c6, 0x17386142, 0x91a0b7b1, 0x94ffa30c],
+            [0xeef39c6c, 0x4e7dfbc1, 0x467a98f3, 0xeb3d5616],
+        ),
+        (
+            [0x6a09e667, 0xbb67ae85, 0x510e527f, 0x9b05688c],
+            [0xeef39c6c, 0x4e7dfbc1, 0x467a98f3, 0xeb3d5616],
+            [0x91a0b7b1, 0x94ffa30c, 0x592340c6, 0x17386142],
+            [0x7e7f3c9d, 0x78db9a20, 0xd82fe6ed, 0xaf1f2704],
+        ),
+        (
+            [0xeef39c6c, 0x4e7dfbc1, 0x467a98f3, 0xeb3d5616],
+            [0x7e7f3c9d, 0x78db9a20, 0xd82fe6ed, 0xaf1f2704],
+            [0x1a89c3f6, 0xf3b6e817, 0x7a5a8511, 0x8bcc35cf],
+            [0xc9292f7e, 0x49137bd9, 0x7e5f9e08, 0xd10f9247],
+        ),
+    ];
+    for (cdgh, abef, wk, expected) in test_vectors {
+        let output_reg = _mm_sha256rnds2_epu32(set_arr(cdgh), set_arr(abef), set_arr(wk));
+        let mut output = [0u32; 4];
+        _mm_storeu_si128(output.as_mut_ptr().cast(), output_reg);
+        // The values are stored as little endian, so we need to reverse them
+        output.reverse();
+        assert_eq!(output, expected);
+    }
+}
+
+#[target_feature(enable = "sha,sse2,ssse3,sse4.1")]
+unsafe fn test_sha256msg1() {
+    let test_vectors = [
+        (
+            [0x6f6d6521, 0x61776573, 0x20697320, 0x52757374],
+            [0x6f6d6521, 0x61776573, 0x20697320, 0x52757374],
+            [0x2da4b536, 0x77f29328, 0x541a4d59, 0x6afb680c],
+        ),
+        (
+            [0x6f6d6521, 0x61776573, 0x20697320, 0x52757374],
+            [0x6f6d6521, 0x61776573, 0x20697320, 0x52757374],
+            [0x2da4b536, 0x77f29328, 0x541a4d59, 0x6afb680c],
+        ),
+        (
+            [0x6f6d6521, 0x61776573, 0x20697320, 0x52757374],
+            [0x6f6d6521, 0x61776573, 0x20697320, 0x52757374],
+            [0x2da4b536, 0x77f29328, 0x541a4d59, 0x6afb680c],
+        ),
+    ];
+    for (v0, v1, expected) in test_vectors {
+        let output_reg = _mm_sha256msg1_epu32(set_arr(v0), set_arr(v1));
+        let mut output = [0u32; 4];
+        _mm_storeu_si128(output.as_mut_ptr().cast(), output_reg);
+        // The values are stored as little endian, so we need to reverse them
+        output.reverse();
+        assert_eq!(output, expected);
+    }
+}
+
+#[target_feature(enable = "sha,sse2,ssse3,sse4.1")]
+unsafe fn test_sha256msg2() {
+    let test_vectors = [
+        (
+            [0x801a28aa, 0xe75ff849, 0xb591b2cc, 0x8b64db2c],
+            [0x6f6d6521, 0x61776573, 0x20697320, 0x52757374],
+            [0xe7c46c4e, 0x8ce92ccc, 0xd3c0f3ce, 0xe9745c78],
+        ),
+        (
+            [0x171911ae, 0xe75ff849, 0xb591b2cc, 0x8b64db2c],
+            [0xe7c46c4e, 0x8ce92ccc, 0xd3c0f3ce, 0xe9745c78],
+            [0xc17c6ea3, 0xc4d10083, 0x712910cd, 0x3f41c8ce],
+        ),
+        (
+            [0x6ce67e04, 0x5fb6ff76, 0xe1037a25, 0x3ebc5bda],
+            [0xc17c6ea3, 0xc4d10083, 0x712910cd, 0x3f41c8ce],
+            [0xf5ab4eff, 0x83d732a5, 0x9bb941af, 0xdf1d0a8c],
+        ),
+    ];
+    for (v4, v3, expected) in test_vectors {
+        let output_reg = _mm_sha256msg2_epu32(set_arr(v4), set_arr(v3));
+        let mut output = [0u32; 4];
+        _mm_storeu_si128(output.as_mut_ptr().cast(), output_reg);
+        // The values are stored as little endian, so we need to reverse them
+        output.reverse();
+        assert_eq!(output, expected);
+    }
+}
+
+#[target_feature(enable = "sha,sse2,ssse3,sse4.1")]
+unsafe fn set_arr(x: [u32; 4]) -> __m128i {
+    _mm_set_epi32(x[0] as i32, x[1] as i32, x[2] as i32, x[3] as i32)
+}
+
+#[target_feature(enable = "sha,sse2,ssse3,sse4.1")]
+unsafe fn test_sha256() {
+    use std::fmt::Write;
+
+    /// The initial state of the hash engine.
+    const INITIAL_STATE: [u32; 8] = [
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
+        0x5be0cd19,
+    ];
+
+    // We don't want to bother with hash finalization algorithm so we just feed constant data.
+    // This is the content that's being hashed - you can feed it to sha256sum and it'll output
+    // the same hash (beware of newlines though).
+    let first_block = *b"Rust is awesome!Rust is awesome!Rust is awesome!Rust is awesome!";
+    // sha256 is fianlized by appending 0x80, then zeros and finally the data lenght at the
+    // end.
+    let mut final_block = [0; 64];
+    final_block[0] = 0x80;
+    final_block[(64 - 8)..].copy_from_slice(&(8u64 * 64).to_be_bytes());
+
+    let mut state = INITIAL_STATE;
+    digest_blocks(&mut state, &[first_block, final_block]);
+
+    // We compare strings because it's easier to check the hex and the output of panic.
+    let mut hash = String::new();
+    for chunk in &state {
+        write!(hash, "{:08x}", chunk).expect("writing to String doesn't fail");
+    }
+    assert_eq!(hash, "1b2293d21b17a0cb0c18737307c37333dea775eded18cefed45e50389f9f8184");
+}
+
+// Almost full SHA256 implementation copied from RustCrypto's sha2 crate
+// https://github.com/RustCrypto/hashes/blob/6be8466247e936c415d8aafb848697f39894a386/sha2/src/sha256/x86.rs
+
+#[target_feature(enable = "sha,sse2,ssse3,sse4.1")]
+unsafe fn schedule(v0: __m128i, v1: __m128i, v2: __m128i, v3: __m128i) -> __m128i {
+    let t1 = _mm_sha256msg1_epu32(v0, v1);
+    let t2 = _mm_alignr_epi8(v3, v2, 4);
+    let t3 = _mm_add_epi32(t1, t2);
+    _mm_sha256msg2_epu32(t3, v3)
+}
+
+// we use unaligned loads with `__m128i` pointers
+#[allow(clippy::cast_ptr_alignment)]
+#[target_feature(enable = "sha,sse2,ssse3,sse4.1")]
+unsafe fn digest_blocks(state: &mut [u32; 8], blocks: &[[u8; 64]]) {
+    #[allow(non_snake_case)]
+    let MASK: __m128i =
+        _mm_set_epi64x(0x0C0D_0E0F_0809_0A0Bu64 as i64, 0x0405_0607_0001_0203u64 as i64);
+
+    let state_ptr: *const __m128i = state.as_ptr().cast();
+    let dcba = _mm_loadu_si128(state_ptr.add(0));
+    let efgh = _mm_loadu_si128(state_ptr.add(1));
+
+    let cdab = _mm_shuffle_epi32(dcba, 0xB1);
+    let efgh = _mm_shuffle_epi32(efgh, 0x1B);
+    let mut abef = _mm_alignr_epi8(cdab, efgh, 8);
+    let mut cdgh = _mm_blend_epi16(efgh, cdab, 0xF0);
+
+    for block in blocks {
+        let abef_save = abef;
+        let cdgh_save = cdgh;
+
+        let block_ptr: *const __m128i = block.as_ptr().cast();
+        let mut w0 = _mm_shuffle_epi8(_mm_loadu_si128(block_ptr.add(0)), MASK);
+        let mut w1 = _mm_shuffle_epi8(_mm_loadu_si128(block_ptr.add(1)), MASK);
+        let mut w2 = _mm_shuffle_epi8(_mm_loadu_si128(block_ptr.add(2)), MASK);
+        let mut w3 = _mm_shuffle_epi8(_mm_loadu_si128(block_ptr.add(3)), MASK);
+        let mut w4;
+
+        rounds4!(abef, cdgh, w0, 0);
+        rounds4!(abef, cdgh, w1, 1);
+        rounds4!(abef, cdgh, w2, 2);
+        rounds4!(abef, cdgh, w3, 3);
+        schedule_rounds4!(abef, cdgh, w0, w1, w2, w3, w4, 4);
+        schedule_rounds4!(abef, cdgh, w1, w2, w3, w4, w0, 5);
+        schedule_rounds4!(abef, cdgh, w2, w3, w4, w0, w1, 6);
+        schedule_rounds4!(abef, cdgh, w3, w4, w0, w1, w2, 7);
+        schedule_rounds4!(abef, cdgh, w4, w0, w1, w2, w3, 8);
+        schedule_rounds4!(abef, cdgh, w0, w1, w2, w3, w4, 9);
+        schedule_rounds4!(abef, cdgh, w1, w2, w3, w4, w0, 10);
+        schedule_rounds4!(abef, cdgh, w2, w3, w4, w0, w1, 11);
+        schedule_rounds4!(abef, cdgh, w3, w4, w0, w1, w2, 12);
+        schedule_rounds4!(abef, cdgh, w4, w0, w1, w2, w3, 13);
+        schedule_rounds4!(abef, cdgh, w0, w1, w2, w3, w4, 14);
+        schedule_rounds4!(abef, cdgh, w1, w2, w3, w4, w0, 15);
+
+        abef = _mm_add_epi32(abef, abef_save);
+        cdgh = _mm_add_epi32(cdgh, cdgh_save);
+    }
+
+    let feba = _mm_shuffle_epi32(abef, 0x1B);
+    let dchg = _mm_shuffle_epi32(cdgh, 0xB1);
+    let dcba = _mm_blend_epi16(feba, dchg, 0xF0);
+    let hgef = _mm_alignr_epi8(dchg, feba, 8);
+
+    let state_ptr_mut: *mut __m128i = state.as_mut_ptr().cast();
+    _mm_storeu_si128(state_ptr_mut.add(0), dcba);
+    _mm_storeu_si128(state_ptr_mut.add(1), hgef);
+}
+
+/// Swapped round constants for SHA-256 family of digests
+pub static K32X4: [[u32; 4]; 16] = {
+    let mut res = [[0u32; 4]; 16];
+    let mut i = 0;
+    while i < 16 {
+        res[i] = [K32[4 * i + 3], K32[4 * i + 2], K32[4 * i + 1], K32[4 * i]];
+        i += 1;
+    }
+    res
+};
+
+/// Round constants for SHA-256 family of digests
+pub static K32: [u32; 64] = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+];

From 40af2143f19c3f8fcd32513b0761198b64465242 Mon Sep 17 00:00:00 2001
From: Chris Denton <chris@chrisdenton.dev>
Date: Mon, 19 Aug 2024 17:33:24 +0000
Subject: [PATCH 466/685] Make import libraries compatible with wholearchive

---
 Cargo.lock                                     | 4 ++--
 compiler/rustc_codegen_ssa/Cargo.toml          | 2 +-
 compiler/rustc_codegen_ssa/src/back/archive.rs | 6 +++++-
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3ad21b0abf920..084723ec3a6a2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -205,9 +205,9 @@ dependencies = [
 
 [[package]]
 name = "ar_archive_writer"
-version = "0.4.0"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de11a9d32db3327f981143bdf699ade4d637c6887b13b97e6e91a9154666963c"
+checksum = "01667f6f40216b9a0b2945e05fed5f1ad0ab6470e69cb9378001e37b1c0668e4"
 dependencies = [
  "object 0.36.2",
 ]
diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml
index 0af34a1b9fa62..779aeb721843e 100644
--- a/compiler/rustc_codegen_ssa/Cargo.toml
+++ b/compiler/rustc_codegen_ssa/Cargo.toml
@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 # tidy-alphabetical-start
-ar_archive_writer = "0.4.0"
+ar_archive_writer = "0.4.2"
 arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
 cc = "1.0.90"
diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs
index 38a440a707a23..c8c1bd3e8f9c3 100644
--- a/compiler/rustc_codegen_ssa/src/back/archive.rs
+++ b/compiler/rustc_codegen_ssa/src/back/archive.rs
@@ -108,7 +108,11 @@ pub trait ArchiveBuilderBuilder {
                 &exports,
                 machine,
                 !sess.target.is_like_msvc,
-                /*comdat=*/ false,
+                // Enable compatibility with MSVC's `/WHOLEARCHIVE` flag.
+                // Without this flag a duplicate symbol error would be emitted
+                // when linking a rust staticlib using `/WHOLEARCHIVE`.
+                // See #129020
+                true,
             ) {
                 sess.dcx()
                     .emit_fatal(ErrorCreatingImportLibrary { lib_name, error: error.to_string() });

From df568af244cc67eb6706ad5a27b9800043b37893 Mon Sep 17 00:00:00 2001
From: kyoto7250 <50972773+kyoto7250@users.noreply.github.com>
Date: Wed, 21 Aug 2024 00:14:04 +0900
Subject: [PATCH 467/685] fix link in mir/mod

change url path when rewrite those code
---
 compiler/rustc_middle/src/mir/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 46c4d586f6ad9..5b2aac781ebad 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -1368,7 +1368,7 @@ rustc_index::newtype_index! {
     /// [CFG]: https://rustc-dev-guide.rust-lang.org/appendix/background.html#cfg
     /// [data-flow analyses]:
     ///     https://rustc-dev-guide.rust-lang.org/appendix/background.html#what-is-a-dataflow-analysis
-    /// [`CriticalCallEdges`]: ../../rustc_const_eval/transform/add_call_guards/enum.AddCallGuards.html#variant.CriticalCallEdges
+    /// [`CriticalCallEdges`]: ../../rustc_mir_transform/add_call_guards/enum.AddCallGuards.html#variant.CriticalCallEdges
     /// [guide-mir]: https://rustc-dev-guide.rust-lang.org/mir/
     #[derive(HashStable)]
     #[encodable]

From 687d4e3d16d946a7b2a721db18a357cfc877422e Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Tue, 20 Aug 2024 11:52:47 -0400
Subject: [PATCH 468/685] `declare_interior_mutable_const`: Ignore pointer
 types.

---
 clippy_lints/src/non_copy_const.rs              |  2 +-
 .../ui/declare_interior_mutable_const/others.rs | 17 +++++++++++++++++
 .../others.stderr                               | 10 +++++-----
 3 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/clippy_lints/src/non_copy_const.rs b/clippy_lints/src/non_copy_const.rs
index e50562d8e4973..25f547f1a43c0 100644
--- a/clippy_lints/src/non_copy_const.rs
+++ b/clippy_lints/src/non_copy_const.rs
@@ -184,7 +184,7 @@ impl_lint_pass!(NonCopyConst<'_> => [DECLARE_INTERIOR_MUTABLE_CONST, BORROW_INTE
 impl<'tcx> NonCopyConst<'tcx> {
     pub fn new(tcx: TyCtxt<'tcx>, conf: &'static Conf) -> Self {
         Self {
-            interior_mut: InteriorMut::new(tcx, &conf.ignore_interior_mutability),
+            interior_mut: InteriorMut::without_pointers(tcx, &conf.ignore_interior_mutability),
         }
     }
 
diff --git a/tests/ui/declare_interior_mutable_const/others.rs b/tests/ui/declare_interior_mutable_const/others.rs
index 56a8d22cb1c81..9dafad8b784b9 100644
--- a/tests/ui/declare_interior_mutable_const/others.rs
+++ b/tests/ui/declare_interior_mutable_const/others.rs
@@ -3,6 +3,7 @@
 use std::borrow::Cow;
 use std::cell::Cell;
 use std::fmt::Display;
+use std::ptr;
 use std::sync::atomic::AtomicUsize;
 use std::sync::Once;
 
@@ -53,4 +54,20 @@ mod issue_8493 {
     issue_8493!();
 }
 
+#[repr(C, align(8))]
+struct NoAtomic(usize);
+#[repr(C, align(8))]
+struct WithAtomic(AtomicUsize);
+
+const fn with_non_null() -> *const WithAtomic {
+    const NO_ATOMIC: NoAtomic = NoAtomic(0);
+    (&NO_ATOMIC as *const NoAtomic).cast()
+}
+const WITH_ATOMIC: *const WithAtomic = with_non_null();
+
+struct Generic<T>(T);
+impl<T> Generic<T> {
+    const RAW_POINTER: *const Cell<T> = ptr::null();
+}
+
 fn main() {}
diff --git a/tests/ui/declare_interior_mutable_const/others.stderr b/tests/ui/declare_interior_mutable_const/others.stderr
index 1f2b9561ce509..4a7251471424e 100644
--- a/tests/ui/declare_interior_mutable_const/others.stderr
+++ b/tests/ui/declare_interior_mutable_const/others.stderr
@@ -1,5 +1,5 @@
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/others.rs:9:1
+  --> tests/ui/declare_interior_mutable_const/others.rs:10:1
    |
 LL | const ATOMIC: AtomicUsize = AtomicUsize::new(5);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL | const ATOMIC: AtomicUsize = AtomicUsize::new(5);
    = help: to override `-D warnings` add `#[allow(clippy::declare_interior_mutable_const)]`
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/others.rs:10:1
+  --> tests/ui/declare_interior_mutable_const/others.rs:11:1
    |
 LL | const CELL: Cell<usize> = Cell::new(6);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | const CELL: Cell<usize> = Cell::new(6);
    = help: consider making this `Sync` so that it can go in a static item or using a `thread_local`
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/others.rs:11:1
+  --> tests/ui/declare_interior_mutable_const/others.rs:12:1
    |
 LL | const ATOMIC_TUPLE: ([AtomicUsize; 1], Vec<AtomicUsize>, u8) = ([ATOMIC], Vec::new(), 7);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL | const ATOMIC_TUPLE: ([AtomicUsize; 1], Vec<AtomicUsize>, u8) = ([ATOMIC], V
    = help: consider making this a static item
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/others.rs:16:9
+  --> tests/ui/declare_interior_mutable_const/others.rs:17:9
    |
 LL |         const $name: $ty = $e;
    |         ^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL | declare_const!(_ONCE: Once = Once::new());
    = note: this error originates in the macro `declare_const` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/others.rs:44:13
+  --> tests/ui/declare_interior_mutable_const/others.rs:45:13
    |
 LL |             const _BAZ: Cell<usize> = Cell::new(0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

From 83fce478f43c91dd94b140a6fc4430d68ddc87a9 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Tue, 20 Aug 2024 18:09:58 +0200
Subject: [PATCH 469/685] Remove unneeded conversion to `DefId` for `ExtraInfo`

---
 src/librustdoc/clean/types.rs                 |  7 ++-
 src/librustdoc/doctest/rust.rs                |  2 +-
 src/librustdoc/html/markdown.rs               | 44 +++++++++----------
 .../passes/lint/check_code_block_syntax.rs    |  6 ++-
 4 files changed, 31 insertions(+), 28 deletions(-)

diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index ff5c16f2b3e9a..63d71a73cdfc8 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -12,7 +12,7 @@ use rustc_attr::{ConstStability, Deprecation, Stability, StabilityLevel, StableS
 use rustc_const_eval::const_eval::is_unstable_const_fn;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_hir::def::{CtorKind, DefKind, Res};
-use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
+use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{BodyId, Mutability};
 use rustc_hir_analysis::check::intrinsic::intrinsic_operation_unsafety;
@@ -88,6 +88,11 @@ impl ItemId {
         }
     }
 
+    #[inline]
+    pub(crate) fn as_local_def_id(self) -> Option<LocalDefId> {
+        self.as_def_id().and_then(|id| id.as_local())
+    }
+
     #[inline]
     pub(crate) fn krate(self) -> CrateNum {
         match self {
diff --git a/src/librustdoc/doctest/rust.rs b/src/librustdoc/doctest/rust.rs
index abd66f15dc0c1..5c0898f28fcc0 100644
--- a/src/librustdoc/doctest/rust.rs
+++ b/src/librustdoc/doctest/rust.rs
@@ -136,7 +136,7 @@ impl<'a, 'tcx> HirCollector<'a, 'tcx> {
                 self.enable_per_target_ignores,
                 Some(&crate::html::markdown::ExtraInfo::new(
                     self.tcx,
-                    def_id.to_def_id(),
+                    def_id,
                     span_of_fragments(&attrs.doc_strings).unwrap_or(sp),
                 )),
             );
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index 7bfe5d87d399f..364d4e077b18b 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -40,7 +40,7 @@ use pulldown_cmark::{
 };
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Diag, DiagMessage};
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::LocalDefId;
 use rustc_middle::ty::TyCtxt;
 pub(crate) use rustc_resolve::rustdoc::main_body_opts;
 use rustc_resolve::rustdoc::may_be_doc_link;
@@ -818,27 +818,25 @@ pub(crate) fn find_codes<T: doctest::DocTestVisitor>(
 }
 
 pub(crate) struct ExtraInfo<'tcx> {
-    def_id: DefId,
+    def_id: LocalDefId,
     sp: Span,
     tcx: TyCtxt<'tcx>,
 }
 
 impl<'tcx> ExtraInfo<'tcx> {
-    pub(crate) fn new(tcx: TyCtxt<'tcx>, def_id: DefId, sp: Span) -> ExtraInfo<'tcx> {
+    pub(crate) fn new(tcx: TyCtxt<'tcx>, def_id: LocalDefId, sp: Span) -> ExtraInfo<'tcx> {
         ExtraInfo { def_id, sp, tcx }
     }
 
     fn error_invalid_codeblock_attr(&self, msg: impl Into<DiagMessage>) {
-        if let Some(def_id) = self.def_id.as_local() {
-            self.tcx.node_span_lint(
-                crate::lint::INVALID_CODEBLOCK_ATTRIBUTES,
-                self.tcx.local_def_id_to_hir_id(def_id),
-                self.sp,
-                |lint| {
-                    lint.primary_message(msg);
-                },
-            );
-        }
+        self.tcx.node_span_lint(
+            crate::lint::INVALID_CODEBLOCK_ATTRIBUTES,
+            self.tcx.local_def_id_to_hir_id(self.def_id),
+            self.sp,
+            |lint| {
+                lint.primary_message(msg);
+            },
+        );
     }
 
     fn error_invalid_codeblock_attr_with_help(
@@ -846,17 +844,15 @@ impl<'tcx> ExtraInfo<'tcx> {
         msg: impl Into<DiagMessage>,
         f: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>),
     ) {
-        if let Some(def_id) = self.def_id.as_local() {
-            self.tcx.node_span_lint(
-                crate::lint::INVALID_CODEBLOCK_ATTRIBUTES,
-                self.tcx.local_def_id_to_hir_id(def_id),
-                self.sp,
-                |lint| {
-                    lint.primary_message(msg);
-                    f(lint);
-                },
-            );
-        }
+        self.tcx.node_span_lint(
+            crate::lint::INVALID_CODEBLOCK_ATTRIBUTES,
+            self.tcx.local_def_id_to_hir_id(self.def_id),
+            self.sp,
+            |lint| {
+                lint.primary_message(msg);
+                f(lint);
+            },
+        );
     }
 }
 
diff --git a/src/librustdoc/passes/lint/check_code_block_syntax.rs b/src/librustdoc/passes/lint/check_code_block_syntax.rs
index ef05befdddc54..977c095333641 100644
--- a/src/librustdoc/passes/lint/check_code_block_syntax.rs
+++ b/src/librustdoc/passes/lint/check_code_block_syntax.rs
@@ -16,9 +16,11 @@ use crate::core::DocContext;
 use crate::html::markdown::{self, RustCodeBlock};
 
 pub(crate) fn visit_item(cx: &DocContext<'_>, item: &clean::Item) {
-    if let Some(dox) = &item.opt_doc_value() {
+    if let Some(def_id) = item.item_id.as_local_def_id()
+        && let Some(dox) = &item.opt_doc_value()
+    {
         let sp = item.attr_span(cx.tcx);
-        let extra = crate::html::markdown::ExtraInfo::new(cx.tcx, item.item_id.expect_def_id(), sp);
+        let extra = crate::html::markdown::ExtraInfo::new(cx.tcx, def_id, sp);
         for code_block in markdown::rust_code_blocks(dox, &extra) {
             check_rust_syntax(cx, item, dox, code_block);
         }

From 490818851860fb257e23fe7aa0ee32eaffc4ba40 Mon Sep 17 00:00:00 2001
From: Arthur Carcano <arthur.carcano@ocamlpro.com>
Date: Tue, 20 Aug 2024 18:41:42 +0200
Subject: [PATCH 470/685] Change neutral element of <fNN as iter::Sum> to
 neg_zero

The neutral element used to be positive zero, but +0 + -0 = +0 so
-0 seems better indicated.
---
 library/core/src/iter/traits/accum.rs         |  4 +--
 .../core/tests/num/float_iter_sum_identity.rs | 27 +++++++++++++++++++
 library/core/tests/num/mod.rs                 |  1 +
 3 files changed, 30 insertions(+), 2 deletions(-)
 create mode 100644 library/core/tests/num/float_iter_sum_identity.rs

diff --git a/library/core/src/iter/traits/accum.rs b/library/core/src/iter/traits/accum.rs
index c97cd042ab459..5b7d95c2f65e6 100644
--- a/library/core/src/iter/traits/accum.rs
+++ b/library/core/src/iter/traits/accum.rs
@@ -104,7 +104,7 @@ macro_rules! float_sum_product {
         impl Sum for $a {
             fn sum<I: Iterator<Item=Self>>(iter: I) -> Self {
                 iter.fold(
-                    0.0,
+                    -0.0,
                     #[rustc_inherit_overflow_checks]
                     |a, b| a + b,
                 )
@@ -126,7 +126,7 @@ macro_rules! float_sum_product {
         impl<'a> Sum<&'a $a> for $a {
             fn sum<I: Iterator<Item=&'a Self>>(iter: I) -> Self {
                 iter.fold(
-                    0.0,
+                    -0.0,
                     #[rustc_inherit_overflow_checks]
                     |a, b| a + b,
                 )
diff --git a/library/core/tests/num/float_iter_sum_identity.rs b/library/core/tests/num/float_iter_sum_identity.rs
new file mode 100644
index 0000000000000..6d3224522a830
--- /dev/null
+++ b/library/core/tests/num/float_iter_sum_identity.rs
@@ -0,0 +1,27 @@
+#[test]
+fn f32_ref() {
+    let x: f32 = -0.0;
+    let still_x: f32 = [x].iter().sum();
+    assert_eq!(1. / x, 1. / still_x)
+}
+
+#[test]
+fn f32_own() {
+    let x: f32 = -0.0;
+    let still_x: f32 = [x].into_iter().sum();
+    assert_eq!(1. / x, 1. / still_x)
+}
+
+#[test]
+fn f64_ref() {
+    let x: f64 = -0.0;
+    let still_x: f64 = [x].iter().sum();
+    assert_eq!(1. / x, 1. / still_x)
+}
+
+#[test]
+fn f64_own() {
+    let x: f64 = -0.0;
+    let still_x: f64 = [x].into_iter().sum();
+    assert_eq!(1. / x, 1. / still_x)
+}
diff --git a/library/core/tests/num/mod.rs b/library/core/tests/num/mod.rs
index 9d2912c4b22dc..53ff5ab1cedd1 100644
--- a/library/core/tests/num/mod.rs
+++ b/library/core/tests/num/mod.rs
@@ -30,6 +30,7 @@ mod int_log;
 mod ops;
 mod wrapping;
 
+mod float_iter_sum_identity;
 mod ieee754;
 mod nan;
 

From ef25fbd0b4ffa79cdf34a73795bbfbe8ebe6e267 Mon Sep 17 00:00:00 2001
From: Ding Xiang Fei <dingxiangfei2009@protonmail.ch>
Date: Mon, 5 Aug 2024 03:50:15 +0800
Subject: [PATCH 471/685] lint on tail expr drop order change in Edition 2024

---
 compiler/rustc_lint/messages.ftl              |   3 +
 compiler/rustc_lint/src/lib.rs                |   3 +
 .../rustc_lint/src/tail_expr_drop_order.rs    | 306 ++++++++++++++++++
 src/tools/lint-docs/src/lib.rs                |   1 +
 .../drop/lint-tail-expr-drop-order-gated.rs   |  35 ++
 tests/ui/drop/lint-tail-expr-drop-order.rs    |  71 ++++
 .../ui/drop/lint-tail-expr-drop-order.stderr  |  42 +++
 7 files changed, 461 insertions(+)
 create mode 100644 compiler/rustc_lint/src/tail_expr_drop_order.rs
 create mode 100644 tests/ui/drop/lint-tail-expr-drop-order-gated.rs
 create mode 100644 tests/ui/drop/lint-tail-expr-drop-order.rs
 create mode 100644 tests/ui/drop/lint-tail-expr-drop-order.stderr

diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 7a394a6d6c1ad..28aef9055ef44 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -758,6 +758,9 @@ lint_suspicious_double_ref_clone =
 lint_suspicious_double_ref_deref =
     using `.deref()` on a double reference, which returns `{$ty}` instead of dereferencing the inner type
 
+lint_tail_expr_drop_order = these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
+    .label = these values have significant drop implementation and will observe changes in drop order under Edition 2024
+
 lint_trailing_semi_macro = trailing semicolon in macro used in expression position
     .note1 = macro invocations at the end of a block are treated as expressions
     .note2 = to ignore the value produced by the macro, add a semicolon after the invocation of `{$name}`
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 4f3933d461bbd..1828b6ea93c06 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -78,6 +78,7 @@ mod ptr_nulls;
 mod redundant_semicolon;
 mod reference_casting;
 mod shadowed_into_iter;
+mod tail_expr_drop_order;
 mod traits;
 mod types;
 mod unit_bindings;
@@ -115,6 +116,7 @@ use rustc_middle::query::Providers;
 use rustc_middle::ty::TyCtxt;
 use shadowed_into_iter::ShadowedIntoIter;
 pub use shadowed_into_iter::{ARRAY_INTO_ITER, BOXED_SLICE_INTO_ITER};
+use tail_expr_drop_order::TailExprDropOrder;
 use traits::*;
 use types::*;
 use unit_bindings::*;
@@ -238,6 +240,7 @@ late_lint_methods!(
             AsyncFnInTrait: AsyncFnInTrait,
             NonLocalDefinitions: NonLocalDefinitions::default(),
             ImplTraitOvercaptures: ImplTraitOvercaptures,
+            TailExprDropOrder: TailExprDropOrder,
         ]
     ]
 );
diff --git a/compiler/rustc_lint/src/tail_expr_drop_order.rs b/compiler/rustc_lint/src/tail_expr_drop_order.rs
new file mode 100644
index 0000000000000..f9ecc8c9806f4
--- /dev/null
+++ b/compiler/rustc_lint/src/tail_expr_drop_order.rs
@@ -0,0 +1,306 @@
+use std::mem::swap;
+
+use rustc_ast::UnOp;
+use rustc_hir::def::Res;
+use rustc_hir::intravisit::{self, Visitor};
+use rustc_hir::{self as hir, Block, Expr, ExprKind, LetStmt, Pat, PatKind, QPath, StmtKind};
+use rustc_macros::LintDiagnostic;
+use rustc_middle::ty;
+use rustc_session::lint::FutureIncompatibilityReason;
+use rustc_session::{declare_lint, declare_lint_pass};
+use rustc_span::edition::Edition;
+use rustc_span::Span;
+
+use crate::{LateContext, LateLintPass};
+
+declare_lint! {
+    /// The `tail_expr_drop_order` lint looks for those values generated at the tail expression location, that of type
+    /// with a significant `Drop` implementation, such as locks.
+    /// In case there are also local variables of type with significant `Drop` implementation as well,
+    /// this lint warns you of a potential transposition in the drop order.
+    /// Your discretion on the new drop order introduced by Edition 2024 is required.
+    ///
+    /// ### Example
+    /// ```rust,edition2024
+    /// #![feature(shorter_tail_lifetimes)]
+    /// #![warn(tail_expr_drop_order)]
+    /// struct Droppy(i32);
+    /// impl Droppy {
+    ///     fn get(&self) -> i32 {
+    ///         self.0
+    ///     }
+    /// }
+    /// impl Drop for Droppy {
+    ///     fn drop(&mut self) {
+    ///         // This is a custom destructor and it induces side-effects that is observable
+    ///         // especially when the drop order at a tail expression changes.
+    ///         println!("loud drop {}", self.0);
+    ///     }
+    /// }
+    /// fn edition_2024() -> i32 {
+    ///     let another_droppy = Droppy(0);
+    ///     Droppy(1).get()
+    /// }
+    /// fn main() {
+    ///     edition_2024();
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// In tail expression of blocks or function bodies,
+    /// values of type with significant `Drop` implementation has an ill-specified drop order
+    /// before Edition 2024 so that they are dropped only after dropping local variables.
+    /// Edition 2024 introduces a new rule with drop orders for them,
+    /// so that they are dropped first before dropping local variables.
+    ///
+    /// A significant `Drop::drop` destructor here refers to an explicit, arbitrary
+    /// implementation of the `Drop` trait on the type, with exceptions including `Vec`,
+    /// `Box`, `Rc`, `BTreeMap` and `HashMap` that are marked by the compiler otherwise
+    /// so long that the generic types have no significant destructor recursively.
+    /// In other words, a type has a significant drop destructor when it has a `Drop` implementation
+    /// or its destructor invokes a significant destructor on a type.
+    /// Since we cannot completely reason about the change by just inspecting the existence of
+    /// a significant destructor, this lint remains only a suggestion and is set to `allow` by default.
+    ///
+    /// This lint only points out the issue with `Droppy`, which will be dropped before `another_droppy`
+    /// does in Edition 2024.
+    /// No fix will be proposed by this lint.
+    /// However, the most probable fix is to hoist `Droppy` into its own local variable binding.
+    /// ```rust
+    /// struct Droppy(i32);
+    /// impl Droppy {
+    ///     fn get(&self) -> i32 {
+    ///         self.0
+    ///     }
+    /// }
+    /// fn edition_2024() -> i32 {
+    ///     let value = Droppy(0);
+    ///     let another_droppy = Droppy(1);
+    ///     value.get()
+    /// }
+    /// ```
+    pub TAIL_EXPR_DROP_ORDER,
+    Allow,
+    "Detect and warn on significant change in drop order in tail expression location",
+    @future_incompatible = FutureIncompatibleInfo {
+        reason: FutureIncompatibilityReason::EditionSemanticsChange(Edition::Edition2024),
+        reference: "issue #123739 <https://github.com/rust-lang/rust/issues/123739>",
+    };
+}
+
+declare_lint_pass!(TailExprDropOrder => [TAIL_EXPR_DROP_ORDER]);
+
+impl TailExprDropOrder {
+    fn check_fn_or_closure<'tcx>(
+        cx: &LateContext<'tcx>,
+        fn_kind: hir::intravisit::FnKind<'tcx>,
+        body: &'tcx hir::Body<'tcx>,
+        def_id: rustc_span::def_id::LocalDefId,
+    ) {
+        let mut locals = vec![];
+        if matches!(fn_kind, hir::intravisit::FnKind::Closure) {
+            for &capture in cx.tcx.closure_captures(def_id) {
+                if matches!(capture.info.capture_kind, ty::UpvarCapture::ByValue)
+                    && capture.place.ty().has_significant_drop(cx.tcx, cx.param_env)
+                {
+                    locals.push(capture.var_ident.span);
+                }
+            }
+        }
+        for param in body.params {
+            if cx
+                .typeck_results()
+                .node_type(param.hir_id)
+                .has_significant_drop(cx.tcx, cx.param_env)
+            {
+                locals.push(param.span);
+            }
+        }
+        if let hir::ExprKind::Block(block, _) = body.value.kind {
+            LintVisitor { cx, locals }.check_block_inner(block);
+        } else {
+            LintTailExpr { cx, locals: &locals, is_root_tail_expr: true }.visit_expr(body.value);
+        }
+    }
+}
+
+impl<'tcx> LateLintPass<'tcx> for TailExprDropOrder {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        fn_kind: hir::intravisit::FnKind<'tcx>,
+        _: &'tcx hir::FnDecl<'tcx>,
+        body: &'tcx hir::Body<'tcx>,
+        _: Span,
+        def_id: rustc_span::def_id::LocalDefId,
+    ) {
+        if cx.tcx.sess.at_least_rust_2024() && cx.tcx.features().shorter_tail_lifetimes {
+            Self::check_fn_or_closure(cx, fn_kind, body, def_id);
+        }
+    }
+}
+
+struct LintVisitor<'tcx, 'a> {
+    cx: &'a LateContext<'tcx>,
+    // We only record locals that have significant drops
+    locals: Vec<Span>,
+}
+
+struct LocalCollector<'tcx, 'a> {
+    cx: &'a LateContext<'tcx>,
+    locals: &'a mut Vec<Span>,
+}
+
+impl<'tcx, 'a> Visitor<'tcx> for LocalCollector<'tcx, 'a> {
+    type Result = ();
+    fn visit_pat(&mut self, pat: &'tcx Pat<'tcx>) {
+        if let PatKind::Binding(_binding_mode, id, ident, pat) = pat.kind {
+            let ty = self.cx.typeck_results().node_type(id);
+            if ty.has_significant_drop(self.cx.tcx, self.cx.param_env) {
+                self.locals.push(ident.span);
+            }
+            if let Some(pat) = pat {
+                self.visit_pat(pat);
+            }
+        } else {
+            intravisit::walk_pat(self, pat);
+        }
+    }
+}
+
+impl<'tcx, 'a> Visitor<'tcx> for LintVisitor<'tcx, 'a> {
+    fn visit_block(&mut self, block: &'tcx Block<'tcx>) {
+        let mut locals = <_>::default();
+        swap(&mut locals, &mut self.locals);
+        self.check_block_inner(block);
+        swap(&mut locals, &mut self.locals);
+    }
+    fn visit_local(&mut self, local: &'tcx LetStmt<'tcx>) {
+        LocalCollector { cx: self.cx, locals: &mut self.locals }.visit_local(local);
+    }
+}
+
+impl<'tcx, 'a> LintVisitor<'tcx, 'a> {
+    fn check_block_inner(&mut self, block: &Block<'tcx>) {
+        if !block.span.at_least_rust_2024() {
+            // We only lint for Edition 2024 onwards
+            return;
+        }
+        let Some(tail_expr) = block.expr else { return };
+        for stmt in block.stmts {
+            match stmt.kind {
+                StmtKind::Let(let_stmt) => self.visit_local(let_stmt),
+                StmtKind::Item(_) => {}
+                StmtKind::Expr(e) | StmtKind::Semi(e) => self.visit_expr(e),
+            }
+        }
+        if self.locals.is_empty() {
+            return;
+        }
+        LintTailExpr { cx: self.cx, locals: &self.locals, is_root_tail_expr: true }
+            .visit_expr(tail_expr);
+    }
+}
+
+struct LintTailExpr<'tcx, 'a> {
+    cx: &'a LateContext<'tcx>,
+    is_root_tail_expr: bool,
+    locals: &'a [Span],
+}
+
+impl<'tcx, 'a> LintTailExpr<'tcx, 'a> {
+    fn expr_eventually_point_into_local(mut expr: &Expr<'tcx>) -> bool {
+        loop {
+            match expr.kind {
+                ExprKind::Index(access, _, _) | ExprKind::Field(access, _) => expr = access,
+                ExprKind::AddrOf(_, _, referee) | ExprKind::Unary(UnOp::Deref, referee) => {
+                    expr = referee
+                }
+                ExprKind::Path(_)
+                    if let ExprKind::Path(QPath::Resolved(_, path)) = expr.kind
+                        && let [local, ..] = path.segments
+                        && let Res::Local(_) = local.res =>
+                {
+                    return true;
+                }
+                _ => return false,
+            }
+        }
+    }
+
+    fn expr_generates_nonlocal_droppy_value(&self, expr: &Expr<'tcx>) -> bool {
+        if Self::expr_eventually_point_into_local(expr) {
+            return false;
+        }
+        self.cx.typeck_results().expr_ty(expr).has_significant_drop(self.cx.tcx, self.cx.param_env)
+    }
+}
+
+impl<'tcx, 'a> Visitor<'tcx> for LintTailExpr<'tcx, 'a> {
+    fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
+        if self.is_root_tail_expr {
+            self.is_root_tail_expr = false;
+        } else if self.expr_generates_nonlocal_droppy_value(expr) {
+            self.cx.tcx.emit_node_span_lint(
+                TAIL_EXPR_DROP_ORDER,
+                expr.hir_id,
+                expr.span,
+                TailExprDropOrderLint { spans: self.locals.to_vec() },
+            );
+            return;
+        }
+        match expr.kind {
+            ExprKind::Match(scrutinee, _, _) => self.visit_expr(scrutinee),
+
+            ExprKind::ConstBlock(_)
+            | ExprKind::Array(_)
+            | ExprKind::Break(_, _)
+            | ExprKind::Continue(_)
+            | ExprKind::Ret(_)
+            | ExprKind::Become(_)
+            | ExprKind::Yield(_, _)
+            | ExprKind::InlineAsm(_)
+            | ExprKind::If(_, _, _)
+            | ExprKind::Loop(_, _, _, _)
+            | ExprKind::Closure(_)
+            | ExprKind::DropTemps(_)
+            | ExprKind::OffsetOf(_, _)
+            | ExprKind::Assign(_, _, _)
+            | ExprKind::AssignOp(_, _, _)
+            | ExprKind::Lit(_)
+            | ExprKind::Err(_) => {}
+
+            ExprKind::MethodCall(_, _, _, _)
+            | ExprKind::Call(_, _)
+            | ExprKind::Type(_, _)
+            | ExprKind::Tup(_)
+            | ExprKind::Binary(_, _, _)
+            | ExprKind::Unary(_, _)
+            | ExprKind::Path(_)
+            | ExprKind::Let(_)
+            | ExprKind::Cast(_, _)
+            | ExprKind::Field(_, _)
+            | ExprKind::Index(_, _, _)
+            | ExprKind::AddrOf(_, _, _)
+            | ExprKind::Struct(_, _, _)
+            | ExprKind::Repeat(_, _) => intravisit::walk_expr(self, expr),
+
+            ExprKind::Block(_, _) => {
+                // We do not lint further because the drop order stays the same inside the block
+            }
+        }
+    }
+    fn visit_block(&mut self, block: &'tcx Block<'tcx>) {
+        LintVisitor { cx: self.cx, locals: <_>::default() }.check_block_inner(block);
+    }
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_tail_expr_drop_order)]
+struct TailExprDropOrderLint {
+    #[label]
+    pub spans: Vec<Span>,
+}
diff --git a/src/tools/lint-docs/src/lib.rs b/src/tools/lint-docs/src/lib.rs
index e0aef13ca79ef..72bb9db7e7414 100644
--- a/src/tools/lint-docs/src/lib.rs
+++ b/src/tools/lint-docs/src/lib.rs
@@ -444,6 +444,7 @@ impl<'a> LintExtractor<'a> {
         let mut cmd = Command::new(self.rustc_path);
         if options.contains(&"edition2024") {
             cmd.arg("--edition=2024");
+            cmd.arg("-Zunstable-options");
         } else if options.contains(&"edition2021") {
             cmd.arg("--edition=2021");
         } else if options.contains(&"edition2018") {
diff --git a/tests/ui/drop/lint-tail-expr-drop-order-gated.rs b/tests/ui/drop/lint-tail-expr-drop-order-gated.rs
new file mode 100644
index 0000000000000..b22e72bcfad22
--- /dev/null
+++ b/tests/ui/drop/lint-tail-expr-drop-order-gated.rs
@@ -0,0 +1,35 @@
+// This test ensures that `tail_expr_drop_order` does not activate in case Edition 2024 is not used
+// or the feature gate `shorter_tail_lifetimes` is disabled.
+
+//@ revisions: neither no_feature_gate edition_less_than_2024
+//@ check-pass
+//@ [neither] edition: 2021
+//@ [no_feature_gate] compile-flags: -Z unstable-options
+//@ [no_feature_gate] edition: 2024
+//@ [edition_less_than_2024] edition: 2021
+
+#![deny(tail_expr_drop_order)]
+#![cfg_attr(edition_less_than_2024, feature(shorter_tail_lifetimes))]
+
+struct LoudDropper;
+impl Drop for LoudDropper {
+    fn drop(&mut self) {
+        // This destructor should be considered significant because it is a custom destructor
+        // and we will assume that the destructor can generate side effects arbitrarily so that
+        // a change in drop order is visible.
+        println!("loud drop");
+    }
+}
+impl LoudDropper {
+    fn get(&self) -> i32 {
+        0
+    }
+}
+
+fn should_not_lint() -> i32 {
+    let x = LoudDropper;
+    x.get() + LoudDropper.get()
+    // Lint should not action
+}
+
+fn main() {}
diff --git a/tests/ui/drop/lint-tail-expr-drop-order.rs b/tests/ui/drop/lint-tail-expr-drop-order.rs
new file mode 100644
index 0000000000000..0aa0ef026101a
--- /dev/null
+++ b/tests/ui/drop/lint-tail-expr-drop-order.rs
@@ -0,0 +1,71 @@
+//@ compile-flags: -Z unstable-options
+//@ edition: 2024
+
+// Edition 2024 lint for change in drop order at tail expression
+// This lint is to capture potential change in program semantics
+// due to implementation of RFC 3606 <https://github.com/rust-lang/rfcs/pull/3606>
+
+#![deny(tail_expr_drop_order)]
+#![feature(shorter_tail_lifetimes)]
+
+struct LoudDropper;
+impl Drop for LoudDropper {
+    fn drop(&mut self) {
+        // This destructor should be considered significant because it is a custom destructor
+        // and we will assume that the destructor can generate side effects arbitrarily so that
+        // a change in drop order is visible.
+        println!("loud drop");
+    }
+}
+impl LoudDropper {
+    fn get(&self) -> i32 {
+        0
+    }
+}
+
+fn should_lint() -> i32 {
+    let x = LoudDropper;
+    // Should lint
+    x.get() + LoudDropper.get()
+    //~^ ERROR: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
+    //~| WARN: this changes meaning in Rust 2024
+}
+
+fn should_lint_closure() -> impl FnOnce() -> i32 {
+    let x = LoudDropper;
+    move || x.get() + LoudDropper.get()
+    //~^ ERROR: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
+    //~| WARN: this changes meaning in Rust 2024
+}
+
+fn should_not_lint() -> i32 {
+    let x = LoudDropper;
+    // Should not lint
+    x.get()
+}
+
+fn should_not_lint_in_nested_block() -> i32 {
+    let x = LoudDropper;
+    // Should not lint because Edition 2021 drops temporaries in blocks earlier already
+    { LoudDropper.get() }
+}
+
+fn should_not_lint_in_match_arm() -> i32 {
+    let x = LoudDropper;
+    // Should not lint because Edition 2021 drops temporaries in blocks earlier already
+    match &x {
+        _ => LoudDropper.get(),
+    }
+}
+
+fn should_lint_in_nested_items() {
+    fn should_lint_me() -> i32 {
+        let x = LoudDropper;
+        // Should lint
+        x.get() + LoudDropper.get()
+        //~^ ERROR: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
+        //~| WARN: this changes meaning in Rust 2024
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/drop/lint-tail-expr-drop-order.stderr b/tests/ui/drop/lint-tail-expr-drop-order.stderr
new file mode 100644
index 0000000000000..630f0a80f092b
--- /dev/null
+++ b/tests/ui/drop/lint-tail-expr-drop-order.stderr
@@ -0,0 +1,42 @@
+error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
+  --> $DIR/lint-tail-expr-drop-order.rs:29:15
+   |
+LL |     let x = LoudDropper;
+   |         - these values have significant drop implementation and will observe changes in drop order under Edition 2024
+LL |     // Should lint
+LL |     x.get() + LoudDropper.get()
+   |               ^^^^^^^^^^^
+   |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see issue #123739 <https://github.com/rust-lang/rust/issues/123739>
+note: the lint level is defined here
+  --> $DIR/lint-tail-expr-drop-order.rs:8:9
+   |
+LL | #![deny(tail_expr_drop_order)]
+   |         ^^^^^^^^^^^^^^^^^^^^
+
+error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
+  --> $DIR/lint-tail-expr-drop-order.rs:36:23
+   |
+LL |     let x = LoudDropper;
+   |         - these values have significant drop implementation and will observe changes in drop order under Edition 2024
+LL |     move || x.get() + LoudDropper.get()
+   |                       ^^^^^^^^^^^
+   |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see issue #123739 <https://github.com/rust-lang/rust/issues/123739>
+
+error: these values and local bindings have significant drop implementation that will have a different drop order from that of Edition 2021
+  --> $DIR/lint-tail-expr-drop-order.rs:65:19
+   |
+LL |         let x = LoudDropper;
+   |             - these values have significant drop implementation and will observe changes in drop order under Edition 2024
+LL |         // Should lint
+LL |         x.get() + LoudDropper.get()
+   |                   ^^^^^^^^^^^
+   |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see issue #123739 <https://github.com/rust-lang/rust/issues/123739>
+
+error: aborting due to 3 previous errors
+

From 4325ac9652016896edc4209805d23c1cb0ea5ae0 Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Tue, 20 Aug 2024 19:27:29 +0200
Subject: [PATCH 472/685] Implement `ptr::fn_addr_eq`

---
 library/core/src/ptr/mod.rs | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 25d8f4a0adbd9..15b6c570dc0f6 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -2130,6 +2130,33 @@ pub fn addr_eq<T: ?Sized, U: ?Sized>(p: *const T, q: *const U) -> bool {
     (p as *const ()) == (q as *const ())
 }
 
+/// Compares the *addresses* of the two function pointers for equality.
+///
+/// Function pointers comparisons can have surprising results since
+/// they are never guaranteed to be unique and could vary between different
+/// code generation units. Furthermore, different functions could have the
+/// same address after being merged together.
+///
+/// This is the same as `f == g` but using this function makes clear
+/// that you are aware of these potentially surprising semantics.
+///
+/// # Examples
+///
+/// ```
+/// #![feature(ptr_fn_addr_eq)]
+/// use std::ptr;
+///
+/// fn a() { println!("a"); }
+/// fn b() { println!("b"); }
+/// assert!(!ptr::fn_addr_eq(a as fn(), b as fn()));
+/// ```
+#[unstable(feature = "ptr_fn_addr_eq", issue = "129322")]
+#[inline(always)]
+#[must_use = "function pointer comparison produces a value"]
+pub fn fn_addr_eq<T: FnPtr, U: FnPtr>(f: T, g: U) -> bool {
+    f.addr() == g.addr()
+}
+
 /// Hash a raw pointer.
 ///
 /// This can be used to hash a `&T` reference (which coerces to `*const T` implicitly)

From f30392a985c59a52059cedf428b0c118b4195432 Mon Sep 17 00:00:00 2001
From: Nadrieril <nadrieril+git@gmail.com>
Date: Tue, 20 Aug 2024 21:42:48 +0200
Subject: [PATCH 473/685] Move the "matches no value" note to be a span label

---
 compiler/rustc_mir_build/messages.ftl         |   2 +-
 compiler/rustc_mir_build/src/errors.rs        |  11 +-
 .../src/thir/pattern/check_match.rs           |   4 +-
 ...tch-check-notes.exhaustive_patterns.stderr |  12 +-
 .../empty-match-check-notes.normal.stderr     |  12 +-
 .../empty-types.exhaustive_patterns.stderr    | 105 ++++++------------
 .../usefulness/empty-types.never_pats.stderr  | 105 ++++++------------
 .../usefulness/empty-types.normal.stderr      | 105 ++++++------------
 .../explain-unreachable-pats.stderr           |   9 +-
 tests/ui/pattern/usefulness/impl-trait.stderr |  24 ++--
 .../unreachable-loop-patterns.stderr          |   3 +-
 .../reachable/unreachable-try-pattern.stderr  |   6 +-
 .../unreachable.stderr                        |  18 +--
 .../enum_same_crate_empty_match.stderr        |   3 +-
 .../uninhabited/patterns_same_crate.stderr    |  15 +--
 .../uninhabited/uninhabited-patterns.stderr   |   9 +-
 16 files changed, 149 insertions(+), 294 deletions(-)

diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index 15da430759b8e..7a10e627ccd89 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -333,7 +333,7 @@ mir_build_unreachable_matches_same_values = matches some of the same values
 
 mir_build_unreachable_pattern = unreachable pattern
     .label = no value can reach this
-    .unreachable_matches_no_values = matches no values because `{$ty}` is uninhabited
+    .unreachable_matches_no_values = matches no values because `{$matches_no_values_ty}` is uninhabited
     .unreachable_uninhabited_note = to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
     .unreachable_covered_by_catchall = matches any value
     .unreachable_covered_by_one = matches all the relevant values
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index 76b765ad4cd9b..1e470f32eb025 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -586,8 +586,9 @@ pub(crate) struct NonConstPath {
 pub(crate) struct UnreachablePattern<'tcx> {
     #[label]
     pub(crate) span: Option<Span>,
-    #[subdiagnostic]
-    pub(crate) matches_no_values: Option<UnreachableMatchesNoValues<'tcx>>,
+    #[label(mir_build_unreachable_matches_no_values)]
+    pub(crate) matches_no_values: Option<Span>,
+    pub(crate) matches_no_values_ty: Ty<'tcx>,
     #[note(mir_build_unreachable_uninhabited_note)]
     pub(crate) uninhabited_note: Option<()>,
     #[label(mir_build_unreachable_covered_by_catchall)]
@@ -599,12 +600,6 @@ pub(crate) struct UnreachablePattern<'tcx> {
     pub(crate) covered_by_many_n_more_count: usize,
 }
 
-#[derive(Subdiagnostic)]
-#[note(mir_build_unreachable_matches_no_values)]
-pub(crate) struct UnreachableMatchesNoValues<'tcx> {
-    pub(crate) ty: Ty<'tcx>,
-}
-
 #[derive(Diagnostic)]
 #[diag(mir_build_const_pattern_depends_on_generic_parameter, code = E0158)]
 pub(crate) struct ConstPatternDependsOnGenericParameter {
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index ca563e015698b..e5f9f64c220ca 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -922,6 +922,7 @@ fn report_unreachable_pattern<'p, 'tcx>(
     let mut lint = UnreachablePattern {
         span: Some(pat_span),
         matches_no_values: None,
+        matches_no_values_ty: **pat.ty(),
         uninhabited_note: None,
         covered_by_catchall: None,
         covered_by_one: None,
@@ -933,10 +934,11 @@ fn report_unreachable_pattern<'p, 'tcx>(
             // Empty pattern; we report the uninhabited type that caused the emptiness.
             lint.span = None; // Don't label the pattern itself
             lint.uninhabited_note = Some(()); // Give a link about empty types
+            lint.matches_no_values = Some(pat_span);
             pat.walk(&mut |subpat| {
                 let ty = **subpat.ty();
                 if cx.is_uninhabited(ty) {
-                    lint.matches_no_values = Some(UnreachableMatchesNoValues { ty });
+                    lint.matches_no_values_ty = ty;
                     false // No need to dig further.
                 } else if matches!(subpat.ctor(), Constructor::Ref | Constructor::UnionField) {
                     false // Don't explore further since they are not by-value.
diff --git a/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr
index 5ec14a7597a54..60ab4d52c30f1 100644
--- a/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr
+++ b/tests/ui/pattern/usefulness/empty-match-check-notes.exhaustive_patterns.stderr
@@ -2,9 +2,8 @@ error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:17:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `EmptyEnum` is uninhabited
    |
-   = note: matches no values because `EmptyEnum` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/empty-match-check-notes.rs:7:9
@@ -16,27 +15,24 @@ error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:22:9
    |
 LL |         _ if false => {}
-   |         ^
+   |         ^ matches no values because `EmptyEnum` is uninhabited
    |
-   = note: matches no values because `EmptyEnum` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:31:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `EmptyForeignEnum` is uninhabited
    |
-   = note: matches no values because `EmptyForeignEnum` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:36:9
    |
 LL |         _ if false => {}
-   |         ^
+   |         ^ matches no values because `EmptyForeignEnum` is uninhabited
    |
-   = note: matches no values because `EmptyForeignEnum` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0005]: refutable pattern in local binding
diff --git a/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr b/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr
index 5ec14a7597a54..60ab4d52c30f1 100644
--- a/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr
+++ b/tests/ui/pattern/usefulness/empty-match-check-notes.normal.stderr
@@ -2,9 +2,8 @@ error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:17:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `EmptyEnum` is uninhabited
    |
-   = note: matches no values because `EmptyEnum` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/empty-match-check-notes.rs:7:9
@@ -16,27 +15,24 @@ error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:22:9
    |
 LL |         _ if false => {}
-   |         ^
+   |         ^ matches no values because `EmptyEnum` is uninhabited
    |
-   = note: matches no values because `EmptyEnum` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:31:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `EmptyForeignEnum` is uninhabited
    |
-   = note: matches no values because `EmptyForeignEnum` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-match-check-notes.rs:36:9
    |
 LL |         _ if false => {}
-   |         ^
+   |         ^ matches no values because `EmptyForeignEnum` is uninhabited
    |
-   = note: matches no values because `EmptyForeignEnum` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0005]: refutable pattern in local binding
diff --git a/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr b/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
index 4e5f1d0ea8c21..9decddfe5de9a 100644
--- a/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.exhaustive_patterns.stderr
@@ -2,9 +2,8 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:49:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/empty-types.rs:15:9
@@ -16,9 +15,8 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:52:9
    |
 LL |         _x => {}
-   |         ^^
+   |         ^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
@@ -40,36 +38,32 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:70:9
    |
 LL |         (_, _) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `(u32, !)` is uninhabited
    |
-   = note: matches no values because `(u32, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:76:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `(!, !)` is uninhabited
    |
-   = note: matches no values because `(!, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:79:9
    |
 LL |         (_, _) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `(!, !)` is uninhabited
    |
-   = note: matches no values because `(!, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:83:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
@@ -95,18 +89,16 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:94:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:99:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
@@ -145,81 +137,72 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:112:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:115:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:118:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:119:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:122:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:123:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:132:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:135:13
    |
 LL |             _ if false => {}
-   |             ^
+   |             ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:143:13
    |
 LL |             Some(_) => {}
-   |             ^^^^^^^
+   |             ^^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
@@ -234,81 +217,72 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:199:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:204:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:209:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:214:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:220:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:281:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:284:9
    |
 LL |         (_, _) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `(!, !)` is uninhabited
    |
-   = note: matches no values because `(!, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:287:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:288:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&[!]` is non-empty
@@ -370,27 +344,24 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:368:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `[!; 3]` is uninhabited
    |
-   = note: matches no values because `[!; 3]` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:371:9
    |
 LL |         [_, _, _] => {}
-   |         ^^^^^^^^^
+   |         ^^^^^^^^^ matches no values because `[!; 3]` is uninhabited
    |
-   = note: matches no values because `[!; 3]` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:374:9
    |
 LL |         [_, ..] => {}
-   |         ^^^^^^^
+   |         ^^^^^^^ matches no values because `[!; 3]` is uninhabited
    |
-   = note: matches no values because `[!; 3]` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
@@ -433,18 +404,16 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:416:9
    |
 LL |         Some(_) => {}
-   |         ^^^^^^^
+   |         ^^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:421:9
    |
 LL |         Some(_a) => {}
-   |         ^^^^^^^^
+   |         ^^^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
@@ -469,36 +438,32 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:603:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:606:9
    |
 LL |         _x => {}
-   |         ^^
+   |         ^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:609:9
    |
 LL |         _ if false => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:612:9
    |
 LL |         _x if false => {}
-   |         ^^
+   |         ^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: aborting due to 49 previous errors
diff --git a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
index 3332eab8a776c..68213a2d661e0 100644
--- a/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.never_pats.stderr
@@ -11,9 +11,8 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:49:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/empty-types.rs:15:9
@@ -25,9 +24,8 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:52:9
    |
 LL |         _x => {}
-   |         ^^
+   |         ^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
@@ -49,36 +47,32 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:70:9
    |
 LL |         (_, _) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `(u32, !)` is uninhabited
    |
-   = note: matches no values because `(u32, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:76:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `(!, !)` is uninhabited
    |
-   = note: matches no values because `(!, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:79:9
    |
 LL |         (_, _) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `(!, !)` is uninhabited
    |
-   = note: matches no values because `(!, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:83:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
@@ -104,18 +98,16 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:94:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:99:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
@@ -168,81 +160,72 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:112:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:115:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:118:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:119:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:122:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:123:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:132:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:135:13
    |
 LL |             _ if false => {}
-   |             ^
+   |             ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:143:13
    |
 LL |             Some(_) => {}
-   |             ^^^^^^^
+   |             ^^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
@@ -276,81 +259,72 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:199:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:204:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:209:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:214:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:220:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:281:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:284:9
    |
 LL |         (_, _) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `(!, !)` is uninhabited
    |
-   = note: matches no values because `(!, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:287:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:288:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0005]: refutable pattern in local binding
@@ -504,27 +478,24 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:368:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `[!; 3]` is uninhabited
    |
-   = note: matches no values because `[!; 3]` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:371:9
    |
 LL |         [_, _, _] => {}
-   |         ^^^^^^^^^
+   |         ^^^^^^^^^ matches no values because `[!; 3]` is uninhabited
    |
-   = note: matches no values because `[!; 3]` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:374:9
    |
 LL |         [_, ..] => {}
-   |         ^^^^^^^
+   |         ^^^^^^^ matches no values because `[!; 3]` is uninhabited
    |
-   = note: matches no values because `[!; 3]` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
@@ -567,18 +538,16 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:416:9
    |
 LL |         Some(_) => {}
-   |         ^^^^^^^
+   |         ^^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:421:9
    |
 LL |         Some(_a) => {}
-   |         ^^^^^^^^
+   |         ^^^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
@@ -693,36 +662,32 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:603:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:606:9
    |
 LL |         _x => {}
-   |         ^^
+   |         ^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:609:9
    |
 LL |         _ if false => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:612:9
    |
 LL |         _x if false => {}
-   |         ^^
+   |         ^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `&!` not covered
diff --git a/tests/ui/pattern/usefulness/empty-types.normal.stderr b/tests/ui/pattern/usefulness/empty-types.normal.stderr
index 89cf09f011e96..8f60dad4467bc 100644
--- a/tests/ui/pattern/usefulness/empty-types.normal.stderr
+++ b/tests/ui/pattern/usefulness/empty-types.normal.stderr
@@ -2,9 +2,8 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:49:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/empty-types.rs:15:9
@@ -16,9 +15,8 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:52:9
    |
 LL |         _x => {}
-   |         ^^
+   |         ^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `&!` is non-empty
@@ -40,36 +38,32 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:70:9
    |
 LL |         (_, _) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `(u32, !)` is uninhabited
    |
-   = note: matches no values because `(u32, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:76:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `(!, !)` is uninhabited
    |
-   = note: matches no values because `(!, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:79:9
    |
 LL |         (_, _) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `(!, !)` is uninhabited
    |
-   = note: matches no values because `(!, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:83:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(_)` not covered
@@ -95,18 +89,16 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:94:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:99:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `Ok(1_u32..=u32::MAX)` not covered
@@ -159,81 +151,72 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:112:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:115:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:118:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:119:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:122:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:123:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:132:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:135:13
    |
 LL |             _ if false => {}
-   |             ^
+   |             ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:143:13
    |
 LL |             Some(_) => {}
-   |             ^^^^^^^
+   |             ^^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
@@ -267,81 +250,72 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:199:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:204:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:209:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:214:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:220:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:281:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:284:9
    |
 LL |         (_, _) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `(!, !)` is uninhabited
    |
-   = note: matches no values because `(!, !)` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:287:9
    |
 LL |         Ok(_) => {}
-   |         ^^^^^
+   |         ^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:288:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `Result<!, !>` is uninhabited
    |
-   = note: matches no values because `Result<!, !>` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0005]: refutable pattern in local binding
@@ -495,27 +469,24 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:368:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `[!; 3]` is uninhabited
    |
-   = note: matches no values because `[!; 3]` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:371:9
    |
 LL |         [_, _, _] => {}
-   |         ^^^^^^^^^
+   |         ^^^^^^^^^ matches no values because `[!; 3]` is uninhabited
    |
-   = note: matches no values because `[!; 3]` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:374:9
    |
 LL |         [_, ..] => {}
-   |         ^^^^^^^
+   |         ^^^^^^^ matches no values because `[!; 3]` is uninhabited
    |
-   = note: matches no values because `[!; 3]` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `[!; 0]` is non-empty
@@ -558,18 +529,16 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:416:9
    |
 LL |         Some(_) => {}
-   |         ^^^^^^^
+   |         ^^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:421:9
    |
 LL |         Some(_a) => {}
-   |         ^^^^^^^^
+   |         ^^^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
@@ -684,36 +653,32 @@ error: unreachable pattern
   --> $DIR/empty-types.rs:603:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:606:9
    |
 LL |         _x => {}
-   |         ^^
+   |         ^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:609:9
    |
 LL |         _ if false => {}
-   |         ^
+   |         ^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/empty-types.rs:612:9
    |
 LL |         _x if false => {}
-   |         ^^
+   |         ^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: `&_` not covered
diff --git a/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr b/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
index 1378dce606358..7023c2775e9a7 100644
--- a/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
+++ b/tests/ui/pattern/usefulness/explain-unreachable-pats.stderr
@@ -59,27 +59,24 @@ error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:51:9
    |
 LL |         Err(_) => {}
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:65:9
    |
 LL |         (Err(_), Err(_)) => {}
-   |         ^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^ matches no values because `Void2` is uninhabited
    |
-   = note: matches no values because `Void2` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/explain-unreachable-pats.rs:72:9
    |
 LL |         (Err(_), Err(_)) => {}
-   |         ^^^^^^^^^^^^^^^^
+   |         ^^^^^^^^^^^^^^^^ matches no values because `Void1` is uninhabited
    |
-   = note: matches no values because `Void1` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
diff --git a/tests/ui/pattern/usefulness/impl-trait.stderr b/tests/ui/pattern/usefulness/impl-trait.stderr
index 0abfeb5b52907..34b157f0fc443 100644
--- a/tests/ui/pattern/usefulness/impl-trait.stderr
+++ b/tests/ui/pattern/usefulness/impl-trait.stderr
@@ -2,9 +2,8 @@ error: unreachable pattern
   --> $DIR/impl-trait.rs:16:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/impl-trait.rs:4:9
@@ -16,18 +15,16 @@ error: unreachable pattern
   --> $DIR/impl-trait.rs:30:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:44:13
    |
 LL |             Some(_) => {}
-   |             ^^^^^^^
+   |             ^^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
@@ -42,9 +39,8 @@ error: unreachable pattern
   --> $DIR/impl-trait.rs:58:13
    |
 LL |             Some(_) => {}
-   |             ^^^^^^^
+   |             ^^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
@@ -59,9 +55,8 @@ error: unreachable pattern
   --> $DIR/impl-trait.rs:75:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
@@ -76,9 +71,8 @@ error: unreachable pattern
   --> $DIR/impl-trait.rs:93:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
@@ -101,18 +95,16 @@ error: unreachable pattern
   --> $DIR/impl-trait.rs:137:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `SecretelyVoid` is uninhabited
    |
-   = note: matches no values because `SecretelyVoid` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/impl-trait.rs:150:13
    |
 LL |             _ => {}
-   |             ^
+   |             ^ matches no values because `SecretelyDoubleVoid` is uninhabited
    |
-   = note: matches no values because `SecretelyDoubleVoid` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error[E0004]: non-exhaustive patterns: type `impl Copy` is non-empty
diff --git a/tests/ui/reachable/unreachable-loop-patterns.stderr b/tests/ui/reachable/unreachable-loop-patterns.stderr
index f34ca3258ca51..03959ac160695 100644
--- a/tests/ui/reachable/unreachable-loop-patterns.stderr
+++ b/tests/ui/reachable/unreachable-loop-patterns.stderr
@@ -2,9 +2,8 @@ error: unreachable pattern
   --> $DIR/unreachable-loop-patterns.rs:16:9
    |
 LL |     for _ in unimplemented!() as Void {}
-   |         ^
+   |         ^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/unreachable-loop-patterns.rs:3:9
diff --git a/tests/ui/reachable/unreachable-try-pattern.stderr b/tests/ui/reachable/unreachable-try-pattern.stderr
index 2ead661a65886..b082bc1160332 100644
--- a/tests/ui/reachable/unreachable-try-pattern.stderr
+++ b/tests/ui/reachable/unreachable-try-pattern.stderr
@@ -17,9 +17,8 @@ warning: unreachable pattern
   --> $DIR/unreachable-try-pattern.rs:19:24
    |
 LL |     let y = (match x { Ok(n) => Ok(n as u32), Err(e) => Err(e) })?;
-   |                        ^^^^^
+   |                        ^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/unreachable-try-pattern.rs:4:9
@@ -31,9 +30,8 @@ warning: unreachable pattern
   --> $DIR/unreachable-try-pattern.rs:30:40
    |
 LL |     let y = (match x { Ok(n) => Ok(n), Err(e) => Err(e) })?;
-   |                                        ^^^^^^
+   |                                        ^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 warning: 3 warnings emitted
diff --git a/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr b/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr
index b7a5f3e551390..6b3f303eeab84 100644
--- a/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr
+++ b/tests/ui/rfcs/rfc-0000-never_patterns/unreachable.stderr
@@ -2,9 +2,8 @@ error: unreachable pattern
   --> $DIR/unreachable.rs:14:9
    |
 LL |         Err(!),
-   |         ^^^^^^
+   |         ^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/unreachable.rs:4:9
@@ -16,45 +15,40 @@ error: unreachable pattern
   --> $DIR/unreachable.rs:17:19
    |
 LL |     let (Ok(_x) | Err(!)) = res_void;
-   |                   ^^^^^^
+   |                   ^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:19:12
    |
 LL |     if let Err(!) = res_void {}
-   |            ^^^^^^
+   |            ^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:21:24
    |
 LL |     if let (Ok(true) | Err(!)) = res_void {}
-   |                        ^^^^^^
+   |                        ^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:23:23
    |
 LL |     for (Ok(mut _x) | Err(!)) in [res_void] {}
-   |                       ^^^^^^
+   |                       ^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/unreachable.rs:27:18
    |
 LL | fn foo((Ok(_x) | Err(!)): Result<bool, Void>) {}
-   |                  ^^^^^^
+   |                  ^^^^^^ matches no values because `Void` is uninhabited
    |
-   = note: matches no values because `Void` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: aborting due to 6 previous errors
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr
index 88fab333c74af..dfd7f9d630051 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/enum_same_crate_empty_match.stderr
@@ -2,9 +2,8 @@ error: unreachable pattern
   --> $DIR/enum_same_crate_empty_match.rs:28:9
    |
 LL |         _ => {}
-   |         ^
+   |         ^ matches no values because `EmptyNonExhaustiveEnum` is uninhabited
    |
-   = note: matches no values because `EmptyNonExhaustiveEnum` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/enum_same_crate_empty_match.rs:1:9
diff --git a/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr b/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
index 5dbe7a2dc5ac5..7e7dc802e7fbf 100644
--- a/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
+++ b/tests/ui/rfcs/rfc-2008-non-exhaustive/uninhabited/patterns_same_crate.stderr
@@ -2,9 +2,8 @@ error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:51:9
    |
 LL |         Some(_x) => (),
-   |         ^^^^^^^^
+   |         ^^^^^^^^ matches no values because `UninhabitedEnum` is uninhabited
    |
-   = note: matches no values because `UninhabitedEnum` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/patterns_same_crate.rs:1:9
@@ -16,36 +15,32 @@ error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:56:9
    |
 LL |         Some(_x) => (),
-   |         ^^^^^^^^
+   |         ^^^^^^^^ matches no values because `UninhabitedVariants` is uninhabited
    |
-   = note: matches no values because `UninhabitedVariants` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:60:15
    |
 LL |     while let PartiallyInhabitedVariants::Struct { x } = partially_inhabited_variant() {
-   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ matches no values because `!` is uninhabited
    |
-   = note: matches no values because `!` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:64:15
    |
 LL |     while let Some(_x) = uninhabited_struct() {
-   |               ^^^^^^^^
+   |               ^^^^^^^^ matches no values because `UninhabitedStruct` is uninhabited
    |
-   = note: matches no values because `UninhabitedStruct` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/patterns_same_crate.rs:67:15
    |
 LL |     while let Some(_x) = uninhabited_tuple_struct() {
-   |               ^^^^^^^^
+   |               ^^^^^^^^ matches no values because `UninhabitedTupleStruct` is uninhabited
    |
-   = note: matches no values because `UninhabitedTupleStruct` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: aborting due to 5 previous errors
diff --git a/tests/ui/uninhabited/uninhabited-patterns.stderr b/tests/ui/uninhabited/uninhabited-patterns.stderr
index c9b9242384d9a..0e1c9d31a731f 100644
--- a/tests/ui/uninhabited/uninhabited-patterns.stderr
+++ b/tests/ui/uninhabited/uninhabited-patterns.stderr
@@ -2,9 +2,8 @@ error: unreachable pattern
   --> $DIR/uninhabited-patterns.rs:29:9
    |
 LL |         Ok(box _) => (),
-   |         ^^^^^^^^^
+   |         ^^^^^^^^^ matches no values because `NotSoSecretlyEmpty` is uninhabited
    |
-   = note: matches no values because `NotSoSecretlyEmpty` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 note: the lint level is defined here
   --> $DIR/uninhabited-patterns.rs:3:9
@@ -16,18 +15,16 @@ error: unreachable pattern
   --> $DIR/uninhabited-patterns.rs:38:9
    |
 LL |         Err(Ok(_y)) => (),
-   |         ^^^^^^^^^^^
+   |         ^^^^^^^^^^^ matches no values because `NotSoSecretlyEmpty` is uninhabited
    |
-   = note: matches no values because `NotSoSecretlyEmpty` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: unreachable pattern
   --> $DIR/uninhabited-patterns.rs:41:15
    |
 LL |     while let Some(_y) = foo() {
-   |               ^^^^^^^^
+   |               ^^^^^^^^ matches no values because `NotSoSecretlyEmpty` is uninhabited
    |
-   = note: matches no values because `NotSoSecretlyEmpty` is uninhabited
    = note: to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types
 
 error: aborting due to 3 previous errors

From e424e7fcaacf1bd26584a2ecf50299c0058fbba5 Mon Sep 17 00:00:00 2001
From: Josh Stone <jistone@redhat.com>
Date: Tue, 20 Aug 2024 14:04:48 -0700
Subject: [PATCH 474/685] Avoid extra `cast()`s after `CStr::as_ptr()`

These used to be `&str` literals that did need a pointer cast, but that
became a no-op after switching to `c""` literals in #118566.
---
 compiler/rustc_codegen_llvm/src/allocator.rs  |  2 +-
 compiler/rustc_codegen_llvm/src/back/lto.rs   |  2 +-
 compiler/rustc_codegen_llvm/src/back/write.rs |  8 +++----
 compiler/rustc_codegen_llvm/src/consts.rs     |  2 +-
 compiler/rustc_codegen_llvm/src/context.rs    | 22 +++++++++----------
 .../rustc_codegen_llvm/src/debuginfo/gdb.rs   |  5 ++---
 .../src/debuginfo/metadata.rs                 |  2 +-
 .../rustc_codegen_llvm/src/debuginfo/mod.rs   |  6 ++---
 library/std/src/sys/pal/unix/mod.rs           |  4 ++--
 9 files changed, 26 insertions(+), 27 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/allocator.rs b/compiler/rustc_codegen_llvm/src/allocator.rs
index 8fb3108279391..b4f3784a31abd 100644
--- a/compiler/rustc_codegen_llvm/src/allocator.rs
+++ b/compiler/rustc_codegen_llvm/src/allocator.rs
@@ -149,7 +149,7 @@ fn create_wrapper_function(
         }
         llvm::LLVMRustSetVisibility(callee, llvm::Visibility::Hidden);
 
-        let llbb = llvm::LLVMAppendBasicBlockInContext(llcx, llfn, c"entry".as_ptr().cast());
+        let llbb = llvm::LLVMAppendBasicBlockInContext(llcx, llfn, c"entry".as_ptr());
 
         let llbuilder = llvm::LLVMCreateBuilderInContext(llcx);
         llvm::LLVMPositionBuilderAtEnd(llbuilder, llbb);
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index f68155f523a6e..aac446f3149c4 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -616,7 +616,7 @@ pub(crate) fn run_pass_manager(
             llvm::LLVMRustAddModuleFlagU32(
                 module.module_llvm.llmod(),
                 llvm::LLVMModFlagBehavior::Error,
-                c"LTOPostLink".as_ptr().cast(),
+                c"LTOPostLink".as_ptr(),
                 1,
             );
         }
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index a1f2433ab6f3b..51b02891d026b 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -1031,7 +1031,7 @@ unsafe fn embed_bitcode(
             let llglobal = llvm::LLVMAddGlobal(
                 llmod,
                 common::val_ty(llconst),
-                c"rustc.embedded.module".as_ptr().cast(),
+                c"rustc.embedded.module".as_ptr(),
             );
             llvm::LLVMSetInitializer(llglobal, llconst);
 
@@ -1044,7 +1044,7 @@ unsafe fn embed_bitcode(
             let llglobal = llvm::LLVMAddGlobal(
                 llmod,
                 common::val_ty(llconst),
-                c"rustc.embedded.cmdline".as_ptr().cast(),
+                c"rustc.embedded.cmdline".as_ptr(),
             );
             llvm::LLVMSetInitializer(llglobal, llconst);
             let section = if is_apple {
@@ -1054,7 +1054,7 @@ unsafe fn embed_bitcode(
             } else {
                 c".llvmcmd"
             };
-            llvm::LLVMSetSection(llglobal, section.as_ptr().cast());
+            llvm::LLVMSetSection(llglobal, section.as_ptr());
             llvm::LLVMRustSetLinkage(llglobal, llvm::Linkage::PrivateLinkage);
         } else {
             // We need custom section flags, so emit module-level inline assembly.
@@ -1107,7 +1107,7 @@ fn create_msvc_imps(
             .collect::<Vec<_>>();
 
         for (imp_name, val) in globals {
-            let imp = llvm::LLVMAddGlobal(llmod, ptr_ty, imp_name.as_ptr().cast());
+            let imp = llvm::LLVMAddGlobal(llmod, ptr_ty, imp_name.as_ptr());
             llvm::LLVMSetInitializer(imp, val);
             llvm::LLVMRustSetLinkage(imp, llvm::Linkage::ExternalLinkage);
         }
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 75b298f14ca1e..a764b263ec7fd 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -525,7 +525,7 @@ impl<'ll> CodegenCx<'ll, '_> {
                     let val = llvm::LLVMMetadataAsValue(self.llcx, meta);
                     llvm::LLVMAddNamedMetadataOperand(
                         self.llmod,
-                        c"wasm.custom_sections".as_ptr().cast(),
+                        c"wasm.custom_sections".as_ptr(),
                         val,
                     );
                 }
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 1fd9f9e811671..8862f139affb8 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -207,7 +207,7 @@ pub unsafe fn create_module<'ll>(
     // If skipping the PLT is enabled, we need to add some module metadata
     // to ensure intrinsic calls don't use it.
     if !sess.needs_plt() {
-        let avoid_plt = c"RtLibUseGOT".as_ptr().cast();
+        let avoid_plt = c"RtLibUseGOT".as_ptr();
         unsafe {
             llvm::LLVMRustAddModuleFlagU32(llmod, llvm::LLVMModFlagBehavior::Warning, avoid_plt, 1);
         }
@@ -215,7 +215,7 @@ pub unsafe fn create_module<'ll>(
 
     // Enable canonical jump tables if CFI is enabled. (See https://reviews.llvm.org/D65629.)
     if sess.is_sanitizer_cfi_canonical_jump_tables_enabled() && sess.is_sanitizer_cfi_enabled() {
-        let canonical_jump_tables = c"CFI Canonical Jump Tables".as_ptr().cast();
+        let canonical_jump_tables = c"CFI Canonical Jump Tables".as_ptr();
         unsafe {
             llvm::LLVMRustAddModuleFlagU32(
                 llmod,
@@ -228,7 +228,7 @@ pub unsafe fn create_module<'ll>(
 
     // Enable LTO unit splitting if specified or if CFI is enabled. (See https://reviews.llvm.org/D53891.)
     if sess.is_split_lto_unit_enabled() || sess.is_sanitizer_cfi_enabled() {
-        let enable_split_lto_unit = c"EnableSplitLTOUnit".as_ptr().cast();
+        let enable_split_lto_unit = c"EnableSplitLTOUnit".as_ptr();
         unsafe {
             llvm::LLVMRustAddModuleFlagU32(
                 llmod,
@@ -241,7 +241,7 @@ pub unsafe fn create_module<'ll>(
 
     // Add "kcfi" module flag if KCFI is enabled. (See https://reviews.llvm.org/D119296.)
     if sess.is_sanitizer_kcfi_enabled() {
-        let kcfi = c"kcfi".as_ptr().cast();
+        let kcfi = c"kcfi".as_ptr();
         unsafe {
             llvm::LLVMRustAddModuleFlagU32(llmod, llvm::LLVMModFlagBehavior::Override, kcfi, 1);
         }
@@ -280,26 +280,26 @@ pub unsafe fn create_module<'ll>(
                 llvm::LLVMRustAddModuleFlagU32(
                     llmod,
                     llvm::LLVMModFlagBehavior::Min,
-                    c"branch-target-enforcement".as_ptr().cast(),
+                    c"branch-target-enforcement".as_ptr(),
                     bti.into(),
                 );
                 llvm::LLVMRustAddModuleFlagU32(
                     llmod,
                     llvm::LLVMModFlagBehavior::Min,
-                    c"sign-return-address".as_ptr().cast(),
+                    c"sign-return-address".as_ptr(),
                     pac_ret.is_some().into(),
                 );
                 let pac_opts = pac_ret.unwrap_or(PacRet { leaf: false, key: PAuthKey::A });
                 llvm::LLVMRustAddModuleFlagU32(
                     llmod,
                     llvm::LLVMModFlagBehavior::Min,
-                    c"sign-return-address-all".as_ptr().cast(),
+                    c"sign-return-address-all".as_ptr(),
                     pac_opts.leaf.into(),
                 );
                 llvm::LLVMRustAddModuleFlagU32(
                     llmod,
                     llvm::LLVMModFlagBehavior::Min,
-                    c"sign-return-address-with-bkey".as_ptr().cast(),
+                    c"sign-return-address-with-bkey".as_ptr(),
                     u32::from(pac_opts.key == PAuthKey::B),
                 );
             }
@@ -317,7 +317,7 @@ pub unsafe fn create_module<'ll>(
             llvm::LLVMRustAddModuleFlagU32(
                 llmod,
                 llvm::LLVMModFlagBehavior::Override,
-                c"cf-protection-branch".as_ptr().cast(),
+                c"cf-protection-branch".as_ptr(),
                 1,
             );
         }
@@ -327,7 +327,7 @@ pub unsafe fn create_module<'ll>(
             llvm::LLVMRustAddModuleFlagU32(
                 llmod,
                 llvm::LLVMModFlagBehavior::Override,
-                c"cf-protection-return".as_ptr().cast(),
+                c"cf-protection-return".as_ptr(),
                 1,
             );
         }
@@ -338,7 +338,7 @@ pub unsafe fn create_module<'ll>(
             llvm::LLVMRustAddModuleFlagU32(
                 llmod,
                 llvm::LLVMModFlagBehavior::Error,
-                c"Virtual Function Elim".as_ptr().cast(),
+                c"Virtual Function Elim".as_ptr(),
                 1,
             );
         }
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
index 5a08f2f00e5be..e91bcea16a26c 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
@@ -34,8 +34,7 @@ pub fn get_or_insert_gdb_debug_scripts_section_global<'ll>(cx: &CodegenCx<'ll, '
     let c_section_var_name = c"__rustc_debug_gdb_scripts_section__";
     let section_var_name = c_section_var_name.to_str().unwrap();
 
-    let section_var =
-        unsafe { llvm::LLVMGetNamedGlobal(cx.llmod, c_section_var_name.as_ptr().cast()) };
+    let section_var = unsafe { llvm::LLVMGetNamedGlobal(cx.llmod, c_section_var_name.as_ptr()) };
 
     section_var.unwrap_or_else(|| {
         let mut section_contents = Vec::new();
@@ -70,7 +69,7 @@ pub fn get_or_insert_gdb_debug_scripts_section_global<'ll>(cx: &CodegenCx<'ll, '
             let section_var = cx
                 .define_global(section_var_name, llvm_type)
                 .unwrap_or_else(|| bug!("symbol `{}` is already defined", section_var_name));
-            llvm::LLVMSetSection(section_var, c".debug_gdb_scripts".as_ptr().cast());
+            llvm::LLVMSetSection(section_var, c".debug_gdb_scripts".as_ptr());
             llvm::LLVMSetInitializer(section_var, cx.const_bytes(section_contents));
             llvm::LLVMSetGlobalConstant(section_var, llvm::True);
             llvm::LLVMSetUnnamedAddress(section_var, llvm::UnnamedAddr::Global);
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index 87bea22d8ddaf..30f90bada9adc 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -952,7 +952,7 @@ pub fn build_compile_unit_di_node<'ll, 'tcx>(
             producer.as_ptr().cast(),
             producer.len(),
             tcx.sess.opts.optimize != config::OptLevel::No,
-            c"".as_ptr().cast(),
+            c"".as_ptr(),
             0,
             // NB: this doesn't actually have any perceptible effect, it seems. LLVM will instead
             // put the path supplied to `MCSplitDwarfFile` into the debug info of the final
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index b23e05182ca1b..a179254c9c08f 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -109,7 +109,7 @@ impl<'ll, 'tcx> CodegenUnitDebugContext<'ll, 'tcx> {
                 llvm::LLVMRustAddModuleFlagU32(
                     self.llmod,
                     llvm::LLVMModFlagBehavior::Warning,
-                    c"Dwarf Version".as_ptr().cast(),
+                    c"Dwarf Version".as_ptr(),
                     dwarf_version,
                 );
             } else {
@@ -117,7 +117,7 @@ impl<'ll, 'tcx> CodegenUnitDebugContext<'ll, 'tcx> {
                 llvm::LLVMRustAddModuleFlagU32(
                     self.llmod,
                     llvm::LLVMModFlagBehavior::Warning,
-                    c"CodeView".as_ptr().cast(),
+                    c"CodeView".as_ptr(),
                     1,
                 )
             }
@@ -126,7 +126,7 @@ impl<'ll, 'tcx> CodegenUnitDebugContext<'ll, 'tcx> {
             llvm::LLVMRustAddModuleFlagU32(
                 self.llmod,
                 llvm::LLVMModFlagBehavior::Warning,
-                c"Debug Info Version".as_ptr().cast(),
+                c"Debug Info Version".as_ptr(),
                 llvm::LLVMRustDebugMetadataVersion(),
             );
         }
diff --git a/library/std/src/sys/pal/unix/mod.rs b/library/std/src/sys/pal/unix/mod.rs
index b62129f4cdd26..10df3306f9251 100644
--- a/library/std/src/sys/pal/unix/mod.rs
+++ b/library/std/src/sys/pal/unix/mod.rs
@@ -116,7 +116,7 @@ pub unsafe fn init(argc: isize, argv: *const *const u8, sigpipe: u8) {
                 if pfd.revents & libc::POLLNVAL == 0 {
                     continue;
                 }
-                if open64(c"/dev/null".as_ptr().cast(), libc::O_RDWR, 0) == -1 {
+                if open64(c"/dev/null".as_ptr(), libc::O_RDWR, 0) == -1 {
                     // If the stream is closed but we failed to reopen it, abort the
                     // process. Otherwise we wouldn't preserve the safety of
                     // operations on the corresponding Rust object Stdin, Stdout, or
@@ -147,7 +147,7 @@ pub unsafe fn init(argc: isize, argv: *const *const u8, sigpipe: u8) {
             use crate::sys::os::errno;
             for fd in 0..3 {
                 if libc::fcntl(fd, libc::F_GETFD) == -1 && errno() == libc::EBADF {
-                    if open64(c"/dev/null".as_ptr().cast(), libc::O_RDWR, 0) == -1 {
+                    if open64(c"/dev/null".as_ptr(), libc::O_RDWR, 0) == -1 {
                         // If the stream is closed but we failed to reopen it, abort the
                         // process. Otherwise we wouldn't preserve the safety of
                         // operations on the corresponding Rust object Stdin, Stdout, or

From e6b0f27e00c0a6e0bb137bab837fbd5e9d2b7629 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Tue, 20 Aug 2024 18:41:07 -0400
Subject: [PATCH 475/685] Try to golf down the amount of code in Layout

---
 library/core/src/alloc/layout.rs | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/library/core/src/alloc/layout.rs b/library/core/src/alloc/layout.rs
index c2521ffe9cc96..ad3f9d8087897 100644
--- a/library/core/src/alloc/layout.rs
+++ b/library/core/src/alloc/layout.rs
@@ -68,19 +68,14 @@ impl Layout {
     pub const fn from_size_align(size: usize, align: usize) -> Result<Self, LayoutError> {
         if Layout::is_size_align_valid(size, align) {
             // SAFETY: Layout::is_size_align_valid checks the preconditions for this call.
-            let layout = unsafe { Layout::from_size_align_unchecked(size, align) };
-            Ok(layout)
+            unsafe { Ok(Layout { size, align: mem::transmute(align) }) }
         } else {
             Err(LayoutError)
         }
     }
 
     const fn is_size_align_valid(size: usize, align: usize) -> bool {
-        if !align.is_power_of_two() {
-            return false;
-        }
-        // SAFETY: Precondition checked directly above.
-        let align = unsafe { Alignment::new_unchecked(align) };
+        let Some(align) = Alignment::new(align) else { return false };
         if size > Self::max_size_for_align(align) {
             return false;
         }
@@ -139,7 +134,7 @@ impl Layout {
             ) => Layout::is_size_align_valid(size, align)
         );
         // SAFETY: the caller is required to uphold the preconditions.
-        unsafe { Layout { size, align: Alignment::new_unchecked(align) } }
+        unsafe { Layout { size, align: mem::transmute(align) } }
     }
 
     /// The minimum size in bytes for a memory block of this layout.

From 0f5c6eaccc3259c3ce182544077077f1248a7c2e Mon Sep 17 00:00:00 2001
From: beetrees <b@beetr.ee>
Date: Wed, 21 Aug 2024 02:43:12 +0100
Subject: [PATCH 476/685] Make `ArgAbi::make_indirect_force` more specific

---
 compiler/rustc_target/src/abi/call/mod.rs      | 18 ++++++++++++++----
 compiler/rustc_target/src/abi/call/powerpc.rs  |  2 +-
 compiler/rustc_target/src/abi/call/s390x.rs    |  2 +-
 compiler/rustc_target/src/abi/call/sparc64.rs  |  2 +-
 .../rustc_target/src/abi/call/x86_win64.rs     |  2 +-
 5 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/compiler/rustc_target/src/abi/call/mod.rs b/compiler/rustc_target/src/abi/call/mod.rs
index 25e4d70945b2c..c1ddfcb2f9090 100644
--- a/compiler/rustc_target/src/abi/call/mod.rs
+++ b/compiler/rustc_target/src/abi/call/mod.rs
@@ -642,7 +642,7 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
     pub fn make_indirect(&mut self) {
         match self.mode {
             PassMode::Direct(_) | PassMode::Pair(_, _) => {
-                self.make_indirect_force();
+                self.mode = Self::indirect_pass_mode(&self.layout);
             }
             PassMode::Indirect { attrs: _, meta_attrs: _, on_stack: false } => {
                 // already indirect
@@ -652,9 +652,19 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
         }
     }
 
-    /// Same as make_indirect, but doesn't check the current `PassMode`.
-    pub fn make_indirect_force(&mut self) {
-        self.mode = Self::indirect_pass_mode(&self.layout);
+    /// Same as `make_indirect`, but for arguments that are ignored. Only needed for ABIs that pass
+    /// ZSTs indirectly.
+    pub fn make_indirect_from_ignore(&mut self) {
+        match self.mode {
+            PassMode::Ignore => {
+                self.mode = Self::indirect_pass_mode(&self.layout);
+            }
+            PassMode::Indirect { attrs: _, meta_attrs: _, on_stack: false } => {
+                // already indirect
+                return;
+            }
+            _ => panic!("Tried to make {:?} indirect (expected `PassMode::Ignore`)", self.mode),
+        }
     }
 
     /// Pass this argument indirectly, by placing it at a fixed stack offset.
diff --git a/compiler/rustc_target/src/abi/call/powerpc.rs b/compiler/rustc_target/src/abi/call/powerpc.rs
index cb80d64c94304..8f67f57cd2b3e 100644
--- a/compiler/rustc_target/src/abi/call/powerpc.rs
+++ b/compiler/rustc_target/src/abi/call/powerpc.rs
@@ -16,7 +16,7 @@ fn classify_arg<Ty>(cx: &impl HasTargetSpec, arg: &mut ArgAbi<'_, Ty>) {
             && matches!(&*cx.target_spec().env, "gnu" | "musl" | "uclibc")
             && arg.layout.is_zst()
         {
-            arg.make_indirect_force();
+            arg.make_indirect_from_ignore();
         }
         return;
     }
diff --git a/compiler/rustc_target/src/abi/call/s390x.rs b/compiler/rustc_target/src/abi/call/s390x.rs
index 7dcbb3e4a9e9b..901ce139c7be1 100644
--- a/compiler/rustc_target/src/abi/call/s390x.rs
+++ b/compiler/rustc_target/src/abi/call/s390x.rs
@@ -28,7 +28,7 @@ where
             && matches!(&*cx.target_spec().env, "gnu" | "musl" | "uclibc")
             && arg.layout.is_zst()
         {
-            arg.make_indirect_force();
+            arg.make_indirect_from_ignore();
         }
         return;
     }
diff --git a/compiler/rustc_target/src/abi/call/sparc64.rs b/compiler/rustc_target/src/abi/call/sparc64.rs
index 3b2bf9b3187f1..311691d8efb9b 100644
--- a/compiler/rustc_target/src/abi/call/sparc64.rs
+++ b/compiler/rustc_target/src/abi/call/sparc64.rs
@@ -225,7 +225,7 @@ where
                 && matches!(&*cx.target_spec().env, "gnu" | "musl" | "uclibc")
                 && arg.layout.is_zst()
             {
-                arg.make_indirect_force();
+                arg.make_indirect_from_ignore();
             }
             return;
         }
diff --git a/compiler/rustc_target/src/abi/call/x86_win64.rs b/compiler/rustc_target/src/abi/call/x86_win64.rs
index 6ca01cf84eaa4..720707ef53f95 100644
--- a/compiler/rustc_target/src/abi/call/x86_win64.rs
+++ b/compiler/rustc_target/src/abi/call/x86_win64.rs
@@ -43,7 +43,7 @@ pub fn compute_abi_info<Ty>(cx: &impl HasTargetSpec, fn_abi: &mut FnAbi<'_, Ty>)
                 && cx.target_spec().env == "gnu"
                 && arg.layout.is_zst()
             {
-                arg.make_indirect_force();
+                arg.make_indirect_from_ignore();
             }
             continue;
         }

From 25ff9b6bcbba9e7831eb4d6eba2df6bbcd267c55 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 21 Aug 2024 00:57:58 -0400
Subject: [PATCH 477/685] Use bool in favor of Option<()> for diagnostics

---
 compiler/rustc_ast_lowering/src/asm.rs          |  5 ++---
 compiler/rustc_ast_lowering/src/errors.rs       |  2 +-
 compiler/rustc_ast_passes/src/ast_validation.rs | 17 ++++++++---------
 compiler/rustc_ast_passes/src/errors.rs         |  4 ++--
 compiler/rustc_attr/src/builtin.rs              |  2 +-
 compiler/rustc_attr/src/session_diagnostics.rs  |  2 +-
 .../rustc_const_eval/src/check_consts/ops.rs    | 14 +++++++-------
 compiler/rustc_const_eval/src/errors.rs         | 10 +++++-----
 compiler/rustc_expand/src/errors.rs             |  2 +-
 compiler/rustc_expand/src/expand.rs             |  2 +-
 compiler/rustc_hir_analysis/src/check/check.rs  |  2 +-
 .../rustc_hir_analysis/src/check/wfcheck.rs     |  3 +--
 compiler/rustc_hir_analysis/src/errors.rs       |  6 +++---
 .../rustc_hir_analysis/src/impl_wf_check.rs     |  3 +--
 compiler/rustc_hir_typeck/src/cast.rs           |  2 +-
 compiler/rustc_hir_typeck/src/errors.rs         |  6 +++---
 compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs |  6 +++---
 compiler/rustc_incremental/src/errors.rs        |  4 ++--
 compiler/rustc_incremental/src/persist/fs.rs    |  4 ++--
 compiler/rustc_lint/src/builtin.rs              |  2 +-
 compiler/rustc_lint/src/errors.rs               |  2 +-
 compiler/rustc_lint/src/expect.rs               |  2 +-
 compiler/rustc_lint/src/levels.rs               |  2 +-
 compiler/rustc_lint/src/lints.rs                |  8 ++++----
 compiler/rustc_lint/src/reference_casting.rs    |  2 --
 compiler/rustc_middle/src/error.rs              |  2 +-
 compiler/rustc_middle/src/ty/instance.rs        |  4 ++--
 compiler/rustc_mir_build/src/check_unsafety.rs  |  6 +++---
 compiler/rustc_mir_build/src/errors.rs          | 10 +++++-----
 .../src/thir/pattern/check_match.rs             |  2 +-
 .../rustc_mir_build/src/thir/pattern/mod.rs     |  2 +-
 compiler/rustc_monomorphize/src/collector.rs    |  4 ++--
 compiler/rustc_monomorphize/src/errors.rs       |  2 +-
 compiler/rustc_parse/src/errors.rs              | 12 ++++++------
 compiler/rustc_parse/src/parser/diagnostics.rs  | 10 +++++-----
 compiler/rustc_parse/src/parser/expr.rs         |  4 ++--
 compiler/rustc_parse/src/parser/item.rs         |  4 ++--
 compiler/rustc_parse/src/parser/pat.rs          |  2 +-
 compiler/rustc_parse/src/parser/path.rs         | 12 ++----------
 compiler/rustc_passes/src/check_attr.rs         |  3 +--
 compiler/rustc_passes/src/diagnostic_items.rs   |  2 +-
 compiler/rustc_passes/src/errors.rs             |  4 ++--
 .../rustc_resolve/src/build_reduced_graph.rs    |  2 +-
 compiler/rustc_resolve/src/errors.rs            |  2 +-
 .../src/error_reporting/infer/need_type_info.rs | 12 ++++++------
 compiler/rustc_trait_selection/src/errors.rs    |  6 +++---
 compiler/rustc_ty_utils/src/consts.rs           |  4 ++--
 compiler/rustc_ty_utils/src/errors.rs           |  2 +-
 48 files changed, 106 insertions(+), 121 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index 7d9d689e6d7e9..51cbe808a3ac9 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -86,9 +86,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 // Multiple different abi names may actually be the same ABI
                                 // If the specified ABIs are not the same name, alert the user that they resolve to the same ABI
                                 let source_map = self.tcx.sess.source_map();
-                                let equivalent = (source_map.span_to_snippet(*prev_sp)
-                                    != source_map.span_to_snippet(*abi_span))
-                                .then_some(());
+                                let equivalent = source_map.span_to_snippet(*prev_sp)
+                                    != source_map.span_to_snippet(*abi_span);
 
                                 self.dcx().emit_err(AbiSpecifiedMultipleTimes {
                                     abi_span: *abi_span,
diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs
index 7a6c9d8d0d375..8237bfd679241 100644
--- a/compiler/rustc_ast_lowering/src/errors.rs
+++ b/compiler/rustc_ast_lowering/src/errors.rs
@@ -184,7 +184,7 @@ pub struct AbiSpecifiedMultipleTimes {
     #[label]
     pub prev_span: Span,
     #[note]
-    pub equivalent: Option<()>,
+    pub equivalent: bool,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 837cb805700d2..cc35b0e288de1 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -963,14 +963,13 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 self_ty,
                 items,
             }) => {
-                let error =
-                    |annotation_span, annotation, only_trait: bool| errors::InherentImplCannot {
-                        span: self_ty.span,
-                        annotation_span,
-                        annotation,
-                        self_ty: self_ty.span,
-                        only_trait: only_trait.then_some(()),
-                    };
+                let error = |annotation_span, annotation, only_trait| errors::InherentImplCannot {
+                    span: self_ty.span,
+                    annotation_span,
+                    annotation,
+                    self_ty: self_ty.span,
+                    only_trait,
+                };
 
                 self.with_in_trait_impl(None, |this| {
                     this.visibility_not_permitted(
@@ -1195,7 +1194,7 @@ impl<'a> Visitor<'a> for AstValidator<'a> {
                 } else if where_clauses.after.has_where_token {
                     self.dcx().emit_err(errors::WhereClauseAfterTypeAlias {
                         span: where_clauses.after.span,
-                        help: self.session.is_nightly_build().then_some(()),
+                        help: self.session.is_nightly_build(),
                     });
                 }
             }
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 9e40368083729..de1b3f55e801e 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -484,7 +484,7 @@ pub struct InherentImplCannot<'a> {
     #[label(ast_passes_type)]
     pub self_ty: Span,
     #[note(ast_passes_only_trait)]
-    pub only_trait: Option<()>,
+    pub only_trait: bool,
 }
 
 #[derive(Diagnostic)]
@@ -528,7 +528,7 @@ pub struct WhereClauseAfterTypeAlias {
     #[primary_span]
     pub span: Span,
     #[help]
-    pub help: Option<()>,
+    pub help: bool,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs
index d057dcfdf9d0c..e46dabc7a6e22 100644
--- a/compiler/rustc_attr/src/builtin.rs
+++ b/compiler/rustc_attr/src/builtin.rs
@@ -846,7 +846,7 @@ pub fn find_deprecation(
                                     sess.dcx().emit_err(
                                         session_diagnostics::DeprecatedItemSuggestion {
                                             span: mi.span,
-                                            is_nightly: sess.is_nightly_build().then_some(()),
+                                            is_nightly: sess.is_nightly_build(),
                                             details: (),
                                         },
                                     );
diff --git a/compiler/rustc_attr/src/session_diagnostics.rs b/compiler/rustc_attr/src/session_diagnostics.rs
index 92a3a385a7441..9b69325a053eb 100644
--- a/compiler/rustc_attr/src/session_diagnostics.rs
+++ b/compiler/rustc_attr/src/session_diagnostics.rs
@@ -342,7 +342,7 @@ pub(crate) struct DeprecatedItemSuggestion {
     pub span: Span,
 
     #[help]
-    pub is_nightly: Option<()>,
+    pub is_nightly: bool,
 
     #[note]
     pub details: (),
diff --git a/compiler/rustc_const_eval/src/check_consts/ops.rs b/compiler/rustc_const_eval/src/check_consts/ops.rs
index c6361710ac9ca..259114dbdc2eb 100644
--- a/compiler/rustc_const_eval/src/check_consts/ops.rs
+++ b/compiler/rustc_const_eval/src/check_consts/ops.rs
@@ -384,7 +384,7 @@ impl<'tcx> NonConstOp<'tcx> for HeapAllocation {
         ccx.dcx().create_err(errors::UnallowedHeapAllocations {
             span,
             kind: ccx.const_kind(),
-            teach: ccx.tcx.sess.teach(E0010).then_some(()),
+            teach: ccx.tcx.sess.teach(E0010),
         })
     }
 }
@@ -444,16 +444,16 @@ impl<'tcx> NonConstOp<'tcx> for CellBorrow {
         if let hir::ConstContext::Static(_) = ccx.const_kind() {
             ccx.dcx().create_err(errors::InteriorMutableDataRefer {
                 span,
-                opt_help: Some(()),
+                opt_help: true,
                 kind: ccx.const_kind(),
-                teach: ccx.tcx.sess.teach(E0492).then_some(()),
+                teach: ccx.tcx.sess.teach(E0492),
             })
         } else {
             ccx.dcx().create_err(errors::InteriorMutableDataRefer {
                 span,
-                opt_help: None,
+                opt_help: false,
                 kind: ccx.const_kind(),
-                teach: ccx.tcx.sess.teach(E0492).then_some(()),
+                teach: ccx.tcx.sess.teach(E0492),
             })
         }
     }
@@ -481,12 +481,12 @@ impl<'tcx> NonConstOp<'tcx> for MutBorrow {
             hir::BorrowKind::Raw => ccx.tcx.dcx().create_err(errors::UnallowedMutableRaw {
                 span,
                 kind: ccx.const_kind(),
-                teach: ccx.tcx.sess.teach(E0764).then_some(()),
+                teach: ccx.tcx.sess.teach(E0764),
             }),
             hir::BorrowKind::Ref => ccx.dcx().create_err(errors::UnallowedMutableRefs {
                 span,
                 kind: ccx.const_kind(),
-                teach: ccx.tcx.sess.teach(E0764).then_some(()),
+                teach: ccx.tcx.sess.teach(E0764),
             }),
         }
     }
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index 7afb92c08ec9a..6075f3f84cd0f 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -151,7 +151,7 @@ pub(crate) struct UnallowedMutableRefs {
     pub span: Span,
     pub kind: ConstContext,
     #[note(const_eval_teach_note)]
-    pub teach: Option<()>,
+    pub teach: bool,
 }
 
 #[derive(Diagnostic)]
@@ -161,7 +161,7 @@ pub(crate) struct UnallowedMutableRaw {
     pub span: Span,
     pub kind: ConstContext,
     #[note(const_eval_teach_note)]
-    pub teach: Option<()>,
+    pub teach: bool,
 }
 #[derive(Diagnostic)]
 #[diag(const_eval_non_const_fmt_macro_call, code = E0015)]
@@ -196,7 +196,7 @@ pub(crate) struct UnallowedHeapAllocations {
     pub span: Span,
     pub kind: ConstContext,
     #[note(const_eval_teach_note)]
-    pub teach: Option<()>,
+    pub teach: bool,
 }
 
 #[derive(Diagnostic)]
@@ -214,10 +214,10 @@ pub(crate) struct InteriorMutableDataRefer {
     #[label]
     pub span: Span,
     #[help]
-    pub opt_help: Option<()>,
+    pub opt_help: bool,
     pub kind: ConstContext,
     #[note(const_eval_teach_note)]
-    pub teach: Option<()>,
+    pub teach: bool,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs
index c30a9b0c3576d..f6b5cd394b620 100644
--- a/compiler/rustc_expand/src/errors.rs
+++ b/compiler/rustc_expand/src/errors.rs
@@ -281,7 +281,7 @@ pub(crate) struct IncompleteParse<'a> {
     pub macro_path: &'a ast::Path,
     pub kind_name: &'a str,
     #[note(expand_macro_expands_to_match_arm)]
-    pub expands_to_match_arm: Option<()>,
+    pub expands_to_match_arm: bool,
 
     #[suggestion(
         expand_suggestion_add_semi,
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index cb6b13282a2ed..0d56a005f159e 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -1031,7 +1031,7 @@ pub(crate) fn ensure_complete_parse<'a>(
             label_span: span,
             macro_path,
             kind_name,
-            expands_to_match_arm: expands_to_match_arm.then_some(()),
+            expands_to_match_arm,
             add_semicolon,
         });
     }
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 0135cdf1e9002..16eeb57b2b967 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -1564,7 +1564,7 @@ fn check_type_alias_type_params_are_used<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalD
             // * compare the param span to the pred span to detect lone user-written `Sized` bounds
             let has_explicit_bounds = bounded_params.is_empty()
                 || (*bounded_params).get(&param.index).is_some_and(|&&pred_sp| pred_sp != span);
-            let const_param_help = (!has_explicit_bounds).then_some(());
+            let const_param_help = !has_explicit_bounds;
 
             let mut diag = tcx.dcx().create_err(errors::UnusedGenericParameter {
                 span,
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index bdf2914fc50c6..d4b2c3f8a875d 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1972,8 +1972,7 @@ fn report_bivariance<'tcx>(
     }
 
     let const_param_help =
-        matches!(param.kind, hir::GenericParamKind::Type { .. } if !has_explicit_bounds)
-            .then_some(());
+        matches!(param.kind, hir::GenericParamKind::Type { .. } if !has_explicit_bounds);
 
     let mut diag = tcx.dcx().create_err(errors::UnusedGenericParameter {
         span: param.span,
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index 7034735aec038..821f79505f0b4 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -1606,7 +1606,7 @@ pub(crate) struct UnusedGenericParameter {
     #[subdiagnostic]
     pub help: UnusedGenericParameterHelp,
     #[help(hir_analysis_const_param_help)]
-    pub const_param_help: Option<()>,
+    pub const_param_help: bool,
 }
 
 #[derive(Diagnostic)]
@@ -1643,9 +1643,9 @@ pub(crate) struct UnconstrainedGenericParameter {
     pub param_name: Symbol,
     pub param_def_kind: &'static str,
     #[note(hir_analysis_const_param_note)]
-    pub const_param_note: Option<()>,
+    pub const_param_note: bool,
     #[note(hir_analysis_const_param_note2)]
-    pub const_param_note2: Option<()>,
+    pub const_param_note2: bool,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check.rs b/compiler/rustc_hir_analysis/src/impl_wf_check.rs
index ab441ed4cde99..02520c472b9de 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check.rs
@@ -137,8 +137,7 @@ fn enforce_impl_params_are_constrained(
             }
         };
         if err {
-            let const_param_note =
-                matches!(param.kind, ty::GenericParamDefKind::Const { .. }).then_some(());
+            let const_param_note = matches!(param.kind, ty::GenericParamDefKind::Const { .. });
             let mut diag = tcx.dcx().create_err(UnconstrainedGenericParameter {
                 span: tcx.def_span(param.def_id),
                 param_name: param.name,
diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs
index 03a76d44cc987..3a309d2ec0b4a 100644
--- a/compiler/rustc_hir_typeck/src/cast.rs
+++ b/compiler/rustc_hir_typeck/src/cast.rs
@@ -505,7 +505,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                     span: self.span,
                     expr_ty: self.expr_ty,
                     cast_ty: fcx.ty_to_string(self.cast_ty),
-                    teach: fcx.tcx.sess.teach(E0607).then_some(()),
+                    teach: fcx.tcx.sess.teach(E0607),
                 });
             }
             CastError::IntToFatCast(known_metadata) => {
diff --git a/compiler/rustc_hir_typeck/src/errors.rs b/compiler/rustc_hir_typeck/src/errors.rs
index f802b8cf9cc9b..c35f7a84c4fde 100644
--- a/compiler/rustc_hir_typeck/src/errors.rs
+++ b/compiler/rustc_hir_typeck/src/errors.rs
@@ -706,7 +706,7 @@ pub(crate) struct CastThinPointerToFatPointer<'tcx> {
     pub expr_ty: Ty<'tcx>,
     pub cast_ty: String,
     #[note(hir_typeck_teach_help)]
-    pub(crate) teach: Option<()>,
+    pub(crate) teach: bool,
 }
 
 #[derive(Diagnostic)]
@@ -720,7 +720,7 @@ pub(crate) struct PassToVariadicFunction<'tcx, 'a> {
     pub sugg_span: Option<Span>,
     pub replace: String,
     #[help]
-    pub help: Option<()>,
+    pub help: bool,
     #[note(hir_typeck_teach_help)]
-    pub(crate) teach: Option<()>,
+    pub(crate) teach: bool,
 }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 7720faddba376..aca29d4758708 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -406,9 +406,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 ) {
                     let (sugg_span, replace, help) =
                         if let Ok(snippet) = sess.source_map().span_to_snippet(span) {
-                            (Some(span), format!("{snippet} as {cast_ty}"), None)
+                            (Some(span), format!("{snippet} as {cast_ty}"), false)
                         } else {
-                            (None, "".to_string(), Some(()))
+                            (None, "".to_string(), true)
                         };
 
                     sess.dcx().emit_err(errors::PassToVariadicFunction {
@@ -418,7 +418,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         help,
                         replace,
                         sugg_span,
-                        teach: sess.teach(E0617).then_some(()),
+                        teach: sess.teach(E0617),
                     });
                 }
 
diff --git a/compiler/rustc_incremental/src/errors.rs b/compiler/rustc_incremental/src/errors.rs
index f891003063440..b68c149d39823 100644
--- a/compiler/rustc_incremental/src/errors.rs
+++ b/compiler/rustc_incremental/src/errors.rs
@@ -189,10 +189,10 @@ pub struct CreateLock<'a> {
     pub lock_err: std::io::Error,
     pub session_dir: &'a Path,
     #[note(incremental_lock_unsupported)]
-    pub is_unsupported_lock: Option<()>,
+    pub is_unsupported_lock: bool,
     #[help(incremental_cargo_help_1)]
     #[help(incremental_cargo_help_2)]
-    pub is_cargo: Option<()>,
+    pub is_cargo: bool,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_incremental/src/persist/fs.rs b/compiler/rustc_incremental/src/persist/fs.rs
index 5f85e622e892a..253d53c83fb5f 100644
--- a/compiler/rustc_incremental/src/persist/fs.rs
+++ b/compiler/rustc_incremental/src/persist/fs.rs
@@ -486,12 +486,12 @@ fn lock_directory(
         // the lock should be exclusive
         Ok(lock) => Ok((lock, lock_file_path)),
         Err(lock_err) => {
-            let is_unsupported_lock = flock::Lock::error_unsupported(&lock_err).then_some(());
+            let is_unsupported_lock = flock::Lock::error_unsupported(&lock_err);
             Err(sess.dcx().emit_err(errors::CreateLock {
                 lock_err,
                 session_dir,
                 is_unsupported_lock,
-                is_cargo: rustc_session::utils::was_invoked_from_cargo().then_some(()),
+                is_cargo: rustc_session::utils::was_invoked_from_cargo(),
             }))
         }
     }
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 5f6e7fb314d9f..85132dd4f98f0 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -1330,7 +1330,7 @@ impl UnreachablePub {
                 BuiltinUnreachablePub {
                     what,
                     suggestion: (vis_span, applicability),
-                    help: exportable.then_some(()),
+                    help: exportable,
                 },
             );
         }
diff --git a/compiler/rustc_lint/src/errors.rs b/compiler/rustc_lint/src/errors.rs
index 23e6b73ee373b..85ee18aba8f47 100644
--- a/compiler/rustc_lint/src/errors.rs
+++ b/compiler/rustc_lint/src/errors.rs
@@ -77,7 +77,7 @@ pub struct UnknownToolInScopedLint {
     pub tool_name: Symbol,
     pub lint_name: String,
     #[help]
-    pub is_nightly_build: Option<()>,
+    pub is_nightly_build: bool,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_lint/src/expect.rs b/compiler/rustc_lint/src/expect.rs
index 35af694213d09..42b33f9882d76 100644
--- a/compiler/rustc_lint/src/expect.rs
+++ b/compiler/rustc_lint/src/expect.rs
@@ -24,7 +24,7 @@ fn check_expectations(tcx: TyCtxt<'_>, tool_filter: Option<Symbol>) {
                 && tool_filter.map_or(true, |filter| expectation.lint_tool == Some(filter))
             {
                 let rationale = expectation.reason.map(|rationale| ExpectationNote { rationale });
-                let note = expectation.is_unfulfilled_lint_expectations.then_some(());
+                let note = expectation.is_unfulfilled_lint_expectations;
                 tcx.emit_node_span_lint(
                     UNFULFILLED_LINT_EXPECTATIONS,
                     *hir_id,
diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs
index 44117e5d7a573..91d4f95df8054 100644
--- a/compiler/rustc_lint/src/levels.rs
+++ b/compiler/rustc_lint/src/levels.rs
@@ -936,7 +936,7 @@ impl<'s, P: LintLevelsProvider> LintLevelsBuilder<'s, P> {
                             span: tool_ident.map(|ident| ident.span),
                             tool_name: tool_name.unwrap(),
                             lint_name: pprust::path_to_string(&meta_item.path),
-                            is_nightly_build: sess.is_nightly_build().then_some(()),
+                            is_nightly_build: sess.is_nightly_build(),
                         });
                         continue;
                     }
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 03962d796f4e2..c12c5427997f9 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -257,7 +257,7 @@ pub struct BuiltinUnreachablePub<'a> {
     #[suggestion(code = "pub(crate)")]
     pub suggestion: (Span, Applicability),
     #[help]
-    pub help: Option<()>,
+    pub help: bool,
 }
 
 #[derive(LintDiagnostic)]
@@ -572,7 +572,7 @@ pub struct Expectation {
     #[subdiagnostic]
     pub rationale: Option<ExpectationNote>,
     #[note]
-    pub note: Option<()>,
+    pub note: bool,
 }
 
 #[derive(Subdiagnostic)]
@@ -756,7 +756,7 @@ pub enum InvalidReferenceCastingDiag<'tcx> {
         #[label]
         orig_cast: Option<Span>,
         #[note(lint_invalid_reference_casting_note_ty_has_interior_mutability)]
-        ty_has_interior_mutability: Option<()>,
+        ty_has_interior_mutability: bool,
     },
     #[diag(lint_invalid_reference_casting_assign_to_ref)]
     #[note(lint_invalid_reference_casting_note_book)]
@@ -764,7 +764,7 @@ pub enum InvalidReferenceCastingDiag<'tcx> {
         #[label]
         orig_cast: Option<Span>,
         #[note(lint_invalid_reference_casting_note_ty_has_interior_mutability)]
-        ty_has_interior_mutability: Option<()>,
+        ty_has_interior_mutability: bool,
     },
     #[diag(lint_invalid_reference_casting_bigger_layout)]
     #[note(lint_layout)]
diff --git a/compiler/rustc_lint/src/reference_casting.rs b/compiler/rustc_lint/src/reference_casting.rs
index 5e8c39c0023eb..45d97403d6068 100644
--- a/compiler/rustc_lint/src/reference_casting.rs
+++ b/compiler/rustc_lint/src/reference_casting.rs
@@ -54,8 +54,6 @@ impl<'tcx> LateLintPass<'tcx> for InvalidReferenceCasting {
                 && let Some(ty_has_interior_mutability) =
                     is_cast_from_ref_to_mut_ptr(cx, init, &mut peel_casts)
             {
-                let ty_has_interior_mutability = ty_has_interior_mutability.then_some(());
-
                 cx.emit_span_lint(
                     INVALID_REFERENCE_CASTING,
                     expr.span,
diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs
index 61348cdce2340..5c2aa0005d405 100644
--- a/compiler/rustc_middle/src/error.rs
+++ b/compiler/rustc_middle/src/error.rs
@@ -160,7 +160,7 @@ pub struct TypeLengthLimit {
     pub span: Span,
     pub shrunk: String,
     #[note(middle_written_to_path)]
-    pub was_written: Option<()>,
+    pub was_written: bool,
     pub path: PathBuf,
     pub type_length: usize,
 }
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index 6f19739de45ff..ecb3943e78836 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -581,9 +581,9 @@ impl<'tcx> Instance<'tcx> {
                     let mut path = PathBuf::new();
                     let was_written = if let Some(path2) = written_to_path {
                         path = path2;
-                        Some(())
+                        true
                     } else {
-                        None
+                        false
                     };
                     tcx.dcx().emit_fatal(error::TypeLengthLimit {
                         // We don't use `def_span(def_id)` so that diagnostics point
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index e4e5844d2ef8e..b6cf7a40ecd98 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -793,7 +793,7 @@ impl UnsafeOpKind {
                         missing.iter().map(|feature| Cow::from(feature.to_string())).collect(),
                     ),
                     missing_target_features_count: missing.len(),
-                    note: if build_enabled.is_empty() { None } else { Some(()) },
+                    note: !build_enabled.is_empty(),
                     build_target_features: DiagArgValue::StrListSepByAnd(
                         build_enabled
                             .iter()
@@ -958,7 +958,7 @@ impl UnsafeOpKind {
                         missing.iter().map(|feature| Cow::from(feature.to_string())).collect(),
                     ),
                     missing_target_features_count: missing.len(),
-                    note: if build_enabled.is_empty() { None } else { Some(()) },
+                    note: !build_enabled.is_empty(),
                     build_target_features: DiagArgValue::StrListSepByAnd(
                         build_enabled
                             .iter()
@@ -977,7 +977,7 @@ impl UnsafeOpKind {
                         missing.iter().map(|feature| Cow::from(feature.to_string())).collect(),
                     ),
                     missing_target_features_count: missing.len(),
-                    note: if build_enabled.is_empty() { None } else { Some(()) },
+                    note: !build_enabled.is_empty(),
                     build_target_features: DiagArgValue::StrListSepByAnd(
                         build_enabled
                             .iter()
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index 34577f102d1c5..73e941943c320 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -161,7 +161,7 @@ pub(crate) struct UnsafeOpInUnsafeFnCallToFunctionWithRequiresUnsafe {
     pub(crate) missing_target_features: DiagArgValue,
     pub(crate) missing_target_features_count: usize,
     #[note]
-    pub(crate) note: Option<()>,
+    pub(crate) note: bool,
     pub(crate) build_target_features: DiagArgValue,
     pub(crate) build_target_features_count: usize,
     #[subdiagnostic]
@@ -413,7 +413,7 @@ pub(crate) struct CallToFunctionWithRequiresUnsafe {
     pub(crate) missing_target_features: DiagArgValue,
     pub(crate) missing_target_features_count: usize,
     #[note]
-    pub(crate) note: Option<()>,
+    pub(crate) note: bool,
     pub(crate) build_target_features: DiagArgValue,
     pub(crate) build_target_features_count: usize,
     #[subdiagnostic]
@@ -431,7 +431,7 @@ pub(crate) struct CallToFunctionWithRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
     pub(crate) missing_target_features: DiagArgValue,
     pub(crate) missing_target_features_count: usize,
     #[note]
-    pub(crate) note: Option<()>,
+    pub(crate) note: bool,
     pub(crate) build_target_features: DiagArgValue,
     pub(crate) build_target_features_count: usize,
     #[subdiagnostic]
@@ -623,7 +623,7 @@ pub(crate) struct LowerRangeBoundMustBeLessThanOrEqualToUpper {
     #[label]
     pub(crate) span: Span,
     #[note(mir_build_teach_note)]
-    pub(crate) teach: Option<()>,
+    pub(crate) teach: bool,
 }
 
 #[derive(Diagnostic)]
@@ -865,7 +865,7 @@ pub(crate) struct PatternNotCovered<'s, 'tcx> {
     #[subdiagnostic]
     pub(crate) adt_defined_here: Option<AdtDefinedHere<'tcx>>,
     #[note(mir_build_privately_uninhabited)]
-    pub(crate) witness_1_is_privately_uninhabited: Option<()>,
+    pub(crate) witness_1_is_privately_uninhabited: bool,
     #[note(mir_build_pattern_ty)]
     pub(crate) _p: (),
     pub(crate) pattern_ty: Ty<'tcx>,
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index bc1acd51c6911..7c5f236cae905 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -718,7 +718,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             uncovered: Uncovered::new(pat.span, &cx, witnesses),
             inform,
             interpreted_as_const,
-            witness_1_is_privately_uninhabited: witness_1_is_privately_uninhabited.then_some(()),
+            witness_1_is_privately_uninhabited,
             _p: (),
             pattern_ty,
             let_suggestion,
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 615070034b96b..d78e1f5da09f0 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -256,7 +256,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                     RangeEnd::Included => {
                         self.tcx.dcx().emit_err(LowerRangeBoundMustBeLessThanOrEqualToUpper {
                             span,
-                            teach: self.tcx.sess.teach(E0030).then_some(()),
+                            teach: self.tcx.sess.teach(E0030),
                         })
                     }
                     RangeEnd::Excluded => {
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 9f449868f0316..77f6a1e17cefc 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -580,9 +580,9 @@ fn check_recursion_limit<'tcx>(
         let mut path = PathBuf::new();
         let was_written = if let Some(written_to_path) = written_to_path {
             path = written_to_path;
-            Some(())
+            true
         } else {
-            None
+            false
         };
         tcx.dcx().emit_fatal(RecursionLimit {
             span,
diff --git a/compiler/rustc_monomorphize/src/errors.rs b/compiler/rustc_monomorphize/src/errors.rs
index 88286cb73a6c3..c97e07ee3ba67 100644
--- a/compiler/rustc_monomorphize/src/errors.rs
+++ b/compiler/rustc_monomorphize/src/errors.rs
@@ -16,7 +16,7 @@ pub struct RecursionLimit {
     pub def_span: Span,
     pub def_path_str: String,
     #[note(monomorphize_written_to_path)]
-    pub was_written: Option<()>,
+    pub was_written: bool,
     pub path: PathBuf,
 }
 
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index 0d4512be480c3..abaff7d9c19eb 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -913,7 +913,7 @@ pub(crate) struct InvalidLiteralSuffixOnTupleIndex {
     #[help(parse_tuple_exception_line_1)]
     #[help(parse_tuple_exception_line_2)]
     #[help(parse_tuple_exception_line_3)]
-    pub exception: Option<()>,
+    pub exception: bool,
 }
 
 #[derive(Diagnostic)]
@@ -1299,7 +1299,7 @@ pub(crate) struct ComparisonOperatorsCannotBeChained {
     pub suggest_turbofish: Option<Span>,
     #[help(parse_sugg_turbofish_syntax)]
     #[help(parse_sugg_parentheses_for_function_args)]
-    pub help_turbofish: Option<()>,
+    pub help_turbofish: bool,
     #[subdiagnostic]
     pub chaining_sugg: Option<ComparisonOperatorsCannotBeChainedSugg>,
 }
@@ -1578,7 +1578,7 @@ pub(crate) struct PathSingleColon {
     pub suggestion: Span,
 
     #[note(parse_type_ascription_removed)]
-    pub type_ascription: Option<()>,
+    pub type_ascription: bool,
 }
 
 #[derive(Diagnostic)]
@@ -1589,7 +1589,7 @@ pub(crate) struct ColonAsSemi {
     pub span: Span,
 
     #[note(parse_type_ascription_removed)]
-    pub type_ascription: Option<()>,
+    pub type_ascription: bool,
 }
 
 #[derive(Diagnostic)]
@@ -2462,7 +2462,7 @@ pub(crate) struct TrailingVertNotAllowed {
     pub start: Option<Span>,
     pub token: Token,
     #[note(parse_note_pattern_alternatives_use_single_vert)]
-    pub note_double_vert: Option<()>,
+    pub note_double_vert: bool,
 }
 
 #[derive(Diagnostic)]
@@ -2894,7 +2894,7 @@ pub(crate) struct BadItemKind {
     pub descr: &'static str,
     pub ctx: &'static str,
     #[help]
-    pub help: Option<()>,
+    pub help: bool,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index ef1387c50fa8c..fcdc10c0837e5 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -1403,7 +1403,7 @@ impl<'a> Parser<'a> {
                 let mut err = ComparisonOperatorsCannotBeChained {
                     span: vec![op.span, self.prev_token.span],
                     suggest_turbofish: None,
-                    help_turbofish: None,
+                    help_turbofish: false,
                     chaining_sugg: None,
                 };
 
@@ -1436,7 +1436,7 @@ impl<'a> Parser<'a> {
                         {
                             err.suggest_turbofish = Some(op.span.shrink_to_lo());
                         } else {
-                            err.help_turbofish = Some(());
+                            err.help_turbofish = true;
                         }
 
                         let snapshot = self.create_snapshot_for_diagnostic();
@@ -1468,7 +1468,7 @@ impl<'a> Parser<'a> {
                         {
                             err.suggest_turbofish = Some(op.span.shrink_to_lo());
                         } else {
-                            err.help_turbofish = Some(());
+                            err.help_turbofish = true;
                         }
                         // Consume the fn call arguments.
                         match self.consume_fn_args() {
@@ -1487,7 +1487,7 @@ impl<'a> Parser<'a> {
                         {
                             // All we know is that this is `foo < bar >` and *nothing* else. Try to
                             // be helpful, but don't attempt to recover.
-                            err.help_turbofish = Some(());
+                            err.help_turbofish = true;
                         }
 
                         // If it looks like a genuine attempt to chain operators (as opposed to a
@@ -1895,7 +1895,7 @@ impl<'a> Parser<'a> {
         {
             self.dcx().emit_err(ColonAsSemi {
                 span: self.token.span,
-                type_ascription: self.psess.unstable_features.is_nightly_build().then_some(()),
+                type_ascription: self.psess.unstable_features.is_nightly_build(),
             });
             self.bump();
             return true;
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index 422206ebbce07..84684e808d940 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -2162,13 +2162,13 @@ impl<'a> Parser<'a> {
             self.dcx().emit_warn(errors::InvalidLiteralSuffixOnTupleIndex {
                 span,
                 suffix,
-                exception: Some(()),
+                exception: true,
             });
         } else {
             self.dcx().emit_err(errors::InvalidLiteralSuffixOnTupleIndex {
                 span,
                 suffix,
-                exception: None,
+                exception: false,
             });
         }
     }
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 47820e93c23d2..14da6c331f13b 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -1248,8 +1248,8 @@ impl<'a> Parser<'a> {
         let span = self.psess.source_map().guess_head_span(span);
         let descr = kind.descr();
         let help = match kind {
-            ItemKind::DelegationMac(deleg) if deleg.suffixes.is_none() => None,
-            _ => Some(()),
+            ItemKind::DelegationMac(deleg) if deleg.suffixes.is_none() => false,
+            _ => true,
         };
         self.dcx().emit_err(errors::BadItemKind { span, descr, ctx, help });
         None
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index eb9a957032f6c..cc68ae237ba18 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -333,7 +333,7 @@ impl<'a> Parser<'a> {
                     span: self.token.span,
                     start: lo,
                     token: self.token.clone(),
-                    note_double_vert: matches!(self.token.kind, token::OrOr).then_some(()),
+                    note_double_vert: matches!(self.token.kind, token::OrOr),
                 });
                 self.bump();
                 true
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index b58f398efede2..d8bf10e6021cc 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -261,11 +261,7 @@ impl<'a> Parser<'a> {
                         self.dcx().emit_err(PathSingleColon {
                             span: self.prev_token.span,
                             suggestion: self.prev_token.span.shrink_to_hi(),
-                            type_ascription: self
-                                .psess
-                                .unstable_features
-                                .is_nightly_build()
-                                .then_some(()),
+                            type_ascription: self.psess.unstable_features.is_nightly_build(),
                         });
                     }
                     continue;
@@ -334,11 +330,7 @@ impl<'a> Parser<'a> {
                             err = self.dcx().create_err(PathSingleColon {
                                 span: self.token.span,
                                 suggestion: self.prev_token.span.shrink_to_hi(),
-                                type_ascription: self
-                                    .psess
-                                    .unstable_features
-                                    .is_nightly_build()
-                                    .then_some(()),
+                                type_ascription: self.psess.unstable_features.is_nightly_build(),
                             });
                         }
                         // Attempt to find places where a missing `>` might belong.
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index e3c2999142f3b..c93fb5c23b1c4 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -2619,8 +2619,7 @@ fn check_duplicates(
                             warning: matches!(
                                 duplicates,
                                 FutureWarnFollowing | FutureWarnPreceding
-                            )
-                            .then_some(()),
+                            ),
                         },
                     );
                 }
diff --git a/compiler/rustc_passes/src/diagnostic_items.rs b/compiler/rustc_passes/src/diagnostic_items.rs
index 659281c5e711f..624ebb2f9f2e4 100644
--- a/compiler/rustc_passes/src/diagnostic_items.rs
+++ b/compiler/rustc_passes/src/diagnostic_items.rs
@@ -49,7 +49,7 @@ fn report_duplicate_item(
         orig_span,
         crate_name: tcx.crate_name(item_def_id.krate),
         orig_crate_name: tcx.crate_name(original_def_id.krate),
-        different_crates: (item_def_id.krate != original_def_id.krate).then_some(()),
+        different_crates: (item_def_id.krate != original_def_id.krate),
         name,
     });
 }
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index ee7d097e5d387..1190e60f41f18 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -752,7 +752,7 @@ pub struct UnusedDuplicate {
     #[note]
     pub other: Span,
     #[warning]
-    pub warning: Option<()>,
+    pub warning: bool,
 }
 
 #[derive(Diagnostic)]
@@ -911,7 +911,7 @@ pub struct DuplicateDiagnosticItemInCrate {
     #[note(passes_diagnostic_item_first_defined)]
     pub orig_span: Option<Span>,
     #[note]
-    pub different_crates: Option<()>,
+    pub different_crates: bool,
     pub crate_name: Symbol,
     pub orig_crate_name: Symbol,
     pub name: Symbol,
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index d57dabdd78d91..1e5fbf22ee1d8 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -1150,7 +1150,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
     fn contains_macro_use(&mut self, attrs: &[ast::Attribute]) -> bool {
         for attr in attrs {
             if attr.has_name(sym::macro_escape) {
-                let inner_attribute = matches!(attr.style, ast::AttrStyle::Inner).then_some(());
+                let inner_attribute = matches!(attr.style, ast::AttrStyle::Inner);
                 self.r
                     .dcx()
                     .emit_warn(errors::MacroExternDeprecated { span: attr.span, inner_attribute });
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index ad1841e3e8994..662b772413b86 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -850,7 +850,7 @@ pub(crate) struct MacroExternDeprecated {
     #[primary_span]
     pub(crate) span: Span,
     #[help]
-    pub inner_attribute: Option<()>,
+    pub inner_attribute: bool,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index f6dd7898fb28e..173671059ca93 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -382,7 +382,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 infer_subdiags,
                 multi_suggestions,
                 bad_label,
-                was_written: None,
+                was_written: false,
                 path: Default::default(),
             }),
             TypeAnnotationNeeded::E0283 => self.dcx().create_err(AmbiguousImpl {
@@ -393,7 +393,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 infer_subdiags,
                 multi_suggestions,
                 bad_label,
-                was_written: None,
+                was_written: false,
                 path: Default::default(),
             }),
             TypeAnnotationNeeded::E0284 => self.dcx().create_err(AmbiguousReturn {
@@ -404,7 +404,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 infer_subdiags,
                 multi_suggestions,
                 bad_label,
-                was_written: None,
+                was_written: false,
                 path: Default::default(),
             }),
         }
@@ -586,7 +586,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 infer_subdiags,
                 multi_suggestions,
                 bad_label: None,
-                was_written: path.as_ref().map(|_| ()),
+                was_written: path.is_some(),
                 path: path.unwrap_or_default(),
             }),
             TypeAnnotationNeeded::E0283 => self.dcx().create_err(AmbiguousImpl {
@@ -597,7 +597,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 infer_subdiags,
                 multi_suggestions,
                 bad_label: None,
-                was_written: path.as_ref().map(|_| ()),
+                was_written: path.is_some(),
                 path: path.unwrap_or_default(),
             }),
             TypeAnnotationNeeded::E0284 => self.dcx().create_err(AmbiguousReturn {
@@ -608,7 +608,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 infer_subdiags,
                 multi_suggestions,
                 bad_label: None,
-                was_written: path.as_ref().map(|_| ()),
+                was_written: path.is_some(),
                 path: path.unwrap_or_default(),
             }),
         }
diff --git a/compiler/rustc_trait_selection/src/errors.rs b/compiler/rustc_trait_selection/src/errors.rs
index 78f1f7d9b9b59..5384084f6d7c3 100644
--- a/compiler/rustc_trait_selection/src/errors.rs
+++ b/compiler/rustc_trait_selection/src/errors.rs
@@ -203,7 +203,7 @@ pub struct AnnotationRequired<'a> {
     #[subdiagnostic]
     pub multi_suggestions: Vec<SourceKindMultiSuggestion<'a>>,
     #[note(trait_selection_full_type_written)]
-    pub was_written: Option<()>,
+    pub was_written: bool,
     pub path: PathBuf,
 }
 
@@ -224,7 +224,7 @@ pub struct AmbiguousImpl<'a> {
     #[subdiagnostic]
     pub multi_suggestions: Vec<SourceKindMultiSuggestion<'a>>,
     #[note(trait_selection_full_type_written)]
-    pub was_written: Option<()>,
+    pub was_written: bool,
     pub path: PathBuf,
 }
 
@@ -245,7 +245,7 @@ pub struct AmbiguousReturn<'a> {
     #[subdiagnostic]
     pub multi_suggestions: Vec<SourceKindMultiSuggestion<'a>>,
     #[note(trait_selection_full_type_written)]
-    pub was_written: Option<()>,
+    pub was_written: bool,
     pub path: PathBuf,
 }
 
diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
index 4ded935b801d3..ae5341ddec16f 100644
--- a/compiler/rustc_ty_utils/src/consts.rs
+++ b/compiler/rustc_ty_utils/src/consts.rs
@@ -284,7 +284,7 @@ fn error(
 ) -> Result<!, ErrorGuaranteed> {
     let reported = tcx.dcx().emit_err(GenericConstantTooComplex {
         span: root_span,
-        maybe_supported: None,
+        maybe_supported: false,
         sub,
     });
 
@@ -298,7 +298,7 @@ fn maybe_supported_error(
 ) -> Result<!, ErrorGuaranteed> {
     let reported = tcx.dcx().emit_err(GenericConstantTooComplex {
         span: root_span,
-        maybe_supported: Some(()),
+        maybe_supported: true,
         sub,
     });
 
diff --git a/compiler/rustc_ty_utils/src/errors.rs b/compiler/rustc_ty_utils/src/errors.rs
index bfbb45f0cb501..42ecaaeafa905 100644
--- a/compiler/rustc_ty_utils/src/errors.rs
+++ b/compiler/rustc_ty_utils/src/errors.rs
@@ -18,7 +18,7 @@ pub struct GenericConstantTooComplex {
     #[primary_span]
     pub span: Span,
     #[note(ty_utils_maybe_supported)]
-    pub maybe_supported: Option<()>,
+    pub maybe_supported: bool,
     #[subdiagnostic]
     pub sub: GenericConstantTooComplexSub,
 }

From 0b2525c787454fa9afabd7bb8d60782af03fee5f Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 21 Aug 2024 01:29:52 -0400
Subject: [PATCH 478/685] Simplify some redundant field names

---
 compiler/rustc_ast_lowering/src/item.rs                   | 2 +-
 compiler/rustc_ast_passes/src/ast_validation.rs           | 6 ++----
 compiler/rustc_codegen_ssa/src/back/linker.rs             | 4 ++--
 compiler/rustc_hir_analysis/src/check/entry.rs            | 2 +-
 compiler/rustc_hir_typeck/src/method/suggest.rs           | 2 +-
 compiler/rustc_incremental/src/persist/fs.rs              | 2 +-
 compiler/rustc_metadata/src/locator.rs                    | 8 ++------
 compiler/rustc_mir_build/src/thir/cx/expr.rs              | 7 +------
 compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs | 2 +-
 compiler/rustc_mir_transform/src/coroutine.rs             | 2 +-
 compiler/rustc_mir_transform/src/dataflow_const_prop.rs   | 2 +-
 compiler/rustc_query_impl/src/lib.rs                      | 2 +-
 compiler/rustc_resolve/src/diagnostics.rs                 | 2 +-
 .../src/cfi/typeid/itanium_cxx_abi/transform.rs           | 2 +-
 compiler/rustc_smir/src/rustc_smir/alloc.rs               | 2 +-
 compiler/rustc_trait_selection/src/traits/auto_trait.rs   | 2 +-
 16 files changed, 19 insertions(+), 30 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index f6065259d8d21..eef87879c2492 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -1421,7 +1421,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         };
         hir::FnHeader {
             safety: self.lower_safety(h.safety, default_safety),
-            asyncness: asyncness,
+            asyncness,
             constness: self.lower_constness(h.constness),
             abi: self.lower_extern(h.ext),
         }
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 837cb805700d2..f0f3049f0db0c 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -562,10 +562,8 @@ impl<'a> AstValidator<'a> {
         FnHeader { safety: _, coroutine_kind, constness, ext }: FnHeader,
     ) {
         let report_err = |span| {
-            self.dcx().emit_err(errors::FnQualifierInExtern {
-                span: span,
-                block: self.current_extern_span(),
-            });
+            self.dcx()
+                .emit_err(errors::FnQualifierInExtern { span, block: self.current_extern_span() });
         };
         match coroutine_kind {
             Some(knd) => report_err(knd.span()),
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index febeb7093a332..fbab988a32b08 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -1500,7 +1500,7 @@ impl<'a> Linker for L4Bender<'a> {
 
 impl<'a> L4Bender<'a> {
     pub fn new(cmd: Command, sess: &'a Session) -> L4Bender<'a> {
-        L4Bender { cmd, sess: sess, hinted_static: false }
+        L4Bender { cmd, sess, hinted_static: false }
     }
 
     fn hint_static(&mut self) {
@@ -1520,7 +1520,7 @@ pub struct AixLinker<'a> {
 
 impl<'a> AixLinker<'a> {
     pub fn new(cmd: Command, sess: &'a Session) -> AixLinker<'a> {
-        AixLinker { cmd, sess: sess, hinted_static: None }
+        AixLinker { cmd, sess, hinted_static: None }
     }
 
     fn hint_static(&mut self) {
diff --git a/compiler/rustc_hir_analysis/src/check/entry.rs b/compiler/rustc_hir_analysis/src/check/entry.rs
index 1f724580564a4..83d2c2c1e285f 100644
--- a/compiler/rustc_hir_analysis/src/check/entry.rs
+++ b/compiler/rustc_hir_analysis/src/check/entry.rs
@@ -216,7 +216,7 @@ fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: DefId) {
                     }
                     if sig.header.asyncness.is_async() {
                         let span = tcx.def_span(it.owner_id);
-                        tcx.dcx().emit_err(errors::StartAsync { span: span });
+                        tcx.dcx().emit_err(errors::StartAsync { span });
                         error = true;
                     }
 
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index b3cf73bac1aa6..3df32dd85052b 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -527,7 +527,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 {
                     if self.check_and_add_sugg_binding(LetStmt {
                         ty_hir_id_opt: if let Some(ty) = ty { Some(ty.hir_id) } else { None },
-                        binding_id: binding_id,
+                        binding_id,
                         span: pat.span,
                         init_hir_id: init.hir_id,
                     }) {
diff --git a/compiler/rustc_incremental/src/persist/fs.rs b/compiler/rustc_incremental/src/persist/fs.rs
index 5f85e622e892a..3388af1ada88e 100644
--- a/compiler/rustc_incremental/src/persist/fs.rs
+++ b/compiler/rustc_incremental/src/persist/fs.rs
@@ -851,7 +851,7 @@ fn delete_old(sess: &Session, path: &Path) {
     debug!("garbage_collect_session_directories() - deleting `{}`", path.display());
 
     if let Err(err) = safe_remove_dir_all(path) {
-        sess.dcx().emit_warn(errors::SessionGcFailed { path: path, err });
+        sess.dcx().emit_warn(errors::SessionGcFailed { path, err });
     } else {
         delete_session_dir_lock_file(sess, &lock_file_path(path));
     }
diff --git a/compiler/rustc_metadata/src/locator.rs b/compiler/rustc_metadata/src/locator.rs
index 25ae7b2bc3130..90228db378a95 100644
--- a/compiler/rustc_metadata/src/locator.rs
+++ b/compiler/rustc_metadata/src/locator.rs
@@ -1002,11 +1002,7 @@ impl CrateError {
                 if !locator.crate_rejections.via_filename.is_empty() {
                     let mismatches = locator.crate_rejections.via_filename.iter();
                     for CrateMismatch { path, .. } in mismatches {
-                        dcx.emit_err(errors::CrateLocationUnknownType {
-                            span,
-                            path: path,
-                            crate_name,
-                        });
+                        dcx.emit_err(errors::CrateLocationUnknownType { span, path, crate_name });
                         dcx.emit_err(errors::LibFilenameForm {
                             span,
                             dll_prefix: &locator.dll_prefix,
@@ -1035,7 +1031,7 @@ impl CrateError {
                     }
                     dcx.emit_err(errors::NewerCrateVersion {
                         span,
-                        crate_name: crate_name,
+                        crate_name,
                         add_info,
                         found_crates,
                     });
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index 2cbaed2cc6258..89f98a40201e7 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -218,12 +218,7 @@ impl<'tcx> Cx<'tcx> {
                     let lhs =
                         self.thir.exprs.push(Expr { temp_lifetime, ty: discr_ty, span, kind });
                     let bin = ExprKind::Binary { op: BinOp::Add, lhs, rhs: offset };
-                    self.thir.exprs.push(Expr {
-                        temp_lifetime,
-                        ty: discr_ty,
-                        span: span,
-                        kind: bin,
-                    })
+                    self.thir.exprs.push(Expr { temp_lifetime, ty: discr_ty, span, kind: bin })
                 }
                 None => offset,
             };
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index 6f8d17b772aaa..53393046610ac 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -129,7 +129,7 @@ impl<'tcx> ConstToPat<'tcx> {
                 let err = TypeNotPartialEq { span: self.span, non_peq_ty: ty };
                 let e = self.tcx().dcx().emit_err(err);
                 let kind = PatKind::Error(e);
-                return Box::new(Pat { span: self.span, ty: ty, kind });
+                return Box::new(Pat { span: self.span, ty, kind });
             }
         }
 
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index 82528109be9ab..703339bf5bca8 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -931,7 +931,7 @@ fn compute_storage_conflicts<'mir, 'tcx>(
     // Compute the storage conflicts for all eligible locals.
     let mut visitor = StorageConflictVisitor {
         body,
-        saved_locals: saved_locals,
+        saved_locals,
         local_conflicts: BitMatrix::from_row_n(&ineligible_locals, body.local_decls.len()),
         eligible_storage_live: BitSet::new_empty(body.local_decls.len()),
     };
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index 0fc4d6b9f4e1e..f207216d6f423 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -338,7 +338,7 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
             tcx,
             local_decls: &body.local_decls,
             ecx: InterpCx::new(tcx, DUMMY_SP, param_env, DummyMachine),
-            param_env: param_env,
+            param_env,
         }
     }
 
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
index 18f97d6fb8f1b..f4a4c602f69f0 100644
--- a/compiler/rustc_query_impl/src/lib.rs
+++ b/compiler/rustc_query_impl/src/lib.rs
@@ -214,7 +214,7 @@ pub fn query_system<'tcx>(
             local_providers,
             extern_providers,
             encode_query_results: encode_all_query_results,
-            try_mark_green: try_mark_green,
+            try_mark_green,
         },
         jobs: AtomicU64::new(1),
     }
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 942026ef01223..bcbdf627b5662 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -1456,7 +1456,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
             let label_span = ident.span.shrink_to_hi();
             let mut spans = MultiSpan::from_span(label_span);
             spans.push_span_label(label_span, "put a macro name here");
-            err.subdiagnostic(MaybeMissingMacroRulesName { spans: spans });
+            err.subdiagnostic(MaybeMissingMacroRulesName { spans });
             return;
         }
 
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
index e628c17aca3cb..187dd870825f2 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
@@ -316,7 +316,7 @@ pub fn transform_instance<'tcx>(
             .drop_trait()
             .unwrap_or_else(|| bug!("typeid_for_instance: couldn't get drop_trait lang item"));
         let predicate = ty::ExistentialPredicate::Trait(ty::ExistentialTraitRef {
-            def_id: def_id,
+            def_id,
             args: List::empty(),
         });
         let predicates = tcx.mk_poly_existential_predicates(&[ty::Binder::dummy(predicate)]);
diff --git a/compiler/rustc_smir/src/rustc_smir/alloc.rs b/compiler/rustc_smir/src/rustc_smir/alloc.rs
index 0519722e4be71..677b4c7a9c0e3 100644
--- a/compiler/rustc_smir/src/rustc_smir/alloc.rs
+++ b/compiler/rustc_smir/src/rustc_smir/alloc.rs
@@ -132,7 +132,7 @@ pub(super) fn allocation_filter<'tcx>(
         ));
     }
     Allocation {
-        bytes: bytes,
+        bytes,
         provenance: ProvenanceMap { ptrs },
         align: alloc.align.bytes(),
         mutability: alloc.mutability.stable(tables),
diff --git a/compiler/rustc_trait_selection/src/traits/auto_trait.rs b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
index 29f78f9d5f0a1..38d338598a17b 100644
--- a/compiler/rustc_trait_selection/src/traits/auto_trait.rs
+++ b/compiler/rustc_trait_selection/src/traits/auto_trait.rs
@@ -770,7 +770,7 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                                     let reported =
                                         tcx.dcx().emit_err(UnableToConstructConstantValue {
                                             span: tcx.def_span(unevaluated.def),
-                                            unevaluated: unevaluated,
+                                            unevaluated,
                                         });
                                     Err(ErrorHandled::Reported(reported.into(), tcx.def_span(unevaluated.def)))
                                 }

From 210f6036512ffee2c9b0b6444a15b878d2e95763 Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Thu, 8 Aug 2024 23:09:31 -0700
Subject: [PATCH 479/685] Update stdarch submodule

---
 library/stdarch | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/stdarch b/library/stdarch
index 47b929ddc521a..d9466edb4c53c 160000
--- a/library/stdarch
+++ b/library/stdarch
@@ -1 +1 @@
-Subproject commit 47b929ddc521a78b0f699ba8d5c274d28593448a
+Subproject commit d9466edb4c53cece8686ee6e17b028436ddf4151

From 13b02e3d8696458fa3a2ba9a745a744e655bebe7 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 21 Aug 2024 15:12:42 +0200
Subject: [PATCH 480/685] add a test for zero-sized protectors

---
 .../tests/fail/alloc/global_system_mixup.rs   |  4 +--
 .../fail/alloc/global_system_mixup.stderr     |  2 +-
 .../fail/both_borrows/zero-sized-protected.rs | 19 ++++++++++
 .../zero-sized-protected.stack.stderr         | 15 ++++++++
 .../zero-sized-protected.tree.stderr          | 36 +++++++++++++++++++
 5 files changed, 72 insertions(+), 4 deletions(-)
 create mode 100644 src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs
 create mode 100644 src/tools/miri/tests/fail/both_borrows/zero-sized-protected.stack.stderr
 create mode 100644 src/tools/miri/tests/fail/both_borrows/zero-sized-protected.tree.stderr

diff --git a/src/tools/miri/tests/fail/alloc/global_system_mixup.rs b/src/tools/miri/tests/fail/alloc/global_system_mixup.rs
index 19c62913b4c66..804aa13660b99 100644
--- a/src/tools/miri/tests/fail/alloc/global_system_mixup.rs
+++ b/src/tools/miri/tests/fail/alloc/global_system_mixup.rs
@@ -13,7 +13,5 @@ use std::alloc::{Allocator, Global, Layout, System};
 fn main() {
     let l = Layout::from_size_align(1, 1).unwrap();
     let ptr = Global.allocate(l).unwrap().as_non_null_ptr();
-    unsafe {
-        System.deallocate(ptr, l);
-    }
+    unsafe { System.deallocate(ptr, l) };
 }
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 7006b96ee1e61..7790956414961 100644
--- a/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr
+++ b/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr
@@ -12,7 +12,7 @@ LL |         FREE();
 note: inside `main`
   --> $DIR/global_system_mixup.rs:LL:CC
    |
-LL |         System.deallocate(ptr, l);
+LL |     unsafe { System.deallocate(ptr, l) };
    | ^
 
 note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
diff --git a/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs b/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs
new file mode 100644
index 0000000000000..aed5cb1125817
--- /dev/null
+++ b/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.rs
@@ -0,0 +1,19 @@
+//@revisions: stack tree
+//@[tree]compile-flags: -Zmiri-tree-borrows
+//@[tree]error-in-other-file: /deallocation .* is forbidden/
+use std::alloc::{alloc, dealloc, Layout};
+
+// `x` is strongly protected but covers zero bytes.
+// Let's see if deallocating the allocation x points to is UB:
+// in TB, it is UB, but in SB it is not.
+fn test(_x: &mut (), ptr: *mut u8, l: Layout) {
+    unsafe { dealloc(ptr, l) };
+}
+
+fn main() {
+    let l = Layout::from_size_align(1, 1).unwrap();
+    let ptr = unsafe { alloc(l) };
+    unsafe { test(&mut *ptr.cast::<()>(), ptr, l) };
+    // In SB the test would pass if it weren't for this line.
+    unsafe { std::hint::unreachable_unchecked() }; //~[stack] ERROR: unreachable
+}
diff --git a/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.stack.stderr b/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.stack.stderr
new file mode 100644
index 0000000000000..672682ff29401
--- /dev/null
+++ b/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.stack.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: entering unreachable code
+  --> $DIR/zero-sized-protected.rs:LL:CC
+   |
+LL |     unsafe { std::hint::unreachable_unchecked() };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ entering unreachable code
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: BACKTRACE:
+   = note: inside `main` at $DIR/zero-sized-protected.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.tree.stderr b/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.tree.stderr
new file mode 100644
index 0000000000000..ef981038e5540
--- /dev/null
+++ b/src/tools/miri/tests/fail/both_borrows/zero-sized-protected.tree.stderr
@@ -0,0 +1,36 @@
+error: Undefined Behavior: deallocation through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
+  --> RUSTLIB/alloc/src/alloc.rs:LL:CC
+   |
+LL |     unsafe { __rust_dealloc(ptr, layout.size(), layout.align()) }
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ deallocation through <TAG> (root of the allocation) at ALLOC[0x0] is forbidden
+   |
+   = help: this indicates a potential bug in the program: it performed an invalid operation, but the Tree Borrows rules it violated are still experimental
+   = help: the allocation of the accessed tag <TAG> (root of the allocation) also contains the strongly protected tag <TAG>
+   = help: the strongly protected tag <TAG> disallows deallocations
+help: the accessed tag <TAG> was created here
+  --> $DIR/zero-sized-protected.rs:LL:CC
+   |
+LL |     let ptr = unsafe { alloc(l) };
+   |                        ^^^^^^^^
+help: the strongly protected tag <TAG> was created here, in the initial state Reserved
+  --> $DIR/zero-sized-protected.rs:LL:CC
+   |
+LL | fn test(_x: &mut (), ptr: *mut u8, l: Layout) {
+   |         ^^
+   = note: BACKTRACE (of the first span):
+   = note: inside `std::alloc::dealloc` at RUSTLIB/alloc/src/alloc.rs:LL:CC
+note: inside `test`
+  --> $DIR/zero-sized-protected.rs:LL:CC
+   |
+LL |     unsafe { dealloc(ptr, l) };
+   |              ^^^^^^^^^^^^^^^
+note: inside `main`
+  --> $DIR/zero-sized-protected.rs:LL:CC
+   |
+LL |     unsafe { test(&mut *ptr.cast::<()>(), ptr, l) };
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+

From 9010708d9f5dc7e3377acc116a64573fadc7ed2b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 21 Aug 2024 15:52:06 +0200
Subject: [PATCH 481/685] fix comment on PlaceMention semantics

---
 compiler/rustc_middle/src/mir/syntax.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index 51b4154ddab78..748ca047754a9 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -395,7 +395,7 @@ pub enum StatementKind<'tcx> {
     /// `PlaceMention(PLACE)`.
     ///
     /// When executed at runtime, this computes the given place, but then discards
-    /// it without doing a load. It is UB if the place is not pointing to live memory.
+    /// it without doing a load. `let _ = *ptr;` is fine even if the pointer is dangling.
     PlaceMention(Box<Place<'tcx>>),
 
     /// Encodes a user's type ascription. These need to be preserved

From 123bb585f88f21d1035a13f6ed65c4cc898b17a7 Mon Sep 17 00:00:00 2001
From: Tobias Bucher <tobiasbucher5991@gmail.com>
Date: Tue, 20 Aug 2024 16:24:23 +0200
Subject: [PATCH 482/685] Fix stability attribute of `impl !Error for &str`

It was introduced in bf7611d55ee6e24647aefc4d1c82b1dba0164536 (#99917),
which was included in Rust 1.65.0.
---
 library/core/src/str/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 56517348dc7d2..cf9f1bfc0eb72 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -2818,5 +2818,5 @@ impl_fn_for_zst! {
 }
 
 // This is required to make `impl From<&str> for Box<dyn Error>` and `impl<E> From<E> for Box<dyn Error>` not overlap.
-#[stable(feature = "rust1", since = "1.0.0")]
+#[stable(feature = "error_in_core_neg_impl", since = "1.65.0")]
 impl !crate::error::Error for &str {}

From 3f97261fbaff449c86c1ff97d0c342a567527c98 Mon Sep 17 00:00:00 2001
From: Bruce Mitchener <bruce.mitchener@gmail.com>
Date: Wed, 21 Aug 2024 21:42:57 +0700
Subject: [PATCH 483/685] Fix a couple of typos.

---
 clippy_lints/src/returns.rs  | 2 +-
 clippy_lints/src/use_self.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/clippy_lints/src/returns.rs b/clippy_lints/src/returns.rs
index ffc9475cf9cdf..5ce091b7a7a30 100644
--- a/clippy_lints/src/returns.rs
+++ b/clippy_lints/src/returns.rs
@@ -399,7 +399,7 @@ fn check_final_expr<'tcx>(
 
             // Returns may be used to turn an expression into a statement in rustc's AST.
             // This allows the addition of attributes, like `#[allow]` (See: clippy#9361)
-            // `#[expect(clippy::needless_return)]` needs to be handled separatly to
+            // `#[expect(clippy::needless_return)]` needs to be handled separately to
             // actually fulfill the expectation (clippy::#12998)
             match cx.tcx.hir().attrs(expr.hir_id) {
                 [] => {},
diff --git a/clippy_lints/src/use_self.rs b/clippy_lints/src/use_self.rs
index 93785b45c27d4..5da48f4f7fbd7 100644
--- a/clippy_lints/src/use_self.rs
+++ b/clippy_lints/src/use_self.rs
@@ -229,7 +229,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
             && let impl_ty = cx.tcx.type_of(impl_id).instantiate_identity()
             && same_type_and_consts(ty, impl_ty)
             // Ensure the type we encounter and the one from the impl have the same lifetime parameters. It may be that
-            // the lifetime parameters of `ty` are ellided (`impl<'a> Foo<'a> { fn new() -> Self { Foo{..} } }`, in
+            // the lifetime parameters of `ty` are elided (`impl<'a> Foo<'a> { fn new() -> Self { Foo{..} } }`, in
             // which case we must still trigger the lint.
             && (has_no_lifetime(ty) || same_lifetimes(ty, impl_ty))
         {

From 8a4c34a5b7f084f64ab20a4120c61521a1a2b662 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Fri, 9 Aug 2024 09:04:18 -0400
Subject: [PATCH 484/685] Start removing `snippet_opt`

---
 clippy_lints/src/booleans.rs                  | 33 +++++++------
 clippy_lints/src/borrow_deref_ref.rs          |  7 +--
 clippy_lints/src/format.rs                    |  4 +-
 clippy_lints/src/format_args.rs               |  4 +-
 clippy_lints/src/from_over_into.rs            | 12 ++---
 clippy_lints/src/int_plus_one.rs              |  6 +--
 clippy_lints/src/items_after_test_module.rs   |  9 ++--
 clippy_lints/src/large_stack_frames.rs        |  4 +-
 clippy_lints/src/len_zero.rs                  |  4 +-
 clippy_lints/src/literal_representation.rs    |  6 +--
 clippy_lints/src/manual_float_methods.rs      |  4 +-
 clippy_lints/src/manual_hash_one.rs           |  6 +--
 clippy_lints/src/manual_non_exhaustive.rs     |  6 +--
 clippy_lints/src/manual_range_patterns.rs     |  6 +--
 .../src/methods/unnecessary_iter_cloned.rs    |  8 +--
 .../src/misc_early/unneeded_field_pattern.rs  | 27 +++++-----
 .../src/missing_enforced_import_rename.rs     |  4 +-
 clippy_lints/src/needless_if.rs               |  4 +-
 clippy_lints/src/needless_late_init.rs        | 11 +++--
 clippy_lints/src/no_effect.rs                 | 47 +++++++++---------
 clippy_lints/src/nonstandard_macro_braces.rs  |  6 +--
 .../src/operators/assign_op_pattern.rs        |  6 +--
 .../src/operators/misrefactored_assign_op.rs  |  6 ++-
 .../src/operators/needless_bitwise_bool.rs    |  6 +--
 clippy_lints/src/operators/ptr_eq.rs          |  6 +--
 clippy_lints/src/unit_types/unit_arg.rs       | 20 ++++----
 .../src/utils/format_args_collector.rs        | 49 ++++++-------------
 clippy_utils/src/attrs.rs                     | 38 +++++++-------
 clippy_utils/src/hir_utils.rs                 | 18 +++----
 29 files changed, 177 insertions(+), 190 deletions(-)

diff --git a/clippy_lints/src/booleans.rs b/clippy_lints/src/booleans.rs
index a2f48c18170a6..e933fdf1d6e6e 100644
--- a/clippy_lints/src/booleans.rs
+++ b/clippy_lints/src/booleans.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::eq_expr_value;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -134,28 +134,30 @@ fn check_inverted_bool_in_condition(
 
     let suggestion = match (left.kind, right.kind) {
         (ExprKind::Unary(UnOp::Not, left_sub), ExprKind::Unary(UnOp::Not, right_sub)) => {
-            let Some(left) = snippet_opt(cx, left_sub.span) else {
+            let Some(left) = left_sub.span.get_source_text(cx) else {
                 return;
             };
-            let Some(right) = snippet_opt(cx, right_sub.span) else {
+            let Some(right) = right_sub.span.get_source_text(cx) else {
                 return;
             };
             let Some(op) = bin_op_eq_str(op) else { return };
             format!("{left} {op} {right}")
         },
         (ExprKind::Unary(UnOp::Not, left_sub), _) => {
-            let Some(left) = snippet_opt(cx, left_sub.span) else {
+            let Some(left) = left_sub.span.get_source_text(cx) else {
                 return;
             };
-            let Some(right) = snippet_opt(cx, right.span) else {
+            let Some(right) = right.span.get_source_text(cx) else {
                 return;
             };
             let Some(op) = inverted_bin_op_eq_str(op) else { return };
             format!("{left} {op} {right}")
         },
         (_, ExprKind::Unary(UnOp::Not, right_sub)) => {
-            let Some(left) = snippet_opt(cx, left.span) else { return };
-            let Some(right) = snippet_opt(cx, right_sub.span) else {
+            let Some(left) = left.span.get_source_text(cx) else {
+                return;
+            };
+            let Some(right) = right_sub.span.get_source_text(cx) else {
                 return;
             };
             let Some(op) = inverted_bin_op_eq_str(op) else { return };
@@ -313,8 +315,7 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
                         self.output.push_str(&str);
                     } else {
                         self.output.push('!');
-                        let snip = snippet_opt(self.cx, terminal.span)?;
-                        self.output.push_str(&snip);
+                        self.output.push_str(&terminal.span.get_source_text(self.cx)?);
                     }
                 },
                 True | False | Not(_) => {
@@ -345,8 +346,12 @@ impl<'a, 'tcx, 'v> SuggestContext<'a, 'tcx, 'v> {
                 }
             },
             &Term(n) => {
-                let snip = snippet_opt(self.cx, self.terminals[n as usize].span.source_callsite())?;
-                self.output.push_str(&snip);
+                self.output.push_str(
+                    &self.terminals[n as usize]
+                        .span
+                        .source_callsite()
+                        .get_source_text(self.cx)?,
+                );
             },
         }
         Some(())
@@ -370,8 +375,8 @@ fn simplify_not(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
                 _ => None,
             }
             .and_then(|op| {
-                let lhs_snippet = snippet_opt(cx, lhs.span)?;
-                let rhs_snippet = snippet_opt(cx, rhs.span)?;
+                let lhs_snippet = lhs.span.get_source_text(cx)?;
+                let rhs_snippet = rhs.span.get_source_text(cx)?;
 
                 if !(lhs_snippet.starts_with('(') && lhs_snippet.ends_with(')')) {
                     if let (ExprKind::Cast(..), BinOpKind::Ge) = (&lhs.kind, binop.node) {
@@ -399,7 +404,7 @@ fn simplify_not(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
                     let path: &str = path.ident.name.as_str();
                     a == path
                 })
-                .and_then(|(_, neg_method)| Some(format!("{}.{neg_method}()", snippet_opt(cx, receiver.span)?)))
+                .and_then(|(_, neg_method)| Some(format!("{}.{neg_method}()", receiver.span.get_source_text(cx)?)))
         },
         _ => None,
     }
diff --git a/clippy_lints/src/borrow_deref_ref.rs b/clippy_lints/src/borrow_deref_ref.rs
index bd123a725a736..cba8224b84c9e 100644
--- a/clippy_lints/src/borrow_deref_ref.rs
+++ b/clippy_lints/src/borrow_deref_ref.rs
@@ -1,6 +1,6 @@
 use crate::reference::DEREF_ADDROF;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{get_parent_expr, is_from_proc_macro, is_lint_allowed};
 use rustc_errors::Applicability;
@@ -73,6 +73,7 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
                 }
             })
             && !is_from_proc_macro(cx, e)
+            && let Some(deref_text) = deref_target.span.get_source_text(cx)
         {
             span_lint_and_then(
                 cx,
@@ -83,7 +84,7 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
                     diag.span_suggestion(
                         e.span,
                         "if you would like to reborrow, try removing `&*`",
-                        snippet_opt(cx, deref_target.span).unwrap(),
+                        deref_text.as_str(),
                         Applicability::MachineApplicable,
                     );
 
@@ -98,7 +99,7 @@ impl<'tcx> LateLintPass<'tcx> for BorrowDerefRef {
                     diag.span_suggestion(
                         e.span,
                         "if you would like to deref, try using `&**`",
-                        format!("&**{}", &snippet_opt(cx, deref_target.span).unwrap()),
+                        format!("&**{deref_text}"),
                         Applicability::MaybeIncorrect,
                     );
                 },
diff --git a/clippy_lints/src/format.rs b/clippy_lints/src/format.rs
index c14bd38a1f21c..4dedff69b9abd 100644
--- a/clippy_lints/src/format.rs
+++ b/clippy_lints/src/format.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::macros::{find_format_arg_expr, root_macro_call_first_node, FormatArgsStorage};
-use clippy_utils::source::{snippet_opt, snippet_with_context};
+use clippy_utils::source::{snippet_with_context, SpanRangeExt};
 use clippy_utils::sugg::Sugg;
 use rustc_ast::{FormatArgsPiece, FormatOptions, FormatTrait};
 use rustc_errors::Applicability;
@@ -65,7 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessFormat {
                 ([], []) => span_useless_format_empty(cx, call_site, "String::new()".to_owned(), applicability),
                 ([], [_]) => {
                     // Simulate macro expansion, converting {{ and }} to { and }.
-                    let Some(snippet) = snippet_opt(cx, format_args.span) else {
+                    let Some(snippet) = format_args.span.get_source_text(cx) else {
                         return;
                     };
                     let s_expand = snippet.replace("{{", "{").replace("}}", "}");
diff --git a/clippy_lints/src/format_args.rs b/clippy_lints/src/format_args.rs
index 823992767e508..020c0c5440d93 100644
--- a/clippy_lints/src/format_args.rs
+++ b/clippy_lints/src/format_args.rs
@@ -7,7 +7,7 @@ use clippy_utils::macros::{
     find_format_arg_expr, format_arg_removal_span, format_placeholder_format_span, is_assert_macro, is_format_macro,
     is_panic, matching_root_macro_call, root_macro_call_first_node, FormatArgsStorage, FormatParamUsage, MacroCall,
 };
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::{implements_trait, is_type_lang_item};
 use itertools::Itertools;
 use rustc_ast::{
@@ -407,7 +407,7 @@ impl<'a, 'tcx> FormatArgsExpr<'a, 'tcx> {
                 count_needed_derefs(receiver_ty, cx.typeck_results().expr_adjustments(receiver).iter())
             && implements_trait(cx, target, display_trait_id, &[])
             && let Some(sized_trait_id) = cx.tcx.lang_items().sized_trait()
-            && let Some(receiver_snippet) = snippet_opt(cx, receiver.span.source_callsite())
+            && let Some(receiver_snippet) = receiver.span.source_callsite().get_source_text(cx)
         {
             let needs_ref = !implements_trait(cx, receiver_ty, sized_trait_id, &[]);
             if n_needed_derefs == 0 && !needs_ref {
diff --git a/clippy_lints/src/from_over_into.rs b/clippy_lints/src/from_over_into.rs
index b6c8437fb8f73..5e9098474dc02 100644
--- a/clippy_lints/src/from_over_into.rs
+++ b/clippy_lints/src/from_over_into.rs
@@ -3,7 +3,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::span_is_local;
 use clippy_utils::path_def_id;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{walk_path, Visitor};
 use rustc_hir::{
@@ -178,8 +178,8 @@ fn convert_to_from(
         return None;
     };
 
-    let from = snippet_opt(cx, self_ty.span)?;
-    let into = snippet_opt(cx, target_ty.span)?;
+    let from = self_ty.span.get_source_text(cx)?;
+    let into = target_ty.span.get_source_text(cx)?;
 
     let return_type = matches!(sig.decl.output, FnRetTy::Return(_))
         .then_some(String::from("Self"))
@@ -190,10 +190,10 @@ fn convert_to_from(
         (into_trait_seg.ident.span, String::from("From")),
         // impl Into<T> for U  ->  impl Into<U> for U
         //           ~                       ~
-        (target_ty.span, from.clone()),
+        (target_ty.span, from.to_owned()),
         // impl Into<T> for U  ->  impl Into<T> for T
         //                  ~                       ~
-        (self_ty.span, into),
+        (self_ty.span, into.to_owned()),
         // fn into(self) -> T  ->  fn from(self) -> T
         //    ~~~~                    ~~~~
         (impl_item.ident.span, String::from("from")),
@@ -223,7 +223,7 @@ fn convert_to_from(
     }
 
     for span in finder.upper {
-        suggestions.push((span, from.clone()));
+        suggestions.push((span, from.to_owned()));
     }
     for span in finder.lower {
         suggestions.push((span, String::from("val")));
diff --git a/clippy_lints/src/int_plus_one.rs b/clippy_lints/src/int_plus_one.rs
index 941caaab1f1bf..fc575bff7e63f 100644
--- a/clippy_lints/src/int_plus_one.rs
+++ b/clippy_lints/src/int_plus_one.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_ast::ast::{BinOpKind, Expr, ExprKind, LitKind};
 use rustc_ast::token;
 use rustc_errors::Applicability;
@@ -130,8 +130,8 @@ impl IntPlusOne {
             BinOpKind::Le => "<",
             _ => return None,
         };
-        if let Some(snippet) = snippet_opt(cx, node.span) {
-            if let Some(other_side_snippet) = snippet_opt(cx, other_side.span) {
+        if let Some(snippet) = node.span.get_source_text(cx) {
+            if let Some(other_side_snippet) = other_side.span.get_source_text(cx) {
                 let rec = match side {
                     Side::Lhs => Some(format!("{snippet} {binop_string} {other_side_snippet}")),
                     Side::Rhs => Some(format!("{other_side_snippet} {binop_string} {snippet}")),
diff --git a/clippy_lints/src/items_after_test_module.rs b/clippy_lints/src/items_after_test_module.rs
index 3614fb8cc963b..8caa484bb9934 100644
--- a/clippy_lints/src/items_after_test_module.rs
+++ b/clippy_lints/src/items_after_test_module.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::{fulfill_or_allowed, is_cfg_test, is_from_proc_macro};
 use rustc_errors::{Applicability, SuggestionStyle};
 use rustc_hir::{HirId, Item, ItemKind, Mod};
@@ -93,11 +93,14 @@ impl LateLintPass<'_> for ItemsAfterTestModule {
                     if let Some(prev) = mod_pos.checked_sub(1)
                         && let prev = cx.tcx.hir().item(module.item_ids[prev])
                         && let items_span = last.span.with_lo(test_mod.span.hi())
-                        && let Some(items) = snippet_opt(cx, items_span)
+                        && let Some(items) = items_span.get_source_text(cx)
                     {
                         diag.multipart_suggestion_with_style(
                             "move the items to before the test module was defined",
-                            vec![(prev.span.shrink_to_hi(), items), (items_span, String::new())],
+                            vec![
+                                (prev.span.shrink_to_hi(), items.to_owned()),
+                                (items_span, String::new()),
+                            ],
                             Applicability::MachineApplicable,
                             SuggestionStyle::HideCodeAlways,
                         );
diff --git a/clippy_lints/src/large_stack_frames.rs b/clippy_lints/src/large_stack_frames.rs
index 4abf7edc9b4e5..d2bdf194adad9 100644
--- a/clippy_lints/src/large_stack_frames.rs
+++ b/clippy_lints/src/large_stack_frames.rs
@@ -3,7 +3,7 @@ use std::{fmt, ops};
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::fn_has_unsatisfiable_preds;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl};
@@ -186,7 +186,7 @@ impl<'tcx> LateLintPass<'tcx> for LargeStackFrames {
                         // TODO: Is there a cleaner, robust way to ask this question?
                         // The obvious `LocalDecl::is_user_variable()` panics on "unwrapping cross-crate data",
                         // and that doesn't get us the true name in scope rather than the span text either.
-                        if let Some(name) = snippet_opt(cx, local_span)
+                        if let Some(name) = local_span.get_source_text(cx)
                             && is_ident(&name)
                         {
                             // If the local is an ordinary named variable,
diff --git a/clippy_lints/src/len_zero.rs b/clippy_lints/src/len_zero.rs
index 4c737371bd238..0bc7fc2dd9d1e 100644
--- a/clippy_lints/src/len_zero.rs
+++ b/clippy_lints/src/len_zero.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::{snippet_opt, snippet_with_context};
+use clippy_utils::source::{snippet_with_context, SpanRangeExt};
 use clippy_utils::sugg::{has_enclosing_paren, Sugg};
 use clippy_utils::{get_item_name, get_parent_as_impl, is_lint_allowed, peel_ref_operators};
 use rustc_ast::ast::LitKind;
@@ -216,7 +216,7 @@ impl<'tcx> LateLintPass<'tcx> for LenZero {
 }
 
 fn span_without_enclosing_paren(cx: &LateContext<'_>, span: Span) -> Span {
-    let Some(snippet) = snippet_opt(cx, span) else {
+    let Some(snippet) = span.get_source_text(cx) else {
         return span;
     };
     if has_enclosing_paren(snippet) {
diff --git a/clippy_lints/src/literal_representation.rs b/clippy_lints/src/literal_representation.rs
index f51c593b2de9e..81f2a03fb55fb 100644
--- a/clippy_lints/src/literal_representation.rs
+++ b/clippy_lints/src/literal_representation.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::numeric_literal::{NumericLiteral, Radix};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_ast::ast::{Expr, ExprKind, LitKind};
 use rustc_ast::token;
 use rustc_errors::Applicability;
@@ -225,7 +225,7 @@ impl LiteralDigitGrouping {
     }
 
     fn check_lit(&self, cx: &EarlyContext<'_>, lit: token::Lit, span: Span) {
-        if let Some(src) = snippet_opt(cx, span)
+        if let Some(src) = span.get_source_text(cx)
             && let Ok(lit_kind) = LitKind::from_token_lit(lit)
             && let Some(mut num_lit) = NumericLiteral::from_lit_kind(&src, &lit_kind)
         {
@@ -439,7 +439,7 @@ impl DecimalLiteralRepresentation {
         // Lint integral literals.
         if let Ok(lit_kind) = LitKind::from_token_lit(lit)
             && let LitKind::Int(val, _) = lit_kind
-            && let Some(src) = snippet_opt(cx, span)
+            && let Some(src) = span.get_source_text(cx)
             && let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit_kind)
             && num_lit.radix == Radix::Decimal
             && val >= u128::from(self.threshold)
diff --git a/clippy_lints/src/manual_float_methods.rs b/clippy_lints/src/manual_float_methods.rs
index 6bdc79129a9bc..9d3ddab60bb3a 100644
--- a/clippy_lints/src/manual_float_methods.rs
+++ b/clippy_lints/src/manual_float_methods.rs
@@ -1,6 +1,6 @@
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::{is_from_proc_macro, path_to_local};
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Constness, Expr, ExprKind};
@@ -103,7 +103,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
             // case somebody does that for some reason
             && (is_infinity(&const_1) && is_neg_infinity(&const_2)
                 || is_neg_infinity(&const_1) && is_infinity(&const_2))
-            && let Some(local_snippet) = snippet_opt(cx, first.span)
+            && let Some(local_snippet) = first.span.get_source_text(cx)
         {
             let variant = match (kind.node, lhs_kind.node, rhs_kind.node) {
                 (BinOpKind::Or, BinOpKind::Eq, BinOpKind::Eq) => Variant::ManualIsInfinite,
diff --git a/clippy_lints/src/manual_hash_one.rs b/clippy_lints/src/manual_hash_one.rs
index 1c568b1b74f32..11716a539ab5c 100644
--- a/clippy_lints/src/manual_hash_one.rs
+++ b/clippy_lints/src/manual_hash_one.rs
@@ -1,7 +1,7 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::visitors::{is_local_used, local_used_once};
 use clippy_utils::{is_trait_method, path_to_local_id};
 use rustc_errors::Applicability;
@@ -107,8 +107,8 @@ impl LateLintPass<'_> for ManualHashOne {
                 finish_expr.span,
                 "manual implementation of `BuildHasher::hash_one`",
                 |diag| {
-                    if let Some(build_hasher) = snippet_opt(cx, build_hasher.span)
-                        && let Some(hashed_value) = snippet_opt(cx, hashed_value.span)
+                    if let Some(build_hasher) = build_hasher.span.get_source_text(cx)
+                        && let Some(hashed_value) = hashed_value.span.get_source_text(cx)
                     {
                         diag.multipart_suggestion(
                             "try",
diff --git a/clippy_lints/src/manual_non_exhaustive.rs b/clippy_lints/src/manual_non_exhaustive.rs
index 28cfe22835af6..6b1d90483ccd1 100644
--- a/clippy_lints/src/manual_non_exhaustive.rs
+++ b/clippy_lints/src/manual_non_exhaustive.rs
@@ -2,7 +2,7 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::is_doc_hidden;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_ast::ast::{self, VisibilityKind};
 use rustc_ast::attr;
 use rustc_data_structures::fx::FxHashSet;
@@ -124,7 +124,7 @@ impl EarlyLintPass for ManualNonExhaustiveStruct {
                     |diag| {
                         if !item.attrs.iter().any(|attr| attr.has_name(sym::non_exhaustive))
                             && let header_span = cx.sess().source_map().span_until_char(item.span, delimiter)
-                            && let Some(snippet) = snippet_opt(cx, header_span)
+                            && let Some(snippet) = header_span.get_source_text(cx)
                         {
                             diag.span_suggestion(
                                 header_span,
@@ -194,7 +194,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustiveEnum {
                 "this seems like a manual implementation of the non-exhaustive pattern",
                 |diag| {
                     let header_span = cx.sess().source_map().span_until_char(enum_span, '{');
-                    if let Some(snippet) = snippet_opt(cx, header_span) {
+                    if let Some(snippet) = header_span.get_source_text(cx) {
                         diag.span_suggestion(
                             header_span,
                             "add the attribute",
diff --git a/clippy_lints/src/manual_range_patterns.rs b/clippy_lints/src/manual_range_patterns.rs
index 07d4abbf5cd11..9afb2b5bc84cd 100644
--- a/clippy_lints/src/manual_range_patterns.rs
+++ b/clippy_lints/src/manual_range_patterns.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_ast::LitKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -143,8 +143,8 @@ impl LateLintPass<'_> for ManualRangePatterns {
                 pat.span,
                 "this OR pattern can be rewritten using a range",
                 |diag| {
-                    if let Some(min) = snippet_opt(cx, min.span)
-                        && let Some(max) = snippet_opt(cx, max.span)
+                    if let Some(min) = min.span.get_source_text(cx)
+                        && let Some(max) = max.span.get_source_text(cx)
                     {
                         diag.span_suggestion(
                             pat.span,
diff --git a/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
index 70885e46e955e..4d18bc7ac7777 100644
--- a/clippy_lints/src/methods/unnecessary_iter_cloned.rs
+++ b/clippy_lints/src/methods/unnecessary_iter_cloned.rs
@@ -1,7 +1,7 @@
 use super::utils::clone_or_copy_needed;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::ForLoop;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::{get_iterator_item_ty, implements_trait};
 use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{can_mut_borrow_both, fn_def_id, get_parent_expr, path_to_local};
@@ -40,7 +40,7 @@ pub fn check_for_loop_iter(
         && let Some(ForLoop { pat, body, .. }) = ForLoop::hir(grandparent)
         && let (clone_or_copy_needed, references_to_binding) = clone_or_copy_needed(cx, pat, body)
         && !clone_or_copy_needed
-        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+        && let Some(receiver_snippet) = receiver.span.get_source_text(cx)
     {
         // Issue 12098
         // https://github.com/rust-lang/rust-clippy/issues/12098
@@ -100,7 +100,7 @@ pub fn check_for_loop_iter(
             && implements_trait(cx, collection_ty, into_iterator_trait_id, &[])
             && let Some(into_iter_item_ty) = cx.get_associated_type(collection_ty, into_iterator_trait_id, "Item")
             && iter_item_ty == into_iter_item_ty
-            && let Some(collection_snippet) = snippet_opt(cx, collection.span)
+            && let Some(collection_snippet) = collection.span.get_source_text(cx)
         {
             collection_snippet
         } else {
@@ -122,7 +122,7 @@ pub fn check_for_loop_iter(
                 } else {
                     Applicability::MachineApplicable
                 };
-                diag.span_suggestion(expr.span, "use", snippet, applicability);
+                diag.span_suggestion(expr.span, "use", snippet.to_owned(), applicability);
                 if !references_to_binding.is_empty() {
                     diag.multipart_suggestion(
                         "remove any references to the binding",
diff --git a/clippy_lints/src/misc_early/unneeded_field_pattern.rs b/clippy_lints/src/misc_early/unneeded_field_pattern.rs
index 6db03adf44ac9..33ab94e00a5c6 100644
--- a/clippy_lints/src/misc_early/unneeded_field_pattern.rs
+++ b/clippy_lints/src/misc_early/unneeded_field_pattern.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
+use itertools::Itertools;
 use rustc_ast::ast::{Pat, PatKind};
 use rustc_lint::EarlyContext;
 
@@ -45,19 +46,6 @@ pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
                             "you matched a field with a wildcard pattern, consider using `..` instead",
                         );
                     } else {
-                        let mut normal = vec![];
-
-                        for field in pfields {
-                            match field.pat.kind {
-                                PatKind::Wild => {},
-                                _ => {
-                                    if let Some(n) = snippet_opt(cx, field.span) {
-                                        normal.push(n);
-                                    }
-                                },
-                            }
-                        }
-
                         #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
                         span_lint_and_then(
                             cx,
@@ -65,7 +53,16 @@ pub(super) fn check(cx: &EarlyContext<'_>, pat: &Pat) {
                             field.span,
                             "you matched a field with a wildcard pattern, consider using `..` instead",
                             |diag| {
-                                diag.help(format!("try with `{type_name} {{ {}, .. }}`", normal[..].join(", ")));
+                                diag.help(format!(
+                                    "try with `{type_name} {{ {}, .. }}`",
+                                    pfields
+                                        .iter()
+                                        .filter_map(|f| match f.pat.kind {
+                                            PatKind::Wild => None,
+                                            _ => f.span.get_source_text(cx),
+                                        })
+                                        .format(", "),
+                                ));
                             },
                         );
                     }
diff --git a/clippy_lints/src/missing_enforced_import_rename.rs b/clippy_lints/src/missing_enforced_import_rename.rs
index cdf6645b3df77..59f29d242abf3 100644
--- a/clippy_lints/src/missing_enforced_import_rename.rs
+++ b/clippy_lints/src/missing_enforced_import_rename.rs
@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_utils::def_path_def_ids;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
 use rustc_hir::def_id::DefIdMap;
@@ -73,7 +73,7 @@ impl LateLintPass<'_> for ImportRename {
                     && let Some(name) = self.renames.get(&id)
                     // Remove semicolon since it is not present for nested imports
                     && let span_without_semi = cx.sess().source_map().span_until_char(item.span, ';')
-                    && let Some(snip) = snippet_opt(cx, span_without_semi)
+                    && let Some(snip) = span_without_semi.get_source_text(cx)
                     && let Some(import) = match snip.split_once(" as ") {
                         None => Some(snip.as_str()),
                         Some((import, rename)) => {
diff --git a/clippy_lints/src/needless_if.rs b/clippy_lints/src/needless_if.rs
index 1d6233d432a75..8e14fbf2f8061 100644
--- a/clippy_lints/src/needless_if.rs
+++ b/clippy_lints/src/needless_if.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::higher::If;
 use clippy_utils::is_from_proc_macro;
-use clippy_utils::source::{snippet_opt, SpanRangeExt};
+use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::{ExprKind, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@@ -57,7 +57,7 @@ impl LateLintPass<'_> for NeedlessIf {
                 src.bytes()
                     .all(|ch| matches!(ch, b'{' | b'}') || ch.is_ascii_whitespace())
             })
-            && let Some(cond_snippet) = snippet_opt(cx, cond.span)
+            && let Some(cond_snippet) = cond.span.get_source_text(cx)
             && !is_from_proc_macro(cx, expr)
         {
             span_lint_and_sugg(
diff --git a/clippy_lints/src/needless_late_init.rs b/clippy_lints/src/needless_late_init.rs
index 4bfc30fa5cf80..46cdb82130f97 100644
--- a/clippy_lints/src/needless_late_init.rs
+++ b/clippy_lints/src/needless_late_init.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::path_to_local;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::{SourceText, SpanRangeExt};
 use clippy_utils::ty::needs_ordered_drop;
 use clippy_utils::visitors::{for_each_expr, for_each_expr_without_closures, is_local_used};
 use core::ops::ControlFlow;
@@ -236,7 +236,7 @@ fn first_usage<'tcx>(
         })
 }
 
-fn local_snippet_without_semicolon(cx: &LateContext<'_>, local: &LetStmt<'_>) -> Option<String> {
+fn local_snippet_without_semicolon(cx: &LateContext<'_>, local: &LetStmt<'_>) -> Option<SourceText> {
     let span = local.span.with_hi(match local.ty {
         // let <pat>: <ty>;
         // ~~~~~~~~~~~~~~~
@@ -246,7 +246,7 @@ fn local_snippet_without_semicolon(cx: &LateContext<'_>, local: &LetStmt<'_>) ->
         None => local.pat.span.hi(),
     });
 
-    snippet_opt(cx, span)
+    span.get_source_text(cx)
 }
 
 fn check<'tcx>(
@@ -275,7 +275,10 @@ fn check<'tcx>(
                 |diag| {
                     diag.multipart_suggestion(
                         format!("move the declaration `{binding_name}` here"),
-                        vec![(local_stmt.span, String::new()), (assign.lhs_span, let_snippet)],
+                        vec![
+                            (local_stmt.span, String::new()),
+                            (assign.lhs_span, let_snippet.to_owned()),
+                        ],
                         Applicability::MachineApplicable,
                     );
                 },
diff --git a/clippy_lints/src/no_effect.rs b/clippy_lints/src/no_effect.rs
index 8232e69db3917..b181791699a5b 100644
--- a/clippy_lints/src/no_effect.rs
+++ b/clippy_lints/src/no_effect.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_hir, span_lint_hir_and_then};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::has_drop;
 use clippy_utils::{
     in_automatically_derived, is_inside_always_const_context, is_lint_allowed, path_to_local, peel_blocks,
@@ -268,34 +268,31 @@ fn check_unnecessary_operation(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         && reduced.iter().all(|e| e.span.ctxt() == ctxt)
     {
         if let ExprKind::Index(..) = &expr.kind {
-            if is_inside_always_const_context(cx.tcx, expr.hir_id) {
-                return;
+            if !is_inside_always_const_context(cx.tcx, expr.hir_id)
+                && let [arr, func] = &*reduced
+                && let Some(arr) = arr.span.get_source_text(cx)
+                && let Some(func) = func.span.get_source_text(cx)
+            {
+                span_lint_hir_and_then(
+                    cx,
+                    UNNECESSARY_OPERATION,
+                    expr.hir_id,
+                    stmt.span,
+                    "unnecessary operation",
+                    |diag| {
+                        diag.span_suggestion(
+                            stmt.span,
+                            "statement can be written as",
+                            format!("assert!({arr}.len() > {func});"),
+                            Applicability::MaybeIncorrect,
+                        );
+                    },
+                );
             }
-            let snippet =
-                if let (Some(arr), Some(func)) = (snippet_opt(cx, reduced[0].span), snippet_opt(cx, reduced[1].span)) {
-                    format!("assert!({arr}.len() > {func});")
-                } else {
-                    return;
-                };
-            span_lint_hir_and_then(
-                cx,
-                UNNECESSARY_OPERATION,
-                expr.hir_id,
-                stmt.span,
-                "unnecessary operation",
-                |diag| {
-                    diag.span_suggestion(
-                        stmt.span,
-                        "statement can be written as",
-                        snippet,
-                        Applicability::MaybeIncorrect,
-                    );
-                },
-            );
         } else {
             let mut snippet = String::new();
             for e in reduced {
-                if let Some(snip) = snippet_opt(cx, e.span) {
+                if let Some(snip) = e.span.get_source_text(cx) {
                     snippet.push_str(&snip);
                     snippet.push(';');
                 } else {
diff --git a/clippy_lints/src/nonstandard_macro_braces.rs b/clippy_lints/src/nonstandard_macro_braces.rs
index 2aaf1e6ff46da..51ba29d7389b9 100644
--- a/clippy_lints/src/nonstandard_macro_braces.rs
+++ b/clippy_lints/src/nonstandard_macro_braces.rs
@@ -1,7 +1,7 @@
 use clippy_config::types::MacroMatcher;
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::{SourceText, SpanRangeExt};
 use rustc_ast::ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::Applicability;
@@ -34,7 +34,7 @@ declare_clippy_lint! {
 }
 
 /// The (callsite span, (open brace, close brace), source snippet)
-type MacroInfo = (Span, (char, char), String);
+type MacroInfo = (Span, (char, char), SourceText);
 
 pub struct MacroBraces {
     macro_braces: FxHashMap<String, (char, char)>,
@@ -94,7 +94,7 @@ fn is_offending_macro(cx: &EarlyContext<'_>, span: Span, mac_braces: &MacroBrace
     if let ExpnKind::Macro(MacroKind::Bang, mac_name) = span.ctxt().outer_expn_data().kind
         && let name = mac_name.as_str()
         && let Some(&braces) = mac_braces.macro_braces.get(name)
-        && let Some(snip) = snippet_opt(cx, span_call_site)
+        && let Some(snip) = span_call_site.get_source_text(cx)
         // we must check only invocation sites
         // https://github.com/rust-lang/rust-clippy/issues/7422
         && snip.starts_with(&format!("{name}!"))
diff --git a/clippy_lints/src/operators/assign_op_pattern.rs b/clippy_lints/src/operators/assign_op_pattern.rs
index 641d881d974b8..11c97b4ef0073 100644
--- a/clippy_lints/src/operators/assign_op_pattern.rs
+++ b/clippy_lints/src/operators/assign_op_pattern.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{binop_traits, eq_expr_value, trait_ref_of_method};
@@ -46,8 +46,8 @@ pub(super) fn check<'tcx>(
                     expr.span,
                     "manual implementation of an assign operation",
                     |diag| {
-                        if let (Some(snip_a), Some(snip_r)) =
-                            (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs.span))
+                        if let Some(snip_a) = assignee.span.get_source_text(cx)
+                            && let Some(snip_r) = rhs.span.get_source_text(cx)
                         {
                             diag.span_suggestion(
                                 expr.span,
diff --git a/clippy_lints/src/operators/misrefactored_assign_op.rs b/clippy_lints/src/operators/misrefactored_assign_op.rs
index 311cbd050a10c..8daedd1c90140 100644
--- a/clippy_lints/src/operators/misrefactored_assign_op.rs
+++ b/clippy_lints/src/operators/misrefactored_assign_op.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::{eq_expr_value, sugg};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -42,7 +42,9 @@ fn lint_misrefactored_assign_op(
         expr.span,
         "variable appears on both sides of an assignment operation",
         |diag| {
-            if let (Some(snip_a), Some(snip_r)) = (snippet_opt(cx, assignee.span), snippet_opt(cx, rhs_other.span)) {
+            if let Some(snip_a) = assignee.span.get_source_text(cx)
+                && let Some(snip_r) = rhs_other.span.get_source_text(cx)
+            {
                 let a = &sugg::Sugg::hir(cx, assignee, "..");
                 let r = &sugg::Sugg::hir(cx, rhs, "..");
                 let long = format!("{snip_a} = {}", sugg::make_binop(op, a, r));
diff --git a/clippy_lints/src/operators/needless_bitwise_bool.rs b/clippy_lints/src/operators/needless_bitwise_bool.rs
index ab5fb1787004e..9d8e833ef6d75 100644
--- a/clippy_lints/src/operators/needless_bitwise_bool.rs
+++ b/clippy_lints/src/operators/needless_bitwise_bool.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -24,8 +24,8 @@ pub(super) fn check(cx: &LateContext<'_>, e: &Expr<'_>, op: BinOpKind, lhs: &Exp
             e.span,
             "use of bitwise operator instead of lazy operator between booleans",
             |diag| {
-                if let Some(lhs_snip) = snippet_opt(cx, lhs.span)
-                    && let Some(rhs_snip) = snippet_opt(cx, rhs.span)
+                if let Some(lhs_snip) = lhs.span.get_source_text(cx)
+                    && let Some(rhs_snip) = rhs.span.get_source_text(cx)
                 {
                     let sugg = format!("{lhs_snip} {op_str} {rhs_snip}");
                     diag.span_suggestion(e.span, "try", sugg, Applicability::MachineApplicable);
diff --git a/clippy_lints/src/operators/ptr_eq.rs b/clippy_lints/src/operators/ptr_eq.rs
index 607930561e0fc..861564d54569e 100644
--- a/clippy_lints/src/operators/ptr_eq.rs
+++ b/clippy_lints/src/operators/ptr_eq.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::std_or_core;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
@@ -22,8 +22,8 @@ pub(super) fn check<'tcx>(
 
         if let Some(left_var) = expr_as_cast_to_raw_pointer(cx, left)
             && let Some(right_var) = expr_as_cast_to_raw_pointer(cx, right)
-            && let Some(left_snip) = snippet_opt(cx, left_var.span)
-            && let Some(right_snip) = snippet_opt(cx, right_var.span)
+            && let Some(left_snip) = left_var.span.get_source_text(cx)
+            && let Some(right_snip) = right_var.span.get_source_text(cx)
         {
             let Some(top_crate) = std_or_core(cx) else { return };
             span_lint_and_sugg(
diff --git a/clippy_lints/src/unit_types/unit_arg.rs b/clippy_lints/src/unit_types/unit_arg.rs
index afc53e6f32d96..978d49f09c3a8 100644
--- a/clippy_lints/src/unit_types/unit_arg.rs
+++ b/clippy_lints/src/unit_types/unit_arg.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_from_proc_macro;
-use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
+use clippy_utils::source::{indent_of, reindent_multiline, SourceText, SpanRangeExt};
 use rustc_errors::Applicability;
 use rustc_hir::{Block, Expr, ExprKind, MatchSource, Node, StmtKind};
 use rustc_lint::LateContext;
@@ -79,7 +79,7 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
                         && block.expr.is_none()
                         && let Some(last_stmt) = block.stmts.iter().last()
                         && let StmtKind::Semi(last_expr) = last_stmt.kind
-                        && let Some(snip) = snippet_opt(cx, last_expr.span)
+                        && let Some(snip) = last_expr.span.get_source_text(cx)
                     {
                         Some((last_stmt.span, snip))
                     } else {
@@ -90,24 +90,24 @@ fn lint_unit_args(cx: &LateContext<'_>, expr: &Expr<'_>, args_to_recover: &[&Exp
                     db.span_suggestion(
                         span,
                         "remove the semicolon from the last statement in the block",
-                        sugg,
+                        sugg.as_str(),
                         Applicability::MaybeIncorrect,
                     );
                     or = "or ";
                     applicability = Applicability::MaybeIncorrect;
                 });
 
-            let arg_snippets: Vec<String> = args_to_recover
+            let arg_snippets: Vec<_> = args_to_recover
                 .iter()
-                .filter_map(|arg| snippet_opt(cx, arg.span))
+                .filter_map(|arg| arg.span.get_source_text(cx))
                 .collect();
-            let arg_snippets_without_empty_blocks: Vec<String> = args_to_recover
+            let arg_snippets_without_empty_blocks: Vec<_> = args_to_recover
                 .iter()
                 .filter(|arg| !is_empty_block(arg))
-                .filter_map(|arg| snippet_opt(cx, arg.span))
+                .filter_map(|arg| arg.span.get_source_text(cx))
                 .collect();
 
-            if let Some(call_snippet) = snippet_opt(cx, expr.span) {
+            if let Some(call_snippet) = expr.span.get_source_text(cx) {
                 let sugg = fmt_stmts_and_call(
                     cx,
                     expr,
@@ -161,8 +161,8 @@ fn fmt_stmts_and_call(
     cx: &LateContext<'_>,
     call_expr: &Expr<'_>,
     call_snippet: &str,
-    args_snippets: &[impl AsRef<str>],
-    non_empty_block_args_snippets: &[impl AsRef<str>],
+    args_snippets: &[SourceText],
+    non_empty_block_args_snippets: &[SourceText],
 ) -> String {
     let call_expr_indent = indent_of(cx, call_expr.span).unwrap_or(0);
     let call_snippet_with_replacements = args_snippets
diff --git a/clippy_lints/src/utils/format_args_collector.rs b/clippy_lints/src/utils/format_args_collector.rs
index 5acfd35fd6ae6..f50ce6c99deac 100644
--- a/clippy_lints/src/utils/format_args_collector.rs
+++ b/clippy_lints/src/utils/format_args_collector.rs
@@ -1,5 +1,5 @@
 use clippy_utils::macros::FormatArgsStorage;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use itertools::Itertools;
 use rustc_ast::{Crate, Expr, ExprKind, FormatArgs};
 use rustc_data_structures::fx::FxHashMap;
@@ -75,38 +75,21 @@ fn has_span_from_proc_macro(cx: &EarlyContext<'_>, args: &FormatArgs) -> bool {
 
     // `format!("{} {} {c}", "one", "two", c = "three")`
     //                     ^^     ^^     ^^^^^^
-    let between_spans = once(args.span)
+    !once(args.span)
         .chain(argument_span)
         .tuple_windows()
-        .map(|(start, end)| start.between(end));
-
-    for between_span in between_spans {
-        let mut seen_comma = false;
-
-        let Some(snippet) = snippet_opt(cx, between_span) else {
-            return true;
-        };
-        for token in tokenize(&snippet) {
-            match token.kind {
-                TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace => {},
-                TokenKind::Comma if !seen_comma => seen_comma = true,
-                // named arguments, `start_val, name = end_val`
-                //                            ^^^^^^^^^ between_span
-                TokenKind::Ident | TokenKind::Eq if seen_comma => {},
-                // An unexpected token usually indicates that we crossed a macro boundary
-                //
-                // `println!(some_proc_macro!("input {}"), a)`
-                //                                      ^^^ between_span
-                // `println!("{}", val!(x))`
-                //               ^^^^^^^ between_span
-                _ => return true,
-            }
-        }
-
-        if !seen_comma {
-            return true;
-        }
-    }
-
-    false
+        .map(|(start, end)| start.between(end))
+        .all(|sp| {
+            sp.check_source_text(cx, |src| {
+                // text should be either `, name` or `, name =`
+                let mut iter = tokenize(src).filter(|t| {
+                    !matches!(
+                        t.kind,
+                        TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace
+                    )
+                });
+                iter.next().is_some_and(|t| matches!(t.kind, TokenKind::Comma))
+                    && iter.all(|t| matches!(t.kind, TokenKind::Ident | TokenKind::Eq))
+            })
+        })
 }
diff --git a/clippy_utils/src/attrs.rs b/clippy_utils/src/attrs.rs
index d2200bcf7103b..42c8b218d14e8 100644
--- a/clippy_utils/src/attrs.rs
+++ b/clippy_utils/src/attrs.rs
@@ -7,7 +7,7 @@ use rustc_session::Session;
 use rustc_span::{sym, Span};
 use std::str::FromStr;
 
-use crate::source::snippet_opt;
+use crate::source::SpanRangeExt;
 use crate::tokenize_with_text;
 
 /// Deprecation status of attributes known by Clippy.
@@ -179,25 +179,23 @@ pub fn has_non_exhaustive_attr(tcx: TyCtxt<'_>, adt: AdtDef<'_>) -> bool {
 
 /// Checks if the given span contains a `#[cfg(..)]` attribute
 pub fn span_contains_cfg(cx: &LateContext<'_>, s: Span) -> bool {
-    let Some(snip) = snippet_opt(cx, s) else {
-        // Assume true. This would require either an invalid span, or one which crosses file boundaries.
-        return true;
-    };
-    let mut iter = tokenize_with_text(&snip);
+    s.check_source_text(cx, |src| {
+        let mut iter = tokenize_with_text(src);
 
-    // Search for the token sequence [`#`, `[`, `cfg`]
-    while iter.any(|(t, _)| matches!(t, TokenKind::Pound)) {
-        let mut iter = iter.by_ref().skip_while(|(t, _)| {
-            matches!(
-                t,
-                TokenKind::Whitespace | TokenKind::LineComment { .. } | TokenKind::BlockComment { .. }
-            )
-        });
-        if matches!(iter.next(), Some((TokenKind::OpenBracket, _)))
-            && matches!(iter.next(), Some((TokenKind::Ident, "cfg")))
-        {
-            return true;
+        // Search for the token sequence [`#`, `[`, `cfg`]
+        while iter.any(|(t, _)| matches!(t, TokenKind::Pound)) {
+            let mut iter = iter.by_ref().skip_while(|(t, _)| {
+                matches!(
+                    t,
+                    TokenKind::Whitespace | TokenKind::LineComment { .. } | TokenKind::BlockComment { .. }
+                )
+            });
+            if matches!(iter.next(), Some((TokenKind::OpenBracket, _)))
+                && matches!(iter.next(), Some((TokenKind::Ident, "cfg")))
+            {
+                return true;
+            }
         }
-    }
-    false
+        false
+    })
 }
diff --git a/clippy_utils/src/hir_utils.rs b/clippy_utils/src/hir_utils.rs
index b0a668329e920..f61ef9ac1b05e 100644
--- a/clippy_utils/src/hir_utils.rs
+++ b/clippy_utils/src/hir_utils.rs
@@ -1,6 +1,6 @@
 use crate::consts::ConstEvalCtxt;
 use crate::macros::macro_backtrace;
-use crate::source::{snippet_opt, walk_span_to_context, SpanRange, SpanRangeExt};
+use crate::source::{walk_span_to_context, SpanRange, SpanRangeExt};
 use crate::tokenize_with_text;
 use rustc_ast::ast::InlineAsmTemplatePiece;
 use rustc_data_structures::fx::FxHasher;
@@ -588,10 +588,9 @@ fn reduce_exprkind<'hir>(cx: &LateContext<'_>, kind: &'hir ExprKind<'hir>) -> &'
             // block with an empty span.
             ([], None) if block.span.is_empty() => &ExprKind::Tup(&[]),
             // `{}` => `()`
-            ([], None) => match snippet_opt(cx, block.span) {
-                // Don't reduce if there are any tokens contained in the braces
-                Some(snip)
-                    if tokenize(&snip)
+            ([], None)
+                if block.span.check_source_text(cx, |src| {
+                    tokenize(src)
                         .map(|t| t.kind)
                         .filter(|t| {
                             !matches!(
@@ -599,11 +598,10 @@ fn reduce_exprkind<'hir>(cx: &LateContext<'_>, kind: &'hir ExprKind<'hir>) -> &'
                                 TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace
                             )
                         })
-                        .ne([TokenKind::OpenBrace, TokenKind::CloseBrace].iter().copied()) =>
-                {
-                    kind
-                },
-                _ => &ExprKind::Tup(&[]),
+                        .eq([TokenKind::OpenBrace, TokenKind::CloseBrace].iter().copied())
+                }) =>
+            {
+                &ExprKind::Tup(&[])
             },
             ([], Some(expr)) => match expr.kind {
                 // `{ return .. }` => `return ..`

From b509b4226b371a7df226532e253604fb113a9489 Mon Sep 17 00:00:00 2001
From: Krasimir Georgiev <krasimir@google.com>
Date: Wed, 21 Aug 2024 09:58:11 +0000
Subject: [PATCH 485/685] llvm-wrapper: adapt for LLVM 20 API changes

No functional changes intended.

Adapts llvm-wrapper for the LLVM commits https://github.com/llvm/llvm-project/commit/0f22d47a7a1f70ec77ea8ccdf08a6487827937db and https://github.com/llvm/llvm-project/commit/d6d8243dcd4ea768549904036ed31b8e59e14c73.
---
 compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 283c4fbbb7cf4..9884ed15b8a1f 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -1607,8 +1607,13 @@ extern "C" void LLVMRustComputeLTOCacheKey(RustStringRef KeyOut,
   const auto &ExportList = Data->ExportLists.lookup(ModId);
   const auto &ResolvedODR = Data->ResolvedODR.lookup(ModId);
   const auto &DefinedGlobals = Data->ModuleToDefinedGVSummaries.lookup(ModId);
+#if LLVM_VERSION_GE(20, 0)
+  DenseSet<GlobalValue::GUID> CfiFunctionDefs;
+  DenseSet<GlobalValue::GUID> CfiFunctionDecls;
+#else
   std::set<GlobalValue::GUID> CfiFunctionDefs;
   std::set<GlobalValue::GUID> CfiFunctionDecls;
+#endif
 
   // Based on the 'InProcessThinBackend' constructor in LLVM
   for (auto &Name : Data->Index.cfiFunctionDefs())
@@ -1618,9 +1623,15 @@ extern "C" void LLVMRustComputeLTOCacheKey(RustStringRef KeyOut,
     CfiFunctionDecls.insert(
         GlobalValue::getGUID(GlobalValue::dropLLVMManglingEscape(Name)));
 
+#if LLVM_VERSION_GE(20, 0)
+  Key = llvm::computeLTOCacheKey(conf, Data->Index, ModId, ImportList,
+                                 ExportList, ResolvedODR, DefinedGlobals,
+                                 CfiFunctionDefs, CfiFunctionDecls);
+#else
   llvm::computeLTOCacheKey(Key, conf, Data->Index, ModId, ImportList,
                            ExportList, ResolvedODR, DefinedGlobals,
                            CfiFunctionDefs, CfiFunctionDecls);
+#endif
 
   LLVMRustStringWriteImpl(KeyOut, Key.c_str(), Key.size());
 }

From f5bae722be1f81f70d92e30cec1930f7cefc6313 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Mon, 12 Aug 2024 22:57:14 +0000
Subject: [PATCH 486/685] Point at explicit `'static` obligations on a trait

Given `trait Any: 'static` and a `struct` with a `Box<dyn Any + 'a>` field, point at the `'static` bound in `Any` to explain why `'a: 'static`.

```
error[E0478]: lifetime bound not satisfied
   --> f202.rs:2:12
    |
2   |     value: Box<dyn std::any::Any + 'a>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
note: lifetime parameter instantiated with the lifetime `'a` as defined here
   --> f202.rs:1:14
    |
1   | struct Hello<'a> {
    |              ^^
note: but lifetime parameter must outlive the static lifetime
   --> /home/gh-estebank/rust/library/core/src/any.rs:113:16
    |
113 | pub trait Any: 'static {
    |                ^^^^^^^
```

Partially address #33652.
---
 .../rustc_hir_analysis/src/check/wfcheck.rs   |  2 +-
 compiler/rustc_infer/src/infer/context.rs     |  2 +-
 compiler/rustc_infer/src/infer/mod.rs         | 10 ++++--
 .../nice_region_error/placeholder_relation.rs |  2 +-
 .../src/error_reporting/infer/note.rs         |  4 +--
 .../src/error_reporting/infer/region.rs       | 26 +++++++++++++--
 .../regions/explicit-static-bound-on-trait.rs | 13 ++++++++
 .../explicit-static-bound-on-trait.stderr     | 32 +++++++++++++++++++
 8 files changed, 80 insertions(+), 11 deletions(-)
 create mode 100644 tests/ui/regions/explicit-static-bound-on-trait.rs
 create mode 100644 tests/ui/regions/explicit-static-bound-on-trait.stderr

diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index bdf2914fc50c6..6e6e0e90219e5 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -747,7 +747,7 @@ fn region_known_to_outlive<'tcx>(
     region_b: ty::Region<'tcx>,
 ) -> bool {
     test_region_obligations(tcx, id, param_env, wf_tys, |infcx| {
-        infcx.sub_regions(infer::RelateRegionParamBound(DUMMY_SP), region_b, region_a);
+        infcx.sub_regions(infer::RelateRegionParamBound(DUMMY_SP, None), region_b, region_a);
     })
 }
 
diff --git a/compiler/rustc_infer/src/infer/context.rs b/compiler/rustc_infer/src/infer/context.rs
index f35a8162d96f1..95888beb6b198 100644
--- a/compiler/rustc_infer/src/infer/context.rs
+++ b/compiler/rustc_infer/src/infer/context.rs
@@ -167,7 +167,7 @@ impl<'tcx> InferCtxtLike for InferCtxt<'tcx> {
     }
 
     fn sub_regions(&self, sub: ty::Region<'tcx>, sup: ty::Region<'tcx>) {
-        self.sub_regions(SubregionOrigin::RelateRegionParamBound(DUMMY_SP), sub, sup)
+        self.sub_regions(SubregionOrigin::RelateRegionParamBound(DUMMY_SP, None), sub, sup)
     }
 
     fn register_ty_outlives(&self, ty: Ty<'tcx>, r: ty::Region<'tcx>) {
diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs
index f2fc25a2d2e10..5aa7f25968534 100644
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -390,7 +390,7 @@ pub enum SubregionOrigin<'tcx> {
 
     /// The given region parameter was instantiated with a region
     /// that must outlive some other region.
-    RelateRegionParamBound(Span),
+    RelateRegionParamBound(Span, Option<Ty<'tcx>>),
 
     /// Creating a pointer `b` to contents of another reference.
     Reborrow(Span),
@@ -859,7 +859,7 @@ impl<'tcx> InferCtxt<'tcx> {
     ) {
         self.enter_forall(predicate, |ty::OutlivesPredicate(r_a, r_b)| {
             let origin = SubregionOrigin::from_obligation_cause(cause, || {
-                RelateRegionParamBound(cause.span)
+                RelateRegionParamBound(cause.span, None)
             });
             self.sub_regions(origin, r_b, r_a); // `b : a` ==> `a <= b`
         })
@@ -1685,7 +1685,7 @@ impl<'tcx> SubregionOrigin<'tcx> {
             Subtype(ref a) => a.span(),
             RelateObjectBound(a) => a,
             RelateParamBound(a, ..) => a,
-            RelateRegionParamBound(a) => a,
+            RelateRegionParamBound(a, _) => a,
             Reborrow(a) => a,
             ReferenceOutlivesReferent(_, a) => a,
             CompareImplItemObligation { span, .. } => span,
@@ -1726,6 +1726,10 @@ impl<'tcx> SubregionOrigin<'tcx> {
                 SubregionOrigin::AscribeUserTypeProvePredicate(span)
             }
 
+            traits::ObligationCauseCode::ObjectTypeBound(ty, _reg) => {
+                SubregionOrigin::RelateRegionParamBound(cause.span, Some(ty))
+            }
+
             _ => default(),
         }
     }
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_relation.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_relation.rs
index 9c772f42ccaa3..f2a7da707b81a 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_relation.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_relation.rs
@@ -11,7 +11,7 @@ impl<'tcx> NiceRegionError<'_, 'tcx> {
     pub(super) fn try_report_placeholder_relation(&self) -> Option<Diag<'tcx>> {
         match &self.error {
             Some(RegionResolutionError::ConcreteFailure(
-                SubregionOrigin::RelateRegionParamBound(span),
+                SubregionOrigin::RelateRegionParamBound(span, _),
                 Region(Interned(
                     RePlaceholder(ty::Placeholder {
                         bound: ty::BoundRegion { kind: sub_name, .. },
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/note.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/note.rs
index 04e1be22a4d06..600da730845e8 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/note.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/note.rs
@@ -52,7 +52,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         .add_to_diag(err);
                 }
             }
-            infer::RelateRegionParamBound(span) => {
+            infer::RelateRegionParamBound(span, _) => {
                 RegionOriginNote::Plain { span, msg: fluent::infer_relate_region_param_bound }
                     .add_to_diag(err);
             }
@@ -199,7 +199,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     note,
                 })
             }
-            infer::RelateRegionParamBound(span) => {
+            infer::RelateRegionParamBound(span, _) => {
                 let param_instantiated = note_and_explain::RegionExplanation::new(
                     self.tcx,
                     generic_param_scope,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
index 877a8a23d7f2b..765237557d9b3 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
@@ -257,7 +257,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     .add_to_diag(err);
                 }
             }
-            infer::RelateRegionParamBound(span) => {
+            infer::RelateRegionParamBound(span, _) => {
                 RegionOriginNote::Plain {
                     span,
                     msg: fluent::trait_selection_relate_region_param_bound,
@@ -410,7 +410,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     note,
                 })
             }
-            infer::RelateRegionParamBound(span) => {
+            infer::RelateRegionParamBound(span, ty) => {
                 let param_instantiated = note_and_explain::RegionExplanation::new(
                     self.tcx,
                     generic_param_scope,
@@ -419,11 +419,31 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     note_and_explain::PrefixKind::LfParamInstantiatedWith,
                     note_and_explain::SuffixKind::Empty,
                 );
+                let mut alt_span = None;
+                if let Some(ty) = ty
+                    && sub.is_static()
+                    && let ty::Dynamic(preds, _, ty::DynKind::Dyn) = ty.kind()
+                    && let Some(def_id) = preds.principal_def_id()
+                {
+                    for (clause, span) in
+                        self.tcx.predicates_of(def_id).instantiate_identity(self.tcx)
+                    {
+                        if let ty::ClauseKind::TypeOutlives(ty::OutlivesPredicate(a, b)) =
+                            clause.kind().skip_binder()
+                            && let ty::Param(param) = a.kind()
+                            && param.name == kw::SelfUpper
+                            && b.is_static()
+                        {
+                            // Point at explicit `'static` bound on the trait (`trait T: 'static`).
+                            alt_span = Some(span);
+                        }
+                    }
+                }
                 let param_must_outlive = note_and_explain::RegionExplanation::new(
                     self.tcx,
                     generic_param_scope,
                     sub,
-                    None,
+                    alt_span,
                     note_and_explain::PrefixKind::LfParamMustOutlive,
                     note_and_explain::SuffixKind::Empty,
                 );
diff --git a/tests/ui/regions/explicit-static-bound-on-trait.rs b/tests/ui/regions/explicit-static-bound-on-trait.rs
new file mode 100644
index 0000000000000..835da34d1bbf9
--- /dev/null
+++ b/tests/ui/regions/explicit-static-bound-on-trait.rs
@@ -0,0 +1,13 @@
+struct Hello<'a> {
+    value: Box<dyn std::any::Any + 'a>,
+    //~^ ERROR lifetime bound not satisfied
+}
+
+impl<'a> Hello<'a> {
+    fn new<T: 'a>(value: T) -> Self {
+        Self { value: Box::new(value) }
+        //~^ ERROR the parameter type `T` may not live long enough
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/regions/explicit-static-bound-on-trait.stderr b/tests/ui/regions/explicit-static-bound-on-trait.stderr
new file mode 100644
index 0000000000000..30d39c6e86e95
--- /dev/null
+++ b/tests/ui/regions/explicit-static-bound-on-trait.stderr
@@ -0,0 +1,32 @@
+error[E0478]: lifetime bound not satisfied
+  --> $DIR/explicit-static-bound-on-trait.rs:2:12
+   |
+LL |     value: Box<dyn std::any::Any + 'a>,
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: lifetime parameter instantiated with the lifetime `'a` as defined here
+  --> $DIR/explicit-static-bound-on-trait.rs:1:14
+   |
+LL | struct Hello<'a> {
+   |              ^^
+note: but lifetime parameter must outlive the static lifetime
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+
+error[E0310]: the parameter type `T` may not live long enough
+  --> $DIR/explicit-static-bound-on-trait.rs:8:23
+   |
+LL |         Self { value: Box::new(value) }
+   |                       ^^^^^^^^^^^^^^^
+   |                       |
+   |                       the parameter type `T` must be valid for the static lifetime...
+   |                       ...so that the type `T` will meet its required lifetime bounds
+   |
+help: consider adding an explicit lifetime bound
+   |
+LL |     fn new<T: 'a + 'static>(value: T) -> Self {
+   |                  +++++++++
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0310, E0478.
+For more information about an error, try `rustc --explain E0310`.

From b6909ce61e580d7e57c2539d9ae36437bfdb091d Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Wed, 21 Aug 2024 19:05:35 +0200
Subject: [PATCH 487/685] Force `LC_ALL=C` for all run-make tests

---
 src/tools/run-make-support/src/run.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/tools/run-make-support/src/run.rs b/src/tools/run-make-support/src/run.rs
index 12088e5d3b5ae..3eeba6fd5263d 100644
--- a/src/tools/run-make-support/src/run.rs
+++ b/src/tools/run-make-support/src/run.rs
@@ -29,6 +29,7 @@ fn run_common(name: &str, args: Option<&[&str]>) -> Command {
         }
         env::join_paths(paths.iter()).unwrap()
     });
+    cmd.env("LC_ALL", "C"); // force english locale
 
     if is_windows() {
         let mut paths = vec![];
@@ -84,5 +85,6 @@ pub fn run_fail(name: &str) -> CompletedProcess {
 pub fn cmd<S: AsRef<OsStr>>(program: S) -> Command {
     let mut command = Command::new(program);
     set_host_rpath(&mut command);
+    command.env("LC_ALL", "C"); // force english locale
     command
 }

From e2328ebd7f37fdfa5059fa8da954d198f6f744f7 Mon Sep 17 00:00:00 2001
From: Jack Wrenn <jack@wrenn.fyi>
Date: Wed, 21 Aug 2024 17:01:32 +0000
Subject: [PATCH 488/685] safe transmute: gracefully bubble-up layout errors

Changes `.unwrap()`s to `?` to avoid ICEs. Adds ui tests.

Fixes #129327
---
 compiler/rustc_transmute/src/layout/tree.rs   | 18 +++-----
 .../src/maybe_transmutable/mod.rs             | 13 ++----
 .../ui/transmutability/arrays/huge-len.stderr |  4 +-
 .../unknown_dst_field.rs                      | 26 +++++++++++
 .../unknown_dst_field.stderr                  | 46 +++++++++++++++++++
 .../unknown_src_field.rs                      | 12 +++--
 .../unknown_src_field.stderr                  | 31 +++++++++++--
 .../transmute_infinitely_recursive_type.rs    |  1 -
 ...transmute_infinitely_recursive_type.stderr | 19 +-------
 9 files changed, 121 insertions(+), 49 deletions(-)
 create mode 100644 tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.rs
 create mode 100644 tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.stderr

diff --git a/compiler/rustc_transmute/src/layout/tree.rs b/compiler/rustc_transmute/src/layout/tree.rs
index 7c73f74e6290b..2c67e7d4847ac 100644
--- a/compiler/rustc_transmute/src/layout/tree.rs
+++ b/compiler/rustc_transmute/src/layout/tree.rs
@@ -179,7 +179,7 @@ pub(crate) mod rustc {
     };
 
     use super::Tree;
-    use crate::layout::rustc::{Def, Ref};
+    use crate::layout::rustc::{layout_of, Def, Ref};
 
     #[derive(Debug, Copy, Clone)]
     pub(crate) enum Err {
@@ -206,7 +206,7 @@ pub(crate) mod rustc {
     impl<'tcx> Tree<Def<'tcx>, Ref<'tcx>> {
         pub fn from_ty(ty: Ty<'tcx>, cx: LayoutCx<'tcx, TyCtxt<'tcx>>) -> Result<Self, Err> {
             use rustc_target::abi::HasDataLayout;
-            let layout = ty_layout(cx, ty);
+            let layout = layout_of(cx, ty)?;
 
             if let Err(e) = ty.error_reported() {
                 return Err(Err::TypeError(e));
@@ -239,7 +239,7 @@ pub(crate) mod rustc {
                     let FieldsShape::Array { stride, count } = &layout.fields else {
                         return Err(Err::NotYetSupported);
                     };
-                    let inner_layout = ty_layout(cx, *inner_ty);
+                    let inner_layout = layout_of(cx, *inner_ty)?;
                     assert_eq!(*stride, inner_layout.size);
                     let elt = Tree::from_ty(*inner_ty, cx)?;
                     Ok(std::iter::repeat(elt)
@@ -254,7 +254,7 @@ pub(crate) mod rustc {
                 },
 
                 ty::Ref(lifetime, ty, mutability) => {
-                    let layout = ty_layout(cx, *ty);
+                    let layout = layout_of(cx, *ty)?;
                     let align = layout.align.abi.bytes_usize();
                     let size = layout.size.bytes_usize();
                     Ok(Tree::Ref(Ref {
@@ -280,7 +280,7 @@ pub(crate) mod rustc {
                 FieldsShape::Primitive => {
                     assert_eq!(members.len(), 1);
                     let inner_ty = members[0];
-                    let inner_layout = ty_layout(cx, inner_ty);
+                    let inner_layout = layout_of(cx, inner_ty)?;
                     Self::from_ty(inner_ty, cx)
                 }
                 FieldsShape::Arbitrary { offsets, .. } => {
@@ -413,7 +413,7 @@ pub(crate) mod rustc {
                 let padding = Self::padding(padding_needed.bytes_usize());
 
                 let field_ty = ty_field(cx, (ty, layout), field_idx);
-                let field_layout = ty_layout(cx, field_ty);
+                let field_layout = layout_of(cx, field_ty)?;
                 let field_tree = Self::from_ty(field_ty, cx)?;
 
                 struct_tree = struct_tree.then(padding).then(field_tree);
@@ -471,7 +471,7 @@ pub(crate) mod rustc {
                 |fields, (idx, field_def)| {
                     let field_def = Def::Field(field_def);
                     let field_ty = ty_field(cx, (ty, layout), idx);
-                    let field_layout = ty_layout(cx, field_ty);
+                    let field_layout = layout_of(cx, field_ty)?;
                     let field = Self::from_ty(field_ty, cx)?;
                     let trailing_padding_needed = layout.size - field_layout.size;
                     let trailing_padding = Self::padding(trailing_padding_needed.bytes_usize());
@@ -484,10 +484,6 @@ pub(crate) mod rustc {
         }
     }
 
-    pub(crate) fn ty_layout<'tcx>(cx: LayoutCx<'tcx, TyCtxt<'tcx>>, ty: Ty<'tcx>) -> Layout<'tcx> {
-        crate::layout::rustc::layout_of(cx, ty).unwrap()
-    }
-
     fn ty_field<'tcx>(
         cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
         (ty, layout): (Ty<'tcx>, Layout<'tcx>),
diff --git a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
index 1f3c4e3c817de..2762b4e638405 100644
--- a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
+++ b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
@@ -44,18 +44,11 @@ mod rustc {
             let Self { src, dst, assume, context } = self;
 
             let layout_cx = LayoutCx { tcx: context, param_env: ParamEnv::reveal_all() };
-            let layout_of = |ty| {
-                crate::layout::rustc::layout_of(layout_cx, ty)
-                    .map_err(|_| Err::NotYetSupported)
-                    .and_then(|_| Tree::from_ty(ty, layout_cx))
-            };
 
             // Convert `src` and `dst` from their rustc representations, to `Tree`-based
-            // representations. If these conversions fail, conclude that the transmutation is
-            // unacceptable; the layouts of both the source and destination types must be
-            // well-defined.
-            let src = layout_of(src);
-            let dst = layout_of(dst);
+            // representations.
+            let src = Tree::from_ty(src, layout_cx);
+            let dst = Tree::from_ty(dst, layout_cx);
 
             match (src, dst) {
                 (Err(Err::TypeError(_)), _) | (_, Err(Err::TypeError(_))) => {
diff --git a/tests/ui/transmutability/arrays/huge-len.stderr b/tests/ui/transmutability/arrays/huge-len.stderr
index 3fc652f47c12b..37160c5c9596b 100644
--- a/tests/ui/transmutability/arrays/huge-len.stderr
+++ b/tests/ui/transmutability/arrays/huge-len.stderr
@@ -2,7 +2,7 @@ error[E0277]: `()` cannot be safely transmuted into `ExplicitlyPadded`
   --> $DIR/huge-len.rs:21:41
    |
 LL |     assert::is_maybe_transmutable::<(), ExplicitlyPadded>();
-   |                                         ^^^^^^^^^^^^^^^^ analyzing the transmutability of `ExplicitlyPadded` is not yet supported
+   |                                         ^^^^^^^^^^^^^^^^ values of the type `ExplicitlyPadded` are too big for the current architecture
    |
 note: required by a bound in `is_maybe_transmutable`
   --> $DIR/huge-len.rs:8:14
@@ -17,7 +17,7 @@ error[E0277]: `ExplicitlyPadded` cannot be safely transmuted into `()`
   --> $DIR/huge-len.rs:24:55
    |
 LL |     assert::is_maybe_transmutable::<ExplicitlyPadded, ()>();
-   |                                                       ^^ analyzing the transmutability of `ExplicitlyPadded` is not yet supported
+   |                                                       ^^ values of the type `ExplicitlyPadded` are too big for the current architecture
    |
 note: required by a bound in `is_maybe_transmutable`
   --> $DIR/huge-len.rs:8:14
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.rs b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.rs
new file mode 100644
index 0000000000000..8c18de111967f
--- /dev/null
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.rs
@@ -0,0 +1,26 @@
+// An unknown destination type should be gracefully handled.
+
+#![crate_type = "lib"]
+#![feature(transmutability)]
+#![allow(incomplete_features)]
+
+mod assert {
+    use std::mem::BikeshedIntrinsicFrom;
+
+    pub fn is_transmutable<Src, Dst>()
+    where
+        Dst: BikeshedIntrinsicFrom<Src>
+    {}
+}
+
+fn should_gracefully_handle_unknown_dst_field() {
+    #[repr(C)] struct Src;
+    #[repr(C)] struct Dst(Missing); //~ cannot find type
+    assert::is_transmutable::<Src, Dst>(); //~ ERROR cannot be safely transmuted
+}
+
+fn should_gracefully_handle_unknown_dst_ref_field() {
+    #[repr(C)] struct Src(&'static Src);
+    #[repr(C)] struct Dst(&'static Missing); //~ cannot find type
+    assert::is_transmutable::<Src, Dst>(); //~ ERROR cannot be safely transmuted
+}
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.stderr b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.stderr
new file mode 100644
index 0000000000000..df10919f6d3f0
--- /dev/null
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.stderr
@@ -0,0 +1,46 @@
+error[E0412]: cannot find type `Missing` in this scope
+  --> $DIR/unknown_dst_field.rs:18:27
+   |
+LL |     #[repr(C)] struct Dst(Missing);
+   |                           ^^^^^^^ not found in this scope
+
+error[E0412]: cannot find type `Missing` in this scope
+  --> $DIR/unknown_dst_field.rs:24:36
+   |
+LL |     #[repr(C)] struct Dst(&'static Missing);
+   |                                    ^^^^^^^ not found in this scope
+
+error[E0277]: `should_gracefully_handle_unknown_dst_field::Src` cannot be safely transmuted into `should_gracefully_handle_unknown_dst_field::Dst`
+  --> $DIR/unknown_dst_field.rs:19:36
+   |
+LL |     assert::is_transmutable::<Src, Dst>();
+   |                                    ^^^ `should_gracefully_handle_unknown_dst_field::Dst` has an unknown layout
+   |
+note: required by a bound in `is_transmutable`
+  --> $DIR/unknown_dst_field.rs:12:14
+   |
+LL |     pub fn is_transmutable<Src, Dst>()
+   |            --------------- required by a bound in this function
+LL |     where
+LL |         Dst: BikeshedIntrinsicFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+
+error[E0277]: `should_gracefully_handle_unknown_dst_ref_field::Src` cannot be safely transmuted into `should_gracefully_handle_unknown_dst_ref_field::Dst`
+  --> $DIR/unknown_dst_field.rs:25:36
+   |
+LL |     assert::is_transmutable::<Src, Dst>();
+   |                                    ^^^ `should_gracefully_handle_unknown_dst_ref_field::Dst` has an unknown layout
+   |
+note: required by a bound in `is_transmutable`
+  --> $DIR/unknown_dst_field.rs:12:14
+   |
+LL |     pub fn is_transmutable<Src, Dst>()
+   |            --------------- required by a bound in this function
+LL |     where
+LL |         Dst: BikeshedIntrinsicFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+
+error: aborting due to 4 previous errors
+
+Some errors have detailed explanations: E0277, E0412.
+For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.rs b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.rs
index 58c16d773e17a..1da16e67223de 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.rs
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.rs
@@ -13,8 +13,14 @@ mod assert {
     {}
 }
 
-fn should_gracefully_handle_unknown_dst_field() {
-    #[repr(C)] struct Src;
-    #[repr(C)] struct Dst(Missing); //~ cannot find type
+fn should_gracefully_handle_unknown_src_field() {
+    #[repr(C)] struct Src(Missing); //~ cannot find type
+    #[repr(C)] struct Dst();
+    assert::is_transmutable::<Src, Dst>(); //~ ERROR cannot be safely transmuted
+}
+
+fn should_gracefully_handle_unknown_src_ref_field() {
+    #[repr(C)] struct Src(&'static Missing); //~ cannot find type
+    #[repr(C)] struct Dst(&'static Dst);
     assert::is_transmutable::<Src, Dst>(); //~ ERROR cannot be safely transmuted
 }
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.stderr b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.stderr
index cabc7bcfef762..6ec66e1706146 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.stderr
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.stderr
@@ -1,14 +1,35 @@
 error[E0412]: cannot find type `Missing` in this scope
-  --> $DIR/unknown_src_field.rs:18:27
+  --> $DIR/unknown_src_field.rs:17:27
    |
-LL |     #[repr(C)] struct Dst(Missing);
+LL |     #[repr(C)] struct Src(Missing);
    |                           ^^^^^^^ not found in this scope
 
-error[E0277]: `Src` cannot be safely transmuted into `Dst`
+error[E0412]: cannot find type `Missing` in this scope
+  --> $DIR/unknown_src_field.rs:23:36
+   |
+LL |     #[repr(C)] struct Src(&'static Missing);
+   |                                    ^^^^^^^ not found in this scope
+
+error[E0277]: `should_gracefully_handle_unknown_src_field::Src` cannot be safely transmuted into `should_gracefully_handle_unknown_src_field::Dst`
   --> $DIR/unknown_src_field.rs:19:36
    |
 LL |     assert::is_transmutable::<Src, Dst>();
-   |                                    ^^^ analyzing the transmutability of `Dst` is not yet supported
+   |                                    ^^^ `should_gracefully_handle_unknown_src_field::Src` has an unknown layout
+   |
+note: required by a bound in `is_transmutable`
+  --> $DIR/unknown_src_field.rs:12:14
+   |
+LL |     pub fn is_transmutable<Src, Dst>()
+   |            --------------- required by a bound in this function
+LL |     where
+LL |         Dst: BikeshedIntrinsicFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+
+error[E0277]: `should_gracefully_handle_unknown_src_ref_field::Src` cannot be safely transmuted into `should_gracefully_handle_unknown_src_ref_field::Dst`
+  --> $DIR/unknown_src_field.rs:25:36
+   |
+LL |     assert::is_transmutable::<Src, Dst>();
+   |                                    ^^^ `should_gracefully_handle_unknown_src_ref_field::Src` has an unknown layout
    |
 note: required by a bound in `is_transmutable`
   --> $DIR/unknown_src_field.rs:12:14
@@ -19,7 +40,7 @@ LL |     where
 LL |         Dst: BikeshedIntrinsicFrom<Src>
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 
 Some errors have detailed explanations: E0277, E0412.
 For more information about an error, try `rustc --explain E0277`.
diff --git a/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.rs b/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.rs
index 64110753832cb..4c285a616b3d9 100644
--- a/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.rs
+++ b/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.rs
@@ -22,5 +22,4 @@ fn should_pad_explicitly_packed_field() {
     //~^ ERROR: recursive type
 
     assert::is_maybe_transmutable::<ExplicitlyPadded, ()>();
-    //~^ ERROR: cannot be safely transmuted
 }
diff --git a/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.stderr b/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.stderr
index ebfb536114367..7fb051f66250e 100644
--- a/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.stderr
+++ b/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.stderr
@@ -15,22 +15,7 @@ error[E0391]: cycle detected when computing layout of `should_pad_explicitly_pac
    = note: cycle used when evaluating trait selection obligation `(): core::mem::transmutability::BikeshedIntrinsicFrom<should_pad_explicitly_packed_field::ExplicitlyPadded, core::mem::transmutability::Assume { alignment: false, lifetimes: false, safety: false, validity: false }>`
    = 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[E0277]: `ExplicitlyPadded` cannot be safely transmuted into `()`
-  --> $DIR/transmute_infinitely_recursive_type.rs:24:55
-   |
-LL |     assert::is_maybe_transmutable::<ExplicitlyPadded, ()>();
-   |                                                       ^^ analyzing the transmutability of `ExplicitlyPadded` is not yet supported
-   |
-note: required by a bound in `is_maybe_transmutable`
-  --> $DIR/transmute_infinitely_recursive_type.rs:14:14
-   |
-LL |     pub fn is_maybe_transmutable<Src, Dst>()
-   |            --------------------- required by a bound in this function
-LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>,
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
 
-Some errors have detailed explanations: E0072, E0277, E0391.
+Some errors have detailed explanations: E0072, E0391.
 For more information about an error, try `rustc --explain E0072`.

From fbdc191fdc71faa65f38c35c7b3d97ba992fa9a7 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 21 Aug 2024 16:16:48 +0200
Subject: [PATCH 489/685] epoll test: avoid some subtly dangling pointers

---
 .../miri/tests/pass-dep/libc/libc-epoll.rs    | 28 +++----------------
 1 file changed, 4 insertions(+), 24 deletions(-)

diff --git a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
index e28cafd3c285b..052ce73de237f 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-epoll.rs
@@ -1,8 +1,7 @@
 //@only-target-linux
 
-#![feature(exposed_provenance)] // Needed for fn test_pointer()
+#![feature(strict_provenance)]
 use std::convert::TryInto;
-use std::mem::MaybeUninit;
 
 fn main() {
     test_epoll_socketpair();
@@ -17,7 +16,6 @@ fn main() {
     test_no_notification_for_unregister_flag();
     test_epoll_ctl_mod();
     test_epoll_ctl_del();
-    test_pointer();
     test_two_same_fd_in_same_epoll_instance();
     test_epoll_wait_maxevent_zero();
     test_socketpair_epollerr();
@@ -261,24 +259,6 @@ fn test_epoll_eventfd() {
     check_epoll_wait::<8>(epfd, &[(expected_event, expected_value)]);
 }
 
-fn test_pointer() {
-    // Create an epoll instance.
-    let epfd = unsafe { libc::epoll_create1(0) };
-    assert_ne!(epfd, -1);
-
-    // Create a socketpair instance.
-    let mut fds = [-1, -1];
-    let res = unsafe { libc::socketpair(libc::AF_UNIX, libc::SOCK_STREAM, 0, fds.as_mut_ptr()) };
-    assert_eq!(res, 0);
-
-    // Register fd[1] with EPOLLIN|EPOLLOUT|EPOLLET
-    let data = MaybeUninit::<u64>::uninit().as_ptr();
-    let mut ev =
-        libc::epoll_event { events: EPOLL_IN_OUT_ET, u64: data.expose_provenance() as u64 };
-    let res = unsafe { libc::epoll_ctl(epfd, libc::EPOLL_CTL_ADD, fds[1], &mut ev) };
-    assert_eq!(res, 0);
-}
-
 // When read/write happened on one side of the socketpair, only the other side will be notified.
 fn test_epoll_socketpair_both_sides() {
     // Create an epoll instance.
@@ -543,9 +523,9 @@ fn test_epoll_wait_maxevent_zero() {
     // Create an epoll instance.
     let epfd = unsafe { libc::epoll_create1(0) };
     assert_ne!(epfd, -1);
-    // It is ok to use uninitialised pointer here because it will error out before the
-    // pointer actually get accessed.
-    let array_ptr = MaybeUninit::<libc::epoll_event>::uninit().as_mut_ptr();
+    // It is ok to use a dangling pointer here because it will error out before the
+    // pointer actually gets accessed.
+    let array_ptr = std::ptr::without_provenance_mut::<libc::epoll_event>(0x100);
     let res = unsafe { libc::epoll_wait(epfd, array_ptr, 0, 0) };
     let e = std::io::Error::last_os_error();
     assert_eq!(e.raw_os_error(), Some(libc::EINVAL));

From 9450b4af483b4b10fe427c1436e75acc9ba68158 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Wed, 21 Aug 2024 14:04:04 -0400
Subject: [PATCH 490/685] Replace more uses of `snippet_opt`.

---
 clippy_lints/src/casts/cast_lossless.rs       |  4 +-
 clippy_lints/src/casts/unnecessary_cast.rs    |  8 +-
 clippy_lints/src/casts/zero_ptr.rs            |  4 +-
 clippy_lints/src/functions/must_use.rs        |  4 +-
 clippy_lints/src/functions/too_many_lines.rs  | 91 +++++++++----------
 clippy_lints/src/matches/manual_unwrap_or.rs  |  8 +-
 ...se_sensitive_file_extension_comparisons.rs | 12 ++-
 .../src/methods/filter_map_bool_then.rs       |  8 +-
 .../methods/from_iter_instead_of_collect.rs   |  4 +-
 .../src/methods/join_absolute_paths.rs        |  4 +-
 clippy_lints/src/methods/manual_ok_or.rs      |  8 +-
 clippy_lints/src/methods/manual_try_fold.rs   | 10 +-
 .../methods/needless_character_iteration.rs   |  6 +-
 .../src/methods/needless_option_as_deref.rs   |  4 +-
 .../src/methods/string_lit_chars_any.rs       |  4 +-
 .../src/methods/unnecessary_get_then_check.rs | 10 +-
 .../src/methods/unnecessary_to_owned.rs       | 18 ++--
 .../src/methods/unused_enumerate_index.rs     | 12 ++-
 clippy_lints/src/vec.rs                       |  8 +-
 clippy_utils/src/source.rs                    |  7 +-
 20 files changed, 125 insertions(+), 109 deletions(-)

diff --git a/clippy_lints/src/casts/cast_lossless.rs b/clippy_lints/src/casts/cast_lossless.rs
index bd3acc06f4b2b..346aed7e9f117 100644
--- a/clippy_lints/src/casts/cast_lossless.rs
+++ b/clippy_lints/src/casts/cast_lossless.rs
@@ -1,7 +1,7 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::is_in_const_context;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::is_isize_or_usize;
 use rustc_errors::Applicability;
@@ -34,7 +34,7 @@ pub(super) fn check(
             diag.help("an `as` cast can become silently lossy if the types change in the future");
             let mut applicability = Applicability::MachineApplicable;
             let from_sugg = Sugg::hir_with_context(cx, cast_from_expr, expr.span.ctxt(), "<from>", &mut applicability);
-            let Some(ty) = snippet_opt(cx, hygiene::walk_chain(cast_to_hir.span, expr.span.ctxt())) else {
+            let Some(ty) = hygiene::walk_chain(cast_to_hir.span, expr.span.ctxt()).get_source_text(cx) else {
                 return;
             };
             match cast_to_hir.kind {
diff --git a/clippy_lints/src/casts/unnecessary_cast.rs b/clippy_lints/src/casts/unnecessary_cast.rs
index fb0b0cba6a662..566adc83d6903 100644
--- a/clippy_lints/src/casts/unnecessary_cast.rs
+++ b/clippy_lints/src/casts/unnecessary_cast.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::numeric_literal::NumericLiteral;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::{snippet_opt, SpanRangeExt};
 use clippy_utils::visitors::{for_each_expr_without_closures, Visitable};
 use clippy_utils::{get_parent_expr, is_hir_ty_cfg_dependant, is_ty_alias, path_to_local};
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
@@ -104,7 +104,7 @@ pub(super) fn check<'tcx>(
         let literal_str = &cast_str;
 
         if let LitKind::Int(n, _) = lit.node
-            && let Some(src) = snippet_opt(cx, cast_expr.span)
+            && let Some(src) = cast_expr.span.get_source_text(cx)
             && cast_to.is_floating_point()
             && let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node)
             && let from_nbits = 128 - n.get().leading_zeros()
@@ -131,7 +131,7 @@ pub(super) fn check<'tcx>(
             | LitKind::Float(_, LitFloatType::Suffixed(_))
                 if cast_from.kind() == cast_to.kind() =>
             {
-                if let Some(src) = snippet_opt(cx, cast_expr.span) {
+                if let Some(src) = cast_expr.span.get_source_text(cx) {
                     if let Some(num_lit) = NumericLiteral::from_lit_kind(&src, &lit.node) {
                         lint_unnecessary_cast(cx, expr, num_lit.integer, cast_from, cast_to);
                         return true;
@@ -253,7 +253,7 @@ fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx
             let res = cx.qpath_res(&qpath, expr.hir_id);
             // Function call
             if let Res::Def(DefKind::Fn, def_id) = res {
-                let Some(snippet) = snippet_opt(cx, cx.tcx.def_span(def_id)) else {
+                let Some(snippet) = cx.tcx.def_span(def_id).get_source_text(cx) else {
                     return ControlFlow::Continue(());
                 };
                 // This is the worst part of this entire function. This is the only way I know of to
diff --git a/clippy_lints/src/casts/zero_ptr.rs b/clippy_lints/src/casts/zero_ptr.rs
index 3c1c7d2dc3a54..c5c4a28646d27 100644
--- a/clippy_lints/src/casts/zero_ptr.rs
+++ b/clippy_lints/src/casts/zero_ptr.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::{is_in_const_context, is_integer_literal, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, Mutability, Ty, TyKind};
@@ -20,7 +20,7 @@ pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, from: &Expr<'_>, to: &Ty<'_>
 
         let sugg = if let TyKind::Infer = mut_ty.ty.kind {
             format!("{std_or_core}::{sugg_fn}()")
-        } else if let Some(mut_ty_snip) = snippet_opt(cx, mut_ty.ty.span) {
+        } else if let Some(mut_ty_snip) = mut_ty.ty.span.get_source_text(cx) {
             format!("{std_or_core}::{sugg_fn}::<{mut_ty_snip}>()")
         } else {
             return;
diff --git a/clippy_lints/src/functions/must_use.rs b/clippy_lints/src/functions/must_use.rs
index a08415aeb98a1..9382812104706 100644
--- a/clippy_lints/src/functions/must_use.rs
+++ b/clippy_lints/src/functions/must_use.rs
@@ -12,7 +12,7 @@ use rustc_span::{sym, Span};
 
 use clippy_utils::attrs::is_proc_macro;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::is_must_use_ty;
 use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{return_ty, trait_ref_of_method};
@@ -155,7 +155,7 @@ fn check_must_use_candidate<'tcx>(
         return;
     }
     span_lint_and_then(cx, MUST_USE_CANDIDATE, fn_span, msg, |diag| {
-        if let Some(snippet) = snippet_opt(cx, fn_span) {
+        if let Some(snippet) = fn_span.get_source_text(cx) {
             diag.span_suggestion(
                 fn_span,
                 "add the attribute",
diff --git a/clippy_lints/src/functions/too_many_lines.rs b/clippy_lints/src/functions/too_many_lines.rs
index 586ca58d60dd6..0f5ce340c44dd 100644
--- a/clippy_lints/src/functions/too_many_lines.rs
+++ b/clippy_lints/src/functions/too_many_lines.rs
@@ -1,12 +1,11 @@
+use clippy_utils::diagnostics::span_lint;
+use clippy_utils::source::SpanRangeExt;
 use rustc_hir as hir;
 use rustc_hir::intravisit::FnKind;
 use rustc_lint::{LateContext, LintContext};
 use rustc_middle::lint::in_external_macro;
 use rustc_span::Span;
 
-use clippy_utils::diagnostics::span_lint;
-use clippy_utils::source::snippet_opt;
-
 use super::TOO_MANY_LINES;
 
 pub(super) fn check_fn(
@@ -22,57 +21,57 @@ pub(super) fn check_fn(
         return;
     }
 
-    let Some(code_snippet) = snippet_opt(cx, body.value.span) else {
-        return;
-    };
     let mut line_count: u64 = 0;
-    let mut in_comment = false;
-    let mut code_in_line;
+    let too_many = body.value.span.check_source_text(cx, |src| {
+        let mut in_comment = false;
+        let mut code_in_line;
 
-    let function_lines = if matches!(body.value.kind, hir::ExprKind::Block(..))
-        && code_snippet.as_bytes().first().copied() == Some(b'{')
-        && code_snippet.as_bytes().last().copied() == Some(b'}')
-    {
-        // Removing the braces from the enclosing block
-        &code_snippet[1..code_snippet.len() - 1]
-    } else {
-        &code_snippet
-    }
-    .trim() // Remove leading and trailing blank lines
-    .lines();
+        let function_lines = if matches!(body.value.kind, hir::ExprKind::Block(..))
+            && src.as_bytes().first().copied() == Some(b'{')
+            && src.as_bytes().last().copied() == Some(b'}')
+        {
+            // Removing the braces from the enclosing block
+            &src[1..src.len() - 1]
+        } else {
+            src
+        }
+        .trim() // Remove leading and trailing blank lines
+        .lines();
 
-    for mut line in function_lines {
-        code_in_line = false;
-        loop {
-            line = line.trim_start();
-            if line.is_empty() {
-                break;
-            }
-            if in_comment {
-                if let Some(i) = line.find("*/") {
-                    line = &line[i + 2..];
-                    in_comment = false;
-                    continue;
+        for mut line in function_lines {
+            code_in_line = false;
+            loop {
+                line = line.trim_start();
+                if line.is_empty() {
+                    break;
                 }
-            } else {
-                let multi_idx = line.find("/*").unwrap_or(line.len());
-                let single_idx = line.find("//").unwrap_or(line.len());
-                code_in_line |= multi_idx > 0 && single_idx > 0;
-                // Implies multi_idx is below line.len()
-                if multi_idx < single_idx {
-                    line = &line[multi_idx + 2..];
-                    in_comment = true;
-                    continue;
+                if in_comment {
+                    if let Some(i) = line.find("*/") {
+                        line = &line[i + 2..];
+                        in_comment = false;
+                        continue;
+                    }
+                } else {
+                    let multi_idx = line.find("/*").unwrap_or(line.len());
+                    let single_idx = line.find("//").unwrap_or(line.len());
+                    code_in_line |= multi_idx > 0 && single_idx > 0;
+                    // Implies multi_idx is below line.len()
+                    if multi_idx < single_idx {
+                        line = &line[multi_idx + 2..];
+                        in_comment = true;
+                        continue;
+                    }
                 }
+                break;
+            }
+            if code_in_line {
+                line_count += 1;
             }
-            break;
-        }
-        if code_in_line {
-            line_count += 1;
         }
-    }
+        line_count > too_many_lines_threshold
+    });
 
-    if line_count > too_many_lines_threshold {
+    if too_many {
         span_lint(
             cx,
             TOO_MANY_LINES,
diff --git a/clippy_lints/src/matches/manual_unwrap_or.rs b/clippy_lints/src/matches/manual_unwrap_or.rs
index 2d4c8daf5cb66..d5d83df93471c 100644
--- a/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -1,6 +1,6 @@
 use clippy_utils::consts::ConstEvalCtxt;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
+use clippy_utils::source::{indent_of, reindent_multiline, SpanRangeExt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::contains_return_break_continue_macro;
 use clippy_utils::{is_res_lang_ctor, path_to_local_id, peel_blocks, sugg};
@@ -67,11 +67,11 @@ fn check_and_lint<'tcx>(
         && path_to_local_id(peel_blocks(then_expr), binding_hir_id)
         && cx.typeck_results().expr_adjustments(then_expr).is_empty()
         && let Some(ty_name) = find_type_name(cx, ty)
-        && let Some(or_body_snippet) = snippet_opt(cx, else_expr.span)
+        && let Some(or_body_snippet) = else_expr.span.get_source_text(cx)
         && let Some(indent) = indent_of(cx, expr.span)
         && ConstEvalCtxt::new(cx).eval_simple(else_expr).is_some()
     {
-        lint(cx, expr, let_expr, ty_name, or_body_snippet, indent);
+        lint(cx, expr, let_expr, ty_name, &or_body_snippet, indent);
     }
 }
 
@@ -110,7 +110,7 @@ fn lint<'tcx>(
     expr: &Expr<'tcx>,
     scrutinee: &'tcx Expr<'_>,
     ty_name: &str,
-    or_body_snippet: String,
+    or_body_snippet: &str,
     indent: usize,
 ) {
     let reindented_or_body = reindent_multiline(or_body_snippet.into(), true, Some(indent));
diff --git a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index a5df863d800bb..740cce0a6c235 100644
--- a/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
+use clippy_utils::source::{indent_of, reindent_multiline, SpanRangeExt};
 use clippy_utils::ty::is_type_lang_item;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -49,10 +49,12 @@ pub(super) fn check<'tcx>(
             "case-sensitive file extension comparison",
             |diag| {
                 diag.help("consider using a case-insensitive comparison instead");
-                if let Some(mut recv_source) = snippet_opt(cx, recv.span) {
-                    if !cx.typeck_results().expr_ty(recv).is_ref() {
-                        recv_source = format!("&{recv_source}");
-                    }
+                if let Some(recv_source) = recv.span.get_source_text(cx) {
+                    let recv_source = if cx.typeck_results().expr_ty(recv).is_ref() {
+                        recv_source.to_owned()
+                    } else {
+                        format!("&{recv_source}")
+                    };
 
                     let suggestion_source = reindent_multiline(
                         format!(
diff --git a/clippy_lints/src/methods/filter_map_bool_then.rs b/clippy_lints/src/methods/filter_map_bool_then.rs
index 2e43d19a69911..4fbf661727daa 100644
--- a/clippy_lints/src/methods/filter_map_bool_then.rs
+++ b/clippy_lints/src/methods/filter_map_bool_then.rs
@@ -1,7 +1,7 @@
 use super::FILTER_MAP_BOOL_THEN;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::paths::BOOL_THEN;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::is_copy;
 use clippy_utils::{is_from_proc_macro, is_trait_method, match_def_path, peel_blocks};
 use rustc_errors::Applicability;
@@ -42,9 +42,9 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, arg: &
             .iter()
             .filter(|adj| matches!(adj.kind, Adjust::Deref(_)))
             .count()
-        && let Some(param_snippet) = snippet_opt(cx, param.span)
-        && let Some(filter) = snippet_opt(cx, recv.span)
-        && let Some(map) = snippet_opt(cx, then_body.span)
+        && let Some(param_snippet) = param.span.get_source_text(cx)
+        && let Some(filter) = recv.span.get_source_text(cx)
+        && let Some(map) = then_body.span.get_source_text(cx)
     {
         span_lint_and_sugg(
             cx,
diff --git a/clippy_lints/src/methods/from_iter_instead_of_collect.rs b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
index 917a8e33eb9fb..f4840785584ef 100644
--- a/clippy_lints/src/methods/from_iter_instead_of_collect.rs
+++ b/clippy_lints/src/methods/from_iter_instead_of_collect.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{is_path_diagnostic_item, sugg};
 use rustc_errors::Applicability;
@@ -39,7 +39,7 @@ fn extract_turbofish(cx: &LateContext<'_>, expr: &hir::Expr<'_>, ty: Ty<'_>) ->
     }
 
     let call_site = expr.span.source_callsite();
-    if let Some(snippet) = snippet_opt(cx, call_site)
+    if let Some(snippet) = call_site.get_source_text(cx)
         && let snippet_split = snippet.split("::").collect::<Vec<_>>()
         && let Some((_, elements)) = snippet_split.split_last()
     {
diff --git a/clippy_lints/src/methods/join_absolute_paths.rs b/clippy_lints/src/methods/join_absolute_paths.rs
index aa1ec60d434a5..2dad7fcf3c129 100644
--- a/clippy_lints/src/methods/join_absolute_paths.rs
+++ b/clippy_lints/src/methods/join_absolute_paths.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::expr_or_init;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use rustc_ast::ast::LitKind;
 use rustc_errors::Applicability;
@@ -25,7 +25,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, recv: &'tcx Expr<'tcx>, join_a
             join_arg.span,
             "argument to `Path::join` starts with a path separator",
             |diag| {
-                let arg_str = snippet_opt(cx, spanned.span).unwrap_or_else(|| "..".to_string());
+                let arg_str = snippet(cx, spanned.span, "..");
 
                 let no_separator = if sym_str.starts_with('/') {
                     arg_str.replacen('/', "", 1)
diff --git a/clippy_lints/src/methods/manual_ok_or.rs b/clippy_lints/src/methods/manual_ok_or.rs
index b1af0083e65a9..b1a8e1e5e4709 100644
--- a/clippy_lints/src/methods/manual_ok_or.rs
+++ b/clippy_lints/src/methods/manual_ok_or.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::{indent_of, reindent_multiline, snippet_opt};
+use clippy_utils::source::{indent_of, reindent_multiline, SpanRangeExt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{is_res_lang_ctor, path_res, path_to_local_id};
 use rustc_errors::Applicability;
@@ -23,11 +23,11 @@ pub(super) fn check<'tcx>(
         && let ExprKind::Call(err_path, [err_arg]) = or_expr.kind
         && is_res_lang_ctor(cx, path_res(cx, err_path), ResultErr)
         && is_ok_wrapping(cx, map_expr)
-        && let Some(recv_snippet) = snippet_opt(cx, recv.span)
-        && let Some(err_arg_snippet) = snippet_opt(cx, err_arg.span)
+        && let Some(recv_snippet) = recv.span.get_source_text(cx)
+        && let Some(err_arg_snippet) = err_arg.span.get_source_text(cx)
         && let Some(indent) = indent_of(cx, expr.span)
     {
-        let reindented_err_arg_snippet = reindent_multiline(err_arg_snippet.into(), true, Some(indent + 4));
+        let reindented_err_arg_snippet = reindent_multiline(err_arg_snippet.as_str().into(), true, Some(indent + 4));
         span_lint_and_sugg(
             cx,
             MANUAL_OK_OR,
diff --git a/clippy_lints/src/methods/manual_try_fold.rs b/clippy_lints/src/methods/manual_try_fold.rs
index f93edded729fc..11fba35c16ea3 100644
--- a/clippy_lints/src/methods/manual_try_fold.rs
+++ b/clippy_lints/src/methods/manual_try_fold.rs
@@ -1,6 +1,6 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{is_from_proc_macro, is_trait_method};
 use rustc_errors::Applicability;
@@ -31,13 +31,15 @@ pub(super) fn check<'tcx>(
         && let Res::Def(DefKind::Ctor(_, _), _) = cx.qpath_res(&qpath, path.hir_id)
         && let ExprKind::Closure(closure) = acc.kind
         && !is_from_proc_macro(cx, expr)
-        && let Some(args_snip) = closure.fn_arg_span.and_then(|fn_arg_span| snippet_opt(cx, fn_arg_span))
+        && let Some(args_snip) = closure
+            .fn_arg_span
+            .and_then(|fn_arg_span| fn_arg_span.get_source_text(cx))
     {
         let init_snip = rest
             .is_empty()
             .then_some(first.span)
-            .and_then(|span| snippet_opt(cx, span))
-            .unwrap_or("...".to_owned());
+            .and_then(|span| span.get_source_text(cx))
+            .map_or_else(|| "...".to_owned(), |src| src.to_owned());
 
         span_lint_and_sugg(
             cx,
diff --git a/clippy_lints/src/methods/needless_character_iteration.rs b/clippy_lints/src/methods/needless_character_iteration.rs
index e3d7820771547..332da722a37dc 100644
--- a/clippy_lints/src/methods/needless_character_iteration.rs
+++ b/clippy_lints/src/methods/needless_character_iteration.rs
@@ -7,7 +7,7 @@ use rustc_span::Span;
 use super::utils::get_last_chain_binding_hir_id;
 use super::NEEDLESS_CHARACTER_ITERATION;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::{match_def_path, path_to_local_id, peel_blocks};
 
 fn peels_expr_ref<'a, 'tcx>(mut expr: &'a Expr<'tcx>) -> &'a Expr<'tcx> {
@@ -35,7 +35,7 @@ fn handle_expr(
                 && path_to_local_id(receiver, first_param)
                 && let char_arg_ty = cx.typeck_results().expr_ty_adjusted(receiver).peel_refs()
                 && *char_arg_ty.kind() == ty::Char
-                && let Some(snippet) = snippet_opt(cx, before_chars)
+                && let Some(snippet) = before_chars.get_source_text(cx)
             {
                 span_lint_and_sugg(
                     cx,
@@ -79,7 +79,7 @@ fn handle_expr(
                 && let Some(fn_def_id) = cx.qpath_res(&path, fn_path.hir_id).opt_def_id()
                 && match_def_path(cx, fn_def_id, &["core", "char", "methods", "<impl char>", "is_ascii"])
                 && path_to_local_id(peels_expr_ref(arg), first_param)
-                && let Some(snippet) = snippet_opt(cx, before_chars)
+                && let Some(snippet) = before_chars.get_source_text(cx)
             {
                 span_lint_and_sugg(
                     cx,
diff --git a/clippy_lints/src/methods/needless_option_as_deref.rs b/clippy_lints/src/methods/needless_option_as_deref.rs
index eaae8613d44d9..9f714fdd47bb3 100644
--- a/clippy_lints/src/methods/needless_option_as_deref.rs
+++ b/clippy_lints/src/methods/needless_option_as_deref.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::path_res;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::usage::local_used_after_expr;
 use rustc_errors::Applicability;
@@ -32,7 +32,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, name
             expr.span,
             "derefed type is same as origin",
             "try",
-            snippet_opt(cx, recv.span).unwrap(),
+            recv.span.get_source_text(cx).unwrap().to_owned(),
             Applicability::MachineApplicable,
         );
     }
diff --git a/clippy_lints/src/methods/string_lit_chars_any.rs b/clippy_lints/src/methods/string_lit_chars_any.rs
index 5f6f027a3b59e..cc0d432b799d6 100644
--- a/clippy_lints/src/methods/string_lit_chars_any.rs
+++ b/clippy_lints/src/methods/string_lit_chars_any.rs
@@ -1,6 +1,6 @@
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::{is_from_proc_macro, is_trait_method, path_to_local};
 use itertools::Itertools;
 use rustc_ast::LitKind;
@@ -34,7 +34,7 @@ pub(super) fn check<'tcx>(
             _ => return,
         }
         && !is_from_proc_macro(cx, expr)
-        && let Some(scrutinee_snip) = snippet_opt(cx, scrutinee.span)
+        && let Some(scrutinee_snip) = scrutinee.span.get_source_text(cx)
     {
         // Normalize the char using `map` so `join` doesn't use `Display`, if we don't then
         // something like `r"\"` will become `'\'`, which is of course invalid
diff --git a/clippy_lints/src/methods/unnecessary_get_then_check.rs b/clippy_lints/src/methods/unnecessary_get_then_check.rs
index f6184222d8e96..64eb84117954c 100644
--- a/clippy_lints/src/methods/unnecessary_get_then_check.rs
+++ b/clippy_lints/src/methods/unnecessary_get_then_check.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::is_type_diagnostic_item;
 
 use rustc_errors::Applicability;
@@ -38,11 +38,11 @@ pub(super) fn check(
         return;
     };
     let both_calls_span = get_call_span.with_hi(call_span.hi());
-    if let Some(snippet) = snippet_opt(cx, both_calls_span)
-        && let Some(arg_snippet) = snippet_opt(cx, arg.span)
+    if let Some(snippet) = both_calls_span.get_source_text(cx)
+        && let Some(arg_snippet) = arg.span.get_source_text(cx)
     {
         let generics_snippet = if let Some(generics) = path.args
-            && let Some(generics_snippet) = snippet_opt(cx, generics.span_ext)
+            && let Some(generics_snippet) = generics.span_ext.get_source_text(cx)
         {
             format!("::{generics_snippet}")
         } else {
@@ -63,7 +63,7 @@ pub(super) fn check(
                 suggestion,
                 Applicability::MaybeIncorrect,
             );
-        } else if let Some(caller_snippet) = snippet_opt(cx, get_caller.span) {
+        } else if let Some(caller_snippet) = get_caller.span.get_source_text(cx) {
             let full_span = get_caller.span.with_hi(call_span.hi());
 
             span_lint_and_then(
diff --git a/clippy_lints/src/methods/unnecessary_to_owned.rs b/clippy_lints/src/methods/unnecessary_to_owned.rs
index fed2b128dcf30..69c5bc57e2996 100644
--- a/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -2,7 +2,7 @@ use super::implicit_clone::is_clone_like;
 use super::unnecessary_iter_cloned::{self, is_into_iter};
 use clippy_config::msrvs::{self, Msrv};
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::source::{snippet, SpanRangeExt};
 use clippy_utils::ty::{get_iterator_item_ty, implements_trait, is_copy, is_type_diagnostic_item, is_type_lang_item};
 use clippy_utils::visitors::find_all_ret_expressions;
 use clippy_utils::{
@@ -133,7 +133,7 @@ fn check_addr_of_expr(
         && (*referent_ty != receiver_ty
             || (matches!(referent_ty.kind(), ty::Array(..)) && is_copy(cx, *referent_ty))
             || is_cow_into_owned(cx, method_name, method_def_id))
-        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+        && let Some(receiver_snippet) = receiver.span.get_source_text(cx)
     {
         if receiver_ty == target_ty && n_target_refs >= n_receiver_refs {
             span_lint_and_sugg(
@@ -167,7 +167,7 @@ fn check_addr_of_expr(
                     parent.span,
                     format!("unnecessary use of `{method_name}`"),
                     "use",
-                    receiver_snippet,
+                    receiver_snippet.to_owned(),
                     Applicability::MachineApplicable,
                 );
             } else {
@@ -217,7 +217,7 @@ fn check_into_iter_call_arg(
         && let parent_ty = cx.typeck_results().expr_ty(parent)
         && implements_trait(cx, parent_ty, iterator_trait_id, &[])
         && let Some(item_ty) = get_iterator_item_ty(cx, parent_ty)
-        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+        && let Some(receiver_snippet) = receiver.span.get_source_text(cx)
     {
         if unnecessary_iter_cloned::check_for_loop_iter(cx, parent, method_name, receiver, true) {
             return true;
@@ -309,8 +309,8 @@ fn check_split_call_arg(cx: &LateContext<'_>, expr: &Expr<'_>, method_name: Symb
     if let Some(parent) = get_parent_expr(cx, expr)
         && let Some((fn_name, argument_expr)) = get_fn_name_and_arg(cx, parent)
         && fn_name.as_str() == "split"
-        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
-        && let Some(arg_snippet) = snippet_opt(cx, argument_expr.span)
+        && let Some(receiver_snippet) = receiver.span.get_source_text(cx)
+        && let Some(arg_snippet) = argument_expr.span.get_source_text(cx)
     {
         // We may end-up here because of an expression like `x.to_string().split(…)` where the type of `x`
         // implements `AsRef<str>` but does not implement `Deref<Target = str>`. In this case, we have to
@@ -405,7 +405,7 @@ fn check_other_call_arg<'tcx>(
             None
         }
         && can_change_type(cx, maybe_arg, receiver_ty)
-        && let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
+        && let Some(receiver_snippet) = receiver.span.get_source_text(cx)
     {
         span_lint_and_sugg(
             cx,
@@ -695,7 +695,7 @@ fn check_if_applicable_to_argument<'tcx>(cx: &LateContext<'tcx>, arg: &Expr<'tcx
         && let arg_ty = arg_ty.peel_refs()
         // For now we limit this lint to `String` and `Vec`.
         && (is_str_and_string(cx, arg_ty, original_arg_ty) || is_slice_and_vec(cx, arg_ty, original_arg_ty))
-        && let Some(snippet) = snippet_opt(cx, caller.span)
+        && let Some(snippet) = caller.span.get_source_text(cx)
     {
         span_lint_and_sugg(
             cx,
@@ -706,7 +706,7 @@ fn check_if_applicable_to_argument<'tcx>(cx: &LateContext<'tcx>, arg: &Expr<'tcx
             if original_arg_ty.is_array() {
                 format!("{snippet}.as_slice()")
             } else {
-                snippet
+                snippet.to_owned()
             },
             Applicability::MaybeIncorrect,
         );
diff --git a/clippy_lints/src/methods/unused_enumerate_index.rs b/clippy_lints/src/methods/unused_enumerate_index.rs
index 3004d9c4233a7..ee5177d1ffaa1 100644
--- a/clippy_lints/src/methods/unused_enumerate_index.rs
+++ b/clippy_lints/src/methods/unused_enumerate_index.rs
@@ -1,5 +1,5 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::source::{snippet, snippet_opt};
+use clippy_utils::source::{snippet, SpanRangeExt};
 use clippy_utils::{expr_or_init, is_trait_method, pat_is_wild};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, FnDecl, PatKind, TyKind};
@@ -81,8 +81,14 @@ pub(super) fn check(cx: &LateContext<'_>, call_expr: &Expr<'_>, recv: &Expr<'_>,
         let new_closure_param = match find_elem_explicit_type_span(closure.fn_decl) {
             // We have an explicit type. Get its snippet, that of the binding name, and do `binding: ty`.
             // Fallback to `..` if we fail getting either snippet.
-            Some(ty_span) => snippet_opt(cx, elem.span)
-                .and_then(|binding_name| snippet_opt(cx, ty_span).map(|ty_name| format!("{binding_name}: {ty_name}")))
+            Some(ty_span) => elem
+                .span
+                .get_source_text(cx)
+                .and_then(|binding_name| {
+                    ty_span
+                        .get_source_text(cx)
+                        .map(|ty_name| format!("{binding_name}: {ty_name}"))
+                })
                 .unwrap_or_else(|| "..".to_string()),
             // Otherwise, we have no explicit type. We can replace with the binding name of the element.
             None => snippet(cx, elem.span, "..").into_owned(),
diff --git a/clippy_lints/src/vec.rs b/clippy_lints/src/vec.rs
index 228db14d1b7c3..d3e49bff422ca 100644
--- a/clippy_lints/src/vec.rs
+++ b/clippy_lints/src/vec.rs
@@ -5,7 +5,7 @@ use clippy_config::msrvs::{self, Msrv};
 use clippy_config::Conf;
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::source::snippet_opt;
+use clippy_utils::source::SpanRangeExt;
 use clippy_utils::ty::is_copy;
 use clippy_utils::visitors::for_each_local_use_after_expr;
 use clippy_utils::{get_parent_expr, higher, is_in_test, is_trait_method};
@@ -214,9 +214,11 @@ impl SuggestedType {
     }
 
     fn snippet(self, cx: &LateContext<'_>, args_span: Option<Span>, len_span: Option<Span>) -> String {
-        let maybe_args = args_span.and_then(|sp| snippet_opt(cx, sp)).unwrap_or_default();
+        let maybe_args = args_span
+            .and_then(|sp| sp.get_source_text(cx))
+            .map_or(String::new(), |x| x.to_owned());
         let maybe_len = len_span
-            .and_then(|sp| snippet_opt(cx, sp).map(|s| format!("; {s}")))
+            .and_then(|sp| sp.get_source_text(cx).map(|s| format!("; {s}")))
             .unwrap_or_default();
 
         match self {
diff --git a/clippy_utils/src/source.rs b/clippy_utils/src/source.rs
index 8b49b013e0313..d6830b53b1571 100644
--- a/clippy_utils/src/source.rs
+++ b/clippy_utils/src/source.rs
@@ -207,6 +207,7 @@ fn get_source_range(sm: &SourceMap, sp: Range<BytePos>) -> Option<SourceFileRang
     if !Lrc::ptr_eq(&start.sf, &end.sf) || start.pos > end.pos {
         return None;
     }
+    sm.ensure_source_file_source_present(&start.sf);
     let range = start.pos.to_usize()..end.pos.to_usize();
     Some(SourceFileRange { sf: start.sf, range })
 }
@@ -283,7 +284,11 @@ impl SourceFileRange {
     /// Attempts to get the text from the source file. This can fail if the source text isn't
     /// loaded.
     pub fn as_str(&self) -> Option<&str> {
-        self.sf.src.as_ref().and_then(|x| x.get(self.range.clone()))
+        self.sf
+            .src
+            .as_ref()
+            .or_else(|| self.sf.external_src.get().and_then(|src| src.get_source()))
+            .and_then(|x| x.get(self.range.clone()))
     }
 }
 

From 40f1d9d15472416c53f9558074899d007fbbd1c1 Mon Sep 17 00:00:00 2001
From: Sami Tolvanen <samitolvanen@google.com>
Date: Fri, 16 Aug 2024 20:33:58 +0000
Subject: [PATCH 491/685] Add missing module flags for CFI and KCFI sanitizers

Set the cfi-normalize-integers and kcfi-offset module flags when
Control-Flow Integrity sanitizers are used, so functions generated by
the LLVM backend use the same CFI/KCFI options as rustc.

cfi-normalize-integers tells LLVM to also use integer normalization
for generated functions when -Zsanitizer-cfi-normalize-integers is
used.

kcfi-offset specifies the number of prefix nops between the KCFI
type hash and the function entry when -Z patchable-function-entry is
used. Note that LLVM assumes all indirectly callable functions use the
same number of prefix NOPs with -Zsanitizer=kcfi.
---
 compiler/rustc_codegen_llvm/src/context.rs    | 31 +++++++++++++++++++
 .../cfi/add-cfi-normalize-integers-flag.rs    | 10 ++++++
 .../kcfi/add-cfi-normalize-integers-flag.rs   | 21 +++++++++++++
 .../sanitizer/kcfi/add-kcfi-offset-flag.rs    | 21 +++++++++++++
 4 files changed, 83 insertions(+)
 create mode 100644 tests/codegen/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
 create mode 100644 tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
 create mode 100644 tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs

diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index 8862f139affb8..fe71b2e669e0a 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -11,6 +11,7 @@ use rustc_data_structures::base_n::{ToBaseN, ALPHANUMERIC_ONLY};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_hir::def_id::DefId;
+use rustc_middle::middle::codegen_fn_attrs::PatchableFunctionEntry;
 use rustc_middle::mir::mono::CodegenUnit;
 use rustc_middle::ty::layout::{
     FnAbiError, FnAbiOfHelpers, FnAbiRequest, HasParamEnv, LayoutError, LayoutOfHelpers,
@@ -226,6 +227,20 @@ pub unsafe fn create_module<'ll>(
         }
     }
 
+    // If we're normalizing integers with CFI, ensure LLVM generated functions do the same.
+    // See https://github.com/llvm/llvm-project/pull/104826
+    if sess.is_sanitizer_cfi_normalize_integers_enabled() {
+        let cfi_normalize_integers = c"cfi-normalize-integers".as_ptr().cast();
+        unsafe {
+            llvm::LLVMRustAddModuleFlagU32(
+                llmod,
+                llvm::LLVMModFlagBehavior::Override,
+                cfi_normalize_integers,
+                1,
+            );
+        }
+    }
+
     // Enable LTO unit splitting if specified or if CFI is enabled. (See https://reviews.llvm.org/D53891.)
     if sess.is_split_lto_unit_enabled() || sess.is_sanitizer_cfi_enabled() {
         let enable_split_lto_unit = c"EnableSplitLTOUnit".as_ptr();
@@ -245,6 +260,22 @@ pub unsafe fn create_module<'ll>(
         unsafe {
             llvm::LLVMRustAddModuleFlagU32(llmod, llvm::LLVMModFlagBehavior::Override, kcfi, 1);
         }
+
+        // Add "kcfi-offset" module flag with -Z patchable-function-entry (See
+        // https://reviews.llvm.org/D141172).
+        let pfe =
+            PatchableFunctionEntry::from_config(sess.opts.unstable_opts.patchable_function_entry);
+        if pfe.prefix() > 0 {
+            let kcfi_offset = c"kcfi-offset".as_ptr().cast();
+            unsafe {
+                llvm::LLVMRustAddModuleFlagU32(
+                    llmod,
+                    llvm::LLVMModFlagBehavior::Override,
+                    kcfi_offset,
+                    pfe.prefix().into(),
+                );
+            }
+        }
     }
 
     // Control Flow Guard is currently only supported by the MSVC linker on Windows.
diff --git a/tests/codegen/sanitizer/cfi/add-cfi-normalize-integers-flag.rs b/tests/codegen/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
new file mode 100644
index 0000000000000..a54a6d84a8073
--- /dev/null
+++ b/tests/codegen/sanitizer/cfi/add-cfi-normalize-integers-flag.rs
@@ -0,0 +1,10 @@
+// Verifies that "cfi-normalize-integers" module flag is added.
+//
+//@ needs-sanitizer-cfi
+//@ compile-flags: -Clto -Ctarget-feature=-crt-static -Zsanitizer=cfi -Zsanitizer-cfi-normalize-integers
+
+#![crate_type = "lib"]
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"cfi-normalize-integers", i32 1}
diff --git a/tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs b/tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
new file mode 100644
index 0000000000000..d48e4016a16ce
--- /dev/null
+++ b/tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
@@ -0,0 +1,21 @@
+// Verifies that "cfi-normalize-integers" module flag is added.
+//
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components: x86
+//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi -Zsanitizer-cfi-normalize-integers
+
+#![feature(no_core, lang_items)]
+#![crate_type = "lib"]
+#![no_core]
+
+#[lang = "sized"]
+trait Sized {}
+#[lang = "copy"]
+trait Copy {}
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"cfi-normalize-integers", i32 1}
diff --git a/tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs b/tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs
new file mode 100644
index 0000000000000..b4924719f4c15
--- /dev/null
+++ b/tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs
@@ -0,0 +1,21 @@
+// Verifies that "kcfi-offset" module flag is added.
+//
+//@ revisions: aarch64 x86_64
+//@ [aarch64] compile-flags: --target aarch64-unknown-none
+//@ [aarch64] needs-llvm-components: aarch64
+//@ [x86_64] compile-flags: --target x86_64-unknown-none
+//@ [x86_64] needs-llvm-components: x86
+//@ compile-flags: -Ctarget-feature=-crt-static -Zsanitizer=kcfi -Z patchable-function-entry=4,3
+
+#![feature(no_core, lang_items, patchable_function_entry)]
+#![crate_type = "lib"]
+#![no_core]
+
+#[lang = "sized"]
+trait Sized {}
+#[lang = "copy"]
+trait Copy {}
+
+pub fn foo() {}
+
+// CHECK: !{{[0-9]+}} = !{i32 4, !"kcfi-offset", i32 3}

From 191862d701b10f7a060d732aa6fe60c6520ae5a7 Mon Sep 17 00:00:00 2001
From: "Chai T. Rex" <ChaiTRex@users.noreply.github.com>
Date: Wed, 21 Aug 2024 15:59:14 -0400
Subject: [PATCH 492/685] Use `assert_unsafe_precondition!` in
 `AsciiChar::digit_unchecked`

---
 library/core/src/ascii/ascii_char.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/library/core/src/ascii/ascii_char.rs b/library/core/src/ascii/ascii_char.rs
index 375358dddf5c1..ce09a0b444da3 100644
--- a/library/core/src/ascii/ascii_char.rs
+++ b/library/core/src/ascii/ascii_char.rs
@@ -3,8 +3,8 @@
 //! suggestions from rustc if you get anything slightly wrong in here, and overall
 //! helps with clarity as we're also referring to `char` intentionally in here.
 
-use crate::fmt;
 use crate::mem::transmute;
+use crate::{assert_unsafe_precondition, fmt};
 
 /// One of the 128 Unicode characters from U+0000 through U+007F,
 /// often known as the [ASCII] subset.
@@ -497,14 +497,18 @@ impl AsciiChar {
     /// Notably, it should not be expected to return hex digits, or any other
     /// reasonable extension of the decimal digits.
     ///
-    /// (This lose safety condition is intended to simplify soundness proofs
+    /// (This loose safety condition is intended to simplify soundness proofs
     /// when writing code using this method, since the implementation doesn't
     /// need something really specific, not to make those other arguments do
     /// something useful. It might be tightened before stabilization.)
     #[unstable(feature = "ascii_char", issue = "110998")]
     #[inline]
     pub const unsafe fn digit_unchecked(d: u8) -> Self {
-        debug_assert!(d < 10);
+        assert_unsafe_precondition!(
+            check_language_ub,
+            "`AsciiChar::digit_unchecked` input cannot exceed 9.",
+            (d: u8 = d) => d < 10
+        );
 
         // SAFETY: `'0'` through `'9'` are U+00030 through U+0039,
         // so because `d` must be 64 or less the addition can return at most

From 9b5a004bf8a388cfe1fc6b844d65e528cca6e2fd Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Wed, 21 Aug 2024 20:57:50 +0000
Subject: [PATCH 493/685] feat(core): Add implementations for
 `unbounded_shl`/`unbounded_shr`

---
 library/core/src/num/int_macros.rs  | 60 +++++++++++++++++++++++++++++
 library/core/src/num/uint_macros.rs | 54 ++++++++++++++++++++++++++
 2 files changed, 114 insertions(+)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 17cf2a7b261fd..0ec178448e476 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1312,6 +1312,33 @@ macro_rules! int_impl {
             }
         }
 
+        /// Unbounded shift left. Computes `self << rhs`, without bounding the value of `rhs`
+        /// 
+        /// If `rhs` is larger or equal to the number of bits in `self`, 
+        /// the entire value is shifted out, and `0` is returned.
+        ///
+        /// # Examples
+        /// 
+        /// Basic usage:
+        /// ```
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(4), 0x10);")]
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(129), 0);")]
+        /// ```
+        #[unstable(feature = "unbounded_shifts", issue = "129375")]
+        #[rustc_allow_const_fn_unstable(unchecked_shifts)]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn unbounded_shl(self, v: u32) -> $SelfT{
+            if v < Self::BITS{
+                // SAFETY:
+                // v is just checked to be in-range above
+                unsafe{self.unchecked_shl(v)}
+            }else{
+                0
+            }
+        }
+
         /// Checked shift right. Computes `self >> rhs`, returning `None` if `rhs` is
         /// larger than or equal to the number of bits in `self`.
         ///
@@ -1410,6 +1437,39 @@ macro_rules! int_impl {
             }
         }
 
+        /// Unbounded shift right. Computes `self >> rhs`, without bounding the value of `rhs`
+        /// 
+        /// If `rhs` is larger or equal to the number of bits in `self`, 
+        /// the entire value is shifted out, which yields `0` for a positive number,
+        /// and `-1` for a negative number.
+        ///
+        /// # Examples
+        /// 
+        /// Basic usage:
+        /// ```
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shl(4), 0x1);")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(129), 0);")]
+        #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.unbounded_shr(129), -1);")]
+        /// ```
+        #[unstable(feature = "unbounded_shifts", issue = "129375")]
+        #[rustc_allow_const_fn_unstable(unchecked_shifts)]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn unbounded_shr(self, v: u32) -> $SelfT{
+            if v < Self::BITS{
+                // SAFETY:
+                // v is just checked to be in-range above
+                unsafe{self.unchecked_shr(v)}
+            }else{
+                // A shift by `Self::BITS-1` suffices for signed integers, because the sign bit is copied for each of the shifted bits.
+
+                // SAFETY:
+                // `Self::BITS-1` is guaranteed to be less than `Self::BITS`
+                unsafe{self.unchecked_shr(Self::BITS - 1)}
+            }
+        }
+
         /// Checked absolute value. Computes `self.abs()`, returning `None` if
         /// `self == MIN`.
         ///
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 719a6a55940dc..5a2f1876ca2b8 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1501,6 +1501,33 @@ macro_rules! uint_impl {
             }
         }
 
+                /// Unbounded shift left. Computes `self << rhs`, without bounding the value of `rhs`
+        /// 
+        /// If `rhs` is larger or equal to the number of bits in `self`, 
+        /// the entire value is shifted out, and `0` is returned.
+        ///
+        /// # Examples
+        /// 
+        /// Basic usage:
+        /// ```
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(4), 0x10);")]
+        #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(129), 0);")]
+        /// ```
+        #[unstable(feature = "unbounded_shifts", issue = "129375")]
+        #[rustc_allow_const_fn_unstable(unchecked_shifts)]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn unbounded_shl(self, v: u32) -> $SelfT{
+            if v < Self::BITS{
+                // SAFETY:
+                // v is just checked to be in-range above
+                unsafe{self.unchecked_shl(v)}
+            }else{
+                0
+            }
+        }
+
         /// Checked shift right. Computes `self >> rhs`, returning `None`
         /// if `rhs` is larger than or equal to the number of bits in `self`.
         ///
@@ -1599,6 +1626,33 @@ macro_rules! uint_impl {
             }
         }
 
+        /// Unbounded shift right. Computes `self >> rhs`, without bounding the value of `rhs`
+        /// 
+        /// If `rhs` is larger or equal to the number of bits in `self`, 
+        /// the entire value is shifted out, and `0` is returned.
+        ///
+        /// # Examples
+        /// 
+        /// Basic usage:
+        /// ```
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(4), 0x10);")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(129), 0);")]
+        /// ```
+        #[unstable(feature = "unbounded_shifts", issue = "129375")]
+        #[rustc_allow_const_fn_unstable(unchecked_shifts)]
+        #[must_use = "this returns the result of the operation, \
+                      without modifying the original"]
+        #[inline]
+        pub const fn unbounded_shr(self, v: u32) -> $SelfT{
+            if v < Self::BITS{
+                // SAFETY:
+                // v is just checked to be in-range above
+                unsafe{self.unchecked_shr(v)}
+            }else{
+                0
+            }
+        }
+
         /// Checked exponentiation. Computes `self.pow(exp)`, returning `None` if
         /// overflow occurred.
         ///

From c89bae0ea8f2b6c04ff26a14f8dd37eaa9bc2f0b Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Wed, 21 Aug 2024 21:16:18 +0000
Subject: [PATCH 494/685] Manually format functions and use `rhs` instead of
 `v` from my CE testing

---
 library/core/src/num/int_macros.rs  | 18 +++++++++---------
 library/core/src/num/uint_macros.rs | 16 ++++++++--------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 0ec178448e476..b22311da1e354 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1329,11 +1329,11 @@ macro_rules! int_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub const fn unbounded_shl(self, v: u32) -> $SelfT{
-            if v < Self::BITS{
+        pub const fn unbounded_shl(self, rhs: u32) -> $SelfT{
+            if rhs < Self::BITS{
                 // SAFETY:
-                // v is just checked to be in-range above
-                unsafe{self.unchecked_shl(v)}
+                // rhs is just checked to be in-range above
+                unsafe { self.unchecked_shl(rhs) }
             }else{
                 0
             }
@@ -1456,17 +1456,17 @@ macro_rules! int_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub const fn unbounded_shr(self, v: u32) -> $SelfT{
-            if v < Self::BITS{
+        pub const fn unbounded_shr(self, rhs: u32) -> $SelfT{
+            if rhs < Self::BITS{
                 // SAFETY:
-                // v is just checked to be in-range above
-                unsafe{self.unchecked_shr(v)}
+                // rhs is just checked to be in-range above
+                unsafe { self.unchecked_shr(rhs) }
             }else{
                 // A shift by `Self::BITS-1` suffices for signed integers, because the sign bit is copied for each of the shifted bits.
 
                 // SAFETY:
                 // `Self::BITS-1` is guaranteed to be less than `Self::BITS`
-                unsafe{self.unchecked_shr(Self::BITS - 1)}
+                unsafe { self.unchecked_shr(Self::BITS - 1) }
             }
         }
 
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 5a2f1876ca2b8..b8ca299f67ddd 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1518,11 +1518,11 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub const fn unbounded_shl(self, v: u32) -> $SelfT{
-            if v < Self::BITS{
+        pub const fn unbounded_shl(self, rhs: u32) -> $SelfT{
+            if rhs < Self::BITS{
                 // SAFETY:
-                // v is just checked to be in-range above
-                unsafe{self.unchecked_shl(v)}
+                // rhs is just checked to be in-range above
+                unsafe { self.unchecked_shl(rhs) }
             }else{
                 0
             }
@@ -1643,11 +1643,11 @@ macro_rules! uint_impl {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub const fn unbounded_shr(self, v: u32) -> $SelfT{
-            if v < Self::BITS{
+        pub const fn unbounded_shr(self, rhs: u32) -> $SelfT{
+            if rhs < Self::BITS{
                 // SAFETY:
-                // v is just checked to be in-range above
-                unsafe{self.unchecked_shr(v)}
+                // rhs is just checked to be in-range above
+                unsafe { self.unchecked_shr(rhs) }
             }else{
                 0
             }

From 38b5a2a67e64e8a02c4bee9bd0314e5023a559cb Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Wed, 21 Aug 2024 21:23:25 +0000
Subject: [PATCH 495/685] chore: Also format the control flow

---
 library/core/src/num/int_macros.rs  | 8 ++++----
 library/core/src/num/uint_macros.rs | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index b22311da1e354..b48b05577c96c 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1330,11 +1330,11 @@ macro_rules! int_impl {
                       without modifying the original"]
         #[inline]
         pub const fn unbounded_shl(self, rhs: u32) -> $SelfT{
-            if rhs < Self::BITS{
+            if rhs < Self::BITS {
                 // SAFETY:
                 // rhs is just checked to be in-range above
                 unsafe { self.unchecked_shl(rhs) }
-            }else{
+            } else {
                 0
             }
         }
@@ -1457,11 +1457,11 @@ macro_rules! int_impl {
                       without modifying the original"]
         #[inline]
         pub const fn unbounded_shr(self, rhs: u32) -> $SelfT{
-            if rhs < Self::BITS{
+            if rhs < Self::BITS {
                 // SAFETY:
                 // rhs is just checked to be in-range above
                 unsafe { self.unchecked_shr(rhs) }
-            }else{
+            } else {
                 // A shift by `Self::BITS-1` suffices for signed integers, because the sign bit is copied for each of the shifted bits.
 
                 // SAFETY:
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index b8ca299f67ddd..f09fd604dc6a4 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1519,11 +1519,11 @@ macro_rules! uint_impl {
                       without modifying the original"]
         #[inline]
         pub const fn unbounded_shl(self, rhs: u32) -> $SelfT{
-            if rhs < Self::BITS{
+            if rhs < Self::BITS {
                 // SAFETY:
                 // rhs is just checked to be in-range above
                 unsafe { self.unchecked_shl(rhs) }
-            }else{
+            } else {
                 0
             }
         }
@@ -1644,11 +1644,11 @@ macro_rules! uint_impl {
                       without modifying the original"]
         #[inline]
         pub const fn unbounded_shr(self, rhs: u32) -> $SelfT{
-            if rhs < Self::BITS{
+            if rhs < Self::BITS {
                 // SAFETY:
                 // rhs is just checked to be in-range above
                 unsafe { self.unchecked_shr(rhs) }
-            }else{
+            } else {
                 0
             }
         }

From c836739529af2cfba4a76fb8b334f5621d66b4c2 Mon Sep 17 00:00:00 2001
From: "Chai T. Rex" <ChaiTRex@users.noreply.github.com>
Date: Wed, 21 Aug 2024 16:39:13 -0400
Subject: [PATCH 496/685] Change `assert_unsafe_precondition` docs to refer to
 `check_language_ub`

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

diff --git a/library/core/src/ub_checks.rs b/library/core/src/ub_checks.rs
index b65b48c162d9c..c1a8c34539e6c 100644
--- a/library/core/src/ub_checks.rs
+++ b/library/core/src/ub_checks.rs
@@ -10,7 +10,7 @@ use crate::intrinsics::{self, const_eval_select};
 /// macro for language UB are always ignored.
 ///
 /// This macro should be called as
-/// `assert_unsafe_precondition!(check_{library,lang}_ub, "message", (ident: type = expr, ident: type = expr) => check_expr)`
+/// `assert_unsafe_precondition!(check_{library,language}_ub, "message", (ident: type = expr, ident: type = expr) => check_expr)`
 /// where each `expr` will be evaluated and passed in as function argument `ident: type`. Then all
 /// those arguments are passed to a function with the body `check_expr`.
 /// Pick `check_language_ub` when this is guarding a violation of language UB, i.e., immediate UB

From d7b2fd4213971edd09ed72f9a6541a036d016666 Mon Sep 17 00:00:00 2001
From: Geoffry Song <goffrie@gmail.com>
Date: Wed, 21 Aug 2024 14:37:39 -0700
Subject: [PATCH 497/685] Clean up cfg-gating of ProcessPrng extern

---
 library/std/src/sys/pal/windows/c.rs | 29 +++++++++++++++-------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/library/std/src/sys/pal/windows/c.rs b/library/std/src/sys/pal/windows/c.rs
index 2f5d75dc4bc23..8900410cf609b 100644
--- a/library/std/src/sys/pal/windows/c.rs
+++ b/library/std/src/sys/pal/windows/c.rs
@@ -109,19 +109,22 @@ if #[cfg(not(target_vendor = "uwp"))] {
 }
 
 // Use raw-dylib to import ProcessPrng as we can't rely on there being an import library.
-cfg_if::cfg_if! {
-if #[cfg(not(target_vendor = "win7"))] {
-    #[cfg(target_arch = "x86")]
-    #[link(name = "bcryptprimitives", kind = "raw-dylib", import_name_type = "undecorated")]
-    extern "system" {
-        pub fn ProcessPrng(pbdata: *mut u8, cbdata: usize) -> BOOL;
-    }
-    #[cfg(not(target_arch = "x86"))]
-    #[link(name = "bcryptprimitives", kind = "raw-dylib")]
-    extern "system" {
-        pub fn ProcessPrng(pbdata: *mut u8, cbdata: usize) -> BOOL;
-    }
-}}
+#[cfg(not(target_vendor = "win7"))]
+#[cfg_attr(
+    target_arch = "x86",
+    link(
+        name = "bcryptprimitives",
+        kind = "raw-dylib",
+        import_name_type = "undecorated"
+    )
+)]
+#[cfg_attr(
+    not(target_arch = "x86"),
+    link(name = "bcryptprimitives", kind = "raw-dylib")
+)]
+extern "system" {
+    pub fn ProcessPrng(pbdata: *mut u8, cbdata: usize) -> BOOL;
+}
 
 // Functions that aren't available on every version of Windows that we support,
 // but we still use them and just provide some form of a fallback implementation.

From 79cbb878c7ca739b5136c9b87402860f017919d2 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Wed, 21 Aug 2024 21:37:50 +0000
Subject: [PATCH 498/685] chore: `x fmt` and hopefully fix the tidy issue

---
 library/core/src/num/int_macros.rs  | 12 ++++++------
 library/core/src/num/uint_macros.rs | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index b48b05577c96c..8c4f6a37fa91e 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1313,12 +1313,12 @@ macro_rules! int_impl {
         }
 
         /// Unbounded shift left. Computes `self << rhs`, without bounding the value of `rhs`
-        /// 
-        /// If `rhs` is larger or equal to the number of bits in `self`, 
+        ///
+        /// If `rhs` is larger or equal to the number of bits in `self`,
         /// the entire value is shifted out, and `0` is returned.
         ///
         /// # Examples
-        /// 
+        ///
         /// Basic usage:
         /// ```
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(4), 0x10);")]
@@ -1438,13 +1438,13 @@ macro_rules! int_impl {
         }
 
         /// Unbounded shift right. Computes `self >> rhs`, without bounding the value of `rhs`
-        /// 
-        /// If `rhs` is larger or equal to the number of bits in `self`, 
+        ///
+        /// If `rhs` is larger or equal to the number of bits in `self`,
         /// the entire value is shifted out, which yields `0` for a positive number,
         /// and `-1` for a negative number.
         ///
         /// # Examples
-        /// 
+        ///
         /// Basic usage:
         /// ```
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shl(4), 0x1);")]
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index f09fd604dc6a4..643a76d23e415 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1502,12 +1502,12 @@ macro_rules! uint_impl {
         }
 
                 /// Unbounded shift left. Computes `self << rhs`, without bounding the value of `rhs`
-        /// 
-        /// If `rhs` is larger or equal to the number of bits in `self`, 
+        ///
+        /// If `rhs` is larger or equal to the number of bits in `self`,
         /// the entire value is shifted out, and `0` is returned.
         ///
         /// # Examples
-        /// 
+        ///
         /// Basic usage:
         /// ```
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(4), 0x10);")]
@@ -1627,12 +1627,12 @@ macro_rules! uint_impl {
         }
 
         /// Unbounded shift right. Computes `self >> rhs`, without bounding the value of `rhs`
-        /// 
-        /// If `rhs` is larger or equal to the number of bits in `self`, 
+        ///
+        /// If `rhs` is larger or equal to the number of bits in `self`,
         /// the entire value is shifted out, and `0` is returned.
         ///
         /// # Examples
-        /// 
+        ///
         /// Basic usage:
         /// ```
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(4), 0x10);")]

From 40481fc70a8626f9e58242b0fb673d90ade2f084 Mon Sep 17 00:00:00 2001
From: Geoffry Song <goffrie@gmail.com>
Date: Wed, 21 Aug 2024 15:34:51 -0700
Subject: [PATCH 499/685] format

---
 library/std/src/sys/pal/windows/c.rs | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/library/std/src/sys/pal/windows/c.rs b/library/std/src/sys/pal/windows/c.rs
index 8900410cf609b..b888eb7d95ca3 100644
--- a/library/std/src/sys/pal/windows/c.rs
+++ b/library/std/src/sys/pal/windows/c.rs
@@ -112,16 +112,9 @@ if #[cfg(not(target_vendor = "uwp"))] {
 #[cfg(not(target_vendor = "win7"))]
 #[cfg_attr(
     target_arch = "x86",
-    link(
-        name = "bcryptprimitives",
-        kind = "raw-dylib",
-        import_name_type = "undecorated"
-    )
-)]
-#[cfg_attr(
-    not(target_arch = "x86"),
-    link(name = "bcryptprimitives", kind = "raw-dylib")
+    link(name = "bcryptprimitives", kind = "raw-dylib", import_name_type = "undecorated")
 )]
+#[cfg_attr(not(target_arch = "x86"), link(name = "bcryptprimitives", kind = "raw-dylib"))]
 extern "system" {
     pub fn ProcessPrng(pbdata: *mut u8, cbdata: usize) -> BOOL;
 }

From 81c00dde2b15120fd1e492909957feb720e33d0a Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Wed, 21 Aug 2024 17:22:08 -0500
Subject: [PATCH 500/685] Add `const_cell_into_inner` to `OnceCell`

`Cell` and `RefCell` have their `into_inner` methods const unstable.
`OnceCell` has the same logic, so add it under the same gate.

Tracking issue: https://github.com/rust-lang/rust/issues/78729
---
 library/core/src/cell/once.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/core/src/cell/once.rs b/library/core/src/cell/once.rs
index 097fa86c93814..87df8a4e272e8 100644
--- a/library/core/src/cell/once.rs
+++ b/library/core/src/cell/once.rs
@@ -309,7 +309,8 @@ impl<T> OnceCell<T> {
     /// ```
     #[inline]
     #[stable(feature = "once_cell", since = "1.70.0")]
-    pub fn into_inner(self) -> Option<T> {
+    #[rustc_const_unstable(feature = "const_cell_into_inner", issue = "78729")]
+    pub const fn into_inner(self) -> Option<T> {
         // Because `into_inner` takes `self` by value, the compiler statically verifies
         // that it is not currently borrowed. So it is safe to move out `Option<T>`.
         self.inner.into_inner()

From 9907f617ab8c0fc1a36161d5b33cd86780fb9b09 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Wed, 21 Aug 2024 23:22:07 +0000
Subject: [PATCH 501/685] fix(core): Add `#![feature(unbounded_shifts)]` to
 doctests for `unbounded_shr`/`unbounded_shl`

---
 library/core/src/num/int_macros.rs  | 4 +++-
 library/core/src/num/uint_macros.rs | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 8c4f6a37fa91e..91d70473a6613 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1321,6 +1321,7 @@ macro_rules! int_impl {
         ///
         /// Basic usage:
         /// ```
+        /// #![feature(unbounded_shifts)]
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(4), 0x10);")]
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(129), 0);")]
         /// ```
@@ -1447,10 +1448,11 @@ macro_rules! int_impl {
         ///
         /// Basic usage:
         /// ```
+        /// #![feature(unbounded_shifts)]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shl(4), 0x1);")]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(129), 0);")]
         #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.unbounded_shr(129), -1);")]
-        /// ```
+        /// ```  
         #[unstable(feature = "unbounded_shifts", issue = "129375")]
         #[rustc_allow_const_fn_unstable(unchecked_shifts)]
         #[must_use = "this returns the result of the operation, \
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 643a76d23e415..161ee649c841b 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1501,7 +1501,7 @@ macro_rules! uint_impl {
             }
         }
 
-                /// Unbounded shift left. Computes `self << rhs`, without bounding the value of `rhs`
+        /// Unbounded shift left. Computes `self << rhs`, without bounding the value of `rhs`
         ///
         /// If `rhs` is larger or equal to the number of bits in `self`,
         /// the entire value is shifted out, and `0` is returned.
@@ -1510,6 +1510,7 @@ macro_rules! uint_impl {
         ///
         /// Basic usage:
         /// ```
+        /// #![feature(unbounded_shifts)]
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(4), 0x10);")]
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(129), 0);")]
         /// ```
@@ -1635,6 +1636,7 @@ macro_rules! uint_impl {
         ///
         /// Basic usage:
         /// ```
+        /// #![feature(unbounded_shifts)]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(4), 0x10);")]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(129), 0);")]
         /// ```

From 27b63b85ec7f8a767b91dd75bad7ca18399901a6 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Wed, 21 Aug 2024 23:38:04 +0000
Subject: [PATCH 502/685] chore: `x fmt`

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

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 91d70473a6613..c11cae1666f20 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1452,7 +1452,7 @@ macro_rules! int_impl {
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shl(4), 0x1);")]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(129), 0);")]
         #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.unbounded_shr(129), -1);")]
-        /// ```  
+        /// ```
         #[unstable(feature = "unbounded_shifts", issue = "129375")]
         #[rustc_allow_const_fn_unstable(unchecked_shifts)]
         #[must_use = "this returns the result of the operation, \

From 2cf48eaebc9aa696aa7e7170e8d340123daddaa4 Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 22 Aug 2024 00:08:03 +0000
Subject: [PATCH 503/685] fix(core): Use correct operations/values in
 `unbounded_shr` doctests

---
 library/core/src/num/int_macros.rs  | 2 +-
 library/core/src/num/uint_macros.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index c11cae1666f20..d3dd68a9d610c 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1449,7 +1449,7 @@ macro_rules! int_impl {
         /// Basic usage:
         /// ```
         /// #![feature(unbounded_shifts)]
-        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shl(4), 0x1);")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(4), 0x1);")]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(129), 0);")]
         #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.unbounded_shr(129), -1);")]
         /// ```
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 161ee649c841b..2e4e367af9b90 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1637,7 +1637,7 @@ macro_rules! uint_impl {
         /// Basic usage:
         /// ```
         /// #![feature(unbounded_shifts)]
-        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(4), 0x10);")]
+        #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(4), 0x1);")]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(129), 0);")]
         /// ```
         #[unstable(feature = "unbounded_shifts", issue = "129375")]

From c51f2d24d1df7a797113b46def0d904d6c877055 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 22 Aug 2024 01:17:01 +0000
Subject: [PATCH 504/685] Use a LocalDefId in ResolvedArg.

---
 .../rustc_hir_analysis/src/check/check.rs     |  4 +--
 .../src/collect/resolve_bound_vars.rs         | 27 +++++++++--------
 .../src/hir_ty_lowering/mod.rs                | 29 ++++++++++---------
 compiler/rustc_lint/src/builtin.rs            | 10 +++----
 .../rustc_lint/src/impl_trait_overcaptures.rs |  7 +++--
 .../src/middle/resolve_bound_vars.rs          |  8 ++---
 compiler/rustc_middle/src/ty/context.rs       | 18 ++++++------
 .../infer/nice_region_error/find_anon_type.rs |  8 ++---
 src/librustdoc/clean/mod.rs                   |  2 +-
 9 files changed, 58 insertions(+), 55 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 16eeb57b2b967..14c5f8d9f16da 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -529,7 +529,7 @@ fn check_opaque_precise_captures<'tcx>(tcx: TyCtxt<'tcx>, opaque_def_id: LocalDe
 
         match tcx.named_bound_var(hir_id) {
             Some(ResolvedArg::EarlyBound(def_id)) => {
-                expected_captures.insert(def_id);
+                expected_captures.insert(def_id.to_def_id());
 
                 // Make sure we allow capturing these lifetimes through `Self` and
                 // `T::Assoc` projection syntax, too. These will occur when we only
@@ -538,7 +538,7 @@ fn check_opaque_precise_captures<'tcx>(tcx: TyCtxt<'tcx>, opaque_def_id: LocalDe
                 // feature -- see <https://github.com/rust-lang/rust/pull/115659>.
                 if let DefKind::LifetimeParam = tcx.def_kind(def_id)
                     && let Some(def_id) = tcx
-                        .map_opaque_lifetime_to_parent_lifetime(def_id.expect_local())
+                        .map_opaque_lifetime_to_parent_lifetime(def_id)
                         .opt_param_def_id(tcx, tcx.parent(opaque_def_id.to_def_id()))
                 {
                     shadowed_captures.insert(def_id);
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
index ae0c70d232685..0cf9e128bceef 100644
--- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
+++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -13,7 +13,6 @@ use rustc_ast::visit::walk_list;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::LocalDefId;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{GenericArg, GenericParam, GenericParamKind, HirId, HirIdMap, LifetimeName, Node};
 use rustc_macros::extension;
@@ -22,7 +21,7 @@ use rustc_middle::middle::resolve_bound_vars::*;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::{self, TyCtxt, TypeSuperVisitable, TypeVisitor};
 use rustc_middle::{bug, span_bug};
-use rustc_span::def_id::DefId;
+use rustc_span::def_id::{DefId, LocalDefId};
 use rustc_span::symbol::{sym, Ident};
 use rustc_span::Span;
 
@@ -32,7 +31,7 @@ use crate::errors;
 impl ResolvedArg {
     fn early(param: &GenericParam<'_>) -> (LocalDefId, ResolvedArg) {
         debug!("ResolvedArg::early: def_id={:?}", param.def_id);
-        (param.def_id, ResolvedArg::EarlyBound(param.def_id.to_def_id()))
+        (param.def_id, ResolvedArg::EarlyBound(param.def_id))
     }
 
     fn late(idx: u32, param: &GenericParam<'_>) -> (LocalDefId, ResolvedArg) {
@@ -41,10 +40,10 @@ impl ResolvedArg {
             "ResolvedArg::late: idx={:?}, param={:?} depth={:?} def_id={:?}",
             idx, param, depth, param.def_id,
         );
-        (param.def_id, ResolvedArg::LateBound(depth, idx, param.def_id.to_def_id()))
+        (param.def_id, ResolvedArg::LateBound(depth, idx, param.def_id))
     }
 
-    fn id(&self) -> Option<DefId> {
+    fn id(&self) -> Option<LocalDefId> {
         match *self {
             ResolvedArg::StaticLifetime | ResolvedArg::Error(_) => None,
 
@@ -288,13 +287,14 @@ fn late_arg_as_bound_arg<'tcx>(
 ) -> ty::BoundVariableKind {
     match arg {
         ResolvedArg::LateBound(_, _, def_id) => {
-            let name = tcx.hir().name(tcx.local_def_id_to_hir_id(def_id.expect_local()));
+            let def_id = def_id.to_def_id();
+            let name = tcx.item_name(def_id);
             match param.kind {
                 GenericParamKind::Lifetime { .. } => {
-                    ty::BoundVariableKind::Region(ty::BrNamed(*def_id, name))
+                    ty::BoundVariableKind::Region(ty::BrNamed(def_id, name))
                 }
                 GenericParamKind::Type { .. } => {
-                    ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(*def_id, name))
+                    ty::BoundVariableKind::Ty(ty::BoundTyKind::Param(def_id, name))
                 }
                 GenericParamKind::Const { .. } => ty::BoundVariableKind::Const,
             }
@@ -717,7 +717,6 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
                     // In the future, this should be fixed and this error should be removed.
                     let def = self.map.defs.get(&lifetime.hir_id).copied();
                     let Some(ResolvedArg::LateBound(_, _, lifetime_def_id)) = def else { continue };
-                    let Some(lifetime_def_id) = lifetime_def_id.as_local() else { continue };
                     let lifetime_hir_id = self.tcx.local_def_id_to_hir_id(lifetime_def_id);
 
                     let bad_place = match self.tcx.hir_node(self.tcx.parent_hir_id(lifetime_hir_id))
@@ -1150,7 +1149,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                             .param_def_id_to_index(self.tcx, region_def_id.to_def_id())
                             .is_some()
                     {
-                        break Some(ResolvedArg::EarlyBound(region_def_id.to_def_id()));
+                        break Some(ResolvedArg::EarlyBound(region_def_id));
                     }
                     break None;
                 }
@@ -1259,7 +1258,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                     kind => span_bug!(
                         use_span,
                         "did not expect to resolve lifetime to {}",
-                        kind.descr(param_def_id)
+                        kind.descr(param_def_id.to_def_id())
                     ),
                 };
                 def = ResolvedArg::Error(guar);
@@ -1277,10 +1276,10 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                         kind: hir::ImplItemKind::Fn(..),
                         ..
                     }) => {
-                        def = ResolvedArg::Free(owner_id.to_def_id(), def.id().unwrap());
+                        def = ResolvedArg::Free(owner_id.def_id, def.id().unwrap());
                     }
                     Node::Expr(hir::Expr { kind: hir::ExprKind::Closure(closure), .. }) => {
-                        def = ResolvedArg::Free(closure.def_id.to_def_id(), def.id().unwrap());
+                        def = ResolvedArg::Free(closure.def_id, def.id().unwrap());
                     }
                     _ => {}
                 }
@@ -1351,7 +1350,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                             .param_def_id_to_index(self.tcx, param_def_id.to_def_id())
                             .is_some()
                     {
-                        break Some(ResolvedArg::EarlyBound(param_def_id.to_def_id()));
+                        break Some(ResolvedArg::EarlyBound(param_def_id));
                     }
                     break None;
                 }
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 2fb1bcf2dbfff..5c8ecf254a54e 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -296,25 +296,29 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             Some(rbv::ResolvedArg::StaticLifetime) => tcx.lifetimes.re_static,
 
             Some(rbv::ResolvedArg::LateBound(debruijn, index, def_id)) => {
-                let name = lifetime_name(def_id.expect_local());
+                let name = lifetime_name(def_id);
                 let br = ty::BoundRegion {
                     var: ty::BoundVar::from_u32(index),
-                    kind: ty::BrNamed(def_id, name),
+                    kind: ty::BrNamed(def_id.to_def_id(), name),
                 };
                 ty::Region::new_bound(tcx, debruijn, br)
             }
 
             Some(rbv::ResolvedArg::EarlyBound(def_id)) => {
-                let name = tcx.hir().ty_param_name(def_id.expect_local());
-                let item_def_id = tcx.hir().ty_param_owner(def_id.expect_local());
+                let name = tcx.hir().ty_param_name(def_id);
+                let item_def_id = tcx.hir().ty_param_owner(def_id);
                 let generics = tcx.generics_of(item_def_id);
-                let index = generics.param_def_id_to_index[&def_id];
+                let index = generics.param_def_id_to_index[&def_id.to_def_id()];
                 ty::Region::new_early_param(tcx, ty::EarlyParamRegion { index, name })
             }
 
             Some(rbv::ResolvedArg::Free(scope, id)) => {
-                let name = lifetime_name(id.expect_local());
-                ty::Region::new_late_param(tcx, scope, ty::BrNamed(id, name))
+                let name = lifetime_name(id);
+                ty::Region::new_late_param(
+                    tcx,
+                    scope.to_def_id(),
+                    ty::BrNamed(id.to_def_id(), name),
+                )
 
                 // (*) -- not late-bound, won't change
             }
@@ -1953,15 +1957,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let tcx = self.tcx();
         match tcx.named_bound_var(hir_id) {
             Some(rbv::ResolvedArg::LateBound(debruijn, index, def_id)) => {
-                let name = tcx.item_name(def_id);
+                let name = tcx.item_name(def_id.to_def_id());
                 let br = ty::BoundTy {
                     var: ty::BoundVar::from_u32(index),
-                    kind: ty::BoundTyKind::Param(def_id, name),
+                    kind: ty::BoundTyKind::Param(def_id.to_def_id(), name),
                 };
                 Ty::new_bound(tcx, debruijn, br)
             }
             Some(rbv::ResolvedArg::EarlyBound(def_id)) => {
-                let def_id = def_id.expect_local();
                 let item_def_id = tcx.hir().ty_param_owner(def_id);
                 let generics = tcx.generics_of(item_def_id);
                 let index = generics.param_def_id_to_index[&def_id.to_def_id()];
@@ -1982,10 +1985,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             Some(rbv::ResolvedArg::EarlyBound(def_id)) => {
                 // Find the name and index of the const parameter by indexing the generics of
                 // the parent item and construct a `ParamConst`.
-                let item_def_id = tcx.parent(def_id);
+                let item_def_id = tcx.local_parent(def_id);
                 let generics = tcx.generics_of(item_def_id);
-                let index = generics.param_def_id_to_index[&def_id];
-                let name = tcx.item_name(def_id);
+                let index = generics.param_def_id_to_index[&def_id.to_def_id()];
+                let name = tcx.item_name(def_id.to_def_id());
                 ty::Const::new_param(tcx, ty::ParamConst::new(index, name))
             }
             Some(rbv::ResolvedArg::LateBound(debruijn, index, _)) => {
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 85132dd4f98f0..d8482567bbe5b 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -1925,8 +1925,8 @@ impl ExplicitOutlivesRequirements {
     fn lifetimes_outliving_lifetime<'tcx>(
         tcx: TyCtxt<'tcx>,
         inferred_outlives: impl Iterator<Item = &'tcx (ty::Clause<'tcx>, Span)>,
-        item: DefId,
-        lifetime: DefId,
+        item: LocalDefId,
+        lifetime: LocalDefId,
     ) -> Vec<ty::Region<'tcx>> {
         let item_generics = tcx.generics_of(item);
 
@@ -1934,7 +1934,7 @@ impl ExplicitOutlivesRequirements {
             .filter_map(|(clause, _)| match clause.kind().skip_binder() {
                 ty::ClauseKind::RegionOutlives(ty::OutlivesPredicate(a, b)) => match *a {
                     ty::ReEarlyParam(ebr)
-                        if item_generics.region_param(ebr, tcx).def_id == lifetime =>
+                        if item_generics.region_param(ebr, tcx).def_id == lifetime.to_def_id() =>
                     {
                         Some(b)
                     }
@@ -1982,7 +1982,7 @@ impl ExplicitOutlivesRequirements {
                 let is_inferred = match tcx.named_bound_var(lifetime.hir_id) {
                     Some(ResolvedArg::EarlyBound(def_id)) => inferred_outlives
                         .iter()
-                        .any(|r| matches!(**r, ty::ReEarlyParam(ebr) if { item_generics.region_param(ebr, tcx).def_id == def_id })),
+                        .any(|r| matches!(**r, ty::ReEarlyParam(ebr) if { item_generics.region_param(ebr, tcx).def_id == def_id.to_def_id() })),
                     _ => false,
                 };
 
@@ -2097,7 +2097,7 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitOutlivesRequirements {
                                         inferred_outlives
                                             .iter()
                                             .filter(|(_, span)| !predicate.span.contains(*span)),
-                                        item.owner_id.to_def_id(),
+                                        item.owner_id.def_id,
                                         region_def_id,
                                     ),
                                     &predicate.bounds,
diff --git a/compiler/rustc_lint/src/impl_trait_overcaptures.rs b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
index 990fb2d16f9dd..2e0da69e92070 100644
--- a/compiler/rustc_lint/src/impl_trait_overcaptures.rs
+++ b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
@@ -300,16 +300,17 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for VisitOpaqueTypes<'tcx> {
                         Some(
                             ResolvedArg::EarlyBound(def_id) | ResolvedArg::LateBound(_, _, def_id),
                         ) => {
-                            if self.tcx.def_kind(self.tcx.parent(def_id)) == DefKind::OpaqueTy {
+                            if self.tcx.def_kind(self.tcx.local_parent(def_id)) == DefKind::OpaqueTy
+                            {
                                 let def_id = self
                                     .tcx
-                                    .map_opaque_lifetime_to_parent_lifetime(def_id.expect_local())
+                                    .map_opaque_lifetime_to_parent_lifetime(def_id)
                                     .opt_param_def_id(self.tcx, self.parent_def_id.to_def_id())
                                     .expect("variable should have been duplicated from parent");
 
                                 explicitly_captured.insert(def_id);
                             } else {
-                                explicitly_captured.insert(def_id);
+                                explicitly_captured.insert(def_id.to_def_id());
                             }
                         }
                         _ => {
diff --git a/compiler/rustc_middle/src/middle/resolve_bound_vars.rs b/compiler/rustc_middle/src/middle/resolve_bound_vars.rs
index a4f6d7afe4d11..32e2f3b4b1685 100644
--- a/compiler/rustc_middle/src/middle/resolve_bound_vars.rs
+++ b/compiler/rustc_middle/src/middle/resolve_bound_vars.rs
@@ -2,7 +2,7 @@
 
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::ErrorGuaranteed;
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::{ItemLocalId, OwnerId};
 use rustc_macros::{Decodable, Encodable, HashStable, TyDecodable, TyEncodable};
 
@@ -11,9 +11,9 @@ use crate::ty;
 #[derive(Clone, Copy, PartialEq, Eq, Hash, TyEncodable, TyDecodable, Debug, HashStable)]
 pub enum ResolvedArg {
     StaticLifetime,
-    EarlyBound(/* decl */ DefId),
-    LateBound(ty::DebruijnIndex, /* late-bound index */ u32, /* decl */ DefId),
-    Free(DefId, /* lifetime decl */ DefId),
+    EarlyBound(/* decl */ LocalDefId),
+    LateBound(ty::DebruijnIndex, /* late-bound index */ u32, /* decl */ LocalDefId),
+    Free(LocalDefId, /* lifetime decl */ LocalDefId),
     Error(ErrorGuaranteed),
 }
 
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 9b39b84970420..cad3515f06809 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -3035,13 +3035,13 @@ impl<'tcx> TyCtxt<'tcx> {
 
             match self.named_bound_var(lifetime.hir_id) {
                 Some(resolve_bound_vars::ResolvedArg::EarlyBound(ebv)) => {
-                    let new_parent = self.parent(ebv);
+                    let new_parent = self.local_parent(ebv);
 
                     // If we map to another opaque, then it should be a parent
                     // of the opaque we mapped from. Continue mapping.
                     if matches!(self.def_kind(new_parent), DefKind::OpaqueTy) {
-                        debug_assert_eq!(self.parent(parent.to_def_id()), new_parent);
-                        opaque_lifetime_param_def_id = ebv.expect_local();
+                        debug_assert_eq!(self.local_parent(parent), new_parent);
+                        opaque_lifetime_param_def_id = ebv;
                         continue;
                     }
 
@@ -3050,20 +3050,20 @@ impl<'tcx> TyCtxt<'tcx> {
                         self,
                         ty::EarlyParamRegion {
                             index: generics
-                                .param_def_id_to_index(self, ebv)
+                                .param_def_id_to_index(self, ebv.to_def_id())
                                 .expect("early-bound var should be present in fn generics"),
-                            name: self.hir().name(self.local_def_id_to_hir_id(ebv.expect_local())),
+                            name: self.item_name(ebv.to_def_id()),
                         },
                     );
                 }
                 Some(resolve_bound_vars::ResolvedArg::LateBound(_, _, lbv)) => {
-                    let new_parent = self.parent(lbv);
+                    let new_parent = self.local_parent(lbv);
                     return ty::Region::new_late_param(
                         self,
-                        new_parent,
+                        new_parent.to_def_id(),
                         ty::BoundRegionKind::BrNamed(
-                            lbv,
-                            self.hir().name(self.local_def_id_to_hir_id(lbv.expect_local())),
+                            lbv.to_def_id(),
+                            self.item_name(lbv.to_def_id()),
                         ),
                     );
                 }
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/find_anon_type.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/find_anon_type.rs
index 3f35391be1355..cd61747917a88 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/find_anon_type.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/find_anon_type.rs
@@ -101,7 +101,7 @@ impl<'tcx> Visitor<'tcx> for FindNestedTypeVisitor<'tcx> {
                     // region at the right depth with the same index
                     (Some(rbv::ResolvedArg::EarlyBound(id)), ty::BrNamed(def_id, _)) => {
                         debug!("EarlyBound id={:?} def_id={:?}", id, def_id);
-                        if id == def_id {
+                        if id.to_def_id() == def_id {
                             return ControlFlow::Break(arg);
                         }
                     }
@@ -118,7 +118,7 @@ impl<'tcx> Visitor<'tcx> for FindNestedTypeVisitor<'tcx> {
                             debruijn_index
                         );
                         debug!("LateBound id={:?} def_id={:?}", id, def_id);
-                        if debruijn_index == self.current_index && id == def_id {
+                        if debruijn_index == self.current_index && id.to_def_id() == def_id {
                             return ControlFlow::Break(arg);
                         }
                     }
@@ -192,7 +192,7 @@ impl<'tcx> Visitor<'tcx> for TyPathVisitor<'tcx> {
             // the lifetime of the TyPath!
             (Some(rbv::ResolvedArg::EarlyBound(id)), ty::BrNamed(def_id, _)) => {
                 debug!("EarlyBound id={:?} def_id={:?}", id, def_id);
-                if id == def_id {
+                if id.to_def_id() == def_id {
                     return ControlFlow::Break(());
                 }
             }
@@ -201,7 +201,7 @@ impl<'tcx> Visitor<'tcx> for TyPathVisitor<'tcx> {
                 debug!("FindNestedTypeVisitor::visit_ty: LateBound depth = {:?}", debruijn_index,);
                 debug!("id={:?}", id);
                 debug!("def_id={:?}", def_id);
-                if debruijn_index == self.current_index && id == def_id {
+                if debruijn_index == self.current_index && id.to_def_id() == def_id {
                     return ControlFlow::Break(());
                 }
             }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index db81b4c4282a1..5260e363dd68c 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -272,7 +272,7 @@ fn clean_lifetime<'tcx>(lifetime: &hir::Lifetime, cx: &mut DocContext<'tcx>) ->
         | rbv::ResolvedArg::LateBound(_, _, did)
         | rbv::ResolvedArg::Free(_, did),
     ) = cx.tcx.named_bound_var(lifetime.hir_id)
-        && let Some(lt) = cx.args.get(&did).and_then(|arg| arg.as_lt())
+        && let Some(lt) = cx.args.get(&did.to_def_id()).and_then(|arg| arg.as_lt())
     {
         return lt.clone();
     }

From 7232a07f5a44831b794be120b8bfd52b856a13f6 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 22 Aug 2024 11:51:02 +1000
Subject: [PATCH 505/685] Explain the `run-make/debugger-visualizer-dep-info`
 Python script

---
 tests/run-make/debugger-visualizer-dep-info/foo.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/tests/run-make/debugger-visualizer-dep-info/foo.py b/tests/run-make/debugger-visualizer-dep-info/foo.py
index 1bb8bf6d7fd4c..d319792657eda 100644
--- a/tests/run-make/debugger-visualizer-dep-info/foo.py
+++ b/tests/run-make/debugger-visualizer-dep-info/foo.py
@@ -1 +1,6 @@
-# empty
+# This is a Python script, but we don't actually run it.
+# So if you're trying to remove Python scripts from the test suite,
+# be aware that there's no value in trying to get rid of this one.
+#
+# It just needs to exist so that the compiler can embed it via
+# `#![debugger_visualizer(gdb_script_file = "...")]`.

From 5fc562c5b1a53fd78ecad2da7481c0559705307b Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 22 Aug 2024 11:52:21 +1000
Subject: [PATCH 506/685] Rename `foo.py` to `my_gdb_script.py`

This makes it easier for maintainers to see what the Python script is for.
---
 tests/run-make/debugger-visualizer-dep-info/main.rs             | 2 +-
 .../debugger-visualizer-dep-info/{foo.py => my_gdb_script.py}   | 0
 tests/run-make/debugger-visualizer-dep-info/rmake.rs            | 2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)
 rename tests/run-make/debugger-visualizer-dep-info/{foo.py => my_gdb_script.py} (100%)

diff --git a/tests/run-make/debugger-visualizer-dep-info/main.rs b/tests/run-make/debugger-visualizer-dep-info/main.rs
index 3aede2215eac2..3539b305be353 100644
--- a/tests/run-make/debugger-visualizer-dep-info/main.rs
+++ b/tests/run-make/debugger-visualizer-dep-info/main.rs
@@ -1,4 +1,4 @@
-#![debugger_visualizer(gdb_script_file = "foo.py")]
+#![debugger_visualizer(gdb_script_file = "my_gdb_script.py")]
 
 fn main() {
     const _UNUSED: u32 = {
diff --git a/tests/run-make/debugger-visualizer-dep-info/foo.py b/tests/run-make/debugger-visualizer-dep-info/my_gdb_script.py
similarity index 100%
rename from tests/run-make/debugger-visualizer-dep-info/foo.py
rename to tests/run-make/debugger-visualizer-dep-info/my_gdb_script.py
diff --git a/tests/run-make/debugger-visualizer-dep-info/rmake.rs b/tests/run-make/debugger-visualizer-dep-info/rmake.rs
index 65ffb2373e7c4..f5cf39157ac65 100644
--- a/tests/run-make/debugger-visualizer-dep-info/rmake.rs
+++ b/tests/run-make/debugger-visualizer-dep-info/rmake.rs
@@ -6,6 +6,6 @@ use run_make_support::{invalid_utf8_contains, rustc};
 
 fn main() {
     rustc().emit("dep-info").input("main.rs").run();
-    invalid_utf8_contains("main.d", "foo.py");
+    invalid_utf8_contains("main.d", "my_gdb_script.py");
     invalid_utf8_contains("main.d", "my_visualizers/bar.natvis");
 }

From 34cdfc9b490c7d7cc284fcdaf2338976ee6329bf Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Thu, 22 Aug 2024 11:58:46 +1000
Subject: [PATCH 507/685] Advise against removing
 `run-make/libtest-junit/validate_junit.py`

Trying to get rid of this Python script looks tempting, because it's currently
the only Python script in the whole `run-make` suite that we actually run.

But getting rid of it would require pulling in a Rust crate to parse XML
instead, and that's probably not worth the extra hassle for a relatively-minor
test.
---
 tests/run-make/libtest-junit/validate_junit.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/run-make/libtest-junit/validate_junit.py b/tests/run-make/libtest-junit/validate_junit.py
index 0d9b34a3cf7e0..f92473751b036 100755
--- a/tests/run-make/libtest-junit/validate_junit.py
+++ b/tests/run-make/libtest-junit/validate_junit.py
@@ -1,5 +1,15 @@
 #!/usr/bin/env python
 
+# Trivial Python script that reads lines from stdin, and checks that each line
+# is a well-formed XML document.
+#
+# This takes advantage of the fact that Python has a built-in XML parser,
+# whereas doing the same check in Rust would require us to pull in an XML
+# crate just for this relatively-minor test.
+#
+# If you're trying to remove Python scripts from the test suite, think twice
+# before removing this one. You could do so, but it's probably not worth it.
+
 import sys
 import xml.etree.ElementTree as ET
 

From ca7c55f0502f1e25bfaf9191bd7e145645eb3d03 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 22 Aug 2024 02:10:45 +0000
Subject: [PATCH 508/685] Do not rely on names to find lifetimes.

---
 .../src/error_reporting/infer/region.rs       | 24 ++++---------------
 ...regions-bound-missing-bound-in-impl.stderr |  9 ++++---
 .../elided-lifetime.stderr                    |  6 ++---
 .../static-trait-impl.stderr                  |  6 ++---
 ...d-bounds-compatibility-unnormalized.stderr |  4 ++--
 tests/ui/issues/issue-20831-debruijn.stderr   |  4 ++--
 tests/ui/issues/issue-37884.stderr            |  5 +---
 7 files changed, 19 insertions(+), 39 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
index 877a8a23d7f2b..212f884b4f70e 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/region.rs
@@ -1079,16 +1079,8 @@ fn msg_span_from_named_region<'tcx>(
 ) -> (String, Option<Span>) {
     match *region {
         ty::ReEarlyParam(br) => {
-            let scope = tcx
-                .parent(tcx.generics_of(generic_param_scope).region_param(br, tcx).def_id)
-                .expect_local();
-            let span = if let Some(param) =
-                tcx.hir().get_generics(scope).and_then(|generics| generics.get_named(br.name))
-            {
-                param.span
-            } else {
-                tcx.def_span(scope)
-            };
+            let param_def_id = tcx.generics_of(generic_param_scope).region_param(br, tcx).def_id;
+            let span = tcx.def_span(param_def_id);
             let text = if br.has_name() {
                 format!("the lifetime `{}` as defined here", br.name)
             } else {
@@ -1104,16 +1096,8 @@ fn msg_span_from_named_region<'tcx>(
                 ("the anonymous lifetime defined here".to_string(), Some(ty.span))
             } else {
                 match fr.bound_region {
-                    ty::BoundRegionKind::BrNamed(_, name) => {
-                        let span = if let Some(param) = tcx
-                            .hir()
-                            .get_generics(generic_param_scope)
-                            .and_then(|generics| generics.get_named(name))
-                        {
-                            param.span
-                        } else {
-                            tcx.def_span(generic_param_scope)
-                        };
+                    ty::BoundRegionKind::BrNamed(param_def_id, name) => {
+                        let span = tcx.def_span(param_def_id);
                         let text = if name == kw::UnderscoreLifetime {
                             "the anonymous lifetime as defined here".to_string()
                         } else {
diff --git a/tests/ui/borrowck/regions-bound-missing-bound-in-impl.stderr b/tests/ui/borrowck/regions-bound-missing-bound-in-impl.stderr
index 54d8f26f4ea8e..5f0347bdb4d49 100644
--- a/tests/ui/borrowck/regions-bound-missing-bound-in-impl.stderr
+++ b/tests/ui/borrowck/regions-bound-missing-bound-in-impl.stderr
@@ -30,9 +30,9 @@ note: the lifetime `'c` as defined here...
 LL |     fn wrong_bound1<'b,'c,'d:'a+'c>(self, b: Inv<'b>, c: Inv<'c>, d: Inv<'d>) {
    |                        ^^
 note: ...does not necessarily outlive the lifetime `'c` as defined here
-  --> $DIR/regions-bound-missing-bound-in-impl.rs:27:24
+  --> $DIR/regions-bound-missing-bound-in-impl.rs:12:24
    |
-LL |     fn wrong_bound1<'b,'c,'d:'a+'c>(self, b: Inv<'b>, c: Inv<'c>, d: Inv<'d>) {
+LL |     fn wrong_bound1<'b,'c,'d:'a+'b>(self, b: Inv<'b>, c: Inv<'c>, d: Inv<'d>);
    |                        ^^
 
 error[E0308]: method not compatible with trait
@@ -44,16 +44,15 @@ LL |     fn wrong_bound1<'b,'c,'d:'a+'c>(self, b: Inv<'b>, c: Inv<'c>, d: Inv<'d
    = note: expected signature `fn(&'a _, Inv<'c>, Inv<'c>, Inv<'_>)`
               found signature `fn(&'a _, Inv<'_>, Inv<'c>, Inv<'_>)`
 note: the lifetime `'c` as defined here...
-  --> $DIR/regions-bound-missing-bound-in-impl.rs:27:24
+  --> $DIR/regions-bound-missing-bound-in-impl.rs:12:24
    |
-LL |     fn wrong_bound1<'b,'c,'d:'a+'c>(self, b: Inv<'b>, c: Inv<'c>, d: Inv<'d>) {
+LL |     fn wrong_bound1<'b,'c,'d:'a+'b>(self, b: Inv<'b>, c: Inv<'c>, d: Inv<'d>);
    |                        ^^
 note: ...does not necessarily outlive the lifetime `'c` as defined here
   --> $DIR/regions-bound-missing-bound-in-impl.rs:27:24
    |
 LL |     fn wrong_bound1<'b,'c,'d:'a+'c>(self, b: Inv<'b>, c: Inv<'c>, d: Inv<'d>) {
    |                        ^^
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0195]: lifetime parameters or bounds on method `wrong_bound2` do not match the trait declaration
   --> $DIR/regions-bound-missing-bound-in-impl.rs:42:20
diff --git a/tests/ui/consts/static-default-lifetime/elided-lifetime.stderr b/tests/ui/consts/static-default-lifetime/elided-lifetime.stderr
index d4fc171753894..ec01225c6bfa1 100644
--- a/tests/ui/consts/static-default-lifetime/elided-lifetime.stderr
+++ b/tests/ui/consts/static-default-lifetime/elided-lifetime.stderr
@@ -48,10 +48,10 @@ LL |     const STATIC: &str = "";
    = note: expected reference `&'static _`
               found reference `&_`
 note: the anonymous lifetime as defined here...
-  --> $DIR/elided-lifetime.rs:15:18
+  --> $DIR/elided-lifetime.rs:16:19
    |
-LL | impl Bar for Foo<'_> {
-   |                  ^^
+LL |     const STATIC: &str = "";
+   |                   ^
    = note: ...does not necessarily outlive the static lifetime
 
 error: aborting due to 3 previous errors
diff --git a/tests/ui/consts/static-default-lifetime/static-trait-impl.stderr b/tests/ui/consts/static-default-lifetime/static-trait-impl.stderr
index 8e4c27875ab3c..b8e2f412b492c 100644
--- a/tests/ui/consts/static-default-lifetime/static-trait-impl.stderr
+++ b/tests/ui/consts/static-default-lifetime/static-trait-impl.stderr
@@ -30,10 +30,10 @@ LL |     const STATIC: &str = "";
    = note: expected reference `&_`
               found reference `&_`
 note: the anonymous lifetime as defined here...
-  --> $DIR/static-trait-impl.rs:8:10
+  --> $DIR/static-trait-impl.rs:9:19
    |
-LL | impl Bar<'_> for A {
-   |          ^^
+LL |     const STATIC: &str = "";
+   |                   ^
 note: ...does not necessarily outlive the anonymous lifetime as defined here
   --> $DIR/static-trait-impl.rs:8:10
    |
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 c8d1614a7f3db..f498257e12f13 100644
--- a/tests/ui/implied-bounds/impl-implied-bounds-compatibility-unnormalized.stderr
+++ b/tests/ui/implied-bounds/impl-implied-bounds-compatibility-unnormalized.stderr
@@ -5,9 +5,9 @@ LL |     fn get<'s>(s: &'s str, _: <&'static &'s () as Project>::Ty) -> &'static
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first, the lifetime cannot outlive the lifetime `'s` as defined here...
-  --> $DIR/impl-implied-bounds-compatibility-unnormalized.rs:11:12
+  --> $DIR/impl-implied-bounds-compatibility-unnormalized.rs:8:12
    |
-LL |     fn get<'s>(s: &'s str, _: <&'static &'s () as Project>::Ty) -> &'static str {
+LL |     fn get<'s>(s: &'s str, _: ()) -> &'static str;
    |            ^^
 note: ...so that the method type is compatible with trait
   --> $DIR/impl-implied-bounds-compatibility-unnormalized.rs:11:5
diff --git a/tests/ui/issues/issue-20831-debruijn.stderr b/tests/ui/issues/issue-20831-debruijn.stderr
index 60721f001b738..fe310998f091d 100644
--- a/tests/ui/issues/issue-20831-debruijn.stderr
+++ b/tests/ui/issues/issue-20831-debruijn.stderr
@@ -5,10 +5,10 @@ LL |     fn subscribe(&mut self, t : Box<dyn Subscriber<Input=<Self as Publisher
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first, the lifetime cannot outlive the anonymous lifetime as defined here...
-  --> $DIR/issue-20831-debruijn.rs:28:18
+  --> $DIR/issue-20831-debruijn.rs:28:67
    |
 LL |     fn subscribe(&mut self, t : Box<dyn Subscriber<Input=<Self as Publisher>::Output> + 'a>) {
-   |                  ^
+   |                                                                   ^^^^^^^^^
 note: ...but the lifetime must also be valid for the lifetime `'a` as defined here...
   --> $DIR/issue-20831-debruijn.rs:26:6
    |
diff --git a/tests/ui/issues/issue-37884.stderr b/tests/ui/issues/issue-37884.stderr
index b7c0095d682a2..17037d2180dcc 100644
--- a/tests/ui/issues/issue-37884.stderr
+++ b/tests/ui/issues/issue-37884.stderr
@@ -7,10 +7,7 @@ LL |     fn next(&'a mut self) -> Option<Self::Item>
    = note: expected signature `fn(&mut RepeatMut<'_, _>) -> Option<_>`
               found signature `fn(&'a mut RepeatMut<'_, _>) -> Option<_>`
 note: the anonymous lifetime as defined here...
-  --> $DIR/issue-37884.rs:6:5
-   |
-LL |     fn next(&'a mut self) -> Option<Self::Item>
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  --> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
 note: ...does not necessarily outlive the lifetime `'a` as defined here
   --> $DIR/issue-37884.rs:3:6
    |

From 080c2ca2dcdf38f9337f0aedaa166ec6fbebd681 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Le=C3=B3n=20Orell=20Valerian=20Liehr?= <me@fmease.dev>
Date: Thu, 22 Aug 2024 05:30:08 +0200
Subject: [PATCH 509/685] Pretty-print own args of existential projections

---
 compiler/rustc_middle/src/ty/print/pretty.rs  |  5 +-
 .../gat-in-trait-path.base.stderr             |  2 +-
 .../issue-76535.base.stderr                   |  2 +-
 .../issue-79422.base.stderr                   |  2 +-
 .../issue-79422.extended.stderr               |  2 +-
 tests/ui/traits/object/pretty.rs              |  7 +++
 tests/ui/traits/object/pretty.stderr          | 50 +++++++++++++------
 7 files changed, 50 insertions(+), 20 deletions(-)

diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 56ddf146636c8..cd80cc4d1abcd 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -3119,7 +3119,10 @@ define_print! {
 
     ty::ExistentialProjection<'tcx> {
         let name = cx.tcx().associated_item(self.def_id).name;
-        p!(write("{} = ", name), print(self.term))
+        // The args don't contain the self ty (as it has been erased) but the corresp.
+        // generics do as the trait always has a self ty param. We need to offset.
+        let args = &self.args[cx.tcx().generics_of(self.def_id).parent_count - 1..];
+        p!(path_generic_args(|cx| write!(cx, "{name}"), args), " = ", print(self.term))
     }
 
     ty::ProjectionPredicate<'tcx> {
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 d1decc0c3f181..37491ca12b000 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
@@ -51,7 +51,7 @@ LL |     type A<'a> where Self: 'a;
    = help: the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing `Foo` for this new enum and using it instead:
              Fooy
              Fooer<T>
-   = note: required for the cast from `Box<Fooer<{integer}>>` to `Box<(dyn Foo<A = &'a ()> + 'static)>`
+   = note: required for the cast from `Box<Fooer<{integer}>>` to `Box<(dyn Foo<A<'a> = &'a ()> + 'static)>`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/generic-associated-types/issue-76535.base.stderr b/tests/ui/generic-associated-types/issue-76535.base.stderr
index bb14e297174a6..88c08051da7ed 100644
--- a/tests/ui/generic-associated-types/issue-76535.base.stderr
+++ b/tests/ui/generic-associated-types/issue-76535.base.stderr
@@ -47,7 +47,7 @@ LL |     type SubType<'a>: SubTrait where Self: 'a;
    = help: consider moving `SubType` to another trait
    = help: only type `SuperStruct` is seen to implement the trait in this crate, consider using it directly instead
    = note: `SuperTrait` can be implemented in other crates; if you want to support your users passing their own types here, you can't refer to a specific type
-   = note: required for the cast from `Box<SuperStruct>` to `Box<dyn SuperTrait<SubType = SubStruct<'_>>>`
+   = note: required for the cast from `Box<SuperStruct>` to `Box<dyn SuperTrait<SubType<'_> = SubStruct<'_>>>`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/generic-associated-types/issue-79422.base.stderr b/tests/ui/generic-associated-types/issue-79422.base.stderr
index bcc6382cf7cd2..551ad2a8fdffc 100644
--- a/tests/ui/generic-associated-types/issue-79422.base.stderr
+++ b/tests/ui/generic-associated-types/issue-79422.base.stderr
@@ -49,7 +49,7 @@ LL |     type VRefCont<'a>: RefCont<'a, V> where Self: 'a;
    = help: the following types implement the trait, consider defining an enum where each variant holds one of these types, implementing `MapLike` for this new enum and using it instead:
              std::collections::BTreeMap<K, V>
              Source
-   = note: required for the cast from `Box<BTreeMap<u8, u8>>` to `Box<dyn MapLike<u8, u8, VRefCont = (dyn RefCont<'_, u8> + 'static)>>`
+   = note: required for the cast from `Box<BTreeMap<u8, u8>>` to `Box<dyn MapLike<u8, u8, VRefCont<'_> = (dyn RefCont<'_, u8> + 'static)>>`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/generic-associated-types/issue-79422.extended.stderr b/tests/ui/generic-associated-types/issue-79422.extended.stderr
index ae1526296a795..031f8d8d851a1 100644
--- a/tests/ui/generic-associated-types/issue-79422.extended.stderr
+++ b/tests/ui/generic-associated-types/issue-79422.extended.stderr
@@ -28,7 +28,7 @@ LL |     type VRefCont<'a> = &'a V where Self: 'a;
    = note: expected trait object `(dyn RefCont<'_, u8> + 'static)`
                  found reference `&u8`
    = help: `&u8` implements `RefCont` so you could box the found value and coerce it to the trait object `Box<dyn RefCont>`, you will have to change the expected type as well
-   = note: required for the cast from `Box<BTreeMap<u8, u8>>` to `Box<dyn MapLike<u8, u8, VRefCont = (dyn RefCont<'_, u8> + 'static)>>`
+   = note: required for the cast from `Box<BTreeMap<u8, u8>>` to `Box<dyn MapLike<u8, u8, VRefCont<'_> = (dyn RefCont<'_, u8> + 'static)>>`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/traits/object/pretty.rs b/tests/ui/traits/object/pretty.rs
index 8958871ed5d72..6660ff040f753 100644
--- a/tests/ui/traits/object/pretty.rs
+++ b/tests/ui/traits/object/pretty.rs
@@ -18,6 +18,10 @@ trait FixedHrtb: for<'a> SuperGeneric<'a, Assoc2 = &'a u8> {}
 trait AnyDifferentBinders: for<'a> SuperGeneric<'a, Assoc2 = &'a u8> + Super {}
 trait FixedDifferentBinders: for<'a> SuperGeneric<'a, Assoc2 = &'a u8> + Super<Assoc = u8> {}
 
+trait HasGat<Outer> {
+    type Assoc<Inner> where Self: Sized;
+}
+
 fn dyn_super(x: &dyn Super<Assoc = u8>) { x } //~ERROR mismatched types
 fn dyn_any(x: &dyn Any<Assoc = u8>) { x } //~ERROR mismatched types
 fn dyn_fixed(x: &dyn Fixed) { x } //~ERROR mismatched types
@@ -34,4 +38,7 @@ fn dyn_fixed_hrtb(x: &dyn FixedHrtb) { x } //~ERROR mismatched types
 fn dyn_any_different_binders(x: &dyn AnyDifferentBinders<Assoc = u8>) { x } //~ERROR mismatched types
 fn dyn_fixed_different_binders(x: &dyn FixedDifferentBinders) { x } //~ERROR mismatched types
 
+fn dyn_has_gat(x: &dyn HasGat<u8, Assoc<bool> = ()>) { x } //~ERROR mismatched types
+//~^ WARN unnecessary associated type bound
+
 fn main() {}
diff --git a/tests/ui/traits/object/pretty.stderr b/tests/ui/traits/object/pretty.stderr
index bc645e5f9677d..6964d97c08ed8 100644
--- a/tests/ui/traits/object/pretty.stderr
+++ b/tests/ui/traits/object/pretty.stderr
@@ -1,5 +1,14 @@
+warning: unnecessary associated type bound for not object safe associated type
+  --> $DIR/pretty.rs:41:35
+   |
+LL | fn dyn_has_gat(x: &dyn HasGat<u8, Assoc<bool> = ()>) { x }
+   |                                   ^^^^^^^^^^^^^^^^ help: remove this bound
+   |
+   = note: this associated type has a `where Self: Sized` bound, and while the associated type can be specified, it cannot be used because trait objects are never `Sized`
+   = note: `#[warn(unused_associated_type_bounds)]` on by default
+
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:21:43
+  --> $DIR/pretty.rs:25:43
    |
 LL | fn dyn_super(x: &dyn Super<Assoc = u8>) { x }
    |                                        -  ^ expected `()`, found `&dyn Super<Assoc = u8>`
@@ -10,7 +19,7 @@ LL | fn dyn_super(x: &dyn Super<Assoc = u8>) { x }
               found reference `&dyn Super<Assoc = u8>`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:22:39
+  --> $DIR/pretty.rs:26:39
    |
 LL | fn dyn_any(x: &dyn Any<Assoc = u8>) { x }
    |                                    -  ^ expected `()`, found `&dyn Any<Assoc = u8>`
@@ -21,7 +30,7 @@ LL | fn dyn_any(x: &dyn Any<Assoc = u8>) { x }
               found reference `&dyn Any<Assoc = u8>`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:23:31
+  --> $DIR/pretty.rs:27:31
    |
 LL | fn dyn_fixed(x: &dyn Fixed) { x }
    |                            -  ^ expected `()`, found `&dyn Fixed`
@@ -32,7 +41,7 @@ LL | fn dyn_fixed(x: &dyn Fixed) { x }
               found reference `&dyn Fixed`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:24:50
+  --> $DIR/pretty.rs:28:50
    |
 LL | fn dyn_fixed_multi(x: &dyn Fixed<Assoc = u16>) { x }
    |                                               -  ^ expected `()`, found `&dyn Fixed<Assoc = u16>`
@@ -43,7 +52,7 @@ LL | fn dyn_fixed_multi(x: &dyn Fixed<Assoc = u16>) { x }
               found reference `&dyn Fixed<Assoc = u16>`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:25:38
+  --> $DIR/pretty.rs:29:38
    |
 LL | fn dyn_fixed_sub(x: &dyn FixedSub) { x }
    |                                   -  ^ expected `()`, found `&dyn FixedSub`
@@ -54,7 +63,7 @@ LL | fn dyn_fixed_sub(x: &dyn FixedSub) { x }
               found reference `&dyn FixedSub`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:26:44
+  --> $DIR/pretty.rs:30:44
    |
 LL | fn dyn_fixed_static(x: &dyn FixedStatic) { x }
    |                                         -  ^ expected `()`, found `&dyn FixedStatic`
@@ -65,7 +74,7 @@ LL | fn dyn_fixed_static(x: &dyn FixedStatic) { x }
               found reference `&dyn FixedStatic`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:28:75
+  --> $DIR/pretty.rs:32:75
    |
 LL | fn dyn_super_generic(x: &dyn for<'a> SuperGeneric<'a, Assoc2 = &'a u8>) { x }
    |                                                                        -  ^ expected `()`, found `&dyn SuperGeneric<'a, Assoc2 = &u8>`
@@ -76,7 +85,7 @@ LL | fn dyn_super_generic(x: &dyn for<'a> SuperGeneric<'a, Assoc2 = &'a u8>) { x
               found reference `&dyn for<'a> SuperGeneric<'a, Assoc2 = &'a u8>`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:29:71
+  --> $DIR/pretty.rs:33:71
    |
 LL | fn dyn_any_generic(x: &dyn for<'a> AnyGeneric<'a, Assoc2 = &'a u8>) { x }
    |                                                                    -  ^ expected `()`, found `&dyn AnyGeneric<'a, Assoc2 = &u8>`
@@ -87,7 +96,7 @@ LL | fn dyn_any_generic(x: &dyn for<'a> AnyGeneric<'a, Assoc2 = &'a u8>) { x }
               found reference `&dyn for<'a> AnyGeneric<'a, Assoc2 = &'a u8>`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:30:60
+  --> $DIR/pretty.rs:34:60
    |
 LL | fn dyn_fixed_generic1(x: &dyn for<'a> FixedGeneric1<'a>) { x }
    |                                                         -  ^ expected `()`, found `&dyn FixedGeneric1<'a>`
@@ -98,7 +107,7 @@ LL | fn dyn_fixed_generic1(x: &dyn for<'a> FixedGeneric1<'a>) { x }
               found reference `&dyn for<'a> FixedGeneric1<'a>`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:31:60
+  --> $DIR/pretty.rs:35:60
    |
 LL | fn dyn_fixed_generic2(x: &dyn for<'a> FixedGeneric2<'a>) { x }
    |                                                         -  ^ expected `()`, found `&dyn FixedGeneric2<'a>`
@@ -109,7 +118,7 @@ LL | fn dyn_fixed_generic2(x: &dyn for<'a> FixedGeneric2<'a>) { x }
               found reference `&dyn for<'a> FixedGeneric2<'a>`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:32:79
+  --> $DIR/pretty.rs:36:79
    |
 LL | fn dyn_fixed_generic_multi(x: &dyn for<'a> FixedGeneric1<'a, Assoc2 = &u8>) { x }
    |                                                                            -  ^ expected `()`, found `&dyn FixedGeneric1<'a, Assoc2 = ...>`
@@ -120,7 +129,7 @@ LL | fn dyn_fixed_generic_multi(x: &dyn for<'a> FixedGeneric1<'a, Assoc2 = &u8>)
               found reference `&dyn for<'a> FixedGeneric1<'a, Assoc2 = &u8>`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:33:40
+  --> $DIR/pretty.rs:37:40
    |
 LL | fn dyn_fixed_hrtb(x: &dyn FixedHrtb) { x }
    |                                     -  ^ expected `()`, found `&dyn FixedHrtb`
@@ -131,7 +140,7 @@ LL | fn dyn_fixed_hrtb(x: &dyn FixedHrtb) { x }
               found reference `&dyn FixedHrtb`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:34:73
+  --> $DIR/pretty.rs:38:73
    |
 LL | fn dyn_any_different_binders(x: &dyn AnyDifferentBinders<Assoc = u8>) { x }
    |                                                                      -  ^ expected `()`, found `&dyn AnyDifferentBinders<Assoc = ...>`
@@ -142,7 +151,7 @@ LL | fn dyn_any_different_binders(x: &dyn AnyDifferentBinders<Assoc = u8>) { x }
               found reference `&dyn AnyDifferentBinders<Assoc = u8>`
 
 error[E0308]: mismatched types
-  --> $DIR/pretty.rs:35:65
+  --> $DIR/pretty.rs:39:65
    |
 LL | fn dyn_fixed_different_binders(x: &dyn FixedDifferentBinders) { x }
    |                                                              -  ^ expected `()`, found `&dyn FixedDifferentBinders`
@@ -152,6 +161,17 @@ LL | fn dyn_fixed_different_binders(x: &dyn FixedDifferentBinders) { x }
    = note: expected unit type `()`
               found reference `&dyn FixedDifferentBinders`
 
-error: aborting due to 14 previous errors
+error[E0308]: mismatched types
+  --> $DIR/pretty.rs:41:56
+   |
+LL | fn dyn_has_gat(x: &dyn HasGat<u8, Assoc<bool> = ()>) { x }
+   |                                                     -  ^ expected `()`, found `&dyn HasGat<u8, Assoc<bool> = ()>`
+   |                                                     |
+   |                                                     help: try adding a return type: `-> &dyn HasGat<u8, Assoc<bool> = ()>`
+   |
+   = note: expected unit type `()`
+              found reference `&dyn HasGat<u8, Assoc<bool> = ()>`
+
+error: aborting due to 15 previous errors; 1 warning emitted
 
 For more information about this error, try `rustc --explain E0308`.

From 0a8343c146d4c5566426db722504f058edf79285 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sun, 18 Aug 2024 19:49:26 +0300
Subject: [PATCH 510/685] do not build `cargo-miri` by default on stable
 channel

miri skipped for stable channel by default, do the same for `cargo-miri`.

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

diff --git a/src/bootstrap/src/core/build_steps/tool.rs b/src/bootstrap/src/core/build_steps/tool.rs
index ff8ca2ad74aaf..3a1eb43b801f5 100644
--- a/src/bootstrap/src/core/build_steps/tool.rs
+++ b/src/bootstrap/src/core/build_steps/tool.rs
@@ -1096,7 +1096,7 @@ tool_extended!((self, builder),
     CargoClippy, "src/tools/clippy", "cargo-clippy", stable=true;
     Clippy, "src/tools/clippy", "clippy-driver", stable=true, add_bins_to_sysroot = ["clippy-driver", "cargo-clippy"];
     Miri, "src/tools/miri", "miri", stable=false, add_bins_to_sysroot = ["miri"];
-    CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri", stable=true, add_bins_to_sysroot = ["cargo-miri"];
+    CargoMiri, "src/tools/miri/cargo-miri", "cargo-miri", stable=false, add_bins_to_sysroot = ["cargo-miri"];
     Rls, "src/tools/rls", "rls", stable=true;
     Rustfmt, "src/tools/rustfmt", "rustfmt", stable=true, add_bins_to_sysroot = ["rustfmt", "cargo-fmt"];
 );

From 0ce7705356cb5161dc733541f2a8c2312f0addcc Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Sun, 18 Aug 2024 19:50:44 +0300
Subject: [PATCH 511/685] document `miri` and `cargo-miri` in `build.tools`

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 config.example.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/config.example.toml b/config.example.toml
index 1b7de662e84ab..f1dc32234ccf2 100644
--- a/config.example.toml
+++ b/config.example.toml
@@ -337,6 +337,7 @@
 #    "analysis",
 #    "src",
 #    "wasm-component-ld",
+#    "miri", "cargo-miri" # for dev/nightly channels
 #]
 
 # Verbosity level: 0 == not verbose, 1 == verbose, 2 == very verbose, 3 == print environment variables on each rustc invocation

From 89e7246875e9a75b115670b9e4e2be6e9324edbc Mon Sep 17 00:00:00 2001
From: Weihang Lo <me@weihanglo.tw>
Date: Tue, 20 Aug 2024 21:28:06 -0400
Subject: [PATCH 512/685] Update cargo

---
 src/tools/cargo | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/cargo b/src/tools/cargo
index ba8b39413c74d..8f40fc59fb0c8 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit ba8b39413c74d08494f94a7542fe79aa636e1661
+Subproject commit 8f40fc59fb0c8df91c97405785197f3c630304ea

From ebfa3e3f6231c7d2353b16f1e9529b90488ee447 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 3 Aug 2024 11:17:43 +0200
Subject: [PATCH 513/685] stabilize const_fn_floating_point_arithmetic

---
 .../src/check_consts/check.rs                 | 16 +++---
 .../rustc_const_eval/src/check_consts/ops.rs  | 44 +++------------
 compiler/rustc_feature/src/accepted.rs        |  2 +
 compiler/rustc_feature/src/unstable.rs        |  2 -
 library/core/src/lib.rs                       |  2 +-
 .../clippy/tests/ui/floating_point_abs.fixed  |  1 -
 .../clippy/tests/ui/floating_point_abs.rs     |  1 -
 .../clippy/tests/ui/floating_point_abs.stderr | 16 +++---
 .../tests/ui/floating_point_mul_add.fixed     |  1 -
 .../clippy/tests/ui/floating_point_mul_add.rs |  1 -
 .../tests/ui/floating_point_mul_add.stderr    | 26 ++++-----
 .../clippy/tests/ui/floating_point_rad.fixed  |  1 -
 .../clippy/tests/ui/floating_point_rad.rs     |  1 -
 .../clippy/tests/ui/floating_point_rad.stderr | 16 +++---
 .../const-extern-fn-min-const-fn.rs           |  4 --
 .../const-extern-fn-min-const-fn.stderr       | 15 +-----
 .../consts/const-extern-fn/const-extern-fn.rs | 17 ++++++
 ..._fn_floating_point_arithmetic.gated.stderr |  8 ---
 .../const_fn_floating_point_arithmetic.rs     | 20 -------
 ..._fn_floating_point_arithmetic.stock.stderr | 53 -------------------
 tests/ui/consts/const_let_eq_float.rs         |  2 -
 .../min_const_fn_libstd_stability.rs          | 12 +++--
 .../min_const_fn_libstd_stability.stderr      | 27 ++++++----
 .../min_const_unsafe_fn_libstd_stability.rs   |  8 +--
 ...in_const_unsafe_fn_libstd_stability.stderr | 21 +-------
 tests/ui/internal/internal-unstable-const.rs  | 13 -----
 .../internal/internal-unstable-const.stderr   | 19 -------
 27 files changed, 92 insertions(+), 257 deletions(-)
 delete mode 100644 tests/ui/consts/const_fn_floating_point_arithmetic.gated.stderr
 delete mode 100644 tests/ui/consts/const_fn_floating_point_arithmetic.rs
 delete mode 100644 tests/ui/consts/const_fn_floating_point_arithmetic.stock.stderr
 delete mode 100644 tests/ui/internal/internal-unstable-const.rs
 delete mode 100644 tests/ui/internal/internal-unstable-const.stderr

diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index 86a5afa65ba87..c80b3e673b099 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -575,10 +575,8 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 
             Rvalue::UnaryOp(_, operand) => {
                 let ty = operand.ty(self.body, self.tcx);
-                if is_int_bool_or_char(ty) {
-                    // Int, bool, and char operations are fine.
-                } else if ty.is_floating_point() {
-                    self.check_op(ops::FloatingPointOp);
+                if is_int_bool_float_or_char(ty) {
+                    // Int, bool, float, and char operations are fine.
                 } else {
                     span_bug!(self.span, "non-primitive type in `Rvalue::UnaryOp`: {:?}", ty);
                 }
@@ -588,8 +586,8 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                 let lhs_ty = lhs.ty(self.body, self.tcx);
                 let rhs_ty = rhs.ty(self.body, self.tcx);
 
-                if is_int_bool_or_char(lhs_ty) && is_int_bool_or_char(rhs_ty) {
-                    // Int, bool, and char operations are fine.
+                if is_int_bool_float_or_char(lhs_ty) && is_int_bool_float_or_char(rhs_ty) {
+                    // Int, bool, float, and char operations are fine.
                 } else if lhs_ty.is_fn_ptr() || lhs_ty.is_unsafe_ptr() {
                     assert_matches!(
                         op,
@@ -603,8 +601,6 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                     );
 
                     self.check_op(ops::RawPtrComparison);
-                } else if lhs_ty.is_floating_point() || rhs_ty.is_floating_point() {
-                    self.check_op(ops::FloatingPointOp);
                 } else {
                     span_bug!(
                         self.span,
@@ -1009,8 +1005,8 @@ fn place_as_reborrow<'tcx>(
     }
 }
 
-fn is_int_bool_or_char(ty: Ty<'_>) -> bool {
-    ty.is_bool() || ty.is_integral() || ty.is_char()
+fn is_int_bool_float_or_char(ty: Ty<'_>) -> bool {
+    ty.is_bool() || ty.is_integral() || ty.is_char() || ty.is_floating_point()
 }
 
 fn emit_unstable_in_stable_error(ccx: &ConstCx<'_, '_>, span: Span, gate: Symbol) {
diff --git a/compiler/rustc_const_eval/src/check_consts/ops.rs b/compiler/rustc_const_eval/src/check_consts/ops.rs
index 259114dbdc2eb..93fafa6055773 100644
--- a/compiler/rustc_const_eval/src/check_consts/ops.rs
+++ b/compiler/rustc_const_eval/src/check_consts/ops.rs
@@ -55,28 +55,6 @@ pub trait NonConstOp<'tcx>: std::fmt::Debug {
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx>;
 }
 
-#[derive(Debug)]
-pub struct FloatingPointOp;
-impl<'tcx> NonConstOp<'tcx> for FloatingPointOp {
-    fn status_in_item(&self, ccx: &ConstCx<'_, 'tcx>) -> Status {
-        if ccx.const_kind() == hir::ConstContext::ConstFn {
-            Status::Unstable(sym::const_fn_floating_point_arithmetic)
-        } else {
-            Status::Allowed
-        }
-    }
-
-    #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
-    fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        feature_err(
-            &ccx.tcx.sess,
-            sym::const_fn_floating_point_arithmetic,
-            span,
-            format!("floating point arithmetic is not allowed in {}s", ccx.const_kind()),
-        )
-    }
-}
-
 /// A function call where the callee is a pointer.
 #[derive(Debug)]
 pub struct FnCallIndirect;
@@ -440,22 +418,12 @@ impl<'tcx> NonConstOp<'tcx> for CellBorrow {
         DiagImportance::Secondary
     }
     fn build_error(&self, ccx: &ConstCx<'_, 'tcx>, span: Span) -> Diag<'tcx> {
-        // FIXME: Maybe a more elegant solution to this if else case
-        if let hir::ConstContext::Static(_) = ccx.const_kind() {
-            ccx.dcx().create_err(errors::InteriorMutableDataRefer {
-                span,
-                opt_help: true,
-                kind: ccx.const_kind(),
-                teach: ccx.tcx.sess.teach(E0492),
-            })
-        } else {
-            ccx.dcx().create_err(errors::InteriorMutableDataRefer {
-                span,
-                opt_help: false,
-                kind: ccx.const_kind(),
-                teach: ccx.tcx.sess.teach(E0492),
-            })
-        }
+        ccx.dcx().create_err(errors::InteriorMutableDataRefer {
+            span,
+            opt_help: matches!(ccx.const_kind(), hir::ConstContext::Static(_)),
+            kind: ccx.const_kind(),
+            teach: ccx.tcx.sess.teach(E0492),
+        })
     }
 }
 
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index a4a2028e26e5c..9223c3c322a56 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -115,6 +115,8 @@ declare_features! (
     (accepted, conservative_impl_trait, "1.26.0", Some(34511)),
     /// Allows calling constructor functions in `const fn`.
     (accepted, const_constructor, "1.40.0", Some(61456)),
+    /// Allows basic arithmetic on floating point types in a `const fn`.
+    (accepted, const_fn_floating_point_arithmetic, "CURRENT_RUSTC_VERSION", Some(57241)),
     /// Allows using and casting function pointers in a `const fn`.
     (accepted, const_fn_fn_ptr_basics, "1.61.0", Some(57563)),
     /// Allows trait bounds in `const fn`.
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index a1741ac33ca5d..3a143c52a8cba 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -400,8 +400,6 @@ declare_features! (
     (incomplete, const_closures, "1.68.0", Some(106003)),
     /// Allows the definition of `const extern fn` and `const unsafe extern fn`.
     (unstable, const_extern_fn, "1.40.0", Some(64926)),
-    /// Allows basic arithmetic on floating point types in a `const fn`.
-    (unstable, const_fn_floating_point_arithmetic, "1.48.0", Some(57241)),
     /// Allows `for _ in _` loops in const contexts.
     (unstable, const_for, "1.56.0", Some(87575)),
     /// Allows using `&mut` in constant functions.
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index e3640627c562a..aa181d6058142 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -194,6 +194,7 @@
 // Language features:
 // tidy-alphabetical-start
 #![cfg_attr(bootstrap, feature(asm_const))]
+#![cfg_attr(bootstrap, feature(const_fn_floating_point_arithmetic))]
 #![cfg_attr(bootstrap, feature(min_exhaustive_patterns))]
 #![feature(abi_unadjusted)]
 #![feature(adt_const_params)]
@@ -203,7 +204,6 @@
 #![feature(cfg_sanitize)]
 #![feature(cfg_target_has_atomic)]
 #![feature(cfg_target_has_atomic_equal_alignment)]
-#![feature(const_fn_floating_point_arithmetic)]
 #![feature(const_for)]
 #![feature(const_mut_refs)]
 #![feature(const_precise_live_drops)]
diff --git a/src/tools/clippy/tests/ui/floating_point_abs.fixed b/src/tools/clippy/tests/ui/floating_point_abs.fixed
index 5312a8b29c67a..33183c7697243 100644
--- a/src/tools/clippy/tests/ui/floating_point_abs.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_abs.fixed
@@ -1,4 +1,3 @@
-#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
 /// Allow suboptimal ops in constant context
diff --git a/src/tools/clippy/tests/ui/floating_point_abs.rs b/src/tools/clippy/tests/ui/floating_point_abs.rs
index 8619177130c9f..a08d5bbcef5ce 100644
--- a/src/tools/clippy/tests/ui/floating_point_abs.rs
+++ b/src/tools/clippy/tests/ui/floating_point_abs.rs
@@ -1,4 +1,3 @@
-#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
 /// Allow suboptimal ops in constant context
diff --git a/src/tools/clippy/tests/ui/floating_point_abs.stderr b/src/tools/clippy/tests/ui/floating_point_abs.stderr
index f5a778c5b7650..0c1f68f3b7fd2 100644
--- a/src/tools/clippy/tests/ui/floating_point_abs.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_abs.stderr
@@ -1,5 +1,5 @@
 error: manual implementation of `abs` method
-  --> tests/ui/floating_point_abs.rs:15:5
+  --> tests/ui/floating_point_abs.rs:14:5
    |
 LL |     if num >= 0.0 { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
@@ -8,43 +8,43 @@ LL |     if num >= 0.0 { num } else { -num }
    = help: to override `-D warnings` add `#[allow(clippy::suboptimal_flops)]`
 
 error: manual implementation of `abs` method
-  --> tests/ui/floating_point_abs.rs:19:5
+  --> tests/ui/floating_point_abs.rs:18:5
    |
 LL |     if 0.0 < num { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
 
 error: manual implementation of `abs` method
-  --> tests/ui/floating_point_abs.rs:23:5
+  --> tests/ui/floating_point_abs.rs:22:5
    |
 LL |     if a.a > 0.0 { a.a } else { -a.a }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.a.abs()`
 
 error: manual implementation of `abs` method
-  --> tests/ui/floating_point_abs.rs:27:5
+  --> tests/ui/floating_point_abs.rs:26:5
    |
 LL |     if 0.0 >= num { -num } else { num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
 
 error: manual implementation of `abs` method
-  --> tests/ui/floating_point_abs.rs:31:5
+  --> tests/ui/floating_point_abs.rs:30:5
    |
 LL |     if a.a < 0.0 { -a.a } else { a.a }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.a.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> tests/ui/floating_point_abs.rs:35:5
+  --> tests/ui/floating_point_abs.rs:34:5
    |
 LL |     if num < 0.0 { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-num.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> tests/ui/floating_point_abs.rs:39:5
+  --> tests/ui/floating_point_abs.rs:38:5
    |
 LL |     if 0.0 >= num { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-num.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> tests/ui/floating_point_abs.rs:44:12
+  --> tests/ui/floating_point_abs.rs:43:12
    |
 LL |         a: if a.a >= 0.0 { -a.a } else { a.a },
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-a.a.abs()`
diff --git a/src/tools/clippy/tests/ui/floating_point_mul_add.fixed b/src/tools/clippy/tests/ui/floating_point_mul_add.fixed
index 3ce2edf2c71f3..164aac2601a55 100644
--- a/src/tools/clippy/tests/ui/floating_point_mul_add.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_mul_add.fixed
@@ -1,4 +1,3 @@
-#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
 /// Allow suboptimal_ops in constant context
diff --git a/src/tools/clippy/tests/ui/floating_point_mul_add.rs b/src/tools/clippy/tests/ui/floating_point_mul_add.rs
index b5e4a8db4db2a..ae024b7f224be 100644
--- a/src/tools/clippy/tests/ui/floating_point_mul_add.rs
+++ b/src/tools/clippy/tests/ui/floating_point_mul_add.rs
@@ -1,4 +1,3 @@
-#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
 /// Allow suboptimal_ops in constant context
diff --git a/src/tools/clippy/tests/ui/floating_point_mul_add.stderr b/src/tools/clippy/tests/ui/floating_point_mul_add.stderr
index 3e1a071de7377..9c75909f71584 100644
--- a/src/tools/clippy/tests/ui/floating_point_mul_add.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_mul_add.stderr
@@ -1,5 +1,5 @@
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:20:13
+  --> tests/ui/floating_point_mul_add.rs:19:13
    |
 LL |     let _ = a * b + c;
    |             ^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
@@ -8,73 +8,73 @@ LL |     let _ = a * b + c;
    = help: to override `-D warnings` add `#[allow(clippy::suboptimal_flops)]`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:21:13
+  --> tests/ui/floating_point_mul_add.rs:20:13
    |
 LL |     let _ = a * b - c;
    |             ^^^^^^^^^ help: consider using: `a.mul_add(b, -c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:22:13
+  --> tests/ui/floating_point_mul_add.rs:21:13
    |
 LL |     let _ = c + a * b;
    |             ^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:23:13
+  --> tests/ui/floating_point_mul_add.rs:22:13
    |
 LL |     let _ = c - a * b;
    |             ^^^^^^^^^ help: consider using: `a.mul_add(-b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:24:13
+  --> tests/ui/floating_point_mul_add.rs:23:13
    |
 LL |     let _ = a + 2.0 * 4.0;
    |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4.0, a)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:25:13
+  --> tests/ui/floating_point_mul_add.rs:24:13
    |
 LL |     let _ = a + 2. * 4.;
    |             ^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4., a)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:27:13
+  --> tests/ui/floating_point_mul_add.rs:26:13
    |
 LL |     let _ = (a * b) + c;
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:28:13
+  --> tests/ui/floating_point_mul_add.rs:27:13
    |
 LL |     let _ = c + (a * b);
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:29:13
+  --> tests/ui/floating_point_mul_add.rs:28:13
    |
 LL |     let _ = a * b * c + d;
    |             ^^^^^^^^^^^^^ help: consider using: `(a * b).mul_add(c, d)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:31:13
+  --> tests/ui/floating_point_mul_add.rs:30:13
    |
 LL |     let _ = a.mul_add(b, c) * a.mul_add(b, c) + a.mul_add(b, c) + c;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `a.mul_add(b, c).mul_add(a.mul_add(b, c), a.mul_add(b, c))`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:32:13
+  --> tests/ui/floating_point_mul_add.rs:31:13
    |
 LL |     let _ = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1234.567_f64.mul_add(45.67834_f64, 0.0004_f64)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:34:13
+  --> tests/ui/floating_point_mul_add.rs:33:13
    |
 LL |     let _ = (a * a + b).sqrt();
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(a, b)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:37:13
+  --> tests/ui/floating_point_mul_add.rs:36:13
    |
 LL |     let _ = a - (b * u as f64);
    |             ^^^^^^^^^^^^^^^^^^ help: consider using: `b.mul_add(-(u as f64), a)`
diff --git a/src/tools/clippy/tests/ui/floating_point_rad.fixed b/src/tools/clippy/tests/ui/floating_point_rad.fixed
index a710bd9bd6074..2f93d233cb408 100644
--- a/src/tools/clippy/tests/ui/floating_point_rad.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_rad.fixed
@@ -1,4 +1,3 @@
-#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
 /// Allow suboptimal_flops in constant context
diff --git a/src/tools/clippy/tests/ui/floating_point_rad.rs b/src/tools/clippy/tests/ui/floating_point_rad.rs
index 14656f021df45..9690effc4e105 100644
--- a/src/tools/clippy/tests/ui/floating_point_rad.rs
+++ b/src/tools/clippy/tests/ui/floating_point_rad.rs
@@ -1,4 +1,3 @@
-#![feature(const_fn_floating_point_arithmetic)]
 #![warn(clippy::suboptimal_flops)]
 
 /// Allow suboptimal_flops in constant context
diff --git a/src/tools/clippy/tests/ui/floating_point_rad.stderr b/src/tools/clippy/tests/ui/floating_point_rad.stderr
index 64674342c2b99..b834f5374e0b3 100644
--- a/src/tools/clippy/tests/ui/floating_point_rad.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_rad.stderr
@@ -1,5 +1,5 @@
 error: conversion to radians can be done more accurately
-  --> tests/ui/floating_point_rad.rs:11:13
+  --> tests/ui/floating_point_rad.rs:10:13
    |
 LL |     let _ = degrees as f64 * std::f64::consts::PI / 180.0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(degrees as f64).to_radians()`
@@ -8,43 +8,43 @@ LL |     let _ = degrees as f64 * std::f64::consts::PI / 180.0;
    = help: to override `-D warnings` add `#[allow(clippy::suboptimal_flops)]`
 
 error: conversion to degrees can be done more accurately
-  --> tests/ui/floating_point_rad.rs:12:13
+  --> tests/ui/floating_point_rad.rs:11:13
    |
 LL |     let _ = degrees as f64 * 180.0 / std::f64::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(degrees as f64).to_degrees()`
 
 error: conversion to degrees can be done more accurately
-  --> tests/ui/floating_point_rad.rs:17:13
+  --> tests/ui/floating_point_rad.rs:16:13
    |
 LL |     let _ = x * 180f32 / std::f32::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_degrees()`
 
 error: conversion to degrees can be done more accurately
-  --> tests/ui/floating_point_rad.rs:18:13
+  --> tests/ui/floating_point_rad.rs:17:13
    |
 LL |     let _ = 90. * 180f64 / std::f64::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.0_f64.to_degrees()`
 
 error: conversion to degrees can be done more accurately
-  --> tests/ui/floating_point_rad.rs:19:13
+  --> tests/ui/floating_point_rad.rs:18:13
    |
 LL |     let _ = 90.5 * 180f64 / std::f64::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.5_f64.to_degrees()`
 
 error: conversion to radians can be done more accurately
-  --> tests/ui/floating_point_rad.rs:20:13
+  --> tests/ui/floating_point_rad.rs:19:13
    |
 LL |     let _ = x * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_radians()`
 
 error: conversion to radians can be done more accurately
-  --> tests/ui/floating_point_rad.rs:21:13
+  --> tests/ui/floating_point_rad.rs:20:13
    |
 LL |     let _ = 90. * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.0_f64.to_radians()`
 
 error: conversion to radians can be done more accurately
-  --> tests/ui/floating_point_rad.rs:22:13
+  --> tests/ui/floating_point_rad.rs:21:13
    |
 LL |     let _ = 90.5 * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.5_f64.to_radians()`
diff --git a/tests/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs b/tests/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs
index c7078e46fa64f..efc0a1c2fba39 100644
--- a/tests/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs
+++ b/tests/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs
@@ -1,9 +1,5 @@
 #![feature(const_extern_fn)]
 
-const extern "C" fn unsize(x: &[u8; 3]) -> &[u8] { x }
-const unsafe extern "C" fn closure() -> fn() { || {} }
-const unsafe extern "C" fn use_float() { 1.0 + 1.0; }
-//~^ ERROR floating point arithmetic
 const extern "C" fn ptr_cast(val: *const u8) { val as usize; }
 //~^ ERROR pointers cannot be cast to integers
 
diff --git a/tests/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr b/tests/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
index 29fa90d611c60..9cdeec159beeb 100644
--- a/tests/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
+++ b/tests/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr
@@ -1,15 +1,5 @@
-error[E0658]: floating point arithmetic is not allowed in constant functions
-  --> $DIR/const-extern-fn-min-const-fn.rs:5:42
-   |
-LL | const unsafe extern "C" fn use_float() { 1.0 + 1.0; }
-   |                                          ^^^^^^^^^
-   |
-   = note: see issue #57241 <https://github.com/rust-lang/rust/issues/57241> for more information
-   = help: add `#![feature(const_fn_floating_point_arithmetic)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
 error: pointers cannot be cast to integers during const eval
-  --> $DIR/const-extern-fn-min-const-fn.rs:7:48
+  --> $DIR/const-extern-fn-min-const-fn.rs:3:48
    |
 LL | const extern "C" fn ptr_cast(val: *const u8) { val as usize; }
    |                                                ^^^^^^^^^^^^
@@ -17,6 +7,5 @@ LL | const extern "C" fn ptr_cast(val: *const u8) { val 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 2 previous errors
+error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/const-extern-fn/const-extern-fn.rs b/tests/ui/consts/const-extern-fn/const-extern-fn.rs
index 57f5da8d0afc7..4b16476706449 100644
--- a/tests/ui/consts/const-extern-fn/const-extern-fn.rs
+++ b/tests/ui/consts/const-extern-fn/const-extern-fn.rs
@@ -17,6 +17,19 @@ const unsafe extern "C" fn bar2(val: bool) -> bool {
     !val
 }
 
+#[allow(improper_ctypes_definitions)]
+const extern "C" fn unsize(x: &[u8; 3]) -> &[u8] {
+    x
+}
+
+#[allow(improper_ctypes_definitions)]
+const unsafe extern "C" fn closure() -> fn() {
+    || {}
+}
+
+const unsafe extern "C" fn use_float() -> f32 {
+    1.0 + 1.0
+}
 
 fn main() {
     let a: [u8; foo1(25) as usize] = [0; 26];
@@ -32,4 +45,8 @@ fn main() {
     let _foo2_cast: extern "C" fn(u8) -> u8 = foo2;
     let _bar1_cast: unsafe extern "C" fn(bool) -> bool = bar1;
     let _bar2_cast: unsafe extern "C" fn(bool) -> bool = bar2;
+
+    unsize(&[0, 1, 2]);
+    unsafe { closure(); }
+    unsafe { use_float(); }
 }
diff --git a/tests/ui/consts/const_fn_floating_point_arithmetic.gated.stderr b/tests/ui/consts/const_fn_floating_point_arithmetic.gated.stderr
deleted file mode 100644
index e1b8154a287e0..0000000000000
--- a/tests/ui/consts/const_fn_floating_point_arithmetic.gated.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: fatal error triggered by #[rustc_error]
-  --> $DIR/const_fn_floating_point_arithmetic.rs:20:1
-   |
-LL | fn main() {}
-   | ^^^^^^^^^
-
-error: aborting due to 1 previous error
-
diff --git a/tests/ui/consts/const_fn_floating_point_arithmetic.rs b/tests/ui/consts/const_fn_floating_point_arithmetic.rs
deleted file mode 100644
index b0d0bc6b9f4a9..0000000000000
--- a/tests/ui/consts/const_fn_floating_point_arithmetic.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// gate-test-const_fn_floating_point_arithmetic
-
-//@ revisions: stock gated
-
-#![feature(rustc_attrs)]
-#![cfg_attr(gated, feature(const_fn_floating_point_arithmetic))]
-
-const fn add(f: f32) -> f32 { f + 2.0 }
-//[stock]~^ floating point arithmetic
-const fn sub(f: f32) -> f32 { 2.0 - f }
-//[stock]~^ floating point arithmetic
-const fn mul(f: f32, g: f32) -> f32 { f * g }
-//[stock]~^ floating point arithmetic
-const fn div(f: f32, g: f32) -> f32 { f / g }
-//[stock]~^ floating point arithmetic
-const fn neg(f: f32) -> f32 { -f }
-//[stock]~^ floating point arithmetic
-
-#[rustc_error]
-fn main() {} //[gated]~ fatal error triggered by #[rustc_error]
diff --git a/tests/ui/consts/const_fn_floating_point_arithmetic.stock.stderr b/tests/ui/consts/const_fn_floating_point_arithmetic.stock.stderr
deleted file mode 100644
index b5b94786ebb91..0000000000000
--- a/tests/ui/consts/const_fn_floating_point_arithmetic.stock.stderr
+++ /dev/null
@@ -1,53 +0,0 @@
-error[E0658]: floating point arithmetic is not allowed in constant functions
-  --> $DIR/const_fn_floating_point_arithmetic.rs:8:31
-   |
-LL | const fn add(f: f32) -> f32 { f + 2.0 }
-   |                               ^^^^^^^
-   |
-   = note: see issue #57241 <https://github.com/rust-lang/rust/issues/57241> for more information
-   = help: add `#![feature(const_fn_floating_point_arithmetic)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: floating point arithmetic is not allowed in constant functions
-  --> $DIR/const_fn_floating_point_arithmetic.rs:10:31
-   |
-LL | const fn sub(f: f32) -> f32 { 2.0 - f }
-   |                               ^^^^^^^
-   |
-   = note: see issue #57241 <https://github.com/rust-lang/rust/issues/57241> for more information
-   = help: add `#![feature(const_fn_floating_point_arithmetic)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: floating point arithmetic is not allowed in constant functions
-  --> $DIR/const_fn_floating_point_arithmetic.rs:12:39
-   |
-LL | const fn mul(f: f32, g: f32) -> f32 { f * g }
-   |                                       ^^^^^
-   |
-   = note: see issue #57241 <https://github.com/rust-lang/rust/issues/57241> for more information
-   = help: add `#![feature(const_fn_floating_point_arithmetic)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: floating point arithmetic is not allowed in constant functions
-  --> $DIR/const_fn_floating_point_arithmetic.rs:14:39
-   |
-LL | const fn div(f: f32, g: f32) -> f32 { f / g }
-   |                                       ^^^^^
-   |
-   = note: see issue #57241 <https://github.com/rust-lang/rust/issues/57241> for more information
-   = help: add `#![feature(const_fn_floating_point_arithmetic)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error[E0658]: floating point arithmetic is not allowed in constant functions
-  --> $DIR/const_fn_floating_point_arithmetic.rs:16:31
-   |
-LL | const fn neg(f: f32) -> f32 { -f }
-   |                               ^^
-   |
-   = note: see issue #57241 <https://github.com/rust-lang/rust/issues/57241> for more information
-   = help: add `#![feature(const_fn_floating_point_arithmetic)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 5 previous errors
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/consts/const_let_eq_float.rs b/tests/ui/consts/const_let_eq_float.rs
index 30d839cdc2a8c..c9ca6b8b7ea75 100644
--- a/tests/ui/consts/const_let_eq_float.rs
+++ b/tests/ui/consts/const_let_eq_float.rs
@@ -1,7 +1,5 @@
 //@ run-pass
 
-#![feature(const_fn_floating_point_arithmetic)]
-
 struct Foo<T>(T);
 struct Bar<T> { x: T }
 struct W(f32);
diff --git a/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.rs b/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.rs
index bb240fb4ad62c..dc653370e5162 100644
--- a/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.rs
+++ b/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.rs
@@ -3,7 +3,7 @@
             we're apparently really bad at it",
             issue = "none")]
 
-#![feature(const_fn_floating_point_arithmetic, foo, foo2)]
+#![feature(const_refs_to_cell, foo, foo2)]
 #![feature(staged_api)]
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -25,9 +25,13 @@ const fn bar2() -> u32 { foo2() } //~ ERROR not yet stable as a const fn
 
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_stable(feature = "rust1", since = "1.0.0")]
-// Const-stable functions cannot rely on unstable const-eval features.
-const fn bar3() -> u32 { (5f32 + 6f32) as u32 }
-//~^ ERROR const-stable function cannot use `#[feature(const_fn_floating_point_arithmetic)]`
+// conformity is required
+const fn bar3() -> u32 {
+    let x = std::cell::Cell::new(0u32);
+    x.get()
+    //~^ ERROR const-stable function cannot use `#[feature(const_refs_to_cell)]`
+    //~| ERROR cannot call non-const fn
+}
 
 // check whether this function cannot be called even with the feature gate active
 #[unstable(feature = "foo2", issue = "none")]
diff --git a/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr b/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr
index 7ec2508ca93a6..e5f8fa25b64ab 100644
--- a/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr
+++ b/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr
@@ -14,30 +14,39 @@ LL | const fn bar2() -> u32 { foo2() }
    |
    = help: const-stable functions can only call other const-stable functions
 
-error: const-stable function cannot use `#[feature(const_fn_floating_point_arithmetic)]`
-  --> $DIR/min_const_fn_libstd_stability.rs:29:26
+error: const-stable function cannot use `#[feature(const_refs_to_cell)]`
+  --> $DIR/min_const_fn_libstd_stability.rs:31:5
    |
-LL | const fn bar3() -> u32 { (5f32 + 6f32) as u32 }
-   |                          ^^^^^^^^^^^^^
+LL |     x.get()
+   |     ^
    |
 help: if it is not part of the public API, make this function unstably const
    |
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const fn bar3() -> u32 { (5f32 + 6f32) as u32 }
+LL | const fn bar3() -> u32 {
    |
 help: otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks
    |
-LL + #[rustc_allow_const_fn_unstable(const_fn_floating_point_arithmetic)]
-LL | const fn bar3() -> u32 { (5f32 + 6f32) as u32 }
+LL + #[rustc_allow_const_fn_unstable(const_refs_to_cell)]
+LL | const fn bar3() -> u32 {
    |
 
+error[E0015]: cannot call non-const fn `Cell::<u32>::get` in constant functions
+  --> $DIR/min_const_fn_libstd_stability.rs:31:7
+   |
+LL |     x.get()
+   |       ^^^^^
+   |
+   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
+
 error: `foo2_gated` is not yet stable as a const fn
-  --> $DIR/min_const_fn_libstd_stability.rs:39:32
+  --> $DIR/min_const_fn_libstd_stability.rs:43:32
    |
 LL | const fn bar2_gated() -> u32 { foo2_gated() }
    |                                ^^^^^^^^^^^^
    |
    = help: const-stable functions can only call other const-stable functions
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
+For more information about this error, try `rustc --explain E0015`.
diff --git a/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.rs b/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.rs
index 03084c8674dc2..f2a54b8a13dee 100644
--- a/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.rs
+++ b/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.rs
@@ -3,7 +3,7 @@
             we're apparently really bad at it",
             issue = "none")]
 
-#![feature(const_fn_floating_point_arithmetic, foo, foo2)]
+#![feature(const_refs_to_cell, foo, foo2)]
 #![feature(staged_api)]
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -23,12 +23,6 @@ const unsafe fn foo2() -> u32 { 42 }
 // can't call non-min_const_fn
 const unsafe fn bar2() -> u32 { unsafe { foo2() } } //~ ERROR not yet stable as a const fn
 
-#[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_stable(feature = "rust1", since = "1.0.0")]
-// conformity is required
-const unsafe fn bar3() -> u32 { (5f32 + 6f32) as u32 }
-//~^ ERROR const-stable function cannot use `#[feature(const_fn_floating_point_arithmetic)]`
-
 // check whether this function cannot be called even with the feature gate active
 #[unstable(feature = "foo2", issue = "none")]
 const unsafe fn foo2_gated() -> u32 { 42 }
diff --git a/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.stderr b/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.stderr
index 72c1f175d1d6b..353b117efbc8f 100644
--- a/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.stderr
+++ b/tests/ui/consts/min_const_fn/min_const_unsafe_fn_libstd_stability.stderr
@@ -14,30 +14,13 @@ LL | const unsafe fn bar2() -> u32 { unsafe { foo2() } }
    |
    = help: const-stable functions can only call other const-stable functions
 
-error: const-stable function cannot use `#[feature(const_fn_floating_point_arithmetic)]`
-  --> $DIR/min_const_unsafe_fn_libstd_stability.rs:29:33
-   |
-LL | const unsafe fn bar3() -> u32 { (5f32 + 6f32) as u32 }
-   |                                 ^^^^^^^^^^^^^
-   |
-help: if it is not part of the public API, make this function unstably const
-   |
-LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | const unsafe fn bar3() -> u32 { (5f32 + 6f32) as u32 }
-   |
-help: otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks
-   |
-LL + #[rustc_allow_const_fn_unstable(const_fn_floating_point_arithmetic)]
-LL | const unsafe fn bar3() -> u32 { (5f32 + 6f32) as u32 }
-   |
-
 error: `foo2_gated` is not yet stable as a const fn
-  --> $DIR/min_const_unsafe_fn_libstd_stability.rs:39:48
+  --> $DIR/min_const_unsafe_fn_libstd_stability.rs:33:48
    |
 LL | const unsafe fn bar2_gated() -> u32 { unsafe { foo2_gated() } }
    |                                                ^^^^^^^^^^^^
    |
    = help: const-stable functions can only call other const-stable functions
 
-error: aborting due to 4 previous errors
+error: aborting due to 3 previous errors
 
diff --git a/tests/ui/internal/internal-unstable-const.rs b/tests/ui/internal/internal-unstable-const.rs
deleted file mode 100644
index 4ec2426dfee7d..0000000000000
--- a/tests/ui/internal/internal-unstable-const.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Don't allow unstable features in stable functions without `allow_internal_unstable`.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-#![feature(staged_api)]
-#![feature(const_fn_floating_point_arithmetic)]
-
-#[stable(feature = "rust1", since = "1.0.0")]
-#[rustc_const_stable(feature = "rust1", since = "1.0.0")]
-pub const fn foo() -> f32 {
-    1.0 + 1.0 //~ ERROR const-stable function cannot use `#[feature(const_fn_floating_point_arithmetic)]`
-}
-
-fn main() {}
diff --git a/tests/ui/internal/internal-unstable-const.stderr b/tests/ui/internal/internal-unstable-const.stderr
deleted file mode 100644
index ed9196d2b63bd..0000000000000
--- a/tests/ui/internal/internal-unstable-const.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error: const-stable function cannot use `#[feature(const_fn_floating_point_arithmetic)]`
-  --> $DIR/internal-unstable-const.rs:10:5
-   |
-LL |     1.0 + 1.0
-   |     ^^^^^^^^^
-   |
-help: if it is not part of the public API, make this function unstably const
-   |
-LL + #[rustc_const_unstable(feature = "...", issue = "...")]
-LL | pub const fn foo() -> f32 {
-   |
-help: otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks
-   |
-LL + #[rustc_allow_const_fn_unstable(const_fn_floating_point_arithmetic)]
-LL | pub const fn foo() -> f32 {
-   |
-
-error: aborting due to 1 previous error
-

From 57b164a9d2ee90ddf46bfe7b3a40d28bcd04b9c1 Mon Sep 17 00:00:00 2001
From: Amjad Alsharafi <26300843+Amjad50@users.noreply.github.com>
Date: Thu, 22 Aug 2024 14:26:00 +0800
Subject: [PATCH 514/685] Update `compiler_builtins` to `0.1.120`

Signed-off-by: Amjad Alsharafi <26300843+Amjad50@users.noreply.github.com>
---
 library/Cargo.lock       | 4 ++--
 library/alloc/Cargo.toml | 2 +-
 library/std/Cargo.toml   | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/library/Cargo.lock b/library/Cargo.lock
index 30f5076e1e223..f2f446b61085d 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -58,9 +58,9 @@ dependencies = [
 
 [[package]]
 name = "compiler_builtins"
-version = "0.1.118"
+version = "0.1.120"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92afe7344b64cccf3662ca26d5d1c0828ab826f04206b97d856e3625e390e4b5"
+checksum = "38c44e9c76d996d8049dee591a997eab801069ad86ed892ed3039f68b73d301c"
 dependencies = [
  "cc",
  "rustc-std-workspace-core",
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index bdf16257c7cd0..43799acc02736 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2021"
 
 [dependencies]
 core = { path = "../core" }
-compiler_builtins = { version = "0.1.118", features = ['rustc-dep-of-std'] }
+compiler_builtins = { version = "0.1.120", features = ['rustc-dep-of-std'] }
 
 [dev-dependencies]
 rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 7f23681ee45fc..dca42a3e98ec1 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -17,7 +17,7 @@ cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
 panic_unwind = { path = "../panic_unwind", optional = true }
 panic_abort = { path = "../panic_abort" }
 core = { path = "../core", public = true }
-compiler_builtins = { version = "0.1.118" }
+compiler_builtins = { version = "0.1.120" }
 profiler_builtins = { path = "../profiler_builtins", optional = true }
 unwind = { path = "../unwind" }
 hashbrown = { version = "0.14", default-features = false, features = [

From 87e4b6789c43c44f07211defbd8c036bc0245562 Mon Sep 17 00:00:00 2001
From: apiraino <apiraino@users.noreply.github.com>
Date: Thu, 22 Aug 2024 09:19:22 +0200
Subject: [PATCH 515/685] Update RELEASES.md

Co-authored-by: Josh Stone <cuviper@gmail.com>
---
 RELEASES.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/RELEASES.md b/RELEASES.md
index 852af4389ea89..5e4827be4ecfd 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -143,8 +143,8 @@ Compatibility Notes
 - [Turn `proc_macro_back_compat` lint into a hard error.](https://github.com/rust-lang/rust/pull/125596/)
 - [Detect unused structs even when implementing private traits](https://github.com/rust-lang/rust/pull/122382/)
 - [`std::sync::ReentrantLockGuard<T>` is no longer `Sync` if `T: !Sync`](https://github.com/rust-lang/rust/pull/125527) which means [`std::io::StdoutLock` and `std::io::StderrLock` are no longer Sync](https://github.com/rust-lang/rust/issues/127340)
-- [Type inference will fail in some cases due to a new impl of FromIterator for Box<str>](https://github.com/rust-lang/rust/pull/99969/)
-  Notably this breaks versions of the `time` crate before 0.3.36, due to no longer inferring the right impl.
+- [Type inference will fail in some cases due to new implementations of `FromIterator for Box<str>`.](https://github.com/rust-lang/rust/pull/99969/)
+  Notably, this breaks versions of the `time` crate before 0.3.35, due to no longer inferring the implementation for `Box<[_]>`.
 
 <a id="1.80-Internal-Changes"></a>
 

From f4dc7830ed64a713ef7d4e3c63032b9002c2040a Mon Sep 17 00:00:00 2001
From: Connor Horman <chorman64@gmail.com>
Date: Thu, 22 Aug 2024 10:28:48 +0000
Subject: [PATCH 516/685] feat(core): Make `unbounded_shl{l,r}` unstably const
 and remove `rustc_allow_const_fn_unstable`

---
 library/core/src/num/int_macros.rs  | 4 ++--
 library/core/src/num/uint_macros.rs | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index d3dd68a9d610c..229cd89bea3f0 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1326,7 +1326,7 @@ macro_rules! int_impl {
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(129), 0);")]
         /// ```
         #[unstable(feature = "unbounded_shifts", issue = "129375")]
-        #[rustc_allow_const_fn_unstable(unchecked_shifts)]
+        #[rustc_const_unstable(feature = "const_unbounded_shifts", issue = "129375")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1454,7 +1454,7 @@ macro_rules! int_impl {
         #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.unbounded_shr(129), -1);")]
         /// ```
         #[unstable(feature = "unbounded_shifts", issue = "129375")]
-        #[rustc_allow_const_fn_unstable(unchecked_shifts)]
+        #[rustc_const_unstable(feature = "const_unbounded_shifts", issue = "129375")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 2e4e367af9b90..0d0bbc5256f78 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1515,7 +1515,7 @@ macro_rules! uint_impl {
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(129), 0);")]
         /// ```
         #[unstable(feature = "unbounded_shifts", issue = "129375")]
-        #[rustc_allow_const_fn_unstable(unchecked_shifts)]
+        #[rustc_const_unstable(feature = "const_unbounded_shifts", issue = "129375")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1641,7 +1641,7 @@ macro_rules! uint_impl {
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(129), 0);")]
         /// ```
         #[unstable(feature = "unbounded_shifts", issue = "129375")]
-        #[rustc_allow_const_fn_unstable(unchecked_shifts)]
+        #[rustc_const_unstable(feature = "const_unbounded_shifts", issue = "129375")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]

From 6a878a9630945cd6a61ad5e83ec5c543c6e8dab7 Mon Sep 17 00:00:00 2001
From: Urgau <urgau@numericable.fr>
Date: Thu, 22 Aug 2024 13:30:50 +0200
Subject: [PATCH 517/685] Fix handling of macro arguments within the
 `dropping_copy_types lint

---
 .../rustc_lint/src/drop_forget_useless.rs     |  5 +++--
 .../ui/lint/dropping_copy_types-macros.fixed  | 12 +++++++++++
 tests/ui/lint/dropping_copy_types-macros.rs   | 12 +++++++++++
 .../ui/lint/dropping_copy_types-macros.stderr | 21 +++++++++++++++++++
 4 files changed, 48 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/lint/dropping_copy_types-macros.fixed
 create mode 100644 tests/ui/lint/dropping_copy_types-macros.rs
 create mode 100644 tests/ui/lint/dropping_copy_types-macros.stderr

diff --git a/compiler/rustc_lint/src/drop_forget_useless.rs b/compiler/rustc_lint/src/drop_forget_useless.rs
index 2060858cc8af0..a9de258e005c9 100644
--- a/compiler/rustc_lint/src/drop_forget_useless.rs
+++ b/compiler/rustc_lint/src/drop_forget_useless.rs
@@ -151,10 +151,11 @@ impl<'tcx> LateLintPass<'tcx> for DropForgetUseless {
                     && let Node::Stmt(stmt) = node
                     && let StmtKind::Semi(e) = stmt.kind
                     && e.hir_id == expr.hir_id
+                    && let Some(arg_span) = arg.span.find_ancestor_inside(expr.span)
                 {
                     UseLetUnderscoreIgnoreSuggestion::Suggestion {
-                        start_span: expr.span.shrink_to_lo().until(arg.span),
-                        end_span: arg.span.shrink_to_hi().until(expr.span.shrink_to_hi()),
+                        start_span: expr.span.shrink_to_lo().until(arg_span),
+                        end_span: arg_span.shrink_to_hi().until(expr.span.shrink_to_hi()),
                     }
                 } else {
                     UseLetUnderscoreIgnoreSuggestion::Note
diff --git a/tests/ui/lint/dropping_copy_types-macros.fixed b/tests/ui/lint/dropping_copy_types-macros.fixed
new file mode 100644
index 0000000000000..a8ceedadc8063
--- /dev/null
+++ b/tests/ui/lint/dropping_copy_types-macros.fixed
@@ -0,0 +1,12 @@
+//@ check-fail
+//@ run-rustfix
+
+#![deny(dropping_copy_types)]
+
+use std::fmt::Write;
+
+fn main() {
+    let mut msg = String::new();
+    let _ = writeln!(&mut msg, "test");
+    //~^ ERROR calls to `std::mem::drop`
+}
diff --git a/tests/ui/lint/dropping_copy_types-macros.rs b/tests/ui/lint/dropping_copy_types-macros.rs
new file mode 100644
index 0000000000000..b249b0c868f37
--- /dev/null
+++ b/tests/ui/lint/dropping_copy_types-macros.rs
@@ -0,0 +1,12 @@
+//@ check-fail
+//@ run-rustfix
+
+#![deny(dropping_copy_types)]
+
+use std::fmt::Write;
+
+fn main() {
+    let mut msg = String::new();
+    drop(writeln!(&mut msg, "test"));
+    //~^ ERROR calls to `std::mem::drop`
+}
diff --git a/tests/ui/lint/dropping_copy_types-macros.stderr b/tests/ui/lint/dropping_copy_types-macros.stderr
new file mode 100644
index 0000000000000..117e9f4fe099c
--- /dev/null
+++ b/tests/ui/lint/dropping_copy_types-macros.stderr
@@ -0,0 +1,21 @@
+error: calls to `std::mem::drop` with a value that implements `Copy` does nothing
+  --> $DIR/dropping_copy_types-macros.rs:10:5
+   |
+LL |     drop(writeln!(&mut msg, "test"));
+   |     ^^^^^--------------------------^
+   |          |
+   |          argument has type `Result<(), std::fmt::Error>`
+   |
+note: the lint level is defined here
+  --> $DIR/dropping_copy_types-macros.rs:4:9
+   |
+LL | #![deny(dropping_copy_types)]
+   |         ^^^^^^^^^^^^^^^^^^^
+help: use `let _ = ...` to ignore the expression or result
+   |
+LL -     drop(writeln!(&mut msg, "test"));
+LL +     let _ = writeln!(&mut msg, "test");
+   |
+
+error: aborting due to 1 previous error
+

From b5d77d849e01bd48fb7d7da6d6f4a613af00e750 Mon Sep 17 00:00:00 2001
From: Johannes Hostert <jhostert@ethz.ch>
Date: Wed, 21 Aug 2024 21:08:09 +0200
Subject: [PATCH 518/685] Make Tree Borrows Provenance GC no longer produce
 stack overflows

---
 src/tools/miri/Cargo.toml                     |   2 +-
 .../src/borrow_tracker/tree_borrows/tree.rs   | 104 +++++++++++-------
 .../src/borrow_tracker/tree_borrows/unimap.rs |  15 ++-
 3 files changed, 74 insertions(+), 47 deletions(-)

diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index e12f3f9012f0d..4b7f3483ff7db 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -20,7 +20,7 @@ doctest = false # and no doc tests
 [dependencies]
 getrandom = { version = "0.2", features = ["std"] }
 rand = "0.8"
-smallvec = "1.7"
+smallvec = { version = "1.7", features = ["drain_filter"] }
 aes = { version = "0.8.3", features = ["hazmat"] }
 measureme = "11"
 ctrlc = "3.2.5"
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
index 90bd11032185c..56643c6cbe811 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/tree.rs
@@ -10,7 +10,7 @@
 //!   and the relative position of the access;
 //! - idempotency properties asserted in `perms.rs` (for optimizations)
 
-use std::fmt;
+use std::{fmt, mem};
 
 use smallvec::SmallVec;
 
@@ -699,8 +699,7 @@ impl<'tcx> Tree {
 /// Integration with the BorTag garbage collector
 impl Tree {
     pub fn remove_unreachable_tags(&mut self, live_tags: &FxHashSet<BorTag>) {
-        let root_is_needed = self.keep_only_needed(self.root, live_tags); // root can't be removed
-        assert!(root_is_needed);
+        self.remove_useless_children(self.root, live_tags);
         // Right after the GC runs is a good moment to check if we can
         // merge some adjacent ranges that were made equal by the removal of some
         // tags (this does not necessarily mean that they have identical internal representations,
@@ -708,9 +707,16 @@ impl Tree {
         self.rperms.merge_adjacent_thorough();
     }
 
+    /// Checks if a node is useless and should be GC'ed.
+    /// A node is useless if it has no children and also the tag is no longer live.
+    fn is_useless(&self, idx: UniIndex, live: &FxHashSet<BorTag>) -> bool {
+        let node = self.nodes.get(idx).unwrap();
+        node.children.is_empty() && !live.contains(&node.tag)
+    }
+
     /// Traverses the entire tree looking for useless tags.
-    /// Returns true iff the tag it was called on is still live or has live children,
-    /// and removes from the tree all tags that have no live children.
+    /// Removes from the tree all useless child nodes of root.
+    /// It will not delete the root itself.
     ///
     /// NOTE: This leaves in the middle of the tree tags that are unreachable but have
     /// reachable children. There is a potential for compacting the tree by reassigning
@@ -721,42 +727,60 @@ impl Tree {
     /// `child: Reserved`. This tree can exist. If we blindly delete `parent` and reassign
     /// `child` to be a direct child of `root` then Writes to `child` are now permitted
     /// whereas they were not when `parent` was still there.
-    fn keep_only_needed(&mut self, idx: UniIndex, live: &FxHashSet<BorTag>) -> bool {
-        let node = self.nodes.get(idx).unwrap();
-        // FIXME: this function does a lot of cloning, a 2-pass approach is possibly
-        // more efficient. It could consist of
-        // 1. traverse the Tree, collect all useless tags in a Vec
-        // 2. traverse the Vec, remove all tags previously selected
-        // Bench it.
-        let children: SmallVec<_> = node
-            .children
-            .clone()
-            .into_iter()
-            .filter(|child| self.keep_only_needed(*child, live))
-            .collect();
-        let no_children = children.is_empty();
-        let node = self.nodes.get_mut(idx).unwrap();
-        node.children = children;
-        if !live.contains(&node.tag) && no_children {
-            // All of the children and this node are unreachable, delete this tag
-            // from the tree (the children have already been deleted by recursive
-            // calls).
-            // Due to the API of UniMap we must absolutely call
-            // `UniValMap::remove` for the key of this tag on *all* maps that used it
-            // (which are `self.nodes` and every range of `self.rperms`)
-            // before we can safely apply `UniValMap::forget` to truly remove
-            // the tag from the mapping.
-            let tag = node.tag;
-            self.nodes.remove(idx);
-            for (_perms_range, perms) in self.rperms.iter_mut_all() {
-                perms.remove(idx);
+    fn remove_useless_children(&mut self, root: UniIndex, live: &FxHashSet<BorTag>) {
+        // To avoid stack overflows, we roll our own stack.
+        // Each element in the stack consists of the current tag, and the number of the
+        // next child to be processed.
+
+        // The other functions are written using the `TreeVisitorStack`, but that does not work here
+        // since we need to 1) do a post-traversal and 2) remove nodes from the tree.
+        // Since we do a post-traversal (by deleting nodes only after handling all children),
+        // we also need to be a bit smarter than "pop node, push all children."
+        let mut stack = vec![(root, 0)];
+        while let Some((tag, nth_child)) = stack.last_mut() {
+            let node = self.nodes.get(*tag).unwrap();
+            if *nth_child < node.children.len() {
+                // Visit the child by pushing it to the stack.
+                // Also increase `nth_child` so that when we come back to the `tag` node, we
+                // look at the next child.
+                let next_child = node.children[*nth_child];
+                *nth_child += 1;
+                stack.push((next_child, 0));
+                continue;
+            } else {
+                // We have processed all children of `node`, so now it is time to process `node` itself.
+                // First, get the current children of `node`. To appease the borrow checker,
+                // we have to temporarily move the list out of the node, and then put the
+                // list of remaining children back in.
+                let mut children_of_node =
+                    mem::take(&mut self.nodes.get_mut(*tag).unwrap().children);
+                // Remove all useless children, and save them for later.
+                // The closure needs `&self` and the loop below needs `&mut self`, so we need to `collect`
+                // in to a temporary list.
+                let to_remove: Vec<_> =
+                    children_of_node.drain_filter(|x| self.is_useless(*x, live)).collect();
+                // Put back the now-filtered vector.
+                self.nodes.get_mut(*tag).unwrap().children = children_of_node;
+                // Now, all that is left is unregistering the children saved in `to_remove`.
+                for idx in to_remove {
+                    // Note: In the rest of this comment, "this node" refers to `idx`.
+                    // This node has no more children (if there were any, they have already been removed).
+                    // It is also unreachable as determined by the GC, so we can remove it everywhere.
+                    // Due to the API of UniMap we must make sure to call
+                    // `UniValMap::remove` for the key of this node on *all* maps that used it
+                    // (which are `self.nodes` and every range of `self.rperms`)
+                    // before we can safely apply `UniKeyMap::remove` to truly remove
+                    // this tag from the `tag_mapping`.
+                    let node = self.nodes.remove(idx).unwrap();
+                    for (_perms_range, perms) in self.rperms.iter_mut_all() {
+                        perms.remove(idx);
+                    }
+                    self.tag_mapping.remove(&node.tag);
+                }
+                // We are done, the parent can continue.
+                stack.pop();
+                continue;
             }
-            self.tag_mapping.remove(&tag);
-            // The tag has been deleted, inform the caller
-            false
-        } else {
-            // The tag is still live or has live children, it must be kept
-            true
         }
     }
 }
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs
index f45b2d9e00a6a..92bae6203b3c0 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/unimap.rs
@@ -12,7 +12,7 @@
 
 #![allow(dead_code)]
 
-use std::hash::Hash;
+use std::{hash::Hash, mem};
 
 use rustc_data_structures::fx::FxHashMap;
 
@@ -187,13 +187,16 @@ impl<V> UniValMap<V> {
         self.data.get_mut(idx.idx as usize).and_then(Option::as_mut)
     }
 
-    /// Delete any value associated with this index. Ok even if the index
-    /// has no associated value.
-    pub fn remove(&mut self, idx: UniIndex) {
+    /// Delete any value associated with this index.
+    /// Returns None if the value was not present, otherwise
+    /// returns the previously stored value.
+    pub fn remove(&mut self, idx: UniIndex) -> Option<V> {
         if idx.idx as usize >= self.data.len() {
-            return;
+            return None;
         }
-        self.data[idx.idx as usize] = None;
+        let mut res = None;
+        mem::swap(&mut res, &mut self.data[idx.idx as usize]);
+        res
     }
 }
 

From f1fac42f4a6aa2f9535a32db91c7f9c93220d5a4 Mon Sep 17 00:00:00 2001
From: Krasimir Georgiev <krasimir@google.com>
Date: Wed, 21 Aug 2024 09:21:29 +0000
Subject: [PATCH 519/685] llvm 20: adapt integer comparison tests

The LLVM commit https://github.com/llvm/llvm-project/commit/abf69a167bbc99054871e3f9cc8810bbebcb6747
changed the IR in a few comparison tests:
https://buildkite.com/llvm-project/rust-llvm-integrate-prototype/builds/30500#01917017-26fe-4a4d-956b-725a2903e5a8

Adapted accordingly.
---
 tests/assembly/x86_64-cmp.rs | 42 ++++++++++++++++++++++++------------
 tests/codegen/integer-cmp.rs | 21 +++++++++++-------
 2 files changed, 41 insertions(+), 22 deletions(-)

diff --git a/tests/assembly/x86_64-cmp.rs b/tests/assembly/x86_64-cmp.rs
index 31efdda1bfafa..67b7ff99ae2d9 100644
--- a/tests/assembly/x86_64-cmp.rs
+++ b/tests/assembly/x86_64-cmp.rs
@@ -1,6 +1,9 @@
-//@ revisions: DEBUG OPTIM
+//@ revisions: DEBUG LLVM-PRE-20-OPTIM LLVM-20-OPTIM
 //@ [DEBUG] compile-flags: -C opt-level=0
-//@ [OPTIM] compile-flags: -C opt-level=3
+//@ [LLVM-PRE-20-OPTIM] compile-flags: -C opt-level=3
+//@ [LLVM-PRE-20-OPTIM] ignore-llvm-version: 20 - 99
+//@ [LLVM-20-OPTIM] compile-flags: -C opt-level=3
+//@ [LLVM-20-OPTIM] min-llvm-version: 20
 //@ assembly-output: emit-asm
 //@ compile-flags: --crate-type=lib -C llvm-args=-x86-asm-syntax=intel
 //@ only-x86_64
@@ -21,12 +24,18 @@ pub fn signed_cmp(a: i16, b: i16) -> std::cmp::Ordering {
     // DEBUG: and
     // DEBUG: sub
 
-    // OPTIM: xor
-    // OPTIM: cmp
-    // OPTIM: setne
-    // OPTIM: mov
-    // OPTIM: cmovge
-    // OPTIM: ret
+    // LLVM-PRE-20-OPTIM: xor
+    // LLVM-PRE-20-OPTIM: cmp
+    // LLVM-PRE-20-OPTIM: setne
+    // LLVM-PRE-20-OPTIM: mov
+    // LLVM-PRE-20-OPTIM: cmovge
+    // LLVM-PRE-20-OPTIM: ret
+    //
+    // LLVM-20-OPTIM: cmp
+    // LLVM-20-OPTIM: setl
+    // LLVM-20-OPTIM: setg
+    // LLVM-20-OPTIM: sub
+    // LLVM-20-OPTIM: ret
     three_way_compare(a, b)
 }
 
@@ -41,11 +50,16 @@ pub fn unsigned_cmp(a: u16, b: u16) -> std::cmp::Ordering {
     // DEBUG: and
     // DEBUG: sub
 
-    // OPTIM: xor
-    // OPTIM: cmp
-    // OPTIM: setne
-    // OPTIM: mov
-    // OPTIM: cmovae
-    // OPTIM: ret
+    // LLVM-PRE-20-OPTIM: xor
+    // LLVM-PRE-20-OPTIM: cmp
+    // LLVM-PRE-20-OPTIM: setne
+    // LLVM-PRE-20-OPTIM: mov
+    // LLVM-PRE-20-OPTIM: cmovae
+    // LLVM-PRE-20-OPTIM: ret
+    //
+    // LLVM-20-OPTIM: cmp
+    // LLVM-20-OPTIM: seta
+    // LLVM-20-OPTIM: sbb
+    // LLVM-20-OPTIM: ret
     three_way_compare(a, b)
 }
diff --git a/tests/codegen/integer-cmp.rs b/tests/codegen/integer-cmp.rs
index bba112b246f3f..8df68d8d4906e 100644
--- a/tests/codegen/integer-cmp.rs
+++ b/tests/codegen/integer-cmp.rs
@@ -1,6 +1,9 @@
 // This is test for more optimal Ord implementation for integers.
 // See <https://github.com/rust-lang/rust/issues/63758> for more info.
 
+//@ revisions: llvm-pre-20 llvm-20
+//@ [llvm-20] min-llvm-version: 20
+//@ [llvm-pre-20] ignore-llvm-version: 20 - 99
 //@ compile-flags: -C opt-level=3
 
 #![crate_type = "lib"]
@@ -10,19 +13,21 @@ use std::cmp::Ordering;
 // CHECK-LABEL: @cmp_signed
 #[no_mangle]
 pub fn cmp_signed(a: i64, b: i64) -> Ordering {
-    // CHECK: icmp slt
-    // CHECK: icmp ne
-    // CHECK: zext i1
-    // CHECK: select i1
+    // llvm-20: @llvm.scmp.i8.i64
+    // llvm-pre-20: icmp slt
+    // llvm-pre-20: icmp ne
+    // llvm-pre-20: zext i1
+    // llvm-pre-20: select i1
     a.cmp(&b)
 }
 
 // CHECK-LABEL: @cmp_unsigned
 #[no_mangle]
 pub fn cmp_unsigned(a: u32, b: u32) -> Ordering {
-    // CHECK: icmp ult
-    // CHECK: icmp ne
-    // CHECK: zext i1
-    // CHECK: select i1
+    // llvm-20: @llvm.ucmp.i8.i32
+    // llvm-pre-20: icmp ult
+    // llvm-pre-20: icmp ne
+    // llvm-pre-20: zext i1
+    // llvm-pre-20: select i1
     a.cmp(&b)
 }

From e276d22efc1443772434981a69f974ad4984fd2d Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Tue, 13 Aug 2024 11:33:01 -0400
Subject: [PATCH 520/685] rewrite x86_64-fortanix-unknown-sgx-lvi to rmake

---
 src/tools/run-make-support/src/env.rs         |  8 ++
 src/tools/run-make-support/src/lib.rs         |  2 +-
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 .../x86_64-fortanix-unknown-sgx-lvi/Makefile  | 23 -----
 .../x86_64-fortanix-unknown-sgx-lvi/rmake.rs  | 96 +++++++++++++++++++
 .../x86_64-fortanix-unknown-sgx-lvi/script.sh | 69 -------------
 6 files changed, 105 insertions(+), 94 deletions(-)
 delete mode 100644 tests/run-make/x86_64-fortanix-unknown-sgx-lvi/Makefile
 create mode 100644 tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rmake.rs
 delete mode 100644 tests/run-make/x86_64-fortanix-unknown-sgx-lvi/script.sh

diff --git a/src/tools/run-make-support/src/env.rs b/src/tools/run-make-support/src/env.rs
index e6460fb93d3e9..9acbb16d73e76 100644
--- a/src/tools/run-make-support/src/env.rs
+++ b/src/tools/run-make-support/src/env.rs
@@ -24,3 +24,11 @@ pub fn env_var_os(name: &str) -> OsString {
 pub fn no_debug_assertions() -> bool {
     std::env::var_os("NO_DEBUG_ASSERTIONS").is_some()
 }
+
+/// A wrapper around [`std::env::set_current_dir`] which includes the directory
+/// path in the panic message.
+#[track_caller]
+pub fn set_current_dir<P: AsRef<std::path::Path>>(dir: P) {
+    std::env::set_current_dir(dir.as_ref())
+        .expect(&format!("could not set current directory to \"{}\"", dir.as_ref().display()));
+}
diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
index fc20fd3b2e86a..956fa1404c7e2 100644
--- a/src/tools/run-make-support/src/lib.rs
+++ b/src/tools/run-make-support/src/lib.rs
@@ -64,7 +64,7 @@ pub use rustdoc::{bare_rustdoc, rustdoc, Rustdoc};
 pub use diff::{diff, Diff};
 
 /// Panic-on-fail [`std::env::var`] and [`std::env::var_os`] wrappers.
-pub use env::{env_var, env_var_os};
+pub use env::{env_var, env_var_os, set_current_dir};
 
 /// Convenience helpers for running binaries and other commands.
 pub use run::{cmd, run, run_fail, run_with_args};
diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index f55abb513b80d..05e8af5e1c5ce 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -11,4 +11,3 @@ run-make/macos-deployment-target/Makefile
 run-make/split-debuginfo/Makefile
 run-make/symbol-mangling-hashed/Makefile
 run-make/translation/Makefile
-run-make/x86_64-fortanix-unknown-sgx-lvi/Makefile
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/Makefile b/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/Makefile
deleted file mode 100644
index 3c88ec34f431e..0000000000000
--- a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/Makefile
+++ /dev/null
@@ -1,23 +0,0 @@
-include ../tools.mk
-
-#only-x86_64-fortanix-unknown-sgx
-
-# For cargo setting
-export RUSTC := $(RUSTC_ORIGINAL)
-export LD_LIBRARY_PATH := $(HOST_RPATH_DIR)
-# We need to be outside of 'src' dir in order to run cargo
-export WORK_DIR := $(TMPDIR)
-export TEST_DIR := $(shell pwd)
-
-## clean up unused env variables which might cause harm.
-unexport RUSTC_LINKER
-unexport RUSTC_BOOTSTRAP
-unexport RUST_BUILD_STAGE
-unexport RUST_TEST_THREADS
-unexport RUST_TEST_TMPDIR
-unexport AR
-unexport CC
-unexport CXX
-
-all:
-	bash script.sh
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rmake.rs b/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rmake.rs
new file mode 100644
index 0000000000000..130781a429371
--- /dev/null
+++ b/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/rmake.rs
@@ -0,0 +1,96 @@
+// ignore-tidy-linelength
+// Reason: intel.com link
+
+// This security test checks that the disassembled form of certain symbols
+// is "hardened" - that means, the assembly instructions match a pattern that
+// mitigate potential Load Value Injection vulnerabilities.
+// To do so, a test crate is compiled, and certain symbols are found, disassembled
+// and checked one by one.
+// See https://github.com/rust-lang/rust/pull/77008
+
+// On load value injection:
+// https://www.intel.com/content/www/us/en/developer/articles/technical/software-security-guidance/technical-documentation/load-value-injection.html
+
+//@ only-x86_64-fortanix-unknown-sgx
+
+use run_make_support::{cmd, cwd, llvm_filecheck, llvm_objdump, regex, set_current_dir, target};
+
+fn main() {
+    let main_dir = cwd();
+    set_current_dir("enclave");
+    // HACK(eddyb) sets `RUSTC_BOOTSTRAP=1` so Cargo can accept nightly features.
+    // These come from the top-level Rust workspace, that this crate is not a
+    // member of, but Cargo tries to load the workspace `Cargo.toml` anyway.
+    cmd("cargo")
+        .env("RUSTC_BOOTSTRAP", "1")
+        .arg("-v")
+        .arg("run")
+        .arg("--target")
+        .arg(target())
+        .run();
+    set_current_dir(&main_dir);
+    // Rust has various ways of adding code to a binary:
+    // - Rust code
+    // - Inline assembly
+    // - Global assembly
+    // - C/C++ code compiled as part of Rust crates
+    // For those different kinds, we do have very small code examples that should be
+    // mitigated in some way. Mostly we check that ret instructions should no longer be present.
+    check("unw_getcontext", "unw_getcontext.checks");
+    check("__libunwind_Registers_x86_64_jumpto", "jumpto.checks");
+
+    check("std::io::stdio::_print::[[:alnum:]]+", "print.with_frame_pointers.checks");
+
+    check("rust_plus_one_global_asm", "rust_plus_one_global_asm.checks");
+
+    check("cc_plus_one_c", "cc_plus_one_c.checks");
+    check("cc_plus_one_c_asm", "cc_plus_one_c_asm.checks");
+    check("cc_plus_one_cxx", "cc_plus_one_cxx.checks");
+    check("cc_plus_one_cxx_asm", "cc_plus_one_cxx_asm.checks");
+    check("cc_plus_one_asm", "cc_plus_one_asm.checks");
+
+    check("cmake_plus_one_c", "cmake_plus_one_c.checks");
+    check("cmake_plus_one_c_asm", "cmake_plus_one_c_asm.checks");
+    check("cmake_plus_one_c_global_asm", "cmake_plus_one_c_global_asm.checks");
+    check("cmake_plus_one_cxx", "cmake_plus_one_cxx.checks");
+    check("cmake_plus_one_cxx_asm", "cmake_plus_one_cxx_asm.checks");
+    check("cmake_plus_one_cxx_global_asm", "cmake_plus_one_cxx_global_asm.checks");
+    check("cmake_plus_one_asm", "cmake_plus_one_asm.checks");
+}
+
+fn check(func_re: &str, mut checks: &str) {
+    let dump = llvm_objdump()
+        .input("enclave/target/x86_64-fortanix-unknown-sgx/debug/enclave")
+        .args(&["--syms", "--demangle"])
+        .run()
+        .stdout_utf8();
+    let re = regex::Regex::new(&format!("[[:blank:]]+{func_re}")).unwrap();
+    let func = re.find_iter(&dump).map(|m| m.as_str().trim()).collect::<Vec<&str>>().join(",");
+    assert!(!func.is_empty());
+    let dump = llvm_objdump()
+        .input("enclave/target/x86_64-fortanix-unknown-sgx/debug/enclave")
+        .args(&["--demangle", &format!("--disassemble-symbols={func}")])
+        .run()
+        .stdout_utf8();
+    let dump = dump.as_bytes();
+
+    // Unique case, must succeed at one of two possible tests.
+    // This is because frame pointers are optional, and them being enabled requires
+    // an additional `popq` in the pattern checking file.
+    if func_re == "std::io::stdio::_print::[[:alnum:]]+" {
+        let output = llvm_filecheck().stdin(&dump).patterns(checks).run_unchecked();
+        if !output.status().success() {
+            checks = "print.without_frame_pointers.checks";
+            llvm_filecheck().stdin(&dump).patterns(checks).run();
+        }
+    } else {
+        llvm_filecheck().stdin(&dump).patterns(checks).run();
+    }
+    if !["rust_plus_one_global_asm", "cmake_plus_one_c_global_asm", "cmake_plus_one_cxx_global_asm"]
+        .contains(&func_re)
+    {
+        // The assembler cannot avoid explicit `ret` instructions. Sequences
+        // of `shlq $0x0, (%rsp); lfence; retq` are used instead.
+        llvm_filecheck().args(&["--implicit-check-not", "ret"]).stdin(dump).patterns(checks).run();
+    }
+}
diff --git a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/script.sh b/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/script.sh
deleted file mode 100644
index a7c4ae13ecb38..0000000000000
--- a/tests/run-make/x86_64-fortanix-unknown-sgx-lvi/script.sh
+++ /dev/null
@@ -1,69 +0,0 @@
-#!/bin/bash
-set -exuo pipefail
-
-function build {
-    CRATE=enclave
-
-    mkdir -p "${WORK_DIR}"
-    pushd "${WORK_DIR}"
-        rm -rf "${CRATE}"
-        cp -a "${TEST_DIR}"/enclave .
-        pushd $CRATE
-            echo "${WORK_DIR}"
-            # HACK(eddyb) sets `RUSTC_BOOTSTRAP=1` so Cargo can accept nightly features.
-            # These come from the top-level Rust workspace, that this crate is not a
-            # member of, but Cargo tries to load the workspace `Cargo.toml` anyway.
-            env RUSTC_BOOTSTRAP=1
-                cargo -v run --target "${TARGET}"
-        popd
-    popd
-}
-
-function check {
-    local func_re="$1"
-    local checks="${TEST_DIR}/$2"
-    local asm=""
-    local objdump="${LLVM_BIN_DIR}/llvm-objdump"
-    local filecheck="${LLVM_BIN_DIR}/FileCheck"
-    local enclave=${WORK_DIR}/enclave/target/x86_64-fortanix-unknown-sgx/debug/enclave
-
-    asm=$(mktemp)
-    func="$(${objdump} --syms --demangle "${enclave}" | \
-            grep --only-matching -E "[[:blank:]]+${func_re}\$" | \
-            sed -e 's/^[[:space:]]*//' )"
-    ${objdump} --disassemble-symbols="${func}" --demangle \
-      "${enclave}" > "${asm}"
-    ${filecheck} --input-file "${asm}" "${checks}"
-
-    if [ "${func_re}" != "rust_plus_one_global_asm" ] &&
-         [ "${func_re}" != "cmake_plus_one_c_global_asm" ] &&
-         [ "${func_re}" != "cmake_plus_one_cxx_global_asm" ]; then
-        # The assembler cannot avoid explicit `ret` instructions. Sequences
-        # of `shlq $0x0, (%rsp); lfence; retq` are used instead.
-        # https://www.intel.com/content/www/us/en/developer/articles/technical/
-        #     software-security-guidance/technical-documentation/load-value-injection.html
-        ${filecheck} --implicit-check-not ret --input-file "${asm}" "${checks}"
-    fi
-}
-
-build
-
-check "unw_getcontext" unw_getcontext.checks
-check "__libunwind_Registers_x86_64_jumpto" jumpto.checks
-check 'std::io::stdio::_print::[[:alnum:]]+' print.with_frame_pointers.checks ||
-    check 'std::io::stdio::_print::[[:alnum:]]+' print.without_frame_pointers.checks
-check rust_plus_one_global_asm rust_plus_one_global_asm.checks
-
-check cc_plus_one_c cc_plus_one_c.checks
-check cc_plus_one_c_asm cc_plus_one_c_asm.checks
-check cc_plus_one_cxx cc_plus_one_cxx.checks
-check cc_plus_one_cxx_asm cc_plus_one_cxx_asm.checks
-check cc_plus_one_asm cc_plus_one_asm.checks
-
-check cmake_plus_one_c cmake_plus_one_c.checks
-check cmake_plus_one_c_asm cmake_plus_one_c_asm.checks
-check cmake_plus_one_c_global_asm cmake_plus_one_c_global_asm.checks
-check cmake_plus_one_cxx cmake_plus_one_cxx.checks
-check cmake_plus_one_cxx_asm cmake_plus_one_cxx_asm.checks
-check cmake_plus_one_cxx_global_asm cmake_plus_one_cxx_global_asm.checks
-check cmake_plus_one_asm cmake_plus_one_asm.checks

From e0900a1bb79a6c844fadb4b27fe8e0793d952476 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?=
 <jieyouxu@outlook.com>
Date: Thu, 22 Aug 2024 15:54:52 +0000
Subject: [PATCH 521/685] Revert "bootstrap: fix clean's `remove_dir_all`
 implementation"

This reverts commit 1687c55168f3837506afcd2240a8a0b6eadcc1eb.
---
 src/bootstrap/src/core/build_steps/clean.rs | 93 +++++++++++++++++----
 1 file changed, 78 insertions(+), 15 deletions(-)

diff --git a/src/bootstrap/src/core/build_steps/clean.rs b/src/bootstrap/src/core/build_steps/clean.rs
index bcbe490c36a0f..f608e5d715e49 100644
--- a/src/bootstrap/src/core/build_steps/clean.rs
+++ b/src/bootstrap/src/core/build_steps/clean.rs
@@ -6,6 +6,7 @@
 //! directory unless the `--all` flag is present.
 
 use std::fs;
+use std::io::{self, ErrorKind};
 use std::path::Path;
 
 use crate::core::builder::{crate_description, Builder, RunConfig, ShouldRun, Step};
@@ -100,11 +101,11 @@ fn clean(build: &Build, all: bool, stage: Option<u32>) {
         return;
     }
 
-    remove_dir_recursive("tmp");
+    rm_rf("tmp".as_ref());
 
     // Clean the entire build directory
     if all {
-        remove_dir_recursive(&build.out);
+        rm_rf(&build.out);
         return;
     }
 
@@ -135,17 +136,17 @@ fn clean_specific_stage(build: &Build, stage: u32) {
             }
 
             let path = t!(entry.path().canonicalize());
-            remove_dir_recursive(&path);
+            rm_rf(&path);
         }
     }
 }
 
 fn clean_default(build: &Build) {
-    remove_dir_recursive(build.out.join("tmp"));
-    remove_dir_recursive(build.out.join("dist"));
-    remove_dir_recursive(build.out.join("bootstrap").join(".last-warned-change-id"));
-    remove_dir_recursive(build.out.join("bootstrap-shims-dump"));
-    remove_dir_recursive(build.out.join("rustfmt.stamp"));
+    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("bootstrap-shims-dump"));
+    rm_rf(&build.out.join("rustfmt.stamp"));
 
     let mut hosts: Vec<_> = build.hosts.iter().map(|t| build.out.join(t)).collect();
     // After cross-compilation, artifacts of the host architecture (which may differ from build.host)
@@ -165,16 +166,78 @@ fn clean_default(build: &Build) {
                 continue;
             }
             let path = t!(entry.path().canonicalize());
-            remove_dir_recursive(&path);
+            rm_rf(&path);
         }
     }
 }
 
-/// Wrapper for [`std::fs::remove_dir_all`] that panics on failure and prints the `path` we failed
-/// on.
-fn remove_dir_recursive<P: AsRef<Path>>(path: P) {
-    let path = path.as_ref();
-    if let Err(e) = fs::remove_dir_all(path) {
-        panic!("failed to `remove_dir_all` at `{}`: {e}", path.display());
+fn rm_rf(path: &Path) {
+    match path.symlink_metadata() {
+        Err(e) => {
+            if e.kind() == ErrorKind::NotFound {
+                return;
+            }
+            panic!("failed to get metadata for file {}: {}", path.display(), e);
+        }
+        Ok(metadata) => {
+            if metadata.file_type().is_file() || metadata.file_type().is_symlink() {
+                do_op(path, "remove file", |p| match fs::remove_file(p) {
+                    #[cfg(windows)]
+                    Err(e)
+                        if e.kind() == std::io::ErrorKind::PermissionDenied
+                            && p.file_name().and_then(std::ffi::OsStr::to_str)
+                                == Some("bootstrap.exe") =>
+                    {
+                        eprintln!("WARNING: failed to delete '{}'.", p.display());
+                        Ok(())
+                    }
+                    r => r,
+                });
+
+                return;
+            }
+
+            for file in t!(fs::read_dir(path)) {
+                rm_rf(&t!(file).path());
+            }
+
+            do_op(path, "remove dir", |p| match fs::remove_dir(p) {
+                // Check for dir not empty on Windows
+                // FIXME: Once `ErrorKind::DirectoryNotEmpty` is stabilized,
+                // match on `e.kind()` instead.
+                #[cfg(windows)]
+                Err(e) if e.raw_os_error() == Some(145) => Ok(()),
+                r => r,
+            });
+        }
+    };
+}
+
+fn do_op<F>(path: &Path, desc: &str, mut f: F)
+where
+    F: FnMut(&Path) -> io::Result<()>,
+{
+    match f(path) {
+        Ok(()) => {}
+        // On windows we can't remove a readonly file, and git will often clone files as readonly.
+        // As a result, we have some special logic to remove readonly files on windows.
+        // This is also the reason that we can't use things like fs::remove_dir_all().
+        #[cfg(windows)]
+        Err(ref e) if e.kind() == ErrorKind::PermissionDenied => {
+            let m = t!(path.symlink_metadata());
+            let mut p = m.permissions();
+            p.set_readonly(false);
+            t!(fs::set_permissions(path, p));
+            f(path).unwrap_or_else(|e| {
+                // Delete symlinked directories on Windows
+                if m.file_type().is_symlink() && path.is_dir() && fs::remove_dir(path).is_ok() {
+                    return;
+                }
+                panic!("failed to {} {}: {}", desc, path.display(), e);
+            });
+        }
+        Err(e) => {
+            panic!("failed to {} {}: {}", desc, path.display(), e);
+        }
     }
 }

From 3957f3933904075a348eda68ae3d34f9f4914116 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=AE=B8=E6=9D=B0=E5=8F=8B=20Jieyou=20Xu=20=28Joe=29?=
 <jieyouxu@outlook.com>
Date: Thu, 22 Aug 2024 15:55:06 +0000
Subject: [PATCH 522/685] Revert "compiletest: use `std::fs::remove_dir_all`
 now that it is available"

This reverts commit 75ed08972703798888fceff12b3217408ca6a4b5.
---
 src/tools/compiletest/src/runtest.rs | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 6d45040345ad4..eca21e559896a 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -3265,7 +3265,7 @@ impl<'test> TestCx<'test> {
 
         let tmpdir = cwd.join(self.output_base_name());
         if tmpdir.exists() {
-            fs::remove_dir_all(&tmpdir).unwrap();
+            self.aggressive_rm_rf(&tmpdir).unwrap();
         }
         create_dir_all(&tmpdir).unwrap();
 
@@ -3404,6 +3404,29 @@ impl<'test> TestCx<'test> {
         }
     }
 
+    fn aggressive_rm_rf(&self, path: &Path) -> io::Result<()> {
+        for e in path.read_dir()? {
+            let entry = e?;
+            let path = entry.path();
+            if entry.file_type()?.is_dir() {
+                self.aggressive_rm_rf(&path)?;
+            } else {
+                // Remove readonly files as well on windows (by default we can't)
+                fs::remove_file(&path).or_else(|e| {
+                    if cfg!(windows) && e.kind() == io::ErrorKind::PermissionDenied {
+                        let mut meta = entry.metadata()?.permissions();
+                        meta.set_readonly(false);
+                        fs::set_permissions(&path, meta)?;
+                        fs::remove_file(&path)
+                    } else {
+                        Err(e)
+                    }
+                })?;
+            }
+        }
+        fs::remove_dir(path)
+    }
+
     fn run_rmake_v2_test(&self) {
         // For `run-make` V2, we need to perform 2 steps to build and run a `run-make` V2 recipe
         // (`rmake.rs`) to run the actual tests. The support library is already built as a tool rust
@@ -3452,7 +3475,7 @@ impl<'test> TestCx<'test> {
         // This setup intentionally diverges from legacy Makefile run-make tests.
         let base_dir = self.output_base_name();
         if base_dir.exists() {
-            fs::remove_dir_all(&base_dir).unwrap();
+            self.aggressive_rm_rf(&base_dir).unwrap();
         }
         let rmake_out_dir = base_dir.join("rmake_out");
         create_dir_all(&rmake_out_dir).unwrap();

From 8eb15586c6472077916730ca994e7bd5def09220 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 22 Aug 2024 12:34:06 -0400
Subject: [PATCH 523/685] Don't trigger refinement lint if predicates reference
 errors

---
 .../src/check/compare_impl_item/refine.rs     |  7 ++++++-
 tests/ui/impl-trait/in-trait/refine-err.rs    | 14 ++++++++++++++
 .../ui/impl-trait/in-trait/refine-err.stderr  |  9 +++++++++
 .../in-trait/span-bug-issue-121457.rs         |  1 -
 .../in-trait/span-bug-issue-121457.stderr     | 19 +------------------
 5 files changed, 30 insertions(+), 20 deletions(-)
 create mode 100644 tests/ui/impl-trait/in-trait/refine-err.rs
 create mode 100644 tests/ui/impl-trait/in-trait/refine-err.stderr

diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
index 80daaa60324a3..d2b7ede65234f 100644
--- a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
+++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs
@@ -7,7 +7,8 @@ use rustc_lint_defs::builtin::{REFINING_IMPL_TRAIT_INTERNAL, REFINING_IMPL_TRAIT
 use rustc_middle::span_bug;
 use rustc_middle::traits::{ObligationCause, Reveal};
 use rustc_middle::ty::{
-    self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperVisitable, TypeVisitable, TypeVisitor,
+    self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperVisitable, TypeVisitable,
+    TypeVisitableExt, TypeVisitor,
 };
 use rustc_span::Span;
 use rustc_trait_selection::regions::InferCtxtRegionExt;
@@ -177,6 +178,10 @@ pub(super) fn check_refining_return_position_impl_trait_in_trait<'tcx>(
         return;
     };
 
+    if trait_bounds.references_error() || impl_bounds.references_error() {
+        return;
+    }
+
     // For quicker lookup, use an `IndexSet` (we don't use one earlier because
     // it's not foldable..).
     // Also, We have to anonymize binders in these types because they may contain
diff --git a/tests/ui/impl-trait/in-trait/refine-err.rs b/tests/ui/impl-trait/in-trait/refine-err.rs
new file mode 100644
index 0000000000000..7518cee97c444
--- /dev/null
+++ b/tests/ui/impl-trait/in-trait/refine-err.rs
@@ -0,0 +1,14 @@
+#![deny(refining_impl_trait)]
+
+trait FromRow {
+    fn prepare(self) -> impl Fn() -> T;
+    //~^ ERROR cannot find type `T` in this scope
+}
+
+impl<T> FromRow for T {
+    fn prepare(self) -> impl Fn() -> T {
+        || todo!()
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/impl-trait/in-trait/refine-err.stderr b/tests/ui/impl-trait/in-trait/refine-err.stderr
new file mode 100644
index 0000000000000..6b4ef74d50afc
--- /dev/null
+++ b/tests/ui/impl-trait/in-trait/refine-err.stderr
@@ -0,0 +1,9 @@
+error[E0412]: cannot find type `T` in this scope
+  --> $DIR/refine-err.rs:4:38
+   |
+LL |     fn prepare(self) -> impl Fn() -> T;
+   |                                      ^ not found in this scope
+
+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/span-bug-issue-121457.rs b/tests/ui/impl-trait/in-trait/span-bug-issue-121457.rs
index 7a51037324f28..ab21dae7dc50d 100644
--- a/tests/ui/impl-trait/in-trait/span-bug-issue-121457.rs
+++ b/tests/ui/impl-trait/in-trait/span-bug-issue-121457.rs
@@ -14,7 +14,6 @@ impl<'a, I: 'a + Iterable> Iterable for &'a I {
     //~^ ERROR binding for associated type `Item` references lifetime `'missing`
     //~| ERROR binding for associated type `Item` references lifetime `'missing`
     //~| ERROR `()` is not an iterator
-    //~| WARNING impl trait in impl method signature does not match trait method signature
 }
 
 fn main() {}
diff --git a/tests/ui/impl-trait/in-trait/span-bug-issue-121457.stderr b/tests/ui/impl-trait/in-trait/span-bug-issue-121457.stderr
index 67c4df0f3a9eb..d8a2eef94a180 100644
--- a/tests/ui/impl-trait/in-trait/span-bug-issue-121457.stderr
+++ b/tests/ui/impl-trait/in-trait/span-bug-issue-121457.stderr
@@ -32,24 +32,7 @@ LL |     fn iter(&self) -> impl for<'missing> Iterator<Item = Self::Item<'missin
    |
    = help: the trait `Iterator` is not implemented for `()`
 
-warning: impl trait in impl method signature does not match trait method signature
-  --> $DIR/span-bug-issue-121457.rs:13:51
-   |
-LL |     fn iter(&self) -> impl Iterator;
-   |                       ------------- return type from trait method defined here
-...
-LL |     fn iter(&self) -> impl for<'missing> Iterator<Item = Self::Item<'missing>> {}
-   |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ this bound is stronger than that defined on the trait
-   |
-   = note: add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate
-   = note: we are soliciting feedback, see issue #121718 <https://github.com/rust-lang/rust/issues/121718> for more information
-   = note: `#[warn(refining_impl_trait_reachable)]` on by default
-help: replace the return type so that it matches the trait
-   |
-LL |     fn iter(&self) -> impl Iterator {}
-   |                       ~~~~~~~~~~~~~
-
-error: aborting due to 4 previous errors; 1 warning emitted
+error: aborting due to 4 previous errors
 
 Some errors have detailed explanations: E0195, E0277, E0582.
 For more information about an error, try `rustc --explain E0195`.

From e91f32829ccfb60e13fcb07dab4947c382a376c9 Mon Sep 17 00:00:00 2001
From: Stephen Lazaro <stephen.lazaro@gmail.com>
Date: Tue, 20 Aug 2024 17:53:30 -0700
Subject: [PATCH 524/685] Deduplicate Spans in Uninitialized Check

Prevents reporting labels or diagnostics on spans that are produced
multiple times.
---
 .../src/diagnostics/conflict_errors.rs            |  5 +++--
 tests/ui/duplicate-label-E0381-issue-129274.rs    | 13 +++++++++++++
 .../ui/duplicate-label-E0381-issue-129274.stderr  | 15 +++++++++++++++
 3 files changed, 31 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/duplicate-label-E0381-issue-129274.rs
 create mode 100644 tests/ui/duplicate-label-E0381-issue-129274.stderr

diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index 2b46e5597f778..4106a5de070a5 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -678,14 +678,15 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
         let inits = &self.move_data.init_path_map[mpi];
         let move_path = &self.move_data.move_paths[mpi];
         let decl_span = self.body.local_decls[move_path.place.local].source_info.span;
-        let mut spans = vec![];
+        let mut spans_set = FxIndexSet::default();
         for init_idx in inits {
             let init = &self.move_data.inits[*init_idx];
             let span = init.span(self.body);
             if !span.is_dummy() {
-                spans.push(span);
+                spans_set.insert(span);
             }
         }
+        let spans: Vec<_> = spans_set.into_iter().collect();
 
         let (name, desc) = match self.describe_place_with_options(
             moved_place,
diff --git a/tests/ui/duplicate-label-E0381-issue-129274.rs b/tests/ui/duplicate-label-E0381-issue-129274.rs
new file mode 100644
index 0000000000000..b2156e630c87f
--- /dev/null
+++ b/tests/ui/duplicate-label-E0381-issue-129274.rs
@@ -0,0 +1,13 @@
+fn main() {
+    fn test() {
+        loop {
+            let blah: Option<String>;
+            if true {
+                blah = Some("".to_string());
+            }
+            if let Some(blah) = blah.as_ref() { //~ ERROR E0381
+            }
+        }
+    }
+    println!("{:?}", test())
+}
diff --git a/tests/ui/duplicate-label-E0381-issue-129274.stderr b/tests/ui/duplicate-label-E0381-issue-129274.stderr
new file mode 100644
index 0000000000000..7f8bddb17c5a8
--- /dev/null
+++ b/tests/ui/duplicate-label-E0381-issue-129274.stderr
@@ -0,0 +1,15 @@
+error[E0381]: used binding `blah` is possibly-uninitialized
+  --> $DIR/duplicate-label-E0381-issue-129274.rs:8:33
+   |
+LL |             let blah: Option<String>;
+   |                 ---- binding declared here but left uninitialized
+LL |             if true {
+LL |                 blah = Some("".to_string());
+   |                 ---- binding initialized here in some conditions
+LL |             }
+LL |             if let Some(blah) = blah.as_ref() {
+   |                                 ^^^^ `blah` used here but it is possibly-uninitialized
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0381`.

From f62b9e0179434218040f42ee58bb99c1bf27c6d7 Mon Sep 17 00:00:00 2001
From: Vadim Petrochenkov <vadim.petrochenkov@gmail.com>
Date: Tue, 30 Jul 2024 20:27:17 +0300
Subject: [PATCH 525/685] rustc: Simplify getting sysroot library directory

---
 compiler/rustc_codegen_ssa/src/back/link.rs | 27 +++++++++------------
 compiler/rustc_session/src/filesearch.rs    | 16 +-----------
 compiler/rustc_session/src/session.rs       | 16 ++----------
 3 files changed, 14 insertions(+), 45 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 7bad9d33e7d31..ca439460adc11 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1317,11 +1317,9 @@ fn link_sanitizer_runtime(
     name: &str,
 ) {
     fn find_sanitizer_runtime(sess: &Session, filename: &str) -> PathBuf {
-        let session_tlib =
-            filesearch::make_target_lib_path(&sess.sysroot, sess.opts.target_triple.triple());
-        let path = session_tlib.join(filename);
+        let path = sess.target_tlib_path.dir.join(filename);
         if path.exists() {
-            return session_tlib;
+            return sess.target_tlib_path.dir.clone();
         } else {
             let default_sysroot =
                 filesearch::get_or_default_sysroot().expect("Failed finding sysroot");
@@ -1612,19 +1610,18 @@ fn print_native_static_libs(
 }
 
 fn get_object_file_path(sess: &Session, name: &str, self_contained: bool) -> PathBuf {
-    let fs = sess.target_filesearch(PathKind::Native);
-    let file_path = fs.get_lib_path().join(name);
+    let file_path = sess.target_tlib_path.dir.join(name);
     if file_path.exists() {
         return file_path;
     }
     // Special directory with objects used only in self-contained linkage mode
     if self_contained {
-        let file_path = fs.get_self_contained_lib_path().join(name);
+        let file_path = sess.target_tlib_path.dir.join("self-contained").join(name);
         if file_path.exists() {
             return file_path;
         }
     }
-    for search_path in fs.search_paths() {
+    for search_path in sess.target_filesearch(PathKind::Native).search_paths() {
         let file_path = search_path.dir.join(name);
         if file_path.exists() {
             return file_path;
@@ -2131,7 +2128,7 @@ fn add_library_search_dirs(
             | LinkSelfContainedComponents::UNWIND
             | LinkSelfContainedComponents::MINGW,
     ) {
-        let lib_path = sess.target_filesearch(PathKind::Native).get_self_contained_lib_path();
+        let lib_path = sess.target_tlib_path.dir.join("self-contained");
         cmd.include_path(&fix_windows_verbatim_for_gcc(&lib_path));
     }
 
@@ -2146,8 +2143,7 @@ fn add_library_search_dirs(
         || sess.target.os == "fuchsia"
         || sess.target.is_like_osx && !sess.opts.unstable_opts.sanitizer.is_empty()
     {
-        let lib_path = sess.target_filesearch(PathKind::Native).get_lib_path();
-        cmd.include_path(&fix_windows_verbatim_for_gcc(&lib_path));
+        cmd.include_path(&fix_windows_verbatim_for_gcc(&sess.target_tlib_path.dir));
     }
 
     // Mac Catalyst uses the macOS SDK, but to link to iOS-specific frameworks
@@ -2859,15 +2855,14 @@ fn add_upstream_native_libraries(
 //
 // The returned path will always have `fix_windows_verbatim_for_gcc()` applied to it.
 fn rehome_sysroot_lib_dir(sess: &Session, lib_dir: &Path) -> PathBuf {
-    let sysroot_lib_path = sess.target_filesearch(PathKind::All).get_lib_path();
+    let sysroot_lib_path = &sess.target_tlib_path.dir;
     let canonical_sysroot_lib_path =
-        { try_canonicalize(&sysroot_lib_path).unwrap_or_else(|_| sysroot_lib_path.clone()) };
+        { try_canonicalize(sysroot_lib_path).unwrap_or_else(|_| sysroot_lib_path.clone()) };
 
     let canonical_lib_dir = try_canonicalize(lib_dir).unwrap_or_else(|_| lib_dir.to_path_buf());
     if canonical_lib_dir == canonical_sysroot_lib_path {
-        // This path, returned by `target_filesearch().get_lib_path()`, has
-        // already had `fix_windows_verbatim_for_gcc()` applied if needed.
-        sysroot_lib_path
+        // This path already had `fix_windows_verbatim_for_gcc()` applied if needed.
+        sysroot_lib_path.clone()
     } else {
         fix_windows_verbatim_for_gcc(lib_dir)
     }
diff --git a/compiler/rustc_session/src/filesearch.rs b/compiler/rustc_session/src/filesearch.rs
index 63ca5fefd9faf..d78f4a78de732 100644
--- a/compiler/rustc_session/src/filesearch.rs
+++ b/compiler/rustc_session/src/filesearch.rs
@@ -5,14 +5,11 @@ use std::{env, fs};
 
 use rustc_fs_util::{fix_windows_verbatim_for_gcc, try_canonicalize};
 use smallvec::{smallvec, SmallVec};
-use tracing::debug;
 
 use crate::search_paths::{PathKind, SearchPath};
 
 #[derive(Clone)]
 pub struct FileSearch<'a> {
-    sysroot: &'a Path,
-    triple: &'a str,
     cli_search_paths: &'a [SearchPath],
     tlib_path: &'a SearchPath,
     kind: PathKind,
@@ -32,23 +29,12 @@ impl<'a> FileSearch<'a> {
             .chain(std::iter::once(self.tlib_path))
     }
 
-    pub fn get_lib_path(&self) -> PathBuf {
-        make_target_lib_path(self.sysroot, self.triple)
-    }
-
-    pub fn get_self_contained_lib_path(&self) -> PathBuf {
-        self.get_lib_path().join("self-contained")
-    }
-
     pub fn new(
-        sysroot: &'a Path,
-        triple: &'a str,
         cli_search_paths: &'a [SearchPath],
         tlib_path: &'a SearchPath,
         kind: PathKind,
     ) -> FileSearch<'a> {
-        debug!("using sysroot = {}, triple = {}", sysroot.display(), triple);
-        FileSearch { sysroot, triple, cli_search_paths, tlib_path, kind }
+        FileSearch { cli_search_paths, tlib_path, kind }
     }
 }
 
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 693867c3853da..b073950a750b4 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -439,22 +439,10 @@ impl Session {
     }
 
     pub fn target_filesearch(&self, kind: PathKind) -> filesearch::FileSearch<'_> {
-        filesearch::FileSearch::new(
-            &self.sysroot,
-            self.opts.target_triple.triple(),
-            &self.opts.search_paths,
-            &self.target_tlib_path,
-            kind,
-        )
+        filesearch::FileSearch::new(&self.opts.search_paths, &self.target_tlib_path, kind)
     }
     pub fn host_filesearch(&self, kind: PathKind) -> filesearch::FileSearch<'_> {
-        filesearch::FileSearch::new(
-            &self.sysroot,
-            config::host_triple(),
-            &self.opts.search_paths,
-            &self.host_tlib_path,
-            kind,
-        )
+        filesearch::FileSearch::new(&self.opts.search_paths, &self.host_tlib_path, kind)
     }
 
     /// Returns a list of directories where target-specific tool binaries are located. Some fallback

From 736f773844e7ebf05ccb827c17b7ad9eb28aa295 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 11 Jul 2024 15:44:58 -0400
Subject: [PATCH 526/685] fix: fs::remove_dir_all: treat ENOENT as success

fixes #127576

windows implementation still needs some work
---
 library/std/src/fs.rs                       |  2 +
 library/std/src/sys/pal/solid/fs.rs         | 23 +++++---
 library/std/src/sys/pal/unix/fs.rs          | 49 +++++++++++-----
 library/std/src/sys/pal/wasi/fs.rs          | 20 +++++--
 library/std/src/sys/pal/windows/fs.rs       |  4 +-
 library/std/src/sys_common/fs.rs            | 21 +++++--
 library/std/src/sys_common/mod.rs           |  8 +++
 tests/run-make/remove-dir-all-race/rmake.rs | 62 +++++++++++++++++++++
 8 files changed, 153 insertions(+), 36 deletions(-)
 create mode 100644 tests/run-make/remove-dir-all-race/rmake.rs

diff --git a/library/std/src/fs.rs b/library/std/src/fs.rs
index c5edb03bb08be..6a0d9f47960ec 100644
--- a/library/std/src/fs.rs
+++ b/library/std/src/fs.rs
@@ -2491,6 +2491,8 @@ pub fn remove_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
 ///
 /// Consider ignoring the error if validating the removal is not required for your use case.
 ///
+/// [`io::ErrorKind::NotFound`] is only returned if no removal occurs.
+///
 /// [`fs::remove_file`]: remove_file
 /// [`fs::remove_dir`]: remove_dir
 ///
diff --git a/library/std/src/sys/pal/solid/fs.rs b/library/std/src/sys/pal/solid/fs.rs
index 8179ec8821a38..591be66fcb463 100644
--- a/library/std/src/sys/pal/solid/fs.rs
+++ b/library/std/src/sys/pal/solid/fs.rs
@@ -10,6 +10,7 @@ use crate::sync::Arc;
 use crate::sys::time::SystemTime;
 use crate::sys::unsupported;
 pub use crate::sys_common::fs::exists;
+use crate::sys_common::ignore_notfound;
 
 /// A file descriptor.
 #[derive(Clone, Copy)]
@@ -527,15 +528,23 @@ pub fn rmdir(p: &Path) -> io::Result<()> {
 
 pub fn remove_dir_all(path: &Path) -> io::Result<()> {
     for child in readdir(path)? {
-        let child = child?;
-        let child_type = child.file_type()?;
-        if child_type.is_dir() {
-            remove_dir_all(&child.path())?;
-        } else {
-            unlink(&child.path())?;
+        let result: io::Result<()> = try {
+            let child = child?;
+            let child_type = child.file_type()?;
+            if child_type.is_dir() {
+                remove_dir_all(&child.path())?;
+            } else {
+                unlink(&child.path())?;
+            }
+        };
+        // ignore internal NotFound errors
+        if let Err(err) = result
+            && err.kind() != io::ErrorKind::NotFound
+        {
+            return result;
         }
     }
-    rmdir(path)
+    ignore_notfound(rmdir(path))
 }
 
 pub fn readlink(p: &Path) -> io::Result<PathBuf> {
diff --git a/library/std/src/sys/pal/unix/fs.rs b/library/std/src/sys/pal/unix/fs.rs
index bdb83f0785784..acd9c338f05a6 100644
--- a/library/std/src/sys/pal/unix/fs.rs
+++ b/library/std/src/sys/pal/unix/fs.rs
@@ -2029,6 +2029,7 @@ mod remove_dir_impl {
     use crate::path::{Path, PathBuf};
     use crate::sys::common::small_c_string::run_path_with_cstr;
     use crate::sys::{cvt, cvt_r};
+    use crate::sys_common::ignore_notfound;
 
     pub fn openat_nofollow_dironly(parent_fd: Option<RawFd>, p: &CStr) -> io::Result<OwnedFd> {
         let fd = cvt_r(|| unsafe {
@@ -2082,6 +2083,16 @@ mod remove_dir_impl {
         }
     }
 
+    fn is_enoent(result: &io::Result<()>) -> bool {
+        if let Err(err) = result
+            && matches!(err.raw_os_error(), Some(libc::ENOENT))
+        {
+            true
+        } else {
+            false
+        }
+    }
+
     fn remove_dir_all_recursive(parent_fd: Option<RawFd>, path: &CStr) -> io::Result<()> {
         // try opening as directory
         let fd = match openat_nofollow_dironly(parent_fd, &path) {
@@ -2105,27 +2116,35 @@ mod remove_dir_impl {
         for child in dir {
             let child = child?;
             let child_name = child.name_cstr();
-            match is_dir(&child) {
-                Some(true) => {
-                    remove_dir_all_recursive(Some(fd), child_name)?;
-                }
-                Some(false) => {
-                    cvt(unsafe { unlinkat(fd, child_name.as_ptr(), 0) })?;
-                }
-                None => {
-                    // POSIX specifies that calling unlink()/unlinkat(..., 0) on a directory can succeed
-                    // if the process has the appropriate privileges. This however can causing orphaned
-                    // directories requiring an fsck e.g. on Solaris and Illumos. So we try recursing
-                    // into it first instead of trying to unlink() it.
-                    remove_dir_all_recursive(Some(fd), child_name)?;
+            // we need an inner try block, because if one of these
+            // directories has already been deleted, then we need to
+            // continue the loop, not return ok.
+            let result: io::Result<()> = try {
+                match is_dir(&child) {
+                    Some(true) => {
+                        remove_dir_all_recursive(Some(fd), child_name)?;
+                    }
+                    Some(false) => {
+                        cvt(unsafe { unlinkat(fd, child_name.as_ptr(), 0) })?;
+                    }
+                    None => {
+                        // POSIX specifies that calling unlink()/unlinkat(..., 0) on a directory can succeed
+                        // if the process has the appropriate privileges. This however can causing orphaned
+                        // directories requiring an fsck e.g. on Solaris and Illumos. So we try recursing
+                        // into it first instead of trying to unlink() it.
+                        remove_dir_all_recursive(Some(fd), child_name)?;
+                    }
                 }
+            };
+            if result.is_err() && !is_enoent(&result) {
+                return result;
             }
         }
 
         // unlink the directory after removing its contents
-        cvt(unsafe {
+        ignore_notfound(cvt(unsafe {
             unlinkat(parent_fd.unwrap_or(libc::AT_FDCWD), path.as_ptr(), libc::AT_REMOVEDIR)
-        })?;
+        }))?;
         Ok(())
     }
 
diff --git a/library/std/src/sys/pal/wasi/fs.rs b/library/std/src/sys/pal/wasi/fs.rs
index 11900886f0b5c..7064473f274e6 100644
--- a/library/std/src/sys/pal/wasi/fs.rs
+++ b/library/std/src/sys/pal/wasi/fs.rs
@@ -13,7 +13,7 @@ use crate::sys::common::small_c_string::run_path_with_cstr;
 use crate::sys::time::SystemTime;
 use crate::sys::unsupported;
 pub use crate::sys_common::fs::exists;
-use crate::sys_common::{AsInner, FromInner, IntoInner};
+use crate::sys_common::{ignore_notfound, AsInner, FromInner, IntoInner};
 use crate::{fmt, iter, ptr};
 
 pub struct File {
@@ -794,14 +794,22 @@ fn remove_dir_all_recursive(parent: &WasiFd, path: &Path) -> io::Result<()> {
             io::const_io_error!(io::ErrorKind::Uncategorized, "invalid utf-8 file name found")
         })?;
 
-        if entry.file_type()?.is_dir() {
-            remove_dir_all_recursive(&entry.inner.dir.fd, path.as_ref())?;
-        } else {
-            entry.inner.dir.fd.unlink_file(path)?;
+        let result: io::Result<()> = try {
+            if entry.file_type()?.is_dir() {
+                remove_dir_all_recursive(&entry.inner.dir.fd, path.as_ref())?;
+            } else {
+                entry.inner.dir.fd.unlink_file(path)?;
+            }
+        };
+        // ignore internal NotFound errors
+        if let Err(err) = &result
+            && err.kind() != io::ErrorKind::NotFound
+        {
+            return result;
         }
     }
 
     // Once all this directory's contents are deleted it should be safe to
     // delete the directory tiself.
-    parent.remove_directory(osstr2str(path.as_ref())?)
+    ignore_notfound(parent.remove_directory(osstr2str(path.as_ref())?))
 }
diff --git a/library/std/src/sys/pal/windows/fs.rs b/library/std/src/sys/pal/windows/fs.rs
index d99d4931de40f..2134152ea93f1 100644
--- a/library/std/src/sys/pal/windows/fs.rs
+++ b/library/std/src/sys/pal/windows/fs.rs
@@ -14,7 +14,7 @@ use crate::sys::handle::Handle;
 use crate::sys::path::maybe_verbatim;
 use crate::sys::time::SystemTime;
 use crate::sys::{c, cvt, Align8};
-use crate::sys_common::{AsInner, FromInner, IntoInner};
+use crate::sys_common::{ignore_notfound, AsInner, FromInner, IntoInner};
 use crate::{fmt, ptr, slice, thread};
 
 pub struct File {
@@ -1160,7 +1160,7 @@ pub fn remove_dir_all(path: &Path) -> io::Result<()> {
         return Err(io::Error::from_raw_os_error(c::ERROR_DIRECTORY as _));
     }
 
-    match remove_dir_all_iterative(&file, File::posix_delete) {
+    match ignore_notfound(remove_dir_all_iterative(&file, File::posix_delete)) {
         Err(e) => {
             if let Some(code) = e.raw_os_error() {
                 match code as u32 {
diff --git a/library/std/src/sys_common/fs.rs b/library/std/src/sys_common/fs.rs
index acb6713cf1b14..a25a7244660bb 100644
--- a/library/std/src/sys_common/fs.rs
+++ b/library/std/src/sys_common/fs.rs
@@ -3,6 +3,7 @@
 use crate::fs;
 use crate::io::{self, Error, ErrorKind};
 use crate::path::Path;
+use crate::sys_common::ignore_notfound;
 
 pub(crate) const NOT_FILE_ERROR: Error = io::const_io_error!(
     ErrorKind::InvalidInput,
@@ -32,14 +33,22 @@ pub fn remove_dir_all(path: &Path) -> io::Result<()> {
 
 fn remove_dir_all_recursive(path: &Path) -> io::Result<()> {
     for child in fs::read_dir(path)? {
-        let child = child?;
-        if child.file_type()?.is_dir() {
-            remove_dir_all_recursive(&child.path())?;
-        } else {
-            fs::remove_file(&child.path())?;
+        let result: io::Result<()> = try {
+            let child = child?;
+            if child.file_type()?.is_dir() {
+                remove_dir_all_recursive(&child.path())?;
+            } else {
+                fs::remove_file(&child.path())?;
+            }
+        };
+        // ignore internal NotFound errors to prevent race conditions
+        if let Err(err) = &result
+            && err.kind() != io::ErrorKind::NotFound
+        {
+            return result;
         }
     }
-    fs::remove_dir(path)
+    ignore_notfound(fs::remove_dir(path))
 }
 
 pub fn exists(path: &Path) -> io::Result<bool> {
diff --git a/library/std/src/sys_common/mod.rs b/library/std/src/sys_common/mod.rs
index 60ee405ecaaa2..1c884f107beeb 100644
--- a/library/std/src/sys_common/mod.rs
+++ b/library/std/src/sys_common/mod.rs
@@ -80,3 +80,11 @@ pub fn mul_div_u64(value: u64, numer: u64, denom: u64) -> u64 {
     // r < denom, so (denom*numer) is the upper bound of (r*numer)
     q * numer + r * numer / denom
 }
+
+pub fn ignore_notfound<T>(result: crate::io::Result<T>) -> crate::io::Result<()> {
+    match result {
+        Err(err) if err.kind() == crate::io::ErrorKind::NotFound => Ok(()),
+        Ok(_) => Ok(()),
+        Err(err) => Err(err),
+    }
+}
diff --git a/tests/run-make/remove-dir-all-race/rmake.rs b/tests/run-make/remove-dir-all-race/rmake.rs
new file mode 100644
index 0000000000000..03c94b76127d5
--- /dev/null
+++ b/tests/run-make/remove-dir-all-race/rmake.rs
@@ -0,0 +1,62 @@
+//@ ignore-windows
+
+// This test attempts to make sure that running `remove_dir_all`
+// doesn't result in a NotFound error one of the files it
+// is deleting is deleted concurrently.
+//
+// The windows implementation for `remove_dir_all` is significantly
+// more complicated, and has not yet been brought up to par with
+// the implementation on other platforms, so this test is marked as
+// `ignore-windows` until someone more expirenced with windows can
+// sort that out.
+
+use std::fs::remove_dir_all;
+use std::path::Path;
+use std::thread;
+use std::time::Duration;
+
+use run_make_support::rfs::{create_dir, write};
+use run_make_support::run_in_tmpdir;
+
+fn main() {
+    let mut race_happened = false;
+    run_in_tmpdir(|| {
+        for i in 0..150 {
+            create_dir("outer");
+            create_dir("outer/inner");
+            write("outer/inner.txt", b"sometext");
+
+            thread::scope(|scope| {
+                let t1 = scope.spawn(|| {
+                    thread::sleep(Duration::from_nanos(i));
+                    remove_dir_all("outer").unwrap();
+                });
+
+                let race_happened_ref = &race_happened;
+                let t2 = scope.spawn(|| {
+                    let r1 = remove_dir_all("outer/inner");
+                    let r2 = remove_dir_all("outer/inner.txt");
+                    if r1.is_ok() && r2.is_err() {
+                        race_happened = true;
+                    }
+                });
+            });
+
+            assert!(!Path::new("outer").exists());
+
+            // trying to remove a nonexistant top-level directory should
+            // still result in an error.
+            let Err(err) = remove_dir_all("outer") else {
+                panic!("removing nonexistant dir did not result in an error");
+            };
+            assert_eq!(err.kind(), std::io::ErrorKind::NotFound);
+        }
+    });
+    if !race_happened {
+        eprintln!(
+            "WARNING: multithreaded deletion never raced, \
+                   try increasing the number of attempts or \
+                   adjusting the sleep timing"
+        );
+    }
+}

From 988bc1c654a1319a7b6fb198184459d503b249be Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 22 Aug 2024 14:25:54 -0400
Subject: [PATCH 527/685] fix typos in new pointer conversion docs

---
 library/core/src/ptr/const_ptr.rs | 2 +-
 library/core/src/ptr/mod.rs       | 2 +-
 library/core/src/ptr/mut_ptr.rs   | 8 ++++----
 library/core/src/ptr/non_null.rs  | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs
index 8b9f7b57d0053..d7eea937ef847 100644
--- a/library/core/src/ptr/const_ptr.rs
+++ b/library/core/src/ptr/const_ptr.rs
@@ -239,7 +239,7 @@ impl<T: ?Sized> *const T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     ///
     /// # Examples
     ///
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index b2fb365d22745..a7d6602287b90 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -87,7 +87,7 @@
 //!   even if they only modify `UnsafeCell` data.
 //!
 //! If a pointer follows all of these rules, it is said to be
-//! *convertable to a reference*.
+//! *convertible to a reference*.
 // ^ we use this term instead of saying that the produced reference must
 // be valid, as the validity of a reference is easily confused for the
 // validity of the thing it refers to, and while the two concepts are
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
index fb393ffadd5cd..d7bb18590ed5e 100644
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -247,7 +247,7 @@ impl<T: ?Sized> *mut T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
     /// # Examples
     ///
@@ -296,7 +296,7 @@ impl<T: ?Sized> *mut T {
     ///
     /// # Safety
     ///
-    /// When calling this method, you have to ensure that the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// When calling this method, you have to ensure that the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
     ///
     /// # Examples
     ///
@@ -330,7 +330,7 @@ impl<T: ?Sized> *mut T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion).
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     /// Note that because the created reference is to `MaybeUninit<T>`, the
     /// source pointer can point to uninitialized memory.
     ///
@@ -566,7 +566,7 @@ impl<T: ?Sized> *mut T {
     ///
     /// When calling this method, you have to ensure that *either*
     /// the pointer is null *or*
-    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     ///
     ///
     /// # Examples
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index 1e1cf780c28f0..5d5d9d401a295 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -129,7 +129,7 @@ impl<T: Sized> NonNull<T> {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that
-    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion).
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     /// Note that because the created reference is to `MaybeUninit<T>`, the
     /// source pointer can point to uninitialized memory.
     #[inline]
@@ -153,7 +153,7 @@ impl<T: Sized> NonNull<T> {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that
-    /// the pointer is [convirtible to a reference](crate::ptr#pointer-to-reference-conversion).
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     /// Note that because the created reference is to `MaybeUninit<T>`, the
     /// source pointer can point to uninitialized memory.
     #[inline]

From e37e15dc0bd9e4a21ced7a5c534c4c64dc3dfeda Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 22 Aug 2024 18:05:11 +0200
Subject: [PATCH 528/685] Fix extern crates not being hidden with `doc(hidden)`

---
 src/librustdoc/passes/strip_hidden.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/librustdoc/passes/strip_hidden.rs b/src/librustdoc/passes/strip_hidden.rs
index faf42b3aab13e..23e298571d5ce 100644
--- a/src/librustdoc/passes/strip_hidden.rs
+++ b/src/librustdoc/passes/strip_hidden.rs
@@ -2,7 +2,7 @@
 
 use std::mem;
 
-use rustc_hir::def_id::LocalDefId;
+use rustc_hir::def_id::{LocalDefId, CRATE_DEF_ID};
 use rustc_middle::ty::TyCtxt;
 use rustc_span::symbol::sym;
 
@@ -145,8 +145,9 @@ impl<'a, 'tcx> DocFolder for Stripper<'a, 'tcx> {
                 let old = mem::replace(&mut self.update_retained, false);
                 let ret = self.set_is_in_hidden_item_and_fold(true, i);
                 self.update_retained = old;
-                if ret.is_crate() {
-                    // We don't strip the crate, even if it has `#[doc(hidden)]`.
+                if ret.item_id == clean::ItemId::DefId(CRATE_DEF_ID.into()) {
+                    // We don't strip the current crate, even if it has `#[doc(hidden)]`.
+                    debug!("strip_hidden: Not strippping local crate");
                     Some(ret)
                 } else {
                     Some(strip_item(ret))

From 4de29c90478003ce28880e92986ee7f2fc9c2d33 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Thu, 22 Aug 2024 18:05:52 +0200
Subject: [PATCH 529/685] Add regression test for #126796

---
 tests/rustdoc/doc-hidden-crate.rs | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 tests/rustdoc/doc-hidden-crate.rs

diff --git a/tests/rustdoc/doc-hidden-crate.rs b/tests/rustdoc/doc-hidden-crate.rs
new file mode 100644
index 0000000000000..dac557107a903
--- /dev/null
+++ b/tests/rustdoc/doc-hidden-crate.rs
@@ -0,0 +1,27 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/126796>.
+// `doc(hidden)` should still be able to hide extern crates, only the local crates
+// cannot be hidden because we still need to generate its `index.html` file.
+
+#![crate_name = "foo"]
+#![doc(hidden)]
+
+//@ has 'foo/index.html'
+// First we check that the page contains the crate name (`foo`).
+//@ has - '//*' 'foo'
+// But doesn't contain any of the other items.
+//@ !has - '//*' 'other'
+//@ !has - '//*' 'marker'
+//@ !has - '//*' 'PhantomData'
+
+#[doc(inline)]
+pub use std as other;
+
+#[doc(inline)]
+pub use std::marker;
+
+#[doc(inline)]
+pub use std::marker::PhantomData;
+
+//@ !has - '//*' 'myself'
+#[doc(inline)]
+pub use crate as myself;

From 8151de2820442d2d19a5cabaefcafc64d7490c6f Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Thu, 22 Aug 2024 11:33:51 -0700
Subject: [PATCH 530/685] rustdoc-search: use tighter json for names and
 parents

File size
---------

```console
$ du -hs doc.old/search-index1.82.0.js doc/search-index1.82.0.js
3.2M    doc.old/search-index1.82.0.js
2.8M    doc/search-index1.82.0.js
$ gzip doc/search-index1.82.0.js
$ gzip doc.old/search-index1.82.0.js
$ du -hs doc.old/search-index1.82.0.js.gz doc/search-index1.82.0.js.gz
464K    doc.old/search-index1.82.0.js.gz
456K    doc/search-index1.82.0.js.gz
$ du -hs compiler-doc.old/search-index.js compiler-doc/search-index.js
8.5M    compiler-doc.old/search-index.js
6.5M    compiler-doc/search-index.js
$ gzip compiler-doc/search-index1.82.0.js
$ gzip compiler-doc.old/search-index1.82.0.js
$ du -hs compiler-doc.old/search-index.js.gz compiler-doc/search-index.js.gz
1.4M    compiler-doc.old/search-index.js.gz
1.4M    compiler-doc/search-index.js.gz
```
---
 src/librustdoc/html/render/search_index.rs | 36 ++++++++++++++++++----
 src/librustdoc/html/static/js/search.js    | 17 +++++-----
 2 files changed, 40 insertions(+), 13 deletions(-)

diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
index 8a12bdef69bf4..d7682bd1c1917 100644
--- a/src/librustdoc/html/render/search_index.rs
+++ b/src/librustdoc/html/render/search_index.rs
@@ -579,12 +579,14 @@ pub(crate) fn build_index<'tcx>(
             let mut names = Vec::with_capacity(self.items.len());
             let mut types = String::with_capacity(self.items.len());
             let mut full_paths = Vec::with_capacity(self.items.len());
-            let mut parents = Vec::with_capacity(self.items.len());
+            let mut parents = String::with_capacity(self.items.len());
+            let mut parents_backref_queue = VecDeque::new();
             let mut functions = String::with_capacity(self.items.len());
             let mut deprecated = Vec::with_capacity(self.items.len());
 
-            let mut backref_queue = VecDeque::new();
+            let mut type_backref_queue = VecDeque::new();
 
+            let mut last_name = None;
             for (index, item) in self.items.iter().enumerate() {
                 let n = item.ty as u8;
                 let c = char::try_from(n + b'A').expect("item types must fit in ASCII");
@@ -597,17 +599,39 @@ pub(crate) fn build_index<'tcx>(
                     "`{}` is missing idx",
                     item.name
                 );
-                // 0 is a sentinel, everything else is one-indexed
-                parents.push(item.parent_idx.map(|x| x + 1).unwrap_or(0));
+                assert!(
+                    parents_backref_queue.len() <= 16,
+                    "the string encoding only supports 16 slots of lookback"
+                );
+                let parent: i32 = item.parent_idx.map(|x| x + 1).unwrap_or(0).try_into().unwrap();
+                if let Some(idx) = parents_backref_queue.iter().position(|p: &i32| *p == parent) {
+                    parents.push(
+                        char::try_from('0' as u32 + u32::try_from(idx).unwrap())
+                            .expect("last possible value is '?'"),
+                    );
+                } else if parent == 0 {
+                    write_vlqhex_to_string(parent, &mut parents);
+                } else {
+                    parents_backref_queue.push_front(parent);
+                    write_vlqhex_to_string(parent, &mut parents);
+                    if parents_backref_queue.len() > 16 {
+                        parents_backref_queue.pop_back();
+                    }
+                }
 
-                names.push(item.name.as_str());
+                if Some(item.name.as_str()) == last_name {
+                    names.push("");
+                } else {
+                    names.push(item.name.as_str());
+                    last_name = Some(item.name.as_str());
+                }
 
                 if !item.path.is_empty() {
                     full_paths.push((index, &item.path));
                 }
 
                 match &item.search_type {
-                    Some(ty) => ty.write_to_string(&mut functions, &mut backref_queue),
+                    Some(ty) => ty.write_to_string(&mut functions, &mut type_backref_queue),
                     None => functions.push('`'),
                 }
 
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 3eb27ea087c1d..4e3b532ae08ae 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -3546,7 +3546,7 @@ ${item.displayPath}<span class="${type}">${name}</span>\
             // Used to de-duplicate inlined and re-exported stuff
             const itemReexports = new Map(crateCorpus.r);
             // an array of (Number) the parent path index + 1 to `paths`, or 0 if none
-            const itemParentIdxs = crateCorpus.i;
+            const itemParentIdxDecoder = new VlqHexDecoder(crateCorpus.i, noop => noop);
             // a map Number, string for impl disambiguators
             const implDisambiguator = new Map(crateCorpus.b);
             // an array of [(Number) item type,
@@ -3593,6 +3593,8 @@ ${item.displayPath}<span class="${type}">${name}</span>\
             // faster analysis operations
             lastPath = "";
             len = itemTypes.length;
+            let lastName = "";
+            let lastWord = "";
             for (let i = 0; i < len; ++i) {
                 const bitIndex = i + 1;
                 if (descIndex >= descShard.len &&
@@ -3608,10 +3610,8 @@ ${item.displayPath}<span class="${type}">${name}</span>\
                     descIndex = 0;
                     descShardList.push(descShard);
                 }
-                let word = "";
-                if (typeof itemNames[i] === "string") {
-                    word = itemNames[i].toLowerCase();
-                }
+                const name = itemNames[i] === "" ? lastName : itemNames[i];
+                const word = itemNames[i] === "" ? lastWord : itemNames[i].toLowerCase();
                 const path = itemPaths.has(i) ? itemPaths.get(i) : lastPath;
                 const type = itemFunctionDecoder.next();
                 if (type !== null) {
@@ -3633,15 +3633,16 @@ ${item.displayPath}<span class="${type}">${name}</span>\
                 }
                 // This object should have exactly the same set of fields as the "crateRow"
                 // object defined above.
+                const itemParentIdx = itemParentIdxDecoder.next();
                 const row = {
                     crate,
                     ty: itemTypes.charCodeAt(i) - 65, // 65 = "A"
-                    name: itemNames[i],
+                    name,
                     path,
                     descShard,
                     descIndex,
                     exactPath: itemReexports.has(i) ? itemPaths.get(itemReexports.get(i)) : path,
-                    parent: itemParentIdxs[i] > 0 ? paths[itemParentIdxs[i] - 1] : undefined,
+                    parent: itemParentIdx > 0 ? paths[itemParentIdx - 1] : undefined,
                     type,
                     id,
                     word,
@@ -3655,6 +3656,8 @@ ${item.displayPath}<span class="${type}">${name}</span>\
                 if (!searchIndexEmptyDesc.get(crate).contains(bitIndex)) {
                     descIndex += 1;
                 }
+                lastName = name;
+                lastWord = word;
             }
 
             if (aliases) {

From d1b41f3747ecb01b717bd50918513227de36f3cb Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 22 Aug 2024 19:04:34 -0400
Subject: [PATCH 531/685] remove dbg!()

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

diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index 2bde05501fcfc..201addaec2fc5 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -249,7 +249,7 @@ impl Config {
             curl.arg("--progress-bar");
         }
         // --retry-all-errors was added in 7.71.0, don't use it if curl is old.
-        if dbg!(curl_version()) > 7.70 {
+        if curl_version() > 7.70 {
             curl.arg("--retry-all-errors");
         }
         curl.arg(url);

From 9ad0b15a8e3e199a73bcf32ab9e56f7caa1f14a7 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Fri, 23 Aug 2024 02:44:15 +0300
Subject: [PATCH 532/685] Fix a missing import in a doc in run-make-support

---
 src/tools/run-make-support/src/path_helpers.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/run-make-support/src/path_helpers.rs b/src/tools/run-make-support/src/path_helpers.rs
index 1e6e44c458423..87901793a921e 100644
--- a/src/tools/run-make-support/src/path_helpers.rs
+++ b/src/tools/run-make-support/src/path_helpers.rs
@@ -21,6 +21,7 @@ pub fn cwd() -> PathBuf {
 /// # Example
 ///
 /// ```rust
+/// # use run_make_support::path;
 /// let p = path("support_file.txt");
 /// ```
 pub fn path<P: AsRef<Path>>(p: P) -> PathBuf {

From 585804fceeeb0f95fc18fbd4a072dfc9c63bee14 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Tue, 20 Aug 2024 15:57:16 +1000
Subject: [PATCH 533/685] Check that `library/profiler_builtins` actually found
 some source files

The current `build.rs` will automatically skip source files that don't exist.
An unfortunate side-effect is that if _no_ files could be found (e.g. because
the directory was wrong), the build fails with a mysterious linker error.

We can reduce the awkwardness of this by explicitly checking that at least one
source file was found.
---
 library/profiler_builtins/build.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/library/profiler_builtins/build.rs b/library/profiler_builtins/build.rs
index 9d1c1ba305bc5..177b027e4f175 100644
--- a/library/profiler_builtins/build.rs
+++ b/library/profiler_builtins/build.rs
@@ -84,12 +84,16 @@ fn main() {
     let root = Path::new("../../src/llvm-project/compiler-rt");
 
     let src_root = root.join("lib").join("profile");
+    assert!(src_root.exists(), "profiler runtime source directory not found: {src_root:?}");
+    let mut n_sources_found = 0u32;
     for src in profile_sources {
         let path = src_root.join(src);
         if path.exists() {
             cfg.file(path);
+            n_sources_found += 1;
         }
     }
+    assert!(n_sources_found > 0, "couldn't find any profiler runtime source files in {src_root:?}");
 
     cfg.include(root.join("include"));
     cfg.warnings(false);

From b544603c039ae15e322f9fb4ae527873601426fd Mon Sep 17 00:00:00 2001
From: Gurinder Singh <frederick.the.fool@gmail.com>
Date: Fri, 23 Aug 2024 08:21:25 +0530
Subject: [PATCH 534/685] Fix typo in help diagnostic

---
 .../src/error_reporting/traits/fulfillment_errors.rs            | 2 +-
 tests/run-make/crate-loading/rmake.rs                           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index d1cc630bc9a67..9f0282319ec0a 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -1693,7 +1693,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     StringPart::highlighted("multiple different versions".to_string()),
                     StringPart::normal(" of crate `".to_string()),
                     StringPart::highlighted(format!("{name}")),
-                    StringPart::normal("` the your dependency graph".to_string()),
+                    StringPart::normal("` in the dependency graph".to_string()),
                 ],
             );
             let candidates = if impl_candidates.is_empty() {
diff --git a/tests/run-make/crate-loading/rmake.rs b/tests/run-make/crate-loading/rmake.rs
index 13585edf6ccbe..95a9011669ec4 100644
--- a/tests/run-make/crate-loading/rmake.rs
+++ b/tests/run-make/crate-loading/rmake.rs
@@ -27,7 +27,7 @@ fn main() {
    |     |
    |     required by a bound introduced by this call
    |
-help: there are multiple different versions of crate `dependency` the your dependency graph
+help: there are multiple different versions of crate `dependency` in the dependency graph
   --> multiple-dep-versions.rs:1:1
    |
 1  | extern crate dep_2_reexport;

From 2339560239ac451f605164f3c2ad58b92f8b45aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jakub=20Ber=C3=A1nek?= <berykubik@gmail.com>
Date: Fri, 23 Aug 2024 10:20:24 +0200
Subject: [PATCH 535/685] kobzol vacation

---
 triagebot.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/triagebot.toml b/triagebot.toml
index a98d5f6a7c215..8a6f1d82be818 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -913,7 +913,7 @@ cc = ["@kobzol"]
 [assign]
 warn_non_default_branch = true
 contributing_url = "https://rustc-dev-guide.rust-lang.org/getting-started.html"
-users_on_vacation = ["jyn514", "jhpratt", "oli-obk"]
+users_on_vacation = ["jyn514", "jhpratt", "oli-obk", "kobzol"]
 
 [assign.adhoc_groups]
 compiler-team = [

From 5f2cedc5dc4ed5653069a83f1ed98b46f0c33c7c Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Fri, 23 Aug 2024 12:08:41 +0300
Subject: [PATCH 536/685] handle stage0 cargo and rustc separately

This change allows setting either `build.cargo` or `build.rustc` without requiring
both to be set simultaneously, which was not possible previously.

To try it, set `build.rustc` without setting `build.cargo`, and try to bootstrap on clean build.

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/bootstrap.py | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
index 4e8e0fd2532f1..0490d31fa584d 100644
--- a/src/bootstrap/bootstrap.py
+++ b/src/bootstrap/bootstrap.py
@@ -533,9 +533,13 @@ def download_toolchain(self):
         bin_root = self.bin_root()
 
         key = self.stage0_compiler.date
-        if self.rustc().startswith(bin_root) and \
-                (not os.path.exists(self.rustc()) or
-                 self.program_out_of_date(self.rustc_stamp(), key)):
+        is_outdated = self.program_out_of_date(self.rustc_stamp(), key)
+        need_rustc = self.rustc().startswith(bin_root) and (not os.path.exists(self.rustc()) \
+            or is_outdated)
+        need_cargo = self.cargo().startswith(bin_root) and (not os.path.exists(self.cargo()) \
+            or is_outdated)
+
+        if need_rustc or need_cargo:
             if os.path.exists(bin_root):
                 # HACK: On Windows, we can't delete rust-analyzer-proc-macro-server while it's
                 # running. Kill it.
@@ -556,7 +560,6 @@ def download_toolchain(self):
                     run_powershell([script])
                 shutil.rmtree(bin_root)
 
-            key = self.stage0_compiler.date
             cache_dst = (self.get_toml('bootstrap-cache-path', 'build') or
                 os.path.join(self.build_dir, "cache"))
 
@@ -568,11 +571,16 @@ def download_toolchain(self):
 
             toolchain_suffix = "{}-{}{}".format(rustc_channel, self.build, tarball_suffix)
 
-            tarballs_to_download = [
-                ("rust-std-{}".format(toolchain_suffix), "rust-std-{}".format(self.build)),
-                ("rustc-{}".format(toolchain_suffix), "rustc"),
-                ("cargo-{}".format(toolchain_suffix), "cargo"),
-            ]
+            tarballs_to_download = []
+
+            if need_rustc:
+                tarballs_to_download.append(
+                    ("rust-std-{}".format(toolchain_suffix), "rust-std-{}".format(self.build))
+                )
+                tarballs_to_download.append(("rustc-{}".format(toolchain_suffix), "rustc"))
+
+            if need_cargo:
+                tarballs_to_download.append(("cargo-{}".format(toolchain_suffix), "cargo"))
 
             tarballs_download_info = [
                 DownloadInfo(

From 318dfb405f1744dbdb94e83c5ba6969d712c09aa Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Thu, 1 Aug 2024 13:17:34 -0400
Subject: [PATCH 537/685] rewrite libtest-thread-limit to rmake

---
 Cargo.lock                                    |  1 +
 src/tools/run-make-support/Cargo.toml         |  1 +
 src/tools/run-make-support/src/lib.rs         |  1 +
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 tests/run-make/libtest-thread-limit/Makefile  |  7 --
 tests/run-make/libtest-thread-limit/rmake.rs  | 64 +++++++++++++++++++
 tests/run-make/libtest-thread-limit/test.rs   |  7 +-
 7 files changed, 73 insertions(+), 9 deletions(-)
 delete mode 100644 tests/run-make/libtest-thread-limit/Makefile
 create mode 100644 tests/run-make/libtest-thread-limit/rmake.rs

diff --git a/Cargo.lock b/Cargo.lock
index a18219b56837e..97146fcfd516d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3129,6 +3129,7 @@ dependencies = [
  "bstr",
  "build_helper",
  "gimli 0.31.0",
+ "libc",
  "object 0.36.3",
  "regex",
  "serde_json",
diff --git a/src/tools/run-make-support/Cargo.toml b/src/tools/run-make-support/Cargo.toml
index 1a13d56b0e42f..77df6e7beb591 100644
--- a/src/tools/run-make-support/Cargo.toml
+++ b/src/tools/run-make-support/Cargo.toml
@@ -12,3 +12,4 @@ regex = "1.8" # 1.8 to avoid memchr 2.6.0, as 2.5.0 is pinned in the workspace
 gimli = "0.31.0"
 build_helper = { path = "../build_helper" }
 serde_json = "1.0"
+libc = "0.2"
diff --git a/src/tools/run-make-support/src/lib.rs b/src/tools/run-make-support/src/lib.rs
index fc20fd3b2e86a..d010ed29f1d26 100644
--- a/src/tools/run-make-support/src/lib.rs
+++ b/src/tools/run-make-support/src/lib.rs
@@ -36,6 +36,7 @@ pub mod rfs {
 // Re-exports of third-party library crates.
 pub use bstr;
 pub use gimli;
+pub use libc;
 pub use object;
 pub use regex;
 pub use serde_json;
diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index f55abb513b80d..0f7213c536a89 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -6,7 +6,6 @@ run-make/incr-add-rust-src-component/Makefile
 run-make/issue-84395-lto-embed-bitcode/Makefile
 run-make/jobserver-error/Makefile
 run-make/libs-through-symlinks/Makefile
-run-make/libtest-thread-limit/Makefile
 run-make/macos-deployment-target/Makefile
 run-make/split-debuginfo/Makefile
 run-make/symbol-mangling-hashed/Makefile
diff --git a/tests/run-make/libtest-thread-limit/Makefile b/tests/run-make/libtest-thread-limit/Makefile
deleted file mode 100644
index 9496fa30159a6..0000000000000
--- a/tests/run-make/libtest-thread-limit/Makefile
+++ /dev/null
@@ -1,7 +0,0 @@
-include ../tools.mk
-
-# only-linux
-
-all:
-	$(RUSTC) test.rs --test --target $(TARGET)
-	$(shell ulimit -p 0 && $(call RUN,test))
diff --git a/tests/run-make/libtest-thread-limit/rmake.rs b/tests/run-make/libtest-thread-limit/rmake.rs
new file mode 100644
index 0000000000000..be0eeaf1717db
--- /dev/null
+++ b/tests/run-make/libtest-thread-limit/rmake.rs
@@ -0,0 +1,64 @@
+// libtest used to panic if it hit the thread limit. This often resulted in spurious test failures
+// (thread 'main' panicked at 'called Result::unwrap() on an Err value: Os
+// { code: 11, kind: WouldBlock, message: "Resource temporarily unavailable" }' ...
+// error: test failed, to rerun pass '--lib').
+// Since the fix in #81546, the test should continue to run synchronously
+// if it runs out of threads. Therefore, this test's final execution step
+// should succeed without an error.
+// See https://github.com/rust-lang/rust/pull/81546
+
+//@ only-linux
+// Reason: thread limit modification
+//@ ignore-cross-compile
+// Reason: this test fails armhf-gnu, reasons unknown
+
+use std::ffi::{self, CStr, CString};
+use std::path::PathBuf;
+
+use run_make_support::{libc, run, rustc};
+
+fn main() {
+    rustc().input("test.rs").arg("--test").run();
+
+    // We need to emulate an environment for libtest where threads are exhausted and spawning
+    // new threads are guaranteed to fail. This was previously achieved by ulimit shell builtin
+    // that called out to prlimit64 underneath to set resource limits (specifically thread
+    // number limits). Now that we don't have a shell, we need to implement that ourselves.
+    // See https://linux.die.net/man/2/setrlimit
+
+    // The fork + exec is required because we cannot first try to limit the number of
+    // processes/threads to 1 and then try to spawn a new process to run the test. We need to
+    // setrlimit and run the libtest test program in the same process.
+    let pid = unsafe { libc::fork() };
+    assert!(pid >= 0);
+
+    // If the process ID is 0, this is the child process responsible for running the test
+    // program.
+    if pid == 0 {
+        let test = CString::new("test").unwrap();
+        // The argv array should be terminated with a NULL pointer.
+        let argv = [test.as_ptr(), std::ptr::null()];
+        // rlim_cur is soft limit, rlim_max is hard limit.
+        // By setting the limit very low (max 1), we ensure that libtest is unable to create new
+        // threads.
+        let rlimit = libc::rlimit { rlim_cur: 1, rlim_max: 1 };
+        // RLIMIT_NPROC: The maximum number of processes (or, more precisely on Linux,
+        // threads) that can be created for the real user ID of the calling process. Upon
+        // encountering this limit, fork(2) fails with the error EAGAIN.
+        // Therefore, set the resource limit to RLIMIT_NPROC.
+        let ret = unsafe { libc::setrlimit(libc::RLIMIT_NPROC, &rlimit as *const libc::rlimit) };
+        assert_eq!(ret, 0);
+
+        // Finally, execute the 2 tests in test.rs.
+        let ret = unsafe { libc::execv(test.as_ptr(), argv.as_ptr()) };
+        assert_eq!(ret, 0);
+    } else {
+        // Otherwise, other process IDs indicate that this is the parent process.
+
+        let mut status: libc::c_int = 0;
+        let ret = unsafe { libc::waitpid(pid, &mut status as *mut libc::c_int, 0) };
+        assert_eq!(ret, pid);
+        assert!(libc::WIFEXITED(status));
+        assert_eq!(libc::WEXITSTATUS(status), 0);
+    }
+}
diff --git a/tests/run-make/libtest-thread-limit/test.rs b/tests/run-make/libtest-thread-limit/test.rs
index 87e1d51917106..d4eb12426158b 100644
--- a/tests/run-make/libtest-thread-limit/test.rs
+++ b/tests/run-make/libtest-thread-limit/test.rs
@@ -10,7 +10,12 @@ fn spawn_thread_would_block() {
     THREAD_ID.set(thread::current().id()).unwrap();
 }
 
+// Tests are run in alphabetical order, and the second test is dependent on the
+// first to set THREAD_ID. Do not rename the tests in such a way that `test_run_in_same_thread`
+// would run before `spawn_thread_would_block`.
+// See https://doc.rust-lang.org/rustc/tests/index.html#--shuffle
+
 #[test]
-fn run_in_same_thread() {
+fn test_run_in_same_thread() {
     assert_eq!(*THREAD_ID.get().unwrap(), thread::current().id());
 }

From 2540070fd45defe48d02aa7af974c8f295b326a4 Mon Sep 17 00:00:00 2001
From: Jack Wrenn <jack@wrenn.fyi>
Date: Mon, 12 Aug 2024 22:52:59 +0000
Subject: [PATCH 538/685] document & impl the transmutation modeled by
 `BikeshedIntrinsicFrom`

Documents that `BikeshedIntrinsicFrom` models transmute-via-union,
which is slightly more expressive than the transmute-via-cast
implemented by `transmute_copy`. Additionally, we provide an
implementation of transmute-via-union as a method on the
`BikeshedIntrinsicFrom` trait with additional documentation on
the boundary between trait invariants and caller obligations.

Whether or not transmute-via-union is the right kind of transmute
to model remains up for discussion [1]. Regardless, it seems wise
to document the present behavior.

[1] https://rust-lang.zulipchat.com/#narrow/stream/216762-project-safe-transmute/topic/What.20'kind'.20of.20transmute.20to.20model.3F/near/426331967
---
 compiler/rustc_ty_utils/src/instance.rs       |   5 +
 library/core/src/mem/transmutability.rs       | 371 +++++++++++++++++-
 .../issue_72181_1.main.built.after.mir        |   2 +-
 ...inhabited.LowerIntrinsics.panic-abort.diff |   2 +-
 ...nhabited.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...e_ref_dst.LowerIntrinsics.panic-abort.diff |   2 +-
 ..._ref_dst.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...inhabited.LowerIntrinsics.panic-abort.diff |   2 +-
 ...nhabited.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...inhabited.LowerIntrinsics.panic-abort.diff |   2 +-
 ...nhabited.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...inhabited.LowerIntrinsics.panic-abort.diff |   2 +-
 ...nhabited.LowerIntrinsics.panic-unwind.diff |   2 +-
 ...inhabited.LowerIntrinsics.panic-abort.diff |   2 +-
 ...nhabited.LowerIntrinsics.panic-unwind.diff |   2 +-
 .../closures/coerce-unsafe-to-closure.stderr  |   4 +-
 tests/ui/intrinsics/reify-intrinsic.stderr    |   4 +-
 17 files changed, 372 insertions(+), 38 deletions(-)

diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs
index c7ed6e6110fab..d77c3a277bfe8 100644
--- a/compiler/rustc_ty_utils/src/instance.rs
+++ b/compiler/rustc_ty_utils/src/instance.rs
@@ -363,6 +363,11 @@ fn resolve_associated_item<'tcx>(
                         tcx.item_name(trait_item_id)
                     ),
                 }
+            } else if tcx.is_lang_item(trait_ref.def_id, LangItem::TransmuteTrait) {
+                let name = tcx.item_name(trait_item_id);
+                assert_eq!(name, sym::transmute);
+                let args = tcx.erase_regions(rcvr_args);
+                Some(ty::Instance::new(trait_item_id, args))
             } else {
                 Instance::try_resolve_item_for_coroutine(tcx, trait_item_id, trait_id, rcvr_args)
             }
diff --git a/library/core/src/mem/transmutability.rs b/library/core/src/mem/transmutability.rs
index ea73c5b80ba44..62d454a5289b1 100644
--- a/library/core/src/mem/transmutability.rs
+++ b/library/core/src/mem/transmutability.rs
@@ -1,10 +1,88 @@
 use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
 
-/// Are values of a type transmutable into values of another type?
+/// Marks that `Src` is transmutable into `Self`.
 ///
-/// This trait is implemented on-the-fly by the compiler for types `Src` and `Self` when the bits of
-/// any value of type `Self` are safely transmutable into a value of type `Dst`, in a given `Context`,
-/// notwithstanding whatever safety checks you have asked the compiler to [`Assume`] are satisfied.
+/// # Implementation
+///
+/// This trait cannot be implemented explicitly. It is implemented on-the-fly by
+/// the compiler for all types `Src` and `Self` such that, given a set of safety
+/// obligations on the programmer (see [`Assume`]), the compiler has proved that
+/// the bits of a value of type `Src` can be soundly reinterpreted as a `Self`.
+///
+/// # Safety
+///
+/// If `Dst: BikeshedIntrinsicFrom<Src, ASSUMPTIONS>`, the compiler guarantees
+/// that `Src` is soundly *union-transmutable* into a value of type `Dst`,
+/// provided that the programmer has guaranteed that the given
+/// [`ASSUMPTIONS`](Assume) are satisfied.
+///
+/// A union-transmute is any bit-reinterpretation conversion in the form of:
+///
+/// ```rust
+/// pub unsafe fn transmute_via_union<Src, Dst>(src: Src) -> Dst {
+///     use core::mem::ManuallyDrop;
+///
+///     #[repr(C)]
+///     union Transmute<Src, Dst> {
+///         src: ManuallyDrop<Src>,
+///         dst: ManuallyDrop<Dst>,
+///     }
+///
+///     let transmute = Transmute {
+///         src: ManuallyDrop::new(src),
+///     };
+///
+///     let dst = transmute.dst;
+///
+///     ManuallyDrop::into_inner(dst)
+/// }
+/// ```
+///
+/// Note that this construction is more permissive than
+/// [`mem::transmute_copy`](super::transmute_copy); union-transmutes permit
+/// conversions that extend the bits of `Src` with trailing padding to fill
+/// trailing uninitialized bytes of `Self`; e.g.:
+///
+#[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
+#[cfg_attr(not(bootstrap), doc = "```rust")]
+/// #![feature(transmutability)]
+///
+/// use core::mem::{Assume, BikeshedIntrinsicFrom};
+///
+/// let src = 42u8; // size = 1
+///
+/// #[repr(C, align(2))]
+/// struct Dst(u8); // size = 2
+//
+/// let _ = unsafe {
+///     <Dst as BikeshedIntrinsicFrom<u8, { Assume::SAFETY }>>::transmute(src)
+/// };
+/// ```
+///
+/// # Caveats
+///
+/// ## Portability
+///
+/// Implementations of this trait do not provide any guarantee of portability
+/// across toolchains, targets or compilations. This trait may be implemented
+/// for certain combinations of `Src`, `Self` and `ASSUME` on some toolchains,
+/// targets or compilations, but not others. For example, if the layouts of
+/// `Src` or `Self` are non-deterministic, the presence or absence of an
+/// implementation of this trait may also be non-deterministic. Even if `Src`
+/// and `Self` have deterministic layouts (e.g., they are `repr(C)` structs),
+/// Rust does not specify the alignments of its primitive integer types, and
+/// layouts that involve these types may vary across toolchains, targets or
+/// compilations.
+///
+/// ## Stability
+///
+/// Implementations of this trait do not provide any guarantee of SemVer
+/// stability across the crate versions that define the `Src` and `Self` types.
+/// If SemVer stability is crucial to your application, you must consult the
+/// documentation of `Src` and `Self`s' defining crates. Note that the presence
+/// of `repr(C)`, alone, does not carry a safety invariant of SemVer stability.
+/// Furthermore, stability does not imply portability. For example, the size of
+/// `usize` is stable, but not portable.
 #[unstable(feature = "transmutability", issue = "99571")]
 #[lang = "transmute_trait"]
 #[rustc_deny_explicit_impl(implement_via_object = false)]
@@ -13,28 +91,207 @@ pub unsafe trait BikeshedIntrinsicFrom<Src, const ASSUME: Assume = { Assume::NOT
 where
     Src: ?Sized,
 {
+    /// Transmutes a `Src` value into a `Self`.
+    ///
+    /// # Safety
+    ///
+    /// The safety obligations of the caller depend on the value of `ASSUME`:
+    /// - If [`ASSUME.alignment`](Assume::alignment), the caller must guarantee
+    ///   that the addresses of references in the returned `Self` satisfy the
+    ///   alignment requirements of their referent types.
+    /// - If [`ASSUME.lifetimes`](Assume::lifetimes), the caller must guarantee
+    ///   that references in the returned `Self` will not outlive their
+    ///   referents.
+    /// - If [`ASSUME.safety`](Assume::safety), the returned value might not
+    ///   satisfy the library safety invariants of `Self`, and the caller must
+    ///   guarantee that undefined behavior does not arise from uses of the
+    ///   returned value.
+    /// - If [`ASSUME.validity`](Assume::validity), the caller must guarantee
+    ///   that `src` is a bit-valid instance of `Self`.
+    ///
+    /// When satisfying the above obligations (if any), the caller must *not*
+    /// assume that this trait provides any inherent guarantee of layout
+    /// [portability](#portability) or [stability](#stability).
+    unsafe fn transmute(src: Src) -> Self
+    where
+        Src: Sized,
+        Self: Sized,
+    {
+        use super::ManuallyDrop;
+
+        #[repr(C)]
+        union Transmute<Src, Dst> {
+            src: ManuallyDrop<Src>,
+            dst: ManuallyDrop<Dst>,
+        }
+
+        let transmute = Transmute { src: ManuallyDrop::new(src) };
+
+        // SAFETY: It is safe to reinterpret the bits of `src` as a value of
+        // type `Self`, because, by combination of invariant on this trait and
+        // contract on the caller, `src` has been proven to satisfy both the
+        // language and library invariants of `Self`. For all invariants not
+        // `ASSUME`'d by the caller, the safety obligation is supplied by the
+        // compiler. Conversely, for all invariants `ASSUME`'d by the caller,
+        // the safety obligation is supplied by contract on the caller.
+        let dst = unsafe { transmute.dst };
+
+        ManuallyDrop::into_inner(dst)
+    }
 }
 
-/// What transmutation safety conditions shall the compiler assume that *you* are checking?
+/// Configurable proof assumptions of [`BikeshedIntrinsicFrom`].
+///
+/// When `false`, the respective proof obligation belongs to the compiler. When
+/// `true`, the onus of the safety proof belongs to the programmer.
+/// [`BikeshedIntrinsicFrom`].
 #[unstable(feature = "transmutability", issue = "99571")]
 #[lang = "transmute_opts"]
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
 pub struct Assume {
-    /// When `true`, the compiler assumes that *you* are ensuring (either dynamically or statically) that
-    /// destination referents do not have stricter alignment requirements than source referents.
+    /// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for
+    /// transmutations that might violate the the alignment requirements of
+    /// references; e.g.:
+    ///
+    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
+    #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
+    /// #![feature(transmutability)]
+    /// use core::mem::{align_of, BikeshedIntrinsicFrom};
+    ///
+    /// assert_eq!(align_of::<[u8; 2]>(), 1);
+    /// assert_eq!(align_of::<u16>(), 2);
+    ///
+    /// let src: &[u8; 2] = &[0xFF, 0xFF];
+    ///
+    /// // SAFETY: No safety obligations.
+    /// let dst: &u16 = unsafe {
+    ///     <_ as BikeshedIntrinsicFrom<_>>::transmute(src)
+    /// };
+    /// ```
+    ///
+    /// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured
+    /// that references in the transmuted value satisfy the alignment
+    /// requirements of their referent types; e.g.:
+    ///
+    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
+    #[cfg_attr(not(bootstrap), doc = "```rust")]
+    /// #![feature(pointer_is_aligned_to, transmutability)]
+    /// use core::mem::{align_of, Assume, BikeshedIntrinsicFrom};
+    ///
+    /// let src: &[u8; 2] = &[0xFF, 0xFF];
+    ///
+    /// let maybe_dst: Option<&u16> = if <*const _>::is_aligned_to(src, align_of::<u16>()) {
+    ///     // SAFETY: We have checked above that the address of `src` satisfies the
+    ///     // alignment requirements of `u16`.
+    ///     Some(unsafe {
+    ///         <_ as BikeshedIntrinsicFrom<_, { Assume::ALIGNMENT }>>::transmute(src)
+    ///     })
+    /// } else {
+    ///     None
+    /// };
+    ///
+    /// assert!(matches!(maybe_dst, Some(&u16::MAX) | None));
+    /// ```
     pub alignment: bool,
 
-    /// When `true`, the compiler assume that *you* are ensuring that lifetimes are not extended in a manner
-    /// that violates Rust's memory model.
+    /// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for
+    /// transmutations that extend the lifetimes of references.
+    ///
+    /// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured
+    /// that references in the transmuted value do not outlive their referents.
     pub lifetimes: bool,
 
-    /// When `true`, the compiler assumes that *you* have ensured that no
-    /// unsoundness will arise from violating the safety invariants of the
-    /// destination type (and sometimes of the source type, too).
+    /// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for
+    /// transmutations that might violate the library safety invariants of the
+    /// destination type; e.g.:
+    ///
+    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
+    #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
+    /// #![feature(transmutability)]
+    /// use core::mem::BikeshedIntrinsicFrom;
+    ///
+    /// let src: u8 = 3;
+    ///
+    /// struct EvenU8 {
+    ///     // SAFETY: `val` must be an even number.
+    ///     val: u8,
+    /// }
+    ///
+    /// // SAFETY: No safety obligations.
+    /// let dst: EvenU8 = unsafe {
+    ///     <_ as BikeshedIntrinsicFrom<_>>::transmute(src)
+    /// };
+    /// ```
+    ///
+    /// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured
+    /// that undefined behavior does not arise from using the transmuted value;
+    /// e.g.:
+    ///
+    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
+    #[cfg_attr(not(bootstrap), doc = "```rust")]
+    /// #![feature(transmutability)]
+    /// use core::mem::{Assume, BikeshedIntrinsicFrom};
+    ///
+    /// let src: u8 = 42;
+    ///
+    /// struct EvenU8 {
+    ///     // SAFETY: `val` must be an even number.
+    ///     val: u8,
+    /// }
+    ///
+    /// let maybe_dst: Option<EvenU8> = if src % 2 == 0 {
+    ///     // SAFETY: We have checked above that the value of `src` is even.
+    ///     Some(unsafe {
+    ///         <_ as BikeshedIntrinsicFrom<_, { Assume::SAFETY }>>::transmute(src)
+    ///     })
+    /// } else {
+    ///     None
+    /// };
+    ///
+    /// assert!(matches!(maybe_dst, Some(EvenU8 { val: 42 })));
+    /// ```
     pub safety: bool,
 
-    /// When `true`, the compiler assumes that *you* are ensuring that the source type is actually a valid
-    /// instance of the destination type.
+    /// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for
+    /// transmutations that might violate the language-level bit-validity
+    /// invariant of the destination type; e.g.:
+    ///
+    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
+    #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
+    /// #![feature(transmutability)]
+    /// use core::mem::BikeshedIntrinsicFrom;
+    ///
+    /// let src: u8 = 3;
+    ///
+    /// // SAFETY: No safety obligations.
+    /// let dst: bool = unsafe {
+    ///     <_ as BikeshedIntrinsicFrom<_>>::transmute(src)
+    /// };
+    /// ```
+    ///
+    /// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured
+    /// that the value being transmuted is a bit-valid instance of the
+    /// transmuted value; e.g.:
+    ///
+    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
+    #[cfg_attr(not(bootstrap), doc = "```rust")]
+    /// #![feature(transmutability)]
+    /// use core::mem::{Assume, BikeshedIntrinsicFrom};
+    ///
+    /// let src: u8 = 1;
+    ///
+    /// let maybe_dst: Option<bool> = if src == 0 || src == 1 {
+    ///     // SAFETY: We have checked above that the value of `src` is a bit-valid
+    ///     // instance of `bool`.
+    ///     Some(unsafe {
+    ///         <_ as BikeshedIntrinsicFrom<_, { Assume::VALIDITY }>>::transmute(src)
+    ///     })
+    /// } else {
+    ///     None
+    /// };
+    ///
+    /// assert_eq!(maybe_dst, Some(true));
+    /// ```
     pub validity: bool,
 }
 
@@ -44,29 +301,87 @@ impl ConstParamTy_ for Assume {}
 impl UnsizedConstParamTy for Assume {}
 
 impl Assume {
-    /// Do not assume that *you* have ensured any safety properties are met.
+    /// With this, [`BikeshedIntrinsicFrom`] does not assume you have ensured
+    /// any safety obligations are met, and relies only upon its own analysis to
+    /// (dis)prove transmutability.
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const NOTHING: Self =
         Self { alignment: false, lifetimes: false, safety: false, validity: false };
 
-    /// Assume only that alignment conditions are met.
+    /// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured
+    /// that references in the transmuted value satisfy the alignment
+    /// requirements of their referent types. See [`Assume::alignment`] for
+    /// examples.
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const ALIGNMENT: Self = Self { alignment: true, ..Self::NOTHING };
 
-    /// Assume only that lifetime conditions are met.
+    /// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured
+    /// that references in the transmuted value do not outlive their referents.
+    /// See [`Assume::lifetimes`] for examples.
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const LIFETIMES: Self = Self { lifetimes: true, ..Self::NOTHING };
 
-    /// Assume only that safety conditions are met.
+    /// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured
+    /// that undefined behavior does not arise from using the transmuted value.
+    /// See [`Assume::safety`] for examples.
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const SAFETY: Self = Self { safety: true, ..Self::NOTHING };
 
-    /// Assume only that dynamically-satisfiable validity conditions are met.
+    /// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured
+    /// that the value being transmuted is a bit-valid instance of the
+    /// transmuted value. See [`Assume::validity`] for examples.
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const VALIDITY: Self = Self { validity: true, ..Self::NOTHING };
 
-    /// Assume both `self` and `other_assumptions`.
+    /// Combine the assumptions of `self` and `other_assumptions`.
+    ///
+    /// This is especially useful for extending [`Assume`] in generic contexts;
+    /// e.g.:
+    ///
+    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
+    #[cfg_attr(not(bootstrap), doc = "```rust")]
     #[unstable(feature = "transmutability", issue = "99571")]
+    /// #![feature(
+    ///     adt_const_params,
+    ///     generic_const_exprs,
+    ///     pointer_is_aligned_to,
+    ///     transmutability,
+    /// )]
+    /// #![allow(incomplete_features)]
+    /// use core::mem::{align_of, Assume, BikeshedIntrinsicFrom};
+    ///
+    /// /// Attempts to transmute `src` to `&Dst`.
+    /// ///
+    /// /// Returns `None` if `src` violates the alignment requirements of `&Dst`.
+    /// ///
+    /// /// # Safety
+    /// ///
+    /// /// The caller guarantees that the obligations required by `ASSUME`, except
+    /// /// alignment, are satisfied.
+    /// unsafe fn try_transmute_ref<'a, Src, Dst, const ASSUME: Assume>(src: &'a Src) -> Option<&'a Dst>
+    /// where
+    ///     &'a Dst: BikeshedIntrinsicFrom<&'a Src, { ASSUME.and(Assume::ALIGNMENT) }>,
+    /// {
+    ///     if <*const _>::is_aligned_to(src, align_of::<Dst>()) {
+    ///         // SAFETY: By the above dynamic check, we have ensured that the address
+    ///         // of `src` satisfies the alignment requirements of `&Dst`. By contract
+    ///         // on the caller, the safety obligations required by `ASSUME` have also
+    ///         // been satisfied.
+    ///         Some(unsafe {
+    ///             <_ as BikeshedIntrinsicFrom<_, { ASSUME.and(Assume::ALIGNMENT) }>>::transmute(src)
+    ///         })
+    ///     } else {
+    ///         None
+    ///     }
+    /// }
+    ///
+    /// let src: &[u8; 2] = &[0xFF, 0xFF];
+    ///
+    /// // SAFETY: No safety obligations.
+    /// let maybe_dst: Option<&u16> = unsafe {
+    ///     try_transmute_ref::<_, _, { Assume::NOTHING }>(src)
+    /// };
+    ///```
     pub const fn and(self, other_assumptions: Self) -> Self {
         Self {
             alignment: self.alignment || other_assumptions.alignment,
@@ -76,7 +391,21 @@ impl Assume {
         }
     }
 
-    /// Assume `self`, excepting `other_assumptions`.
+    /// Remove `other_assumptions` the obligations of `self`; e.g.:
+    ///
+    #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
+    #[cfg_attr(not(bootstrap), doc = "```rust")]
+    /// #![feature(transmutability)]
+    /// use core::mem::Assume;
+    ///
+    /// let assumptions = Assume::ALIGNMENT.and(Assume::SAFETY);
+    /// let to_be_removed = Assume::SAFETY.and(Assume::VALIDITY);
+    ///
+    /// assert_eq!(
+    ///     assumptions.but_not(to_be_removed),
+    ///     Assume::ALIGNMENT,
+    /// );
+    /// ```
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const fn but_not(self, other_assumptions: Self) -> Self {
         Self {
diff --git a/tests/mir-opt/issue_72181_1.main.built.after.mir b/tests/mir-opt/issue_72181_1.main.built.after.mir
index e8ad5cd8d16a8..293aa37944dd2 100644
--- a/tests/mir-opt/issue_72181_1.main.built.after.mir
+++ b/tests/mir-opt/issue_72181_1.main.built.after.mir
@@ -19,7 +19,7 @@ fn main() -> () {
         StorageLive(_2);
         StorageLive(_3);
         _3 = ();
-        _2 = transmute::<(), Void>(move _3) -> bb4;
+        _2 = std::intrinsics::transmute::<(), Void>(move _3) -> bb4;
     }
 
     bb1: {
diff --git a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff
index 71e84fdd8816e..b1104c70e4696 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-abort.diff
@@ -9,7 +9,7 @@
       bb0: {
           StorageLive(_2);
           _2 = copy _1;
--         _0 = transmute::<std::cmp::Ordering, i8>(move _2) -> [return: bb1, unwind unreachable];
+-         _0 = std::intrinsics::transmute::<std::cmp::Ordering, i8>(move _2) -> [return: bb1, unwind unreachable];
 +         _0 = move _2 as i8 (Transmute);
 +         goto -> bb1;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff
index 71e84fdd8816e..b1104c70e4696 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_inhabited.LowerIntrinsics.panic-unwind.diff
@@ -9,7 +9,7 @@
       bb0: {
           StorageLive(_2);
           _2 = copy _1;
--         _0 = transmute::<std::cmp::Ordering, i8>(move _2) -> [return: bb1, unwind unreachable];
+-         _0 = std::intrinsics::transmute::<std::cmp::Ordering, i8>(move _2) -> [return: bb1, unwind unreachable];
 +         _0 = move _2 as i8 (Transmute);
 +         goto -> bb1;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff
index 37232b826c129..169e48a31ddb9 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-abort.diff
@@ -9,7 +9,7 @@
       bb0: {
           StorageLive(_2);
           _2 = copy _1;
--         _0 = transmute::<&T, *const T>(move _2) -> [return: bb1, unwind unreachable];
+-         _0 = std::intrinsics::transmute::<&T, *const T>(move _2) -> [return: bb1, unwind unreachable];
 +         _0 = move _2 as *const T (Transmute);
 +         goto -> bb1;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff
index 37232b826c129..169e48a31ddb9 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_ref_dst.LowerIntrinsics.panic-unwind.diff
@@ -9,7 +9,7 @@
       bb0: {
           StorageLive(_2);
           _2 = copy _1;
--         _0 = transmute::<&T, *const T>(move _2) -> [return: bb1, unwind unreachable];
+-         _0 = std::intrinsics::transmute::<&T, *const T>(move _2) -> [return: bb1, unwind unreachable];
 +         _0 = move _2 as *const T (Transmute);
 +         goto -> bb1;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff
index 8ac70f99ad2f0..7098b4d316882 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-abort.diff
@@ -11,7 +11,7 @@
   
       bb0: {
           StorageLive(_1);
--         _1 = transmute::<usize, Box<Never>>(const 1_usize) -> [return: bb1, unwind unreachable];
+-         _1 = std::intrinsics::transmute::<usize, Box<Never>>(const 1_usize) -> [return: bb1, unwind unreachable];
 +         _1 = const 1_usize as std::boxed::Box<Never> (Transmute);
 +         goto -> bb1;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff
index 8ac70f99ad2f0..7098b4d316882 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_to_box_uninhabited.LowerIntrinsics.panic-unwind.diff
@@ -11,7 +11,7 @@
   
       bb0: {
           StorageLive(_1);
--         _1 = transmute::<usize, Box<Never>>(const 1_usize) -> [return: bb1, unwind unreachable];
+-         _1 = std::intrinsics::transmute::<usize, Box<Never>>(const 1_usize) -> [return: bb1, unwind unreachable];
 +         _1 = const 1_usize as std::boxed::Box<Never> (Transmute);
 +         goto -> bb1;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_to_mut_uninhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_to_mut_uninhabited.LowerIntrinsics.panic-abort.diff
index c2c4ec0003c26..06225fffd7c2d 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_to_mut_uninhabited.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_to_mut_uninhabited.LowerIntrinsics.panic-abort.diff
@@ -10,7 +10,7 @@
   
       bb0: {
           StorageLive(_1);
--         _1 = transmute::<usize, &mut Never>(const 1_usize) -> [return: bb1, unwind unreachable];
+-         _1 = std::intrinsics::transmute::<usize, &mut Never>(const 1_usize) -> [return: bb1, unwind unreachable];
 +         _1 = const 1_usize as &mut Never (Transmute);
 +         goto -> bb1;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_to_mut_uninhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_to_mut_uninhabited.LowerIntrinsics.panic-unwind.diff
index c2c4ec0003c26..06225fffd7c2d 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_to_mut_uninhabited.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_to_mut_uninhabited.LowerIntrinsics.panic-unwind.diff
@@ -10,7 +10,7 @@
   
       bb0: {
           StorageLive(_1);
--         _1 = transmute::<usize, &mut Never>(const 1_usize) -> [return: bb1, unwind unreachable];
+-         _1 = std::intrinsics::transmute::<usize, &mut Never>(const 1_usize) -> [return: bb1, unwind unreachable];
 +         _1 = const 1_usize as &mut Never (Transmute);
 +         goto -> bb1;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_to_ref_uninhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_to_ref_uninhabited.LowerIntrinsics.panic-abort.diff
index 1b516a1f53b39..dd6ab3a9c97e5 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_to_ref_uninhabited.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_to_ref_uninhabited.LowerIntrinsics.panic-abort.diff
@@ -10,7 +10,7 @@
   
       bb0: {
           StorageLive(_1);
--         _1 = transmute::<usize, &Never>(const 1_usize) -> [return: bb1, unwind unreachable];
+-         _1 = std::intrinsics::transmute::<usize, &Never>(const 1_usize) -> [return: bb1, unwind unreachable];
 +         _1 = const 1_usize as &Never (Transmute);
 +         goto -> bb1;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_to_ref_uninhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_to_ref_uninhabited.LowerIntrinsics.panic-unwind.diff
index 1b516a1f53b39..dd6ab3a9c97e5 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_to_ref_uninhabited.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_to_ref_uninhabited.LowerIntrinsics.panic-unwind.diff
@@ -10,7 +10,7 @@
   
       bb0: {
           StorageLive(_1);
--         _1 = transmute::<usize, &Never>(const 1_usize) -> [return: bb1, unwind unreachable];
+-         _1 = std::intrinsics::transmute::<usize, &Never>(const 1_usize) -> [return: bb1, unwind unreachable];
 +         _1 = const 1_usize as &Never (Transmute);
 +         goto -> bb1;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff
index eab969e9fe5bb..6571f3d9db81a 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-abort.diff
@@ -9,7 +9,7 @@
       bb0: {
           StorageLive(_2);
           _2 = copy _1;
--         _0 = transmute::<(), Never>(move _2) -> unwind unreachable;
+-         _0 = std::intrinsics::transmute::<(), Never>(move _2) -> unwind unreachable;
 +         _0 = move _2 as Never (Transmute);
 +         unreachable;
       }
diff --git a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff
index eab969e9fe5bb..6571f3d9db81a 100644
--- a/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff
+++ b/tests/mir-opt/lower_intrinsics.transmute_uninhabited.LowerIntrinsics.panic-unwind.diff
@@ -9,7 +9,7 @@
       bb0: {
           StorageLive(_2);
           _2 = copy _1;
--         _0 = transmute::<(), Never>(move _2) -> unwind unreachable;
+-         _0 = std::intrinsics::transmute::<(), Never>(move _2) -> unwind unreachable;
 +         _0 = move _2 as Never (Transmute);
 +         unreachable;
       }
diff --git a/tests/ui/closures/coerce-unsafe-to-closure.stderr b/tests/ui/closures/coerce-unsafe-to-closure.stderr
index cb718ca160f8b..2538fc0361c37 100644
--- a/tests/ui/closures/coerce-unsafe-to-closure.stderr
+++ b/tests/ui/closures/coerce-unsafe-to-closure.stderr
@@ -1,4 +1,4 @@
-error[E0277]: expected a `FnOnce(&str)` closure, found `unsafe extern "rust-intrinsic" fn(_) -> _ {transmute::<_, _>}`
+error[E0277]: expected a `FnOnce(&str)` closure, found `unsafe extern "rust-intrinsic" fn(_) -> _ {std::intrinsics::transmute::<_, _>}`
   --> $DIR/coerce-unsafe-to-closure.rs:2:44
    |
 LL |     let x: Option<&[u8]> = Some("foo").map(std::mem::transmute);
@@ -6,7 +6,7 @@ LL |     let x: Option<&[u8]> = Some("foo").map(std::mem::transmute);
    |                                        |
    |                                        required by a bound introduced by this call
    |
-   = help: the trait `FnOnce(&str)` is not implemented for fn item `unsafe extern "rust-intrinsic" fn(_) -> _ {transmute::<_, _>}`
+   = help: the trait `FnOnce(&str)` is not implemented for fn item `unsafe extern "rust-intrinsic" fn(_) -> _ {std::intrinsics::transmute::<_, _>}`
    = note: unsafe function cannot be called generically without an unsafe block
 note: required by a bound in `Option::<T>::map`
   --> $SRC_DIR/core/src/option.rs:LL:COL
diff --git a/tests/ui/intrinsics/reify-intrinsic.stderr b/tests/ui/intrinsics/reify-intrinsic.stderr
index 0119a1a6650d0..21b7bf4e1cb83 100644
--- a/tests/ui/intrinsics/reify-intrinsic.stderr
+++ b/tests/ui/intrinsics/reify-intrinsic.stderr
@@ -7,9 +7,9 @@ LL |     let _: unsafe extern "rust-intrinsic" fn(isize) -> usize = std::mem::tr
    |            expected due to this
    |
    = note: expected fn pointer `unsafe extern "rust-intrinsic" fn(isize) -> usize`
-                 found fn item `unsafe extern "rust-intrinsic" fn(_) -> _ {transmute::<_, _>}`
+                 found fn item `unsafe extern "rust-intrinsic" fn(_) -> _ {std::intrinsics::transmute::<_, _>}`
 
-error[E0606]: casting `unsafe extern "rust-intrinsic" fn(_) -> _ {transmute::<_, _>}` as `unsafe extern "rust-intrinsic" fn(isize) -> usize` is invalid
+error[E0606]: casting `unsafe extern "rust-intrinsic" fn(_) -> _ {std::intrinsics::transmute::<_, _>}` as `unsafe extern "rust-intrinsic" fn(isize) -> usize` is invalid
   --> $DIR/reify-intrinsic.rs:11:13
    |
 LL |     let _ = std::mem::transmute as unsafe extern "rust-intrinsic" fn(isize) -> usize;

From 69ca95bf7f5462eb7ade2de18d1f0d79b2c21cfd Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 23 Aug 2024 11:48:04 -0400
Subject: [PATCH 539/685] use tuples for semver, not floats

---
 src/bootstrap/bootstrap.py         |  7 +++++--
 src/bootstrap/src/core/download.rs | 18 +++++++++++-------
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/src/bootstrap/bootstrap.py b/src/bootstrap/bootstrap.py
index 5ea4b4882a975..c19134b4594fb 100644
--- a/src/bootstrap/bootstrap.py
+++ b/src/bootstrap/bootstrap.py
@@ -80,7 +80,10 @@ def get(base, url, path, checksums, verbose=False):
             os.unlink(temp_path)
 
 def curl_version():
-    return float(re.match(bytes("^curl ([0-9]+\\.[0-9]+)", "utf8"), require(["curl", "-V"]))[1])
+    m = re.match(bytes("^curl ([0-9]+)\\.([0-9]+)", "utf8"), require(["curl", "-V"]))
+    if m is None:
+        return (0, 0)
+    return (int(m[1]), int(m[2]))
 
 def download(path, url, probably_big, verbose):
     for _ in range(4):
@@ -110,7 +113,7 @@ def _download(path, url, probably_big, verbose, exception):
         #   but raise `CalledProcessError` or `OSError` instead
         require(["curl", "--version"], exception=platform_is_win32())
         extra_flags = []
-        if curl_version() > 7.70:
+        if curl_version() > (7, 70):
             extra_flags = [ "--retry-all-errors" ]
         run(["curl", option] + extra_flags + [
             "-L", # Follow redirect.
diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index 201addaec2fc5..fd6f17130ee91 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -21,19 +21,23 @@ fn try_run(config: &Config, cmd: &mut Command) -> Result<(), ()> {
     config.try_run(cmd)
 }
 
-fn extract_curl_version(out: &[u8]) -> f32 {
+fn extract_curl_version(out: &[u8]) -> (u16, u16) {
     let out = &out[5..];
-    let Some(i) = out.iter().position(|&x| x == b' ') else { return 0.0 };
+    let Some(i) = out.iter().position(|&x| x == b' ') else { return (0, 0) };
     let out = &out[..i];
-    let Some(k) = out.iter().rev().position(|&x| x == b'.') else { return 0.0 };
+    let Some(k) = out.iter().rev().position(|&x| x == b'.') else { return (0, 0) };
     let out = &out[..out.len() - k - 1];
-    std::str::from_utf8(out).unwrap().parse().unwrap_or(0.0)
+    let Ok(s) = std::str::from_utf8(out) else { return (0, 0) };
+    let parts = s.split('.').collect::<Vec<_>>();
+    let [s_major, s_minor] = &parts[..] else { return (0, 0) };
+    let (Ok(major), Ok(minor)) = (s_major.parse(), s_minor.parse()) else { return (0, 0) };
+    (major, minor)
 }
 
-fn curl_version() -> f32 {
+fn curl_version() -> (u16, u16) {
     let mut curl = Command::new("curl");
     curl.arg("-V");
-    let Ok(out) = curl.output() else { return 0.0 };
+    let Ok(out) = curl.output() else { return (0, 0) };
     let out = out.stdout;
     extract_curl_version(&out)
 }
@@ -249,7 +253,7 @@ impl Config {
             curl.arg("--progress-bar");
         }
         // --retry-all-errors was added in 7.71.0, don't use it if curl is old.
-        if curl_version() > 7.70 {
+        if curl_version() > (7, 70) {
             curl.arg("--retry-all-errors");
         }
         curl.arg(url);

From 515f5acefeed7880bd69d6ac5b5b222b48a283d9 Mon Sep 17 00:00:00 2001
From: Artem Agvanian <nartagva@amazon.com>
Date: Fri, 23 Aug 2024 12:45:38 -0400
Subject: [PATCH 540/685] Introduce methods for obtaining `Location` for
 statements and terminators

---
 compiler/stable_mir/src/mir/visit.rs | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/compiler/stable_mir/src/mir/visit.rs b/compiler/stable_mir/src/mir/visit.rs
index f391a0f444a30..aeae866e9d344 100644
--- a/compiler/stable_mir/src/mir/visit.rs
+++ b/compiler/stable_mir/src/mir/visit.rs
@@ -465,10 +465,20 @@ impl Location {
     }
 }
 
-impl From<Span> for Location {
-    fn from(span: Span) -> Self {
-        Location(span)
-    }
+/// Location of the statement at the given index for a given basic block. Assumes that `stmt_idx`
+/// and `bb_idx` are valid for a given body.
+pub fn statement_location(body: &Body, bb_idx: &BasicBlockIdx, stmt_idx: usize) -> Location {
+    let bb = &body.blocks[*bb_idx];
+    let stmt = &bb.statements[stmt_idx];
+    Location(stmt.span)
+}
+
+/// Location of the terminator for a given basic block. Assumes that `bb_idx` is valid for a given
+/// body.
+pub fn terminator_location(body: &Body, bb_idx: &BasicBlockIdx) -> Location {
+    let bb = &body.blocks[*bb_idx];
+    let terminator = &bb.terminator;
+    Location(terminator.span)
 }
 
 /// Reference to a place used to represent a partial projection.

From 4c5e888eb6846d4c777bd05cbc6af06a50faeb6a Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Thu, 22 Aug 2024 17:13:13 -0400
Subject: [PATCH 541/685] rustdoc: show exact case-sensitive matches first

fixes #119480
---
 src/librustdoc/html/static/js/search.js | 8 ++++++++
 tests/rustdoc-js-std/exact-case.js      | 7 +++++++
 2 files changed, 15 insertions(+)
 create mode 100644 tests/rustdoc-js-std/exact-case.js

diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
index 3eb27ea087c1d..63f492d5ac17e 100644
--- a/src/librustdoc/html/static/js/search.js
+++ b/src/librustdoc/html/static/js/search.js
@@ -1393,6 +1393,7 @@ function initSearch(rawSearchIndex) {
          */
         async function sortResults(results, isType, preferredCrate) {
             const userQuery = parsedQuery.userQuery;
+            const casedUserQuery = parsedQuery.original;
             const result_list = [];
             for (const result of results.values()) {
                 result.item = searchIndex[result.id];
@@ -1403,6 +1404,13 @@ function initSearch(rawSearchIndex) {
             result_list.sort((aaa, bbb) => {
                 let a, b;
 
+                // sort by exact case-sensitive match
+                a = (aaa.item.name !== casedUserQuery);
+                b = (bbb.item.name !== casedUserQuery);
+                if (a !== b) {
+                    return a - b;
+                }
+
                 // sort by exact match with regard to the last word (mismatch goes later)
                 a = (aaa.word !== userQuery);
                 b = (bbb.word !== userQuery);
diff --git a/tests/rustdoc-js-std/exact-case.js b/tests/rustdoc-js-std/exact-case.js
new file mode 100644
index 0000000000000..d9faff22fff70
--- /dev/null
+++ b/tests/rustdoc-js-std/exact-case.js
@@ -0,0 +1,7 @@
+const EXPECTED = {
+    'query': 'Copy',
+    'others': [
+        { 'path': 'std::marker', 'name': 'Copy' },
+        { 'path': 'std::fs', 'name': 'copy' },
+    ],
+}

From b968b26c03510c80782c4524a334f5fa440cb2d8 Mon Sep 17 00:00:00 2001
From: Noa <coolreader18@gmail.com>
Date: Thu, 22 Aug 2024 14:42:24 -0500
Subject: [PATCH 542/685] Put Pin::as_deref_mut in impl Pin<Ptr>

---
 library/core/src/pin.rs | 121 ++++++++++++++++++++--------------------
 1 file changed, 62 insertions(+), 59 deletions(-)

diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 0569b8b762433..1ad509892d26a 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1291,8 +1291,8 @@ impl<Ptr: Deref> Pin<Ptr> {
     ///     // Now, if `x` was the only reference, we have a mutable reference to
     ///     // data that we pinned above, which we could use to move it as we have
     ///     // seen in the previous example. We have violated the pinning API contract.
-    ///  }
-    ///  ```
+    /// }
+    /// ```
     ///
     /// ## Pinning of closure captures
     ///
@@ -1356,20 +1356,6 @@ impl<Ptr: Deref> Pin<Ptr> {
         Pin { __pointer: pointer }
     }
 
-    /// Gets a shared reference to the pinned value this [`Pin`] points to.
-    ///
-    /// This is a generic method to go from `&Pin<Pointer<T>>` to `Pin<&T>`.
-    /// It is safe because, as part of the contract of `Pin::new_unchecked`,
-    /// the pointee cannot move after `Pin<Pointer<T>>` got created.
-    /// "Malicious" implementations of `Pointer::Deref` are likewise
-    /// ruled out by the contract of `Pin::new_unchecked`.
-    #[stable(feature = "pin", since = "1.33.0")]
-    #[inline(always)]
-    pub fn as_ref(&self) -> Pin<&Ptr::Target> {
-        // SAFETY: see documentation on this function
-        unsafe { Pin::new_unchecked(&*self.__pointer) }
-    }
-
     /// Unwraps this `Pin<Ptr>`, returning the underlying `Ptr`.
     ///
     /// # Safety
@@ -1394,9 +1380,21 @@ impl<Ptr: Deref> Pin<Ptr> {
     pub const unsafe fn into_inner_unchecked(pin: Pin<Ptr>) -> Ptr {
         pin.__pointer
     }
-}
 
-impl<Ptr: DerefMut> Pin<Ptr> {
+    /// Gets a shared reference to the pinned value this [`Pin`] points to.
+    ///
+    /// This is a generic method to go from `&Pin<Pointer<T>>` to `Pin<&T>`.
+    /// It is safe because, as part of the contract of `Pin::new_unchecked`,
+    /// the pointee cannot move after `Pin<Pointer<T>>` got created.
+    /// "Malicious" implementations of `Pointer::Deref` are likewise
+    /// ruled out by the contract of `Pin::new_unchecked`.
+    #[stable(feature = "pin", since = "1.33.0")]
+    #[inline(always)]
+    pub fn as_ref(&self) -> Pin<&Ptr::Target> {
+        // SAFETY: see documentation on this function
+        unsafe { Pin::new_unchecked(&*self.__pointer) }
+    }
+
     /// Gets a mutable reference to the pinned value this `Pin<Ptr>` points to.
     ///
     /// This is a generic method to go from `&mut Pin<Pointer<T>>` to `Pin<&mut T>`.
@@ -1428,11 +1426,55 @@ impl<Ptr: DerefMut> Pin<Ptr> {
     /// ```
     #[stable(feature = "pin", since = "1.33.0")]
     #[inline(always)]
-    pub fn as_mut(&mut self) -> Pin<&mut Ptr::Target> {
+    pub fn as_mut(&mut self) -> Pin<&mut Ptr::Target>
+    where
+        Ptr: DerefMut,
+    {
         // SAFETY: see documentation on this function
         unsafe { Pin::new_unchecked(&mut *self.__pointer) }
     }
 
+    /// Gets `Pin<&mut T>` to the underlying pinned value from this nested `Pin`-pointer.
+    ///
+    /// This is a generic method to go from `Pin<&mut Pin<Pointer<T>>>` to `Pin<&mut T>`. It is
+    /// safe because the existence of a `Pin<Pointer<T>>` ensures that the pointee, `T`, cannot
+    /// move in the future, and this method does not enable the pointee to move. "Malicious"
+    /// implementations of `Ptr::DerefMut` are likewise ruled out by the contract of
+    /// `Pin::new_unchecked`.
+    #[unstable(feature = "pin_deref_mut", issue = "86918")]
+    #[must_use = "`self` will be dropped if the result is not used"]
+    #[inline(always)]
+    pub fn as_deref_mut(self: Pin<&mut Pin<Ptr>>) -> Pin<&mut Ptr::Target>
+    where
+        Ptr: DerefMut,
+    {
+        // SAFETY: What we're asserting here is that going from
+        //
+        //     Pin<&mut Pin<Ptr>>
+        //
+        // to
+        //
+        //     Pin<&mut Ptr::Target>
+        //
+        // is safe.
+        //
+        // We need to ensure that two things hold for that to be the case:
+        //
+        // 1) Once we give out a `Pin<&mut Ptr::Target>`, a `&mut Ptr::Target` will not be given out.
+        // 2) By giving out a `Pin<&mut Ptr::Target>`, we do not risk violating
+        // `Pin<&mut Pin<Ptr>>`
+        //
+        // The existence of `Pin<Ptr>` is sufficient to guarantee #1: since we already have a
+        // `Pin<Ptr>`, it must already uphold the pinning guarantees, which must mean that
+        // `Pin<&mut Ptr::Target>` does as well, since `Pin::as_mut` is safe. We do not have to rely
+        // on the fact that `Ptr` is _also_ pinned.
+        //
+        // For #2, we need to ensure that code given a `Pin<&mut Ptr::Target>` cannot cause the
+        // `Pin<Ptr>` to move? That is not possible, since `Pin<&mut Ptr::Target>` no longer retains
+        // any access to the `Ptr` itself, much less the `Pin<Ptr>`.
+        unsafe { self.get_unchecked_mut() }.as_mut()
+    }
+
     /// Assigns a new value to the memory location pointed to by the `Pin<Ptr>`.
     ///
     /// This overwrites pinned data, but that is okay: the original pinned value's destructor gets
@@ -1457,6 +1499,7 @@ impl<Ptr: DerefMut> Pin<Ptr> {
     #[inline(always)]
     pub fn set(&mut self, value: Ptr::Target)
     where
+        Ptr: DerefMut,
         Ptr::Target: Sized,
     {
         *(self.__pointer) = value;
@@ -1613,46 +1656,6 @@ impl<T: ?Sized> Pin<&'static T> {
     }
 }
 
-impl<'a, Ptr: DerefMut> Pin<&'a mut Pin<Ptr>> {
-    /// Gets `Pin<&mut T>` to the underlying pinned value from this nested `Pin`-pointer.
-    ///
-    /// This is a generic method to go from `Pin<&mut Pin<Pointer<T>>>` to `Pin<&mut T>`. It is
-    /// safe because the existence of a `Pin<Pointer<T>>` ensures that the pointee, `T`, cannot
-    /// move in the future, and this method does not enable the pointee to move. "Malicious"
-    /// implementations of `Ptr::DerefMut` are likewise ruled out by the contract of
-    /// `Pin::new_unchecked`.
-    #[unstable(feature = "pin_deref_mut", issue = "86918")]
-    #[must_use = "`self` will be dropped if the result is not used"]
-    #[inline(always)]
-    pub fn as_deref_mut(self) -> Pin<&'a mut Ptr::Target> {
-        // SAFETY: What we're asserting here is that going from
-        //
-        //     Pin<&mut Pin<Ptr>>
-        //
-        // to
-        //
-        //     Pin<&mut Ptr::Target>
-        //
-        // is safe.
-        //
-        // We need to ensure that two things hold for that to be the case:
-        //
-        // 1) Once we give out a `Pin<&mut Ptr::Target>`, a `&mut Ptr::Target` will not be given out.
-        // 2) By giving out a `Pin<&mut Ptr::Target>`, we do not risk violating
-        // `Pin<&mut Pin<Ptr>>`
-        //
-        // The existence of `Pin<Ptr>` is sufficient to guarantee #1: since we already have a
-        // `Pin<Ptr>`, it must already uphold the pinning guarantees, which must mean that
-        // `Pin<&mut Ptr::Target>` does as well, since `Pin::as_mut` is safe. We do not have to rely
-        // on the fact that `Ptr` is _also_ pinned.
-        //
-        // For #2, we need to ensure that code given a `Pin<&mut Ptr::Target>` cannot cause the
-        // `Pin<Ptr>` to move? That is not possible, since `Pin<&mut Ptr::Target>` no longer retains
-        // any access to the `Ptr` itself, much less the `Pin<Ptr>`.
-        unsafe { self.get_unchecked_mut() }.as_mut()
-    }
-}
-
 impl<T: ?Sized> Pin<&'static mut T> {
     /// Gets a pinning mutable reference from a static mutable reference.
     ///

From c65ef3d37c312dc0404da8b5c3f781d376778aad Mon Sep 17 00:00:00 2001
From: Noa <coolreader18@gmail.com>
Date: Fri, 23 Aug 2024 13:06:26 -0500
Subject: [PATCH 543/685] Move into_inner_unchecked back to the bottom of the
 impl block

---
 library/core/src/pin.rs | 50 ++++++++++++++++++++---------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 1ad509892d26a..0f9e6061c32da 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1356,31 +1356,6 @@ impl<Ptr: Deref> Pin<Ptr> {
         Pin { __pointer: pointer }
     }
 
-    /// Unwraps this `Pin<Ptr>`, returning the underlying `Ptr`.
-    ///
-    /// # Safety
-    ///
-    /// This function is unsafe. You must guarantee that you will continue to
-    /// treat the pointer `Ptr` as pinned after you call this function, so that
-    /// the invariants on the `Pin` type can be upheld. If the code using the
-    /// resulting `Ptr` does not continue to maintain the pinning invariants that
-    /// is a violation of the API contract and may lead to undefined behavior in
-    /// later (safe) operations.
-    ///
-    /// Note that you must be able to guarantee that the data pointed to by `Ptr`
-    /// will be treated as pinned all the way until its `drop` handler is complete!
-    ///
-    /// *For more information, see the [`pin` module docs][self]*
-    ///
-    /// If the underlying data is [`Unpin`], [`Pin::into_inner`] should be used
-    /// instead.
-    #[inline(always)]
-    #[rustc_const_unstable(feature = "const_pin", issue = "76654")]
-    #[stable(feature = "pin_into_inner", since = "1.39.0")]
-    pub const unsafe fn into_inner_unchecked(pin: Pin<Ptr>) -> Ptr {
-        pin.__pointer
-    }
-
     /// Gets a shared reference to the pinned value this [`Pin`] points to.
     ///
     /// This is a generic method to go from `&Pin<Pointer<T>>` to `Pin<&T>`.
@@ -1504,6 +1479,31 @@ impl<Ptr: Deref> Pin<Ptr> {
     {
         *(self.__pointer) = value;
     }
+
+    /// Unwraps this `Pin<Ptr>`, returning the underlying `Ptr`.
+    ///
+    /// # Safety
+    ///
+    /// This function is unsafe. You must guarantee that you will continue to
+    /// treat the pointer `Ptr` as pinned after you call this function, so that
+    /// the invariants on the `Pin` type can be upheld. If the code using the
+    /// resulting `Ptr` does not continue to maintain the pinning invariants that
+    /// is a violation of the API contract and may lead to undefined behavior in
+    /// later (safe) operations.
+    ///
+    /// Note that you must be able to guarantee that the data pointed to by `Ptr`
+    /// will be treated as pinned all the way until its `drop` handler is complete!
+    ///
+    /// *For more information, see the [`pin` module docs][self]*
+    ///
+    /// If the underlying data is [`Unpin`], [`Pin::into_inner`] should be used
+    /// instead.
+    #[inline(always)]
+    #[rustc_const_unstable(feature = "const_pin", issue = "76654")]
+    #[stable(feature = "pin_into_inner", since = "1.39.0")]
+    pub const unsafe fn into_inner_unchecked(pin: Pin<Ptr>) -> Ptr {
+        pin.__pointer
+    }
 }
 
 impl<'a, T: ?Sized> Pin<&'a T> {

From d7e7886b3ce2a36ce96650032d197c149fcf529a Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Fri, 23 Aug 2024 14:27:08 -0400
Subject: [PATCH 544/685] docs: correct panic conditions for rem_euclid and
 similar functions

fixes https://github.com/rust-lang/rust/issues/128857
---
 library/core/src/num/int_macros.rs | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 17cf2a7b261fd..9f14e783ca58b 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -2826,8 +2826,8 @@ macro_rules! int_impl {
         ///
         /// # Panics
         ///
-        /// This function will panic if `rhs` is 0 or if `self` is -1 and `rhs` is
-        /// `Self::MIN`. This behavior is not affected by the `overflow-checks` flag.
+        /// This function will panic if `rhs` is 0 or if `self` is `Self::MIN`
+        /// and `rhs` is -1. This behavior is not affected by the `overflow-checks` flag.
         ///
         /// # Examples
         ///
@@ -2865,8 +2865,8 @@ macro_rules! int_impl {
         ///
         /// # Panics
         ///
-        /// This function will panic if `rhs` is 0 or if `self` is -1 and `rhs` is
-        /// `Self::MIN`. This behavior is not affected by the `overflow-checks` flag.
+        /// This function will panic if `rhs` is 0 or if `self` is `Self::MIN` and
+        /// `rhs` is -1. This behavior is not affected by the `overflow-checks` flag.
         ///
         /// # Examples
         ///
@@ -2881,6 +2881,11 @@ macro_rules! int_impl {
         /// assert_eq!(a.rem_euclid(-b), 3);
         /// assert_eq!((-a).rem_euclid(-b), 1);
         /// ```
+        ///
+        /// This will panic:
+        /// ```should_panic
+        #[doc = concat!("let _ = ", stringify!($SelfT), "::MIN.rem_euclid(-1);")]
+        /// ```
         #[doc(alias = "modulo", alias = "mod")]
         #[stable(feature = "euclidean_division", since = "1.38.0")]
         #[rustc_const_stable(feature = "const_euclidean_int_methods", since = "1.52.0")]
@@ -2909,8 +2914,8 @@ macro_rules! int_impl {
         ///
         /// # Panics
         ///
-        /// This function will panic if `rhs` is 0 or if `self` is -1 and `rhs` is
-        /// `Self::MIN`. This behavior is not affected by the `overflow-checks` flag.
+        /// This function will panic if `rhs` is 0 or if `self` is `Self::MIN`
+        /// and `rhs` is -1. This behavior is not affected by the `overflow-checks` flag.
         ///
         /// # Examples
         ///
@@ -2945,8 +2950,8 @@ macro_rules! int_impl {
         ///
         /// # Panics
         ///
-        /// This function will panic if `rhs` is 0 or if `self` is -1 and `rhs` is
-        /// `Self::MIN`. This behavior is not affected by the `overflow-checks` flag.
+        /// This function will panic if `rhs` is 0 or if `self` is `Self::MIN`
+        /// and `rhs` is -1. This behavior is not affected by the `overflow-checks` flag.
         ///
         /// # Examples
         ///

From 402ce53bfe333e62b48b20b523f340611035ec15 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Mon, 29 Jul 2024 11:12:30 -0400
Subject: [PATCH 545/685] Enable `f16` tests on x86 and x86-64

Since the `compiler_builtins` update [1], ABI bugs on x86 should be
resolved. Enable tests for f16 on these platforms now.

`f16` math functions (`reliable_f16_math`) are still excluded because
there is an LLVM crash for powi [2].

[1]: https://github.com/rust-lang/rust/pull/125016
[2]: https://github.com/llvm/llvm-project/issues/105747
---
 library/std/build.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/library/std/build.rs b/library/std/build.rs
index 35a5977b6ebaf..fecdf2c3e1f43 100644
--- a/library/std/build.rs
+++ b/library/std/build.rs
@@ -103,9 +103,9 @@ fn main() {
         ("arm64ec", _) => false,
         // MinGW ABI bugs <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115054>
         ("x86_64", "windows") => false,
-        // x86 has ABI bugs that show up with optimizations. This should be partially fixed with
-        // the compiler-builtins update. <https://github.com/rust-lang/rust/issues/123885>
-        ("x86" | "x86_64", _) => false,
+        // Apple has a special ABI for `f16` that we do not yet support
+        // FIXME(builtins): fixed by <https://github.com/rust-lang/compiler-builtins/pull/675>
+        ("x86" | "x86_64", _) if target_vendor == "apple" => false,
         // Missing `__gnu_h2f_ieee` and `__gnu_f2h_ieee`
         ("powerpc" | "powerpc64", _) => false,
         // Missing `__gnu_h2f_ieee` and `__gnu_f2h_ieee`
@@ -140,17 +140,17 @@ fn main() {
         _ => false,
     };
 
-    // These are currently empty, but will fill up as some platforms move from completely
-    // unreliable to reliable basics but unreliable math.
+    // Configure platforms that have reliable basics but may have unreliable math.
 
     // LLVM is currenlty adding missing routines, <https://github.com/llvm/llvm-project/issues/93566>
     let has_reliable_f16_math = has_reliable_f16
         && match (target_arch.as_str(), target_os.as_str()) {
             // FIXME: Disabled on Miri as the intrinsics are not implemented yet.
             _ if is_miri => false,
-            // Currently nothing special. Hooray!
-            // This will change as platforms gain better better support for standard ops but math
-            // lags behind.
+            // x86 has a crash for `powi`: <https://github.com/llvm/llvm-project/issues/105747>
+            ("x86" | "x86_64", _) => false,
+            // Assume that working `f16` means working `f16` math for most platforms, since
+            // operations just go through `f32`.
             _ => true,
         };
 

From 62f7d5305e2f702fae205105dffb22447c5b1e6d Mon Sep 17 00:00:00 2001
From: Scott McMurray <scottmcm@users.noreply.github.com>
Date: Fri, 23 Aug 2024 12:02:26 -0700
Subject: [PATCH 546/685] Update `compiler_builtins` to `0.1.121`

---
 library/Cargo.lock       | 4 ++--
 library/alloc/Cargo.toml | 2 +-
 library/std/Cargo.toml   | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/library/Cargo.lock b/library/Cargo.lock
index f2f446b61085d..aa22181a4639a 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -58,9 +58,9 @@ dependencies = [
 
 [[package]]
 name = "compiler_builtins"
-version = "0.1.120"
+version = "0.1.121"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38c44e9c76d996d8049dee591a997eab801069ad86ed892ed3039f68b73d301c"
+checksum = "ce956e6dc07082ec481f0935a51e83b343f8ca51be560452c0ebf830d0bdf5a5"
 dependencies = [
  "cc",
  "rustc-std-workspace-core",
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index 43799acc02736..a39a0a6ce0ea2 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2021"
 
 [dependencies]
 core = { path = "../core" }
-compiler_builtins = { version = "0.1.120", features = ['rustc-dep-of-std'] }
+compiler_builtins = { version = "0.1.121", features = ['rustc-dep-of-std'] }
 
 [dev-dependencies]
 rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index dca42a3e98ec1..334c75df2315a 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -17,7 +17,7 @@ cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
 panic_unwind = { path = "../panic_unwind", optional = true }
 panic_abort = { path = "../panic_abort" }
 core = { path = "../core", public = true }
-compiler_builtins = { version = "0.1.120" }
+compiler_builtins = { version = "0.1.121" }
 profiler_builtins = { path = "../profiler_builtins", optional = true }
 unwind = { path = "../unwind" }
 hashbrown = { version = "0.14", default-features = false, features = [

From 5c6285c5f07a7cb47eff6efe90a9dc20634c3b2d Mon Sep 17 00:00:00 2001
From: Thom Chiovoloni <chiovolonit@gmail.com>
Date: Fri, 23 Aug 2024 19:16:01 +0000
Subject: [PATCH 547/685] Add myself to the review rotation for libs

---
 triagebot.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/triagebot.toml b/triagebot.toml
index 9bb1befb69983..d7bc60e6c6f09 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -951,6 +951,7 @@ libs = [
     "@joboet",
     "@jhpratt",
     "@tgross35",
+    "@thomcc",
 ]
 bootstrap = [
     "@Mark-Simulacrum",

From e76b7d029c8bdd29e76fd6045b85792e3a53ecb3 Mon Sep 17 00:00:00 2001
From: Trevor Gross <tmgross@umich.edu>
Date: Mon, 29 Jul 2024 11:28:45 -0400
Subject: [PATCH 548/685] Change `f16` doctests in core to run on x86-64 linux

Since `f16` now works on x86 and x86-64, change doctests to use this
instead of aarch64. This is to make sure any changes get run in PR CI.
---
 library/core/src/num/f16.rs | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index 41bd34a270238..bb0cc1c60ba5a 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -261,7 +261,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// let nan = f16::NAN;
     /// let f = 7.0_f16;
@@ -293,7 +293,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// let f = 7.0f16;
     /// let inf = f16::INFINITY;
@@ -319,7 +319,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// let f = 7.0f16;
     /// let inf: f16 = f16::INFINITY;
@@ -347,7 +347,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// let min = f16::MIN_POSITIVE; // 6.1035e-5
     /// let max = f16::MAX;
@@ -377,7 +377,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// let min = f16::MIN_POSITIVE; // 6.1035e-5
     /// let max = f16::MAX;
@@ -409,7 +409,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// use std::num::FpCategory;
     ///
@@ -867,7 +867,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// let value = 4.6_f16;
     /// let rounded = unsafe { value.to_int_unchecked::<u16>() };
@@ -910,7 +910,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// # // FIXME(f16_f128): enable this once const casting works
     /// # // assert_ne!((1f16).to_bits(), 1f16 as u128); // to_bits() is not casting!
@@ -958,7 +958,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// let v = f16::from_bits(0x4a40);
     /// assert_eq!(v, 12.5);
@@ -1071,7 +1071,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// let value = f16::from_be_bytes([0x4a, 0x40]);
     /// assert_eq!(value, 12.5);
@@ -1094,7 +1094,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// let value = f16::from_le_bytes([0x40, 0x4a]);
     /// assert_eq!(value, 12.5);
@@ -1124,7 +1124,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// let value = f16::from_ne_bytes(if cfg!(target_endian = "big") {
     ///     [0x4a, 0x40]
@@ -1257,7 +1257,7 @@ impl f16 {
     ///
     /// ```
     /// #![feature(f16)]
-    /// # #[cfg(target_arch = "aarch64")] { // FIXME(f16_F128): rust-lang/rust#123885
+    /// # #[cfg(all(target_arch = "x86_64", target_os = "linux"))] {
     ///
     /// assert!((-3.0f16).clamp(-2.0, 1.0) == -2.0);
     /// assert!((0.0f16).clamp(-2.0, 1.0) == 0.0);

From 5d98d2052923c116a0493528d41d656e9b29c92f Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Fri, 23 Aug 2024 18:26:45 -0400
Subject: [PATCH 549/685] Enable Alignment::new_unchecked precondition check

---
 library/core/src/ptr/alignment.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/library/core/src/ptr/alignment.rs b/library/core/src/ptr/alignment.rs
index 68fce3960c78c..19fe03d57cc0a 100644
--- a/library/core/src/ptr/alignment.rs
+++ b/library/core/src/ptr/alignment.rs
@@ -1,5 +1,4 @@
 use crate::num::NonZero;
-#[cfg(debug_assertions)]
 use crate::ub_checks::assert_unsafe_precondition;
 use crate::{cmp, fmt, hash, mem, num};
 
@@ -77,7 +76,6 @@ impl Alignment {
     #[rustc_const_unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[inline]
     pub const unsafe fn new_unchecked(align: usize) -> Self {
-        #[cfg(debug_assertions)]
         assert_unsafe_precondition!(
             check_language_ub,
             "Alignment::new_unchecked requires a power of two",

From 5cef88c1f492beff80d6694b118ea7526c135185 Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Thu, 22 Aug 2024 21:07:29 +0000
Subject: [PATCH 550/685] Print the generic parameter along with the variance
 in dumps.

---
 .../rustc_hir_analysis/src/variance/dump.rs   | 32 ++++++++++++++-----
 tests/ui/error-codes/E0208.rs                 |  2 +-
 tests/ui/error-codes/E0208.stderr             |  2 +-
 .../impl-trait/capture-lifetime-not-in-hir.rs |  4 +--
 .../capture-lifetime-not-in-hir.stderr        |  4 +--
 .../impl-trait/implicit-capture-late.stderr   |  2 +-
 tests/ui/impl-trait/in-trait/variance.rs      | 12 ++++---
 tests/ui/impl-trait/in-trait/variance.stderr  | 12 +++----
 tests/ui/impl-trait/variance.e2024.stderr     |  8 ++---
 tests/ui/impl-trait/variance.new.stderr       |  8 ++---
 tests/ui/impl-trait/variance.old.stderr       |  6 ++--
 tests/ui/impl-trait/variance.rs               | 14 ++++----
 tests/ui/type-alias-impl-trait/variance.rs    | 32 +++++++++----------
 .../ui/type-alias-impl-trait/variance.stderr  | 32 +++++++++----------
 .../ui/variance/variance-associated-consts.rs |  2 +-
 .../variance-associated-consts.stderr         |  2 +-
 .../ui/variance/variance-associated-types.rs  |  4 +--
 .../variance/variance-associated-types.stderr |  4 +--
 tests/ui/variance/variance-object-types.rs    |  2 +-
 .../ui/variance/variance-object-types.stderr  |  2 +-
 tests/ui/variance/variance-regions-direct.rs  | 14 ++++----
 .../variance/variance-regions-direct.stderr   | 14 ++++----
 .../ui/variance/variance-regions-indirect.rs  | 10 +++---
 .../variance/variance-regions-indirect.stderr | 10 +++---
 tests/ui/variance/variance-trait-bounds.rs    |  8 ++---
 .../ui/variance/variance-trait-bounds.stderr  |  8 ++---
 .../variance/variance-trait-object-bound.rs   |  2 +-
 .../variance-trait-object-bound.stderr        |  2 +-
 tests/ui/variance/variance-types-bounds.rs    | 10 +++---
 .../ui/variance/variance-types-bounds.stderr  | 10 +++---
 tests/ui/variance/variance-types.rs           | 12 +++----
 tests/ui/variance/variance-types.stderr       | 12 +++----
 32 files changed, 158 insertions(+), 140 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/variance/dump.rs b/compiler/rustc_hir_analysis/src/variance/dump.rs
index 1a17dabb677ac..ace183986bd00 100644
--- a/compiler/rustc_hir_analysis/src/variance/dump.rs
+++ b/compiler/rustc_hir_analysis/src/variance/dump.rs
@@ -1,18 +1,36 @@
+use std::fmt::Write;
+
 use rustc_hir::def::DefKind;
-use rustc_hir::def_id::CRATE_DEF_ID;
-use rustc_middle::ty::TyCtxt;
+use rustc_hir::def_id::{LocalDefId, CRATE_DEF_ID};
+use rustc_middle::ty::{GenericArgs, TyCtxt};
 use rustc_span::symbol::sym;
 
+fn format_variances(tcx: TyCtxt<'_>, def_id: LocalDefId) -> String {
+    let variances = tcx.variances_of(def_id);
+    let generics = GenericArgs::identity_for_item(tcx, def_id);
+    // 7 = 2-letter parameter + ": " + 1-letter variance + ", "
+    let mut ret = String::with_capacity(2 + 7 * variances.len());
+    ret.push('[');
+    for (arg, variance) in generics.iter().zip(variances.iter()) {
+        write!(ret, "{arg}: {variance:?}, ").unwrap();
+    }
+    // Remove trailing `, `.
+    if !variances.is_empty() {
+        ret.pop();
+        ret.pop();
+    }
+    ret.push(']');
+    ret
+}
+
 pub(crate) fn variances(tcx: TyCtxt<'_>) {
     if tcx.has_attr(CRATE_DEF_ID, sym::rustc_variance_of_opaques) {
         for id in tcx.hir().items() {
             let DefKind::OpaqueTy = tcx.def_kind(id.owner_id) else { continue };
 
-            let variances = tcx.variances_of(id.owner_id);
-
             tcx.dcx().emit_err(crate::errors::VariancesOf {
                 span: tcx.def_span(id.owner_id),
-                variances: format!("{variances:?}"),
+                variances: format_variances(tcx, id.owner_id.def_id),
             });
         }
     }
@@ -22,11 +40,9 @@ pub(crate) fn variances(tcx: TyCtxt<'_>) {
             continue;
         }
 
-        let variances = tcx.variances_of(id.owner_id);
-
         tcx.dcx().emit_err(crate::errors::VariancesOf {
             span: tcx.def_span(id.owner_id),
-            variances: format!("{variances:?}"),
+            variances: format_variances(tcx, id.owner_id.def_id),
         });
     }
 }
diff --git a/tests/ui/error-codes/E0208.rs b/tests/ui/error-codes/E0208.rs
index 74c138af483c1..2713ba6ed6cb5 100644
--- a/tests/ui/error-codes/E0208.rs
+++ b/tests/ui/error-codes/E0208.rs
@@ -1,7 +1,7 @@
 #![feature(rustc_attrs)]
 
 #[rustc_variance]
-struct Foo<'a, T> { //~ ERROR [+, o]
+struct Foo<'a, T> { //~ ERROR ['a: +, T: o]
     t: &'a mut T,
 }
 
diff --git a/tests/ui/error-codes/E0208.stderr b/tests/ui/error-codes/E0208.stderr
index 77b6ceae4dcee..a39e93afab3e1 100644
--- a/tests/ui/error-codes/E0208.stderr
+++ b/tests/ui/error-codes/E0208.stderr
@@ -1,4 +1,4 @@
-error: [+, o]
+error: ['a: +, T: o]
   --> $DIR/E0208.rs:4:1
    |
 LL | struct Foo<'a, T> {
diff --git a/tests/ui/impl-trait/capture-lifetime-not-in-hir.rs b/tests/ui/impl-trait/capture-lifetime-not-in-hir.rs
index 9c067cb693444..2fde0f200c0e5 100644
--- a/tests/ui/impl-trait/capture-lifetime-not-in-hir.rs
+++ b/tests/ui/impl-trait/capture-lifetime-not-in-hir.rs
@@ -6,13 +6,13 @@ trait Bar<'a> {
 }
 
 fn foo<'a, T: Bar<'a>>() -> impl Into<T::Assoc> {
-    //~^ ERROR [o, o]
+    //~^ ERROR ['a: o, T: o]
     // captures both T and 'a invariantly
     ()
 }
 
 fn foo2<'a, T: Bar<'a>>() -> impl Into<T::Assoc> + 'a {
-    //~^ ERROR [o, o, o]
+    //~^ ERROR ['a: o, T: o, 'a: o]
     // captures both T and 'a invariantly, and also duplicates `'a`
     // i.e. the opaque looks like `impl Into<<T as Bar<'a>>::Assoc> + 'a_duplicated`
     ()
diff --git a/tests/ui/impl-trait/capture-lifetime-not-in-hir.stderr b/tests/ui/impl-trait/capture-lifetime-not-in-hir.stderr
index 9d52001b02460..fe8a2772a00b1 100644
--- a/tests/ui/impl-trait/capture-lifetime-not-in-hir.stderr
+++ b/tests/ui/impl-trait/capture-lifetime-not-in-hir.stderr
@@ -1,10 +1,10 @@
-error: [o, o]
+error: ['a: o, T: o]
   --> $DIR/capture-lifetime-not-in-hir.rs:8:29
    |
 LL | fn foo<'a, T: Bar<'a>>() -> impl Into<T::Assoc> {
    |                             ^^^^^^^^^^^^^^^^^^^
 
-error: [o, o, o]
+error: ['a: o, T: o, 'a: o]
   --> $DIR/capture-lifetime-not-in-hir.rs:14:30
    |
 LL | fn foo2<'a, T: Bar<'a>>() -> impl Into<T::Assoc> + 'a {
diff --git a/tests/ui/impl-trait/implicit-capture-late.stderr b/tests/ui/impl-trait/implicit-capture-late.stderr
index 080750f849767..3adf78322d2e5 100644
--- a/tests/ui/impl-trait/implicit-capture-late.stderr
+++ b/tests/ui/impl-trait/implicit-capture-late.stderr
@@ -10,7 +10,7 @@ note: lifetime declared here
 LL | fn foo(x: Vec<i32>) -> Box<dyn for<'a> Deref<Target = impl ?Sized>> {
    |                                    ^^
 
-error: [o]
+error: ['a: o]
   --> $DIR/implicit-capture-late.rs:10:55
    |
 LL | fn foo(x: Vec<i32>) -> Box<dyn for<'a> Deref<Target = impl ?Sized>> {
diff --git a/tests/ui/impl-trait/in-trait/variance.rs b/tests/ui/impl-trait/in-trait/variance.rs
index 65565dcc2a6f4..0ac44bf7546c2 100644
--- a/tests/ui/impl-trait/in-trait/variance.rs
+++ b/tests/ui/impl-trait/in-trait/variance.rs
@@ -7,14 +7,16 @@ impl<T> Captures<'_> for T {}
 
 trait Foo<'i> {
     fn implicit_capture_early<'a: 'a>() -> impl Sized {}
-    //~^ [o, *, *, o, o]
-    // Self, 'i, 'a, 'i_duplicated, 'a_duplicated
+    //~^ [Self: o, 'i: *, 'a: *, 'a: o, 'i: o]
 
-    fn explicit_capture_early<'a: 'a>() -> impl Sized + Captures<'a> {} //~ [o, *, *, o, o]
+    fn explicit_capture_early<'a: 'a>() -> impl Sized + Captures<'a> {}
+    //~^ [Self: o, 'i: *, 'a: *, 'a: o, 'i: o]
 
-    fn implicit_capture_late<'a>(_: &'a ()) -> impl Sized {} //~ [o, *, o, o]
+    fn implicit_capture_late<'a>(_: &'a ()) -> impl Sized {}
+    //~^ [Self: o, 'i: *, 'a: o, 'i: o]
 
-    fn explicit_capture_late<'a>(_: &'a ()) -> impl Sized + Captures<'a> {} //~ [o, *, o, o]
+    fn explicit_capture_late<'a>(_: &'a ()) -> impl Sized + Captures<'a> {}
+    //~^ [Self: o, 'i: *, 'a: o, 'i: o]
 }
 
 fn main() {}
diff --git a/tests/ui/impl-trait/in-trait/variance.stderr b/tests/ui/impl-trait/in-trait/variance.stderr
index 8cae5a92f0dd5..54e0afbaa950d 100644
--- a/tests/ui/impl-trait/in-trait/variance.stderr
+++ b/tests/ui/impl-trait/in-trait/variance.stderr
@@ -1,23 +1,23 @@
-error: [o, *, *, o, o]
+error: [Self: o, 'i: *, 'a: *, 'a: o, 'i: o]
   --> $DIR/variance.rs:9:44
    |
 LL |     fn implicit_capture_early<'a: 'a>() -> impl Sized {}
    |                                            ^^^^^^^^^^
 
-error: [o, *, *, o, o]
-  --> $DIR/variance.rs:13:44
+error: [Self: o, 'i: *, 'a: *, 'a: o, 'i: o]
+  --> $DIR/variance.rs:12:44
    |
 LL |     fn explicit_capture_early<'a: 'a>() -> impl Sized + Captures<'a> {}
    |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o, *, o, o]
+error: [Self: o, 'i: *, 'a: o, 'i: o]
   --> $DIR/variance.rs:15:48
    |
 LL |     fn implicit_capture_late<'a>(_: &'a ()) -> impl Sized {}
    |                                                ^^^^^^^^^^
 
-error: [o, *, o, o]
-  --> $DIR/variance.rs:17:48
+error: [Self: o, 'i: *, 'a: o, 'i: o]
+  --> $DIR/variance.rs:18:48
    |
 LL |     fn explicit_capture_late<'a>(_: &'a ()) -> impl Sized + Captures<'a> {}
    |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/impl-trait/variance.e2024.stderr b/tests/ui/impl-trait/variance.e2024.stderr
index 1724505574413..011ab3259c477 100644
--- a/tests/ui/impl-trait/variance.e2024.stderr
+++ b/tests/ui/impl-trait/variance.e2024.stderr
@@ -1,22 +1,22 @@
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:14:36
    |
 LL | fn not_captured_early<'a: 'a>() -> impl Sized {}
    |                                    ^^^^^^^^^^
 
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:19:32
    |
 LL | fn captured_early<'a: 'a>() -> impl Sized + Captures<'a> {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o]
+error: ['a: o]
   --> $DIR/variance.rs:21:40
    |
 LL | fn not_captured_late<'a>(_: &'a ()) -> impl Sized {}
    |                                        ^^^^^^^^^^
 
-error: [o]
+error: ['a: o]
   --> $DIR/variance.rs:26:36
    |
 LL | fn captured_late<'a>(_: &'a ()) -> impl Sized + Captures<'a> {}
diff --git a/tests/ui/impl-trait/variance.new.stderr b/tests/ui/impl-trait/variance.new.stderr
index 1724505574413..011ab3259c477 100644
--- a/tests/ui/impl-trait/variance.new.stderr
+++ b/tests/ui/impl-trait/variance.new.stderr
@@ -1,22 +1,22 @@
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:14:36
    |
 LL | fn not_captured_early<'a: 'a>() -> impl Sized {}
    |                                    ^^^^^^^^^^
 
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:19:32
    |
 LL | fn captured_early<'a: 'a>() -> impl Sized + Captures<'a> {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o]
+error: ['a: o]
   --> $DIR/variance.rs:21:40
    |
 LL | fn not_captured_late<'a>(_: &'a ()) -> impl Sized {}
    |                                        ^^^^^^^^^^
 
-error: [o]
+error: ['a: o]
   --> $DIR/variance.rs:26:36
    |
 LL | fn captured_late<'a>(_: &'a ()) -> impl Sized + Captures<'a> {}
diff --git a/tests/ui/impl-trait/variance.old.stderr b/tests/ui/impl-trait/variance.old.stderr
index 9410b54b491a8..ac3bcd2723fb3 100644
--- a/tests/ui/impl-trait/variance.old.stderr
+++ b/tests/ui/impl-trait/variance.old.stderr
@@ -1,10 +1,10 @@
-error: [*]
+error: ['a: *]
   --> $DIR/variance.rs:14:36
    |
 LL | fn not_captured_early<'a: 'a>() -> impl Sized {}
    |                                    ^^^^^^^^^^
 
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:19:32
    |
 LL | fn captured_early<'a: 'a>() -> impl Sized + Captures<'a> {}
@@ -16,7 +16,7 @@ error: []
 LL | fn not_captured_late<'a>(_: &'a ()) -> impl Sized {}
    |                                        ^^^^^^^^^^
 
-error: [o]
+error: ['a: o]
   --> $DIR/variance.rs:26:36
    |
 LL | fn captured_late<'a>(_: &'a ()) -> impl Sized + Captures<'a> {}
diff --git a/tests/ui/impl-trait/variance.rs b/tests/ui/impl-trait/variance.rs
index 72b4a831badcb..43f7207a90423 100644
--- a/tests/ui/impl-trait/variance.rs
+++ b/tests/ui/impl-trait/variance.rs
@@ -12,17 +12,17 @@ trait Captures<'a> {}
 impl<T> Captures<'_> for T {}
 
 fn not_captured_early<'a: 'a>() -> impl Sized {}
-//[old]~^ [*]
-//[new]~^^ [*, o]
-//[e2024]~^^^ [*, o]
+//[old]~^ ['a: *]
+//[new]~^^ ['a: *, 'a: o]
+//[e2024]~^^^ ['a: *, 'a: o]
 
-fn captured_early<'a: 'a>() -> impl Sized + Captures<'a> {} //~ [*, o]
+fn captured_early<'a: 'a>() -> impl Sized + Captures<'a> {} //~ ['a: *, 'a: o]
 
 fn not_captured_late<'a>(_: &'a ()) -> impl Sized {}
 //[old]~^ []
-//[new]~^^ [o]
-//[e2024]~^^^ [o]
+//[new]~^^ ['a: o]
+//[e2024]~^^^ ['a: o]
 
-fn captured_late<'a>(_: &'a ()) -> impl Sized + Captures<'a> {} //~ [o]
+fn captured_late<'a>(_: &'a ()) -> impl Sized + Captures<'a> {} //~ ['a: o]
 
 fn main() {}
diff --git a/tests/ui/type-alias-impl-trait/variance.rs b/tests/ui/type-alias-impl-trait/variance.rs
index ba52eaa035971..113f6a4cc4491 100644
--- a/tests/ui/type-alias-impl-trait/variance.rs
+++ b/tests/ui/type-alias-impl-trait/variance.rs
@@ -5,21 +5,21 @@
 trait Captures<'a> {}
 impl<T> Captures<'_> for T {}
 
-type NotCapturedEarly<'a> = impl Sized; //~ [*, o]
+type NotCapturedEarly<'a> = impl Sized; //~ ['a: *, 'a: o]
 //~^ ERROR: unconstrained opaque type
 
-type CapturedEarly<'a> = impl Sized + Captures<'a>; //~ [*, o]
+type CapturedEarly<'a> = impl Sized + Captures<'a>; //~ ['a: *, 'a: o]
 //~^ ERROR: unconstrained opaque type
 
-type NotCapturedLate<'a> = dyn for<'b> Iterator<Item = impl Sized>; //~ [*, o, o]
+type NotCapturedLate<'a> = dyn for<'b> Iterator<Item = impl Sized>; //~ ['a: *, 'b: o, 'a: o]
 //~^ ERROR `impl Trait` cannot capture higher-ranked lifetime from `dyn` type
 //~| ERROR: unconstrained opaque type
 
-type Captured<'a> = dyn for<'b> Iterator<Item = impl Sized + Captures<'a>>; //~ [*, o, o]
+type Captured<'a> = dyn for<'b> Iterator<Item = impl Sized + Captures<'a>>; //~ ['a: *, 'b: o, 'a: o]
 //~^ ERROR `impl Trait` cannot capture higher-ranked lifetime from `dyn` type
 //~| ERROR: unconstrained opaque type
 
-type Bar<'a, 'b: 'b, T> = impl Sized; //~ ERROR [*, *, o, o, o]
+type Bar<'a, 'b: 'b, T> = impl Sized; //~ ERROR ['a: *, 'b: *, T: o, 'a: o, 'b: o]
 //~^ ERROR: unconstrained opaque type
 
 trait Foo<'i> {
@@ -31,24 +31,24 @@ trait Foo<'i> {
 }
 
 impl<'i> Foo<'i> for &'i () {
-    type ImplicitCapture<'a> = impl Sized; //~ [*, *, o, o]
+    type ImplicitCapture<'a> = impl Sized; //~ ['i: *, 'a: *, 'a: o, 'i: o]
     //~^ ERROR: unconstrained opaque type
 
-    type ExplicitCaptureFromHeader<'a> = impl Sized + Captures<'i>; //~ [*, *, o, o]
+    type ExplicitCaptureFromHeader<'a> = impl Sized + Captures<'i>; //~ ['i: *, 'a: *, 'a: o, 'i: o]
     //~^ ERROR: unconstrained opaque type
 
-    type ExplicitCaptureFromGat<'a> = impl Sized + Captures<'a>; //~ [*, *, o, o]
+    type ExplicitCaptureFromGat<'a> = impl Sized + Captures<'a>; //~ ['i: *, 'a: *, 'a: o, 'i: o]
     //~^ ERROR: unconstrained opaque type
 }
 
 impl<'i> Foo<'i> for () {
-    type ImplicitCapture<'a> = impl Sized; //~ [*, *, o, o]
+    type ImplicitCapture<'a> = impl Sized; //~ ['i: *, 'a: *, 'a: o, 'i: o]
     //~^ ERROR: unconstrained opaque type
 
-    type ExplicitCaptureFromHeader<'a> = impl Sized + Captures<'i>; //~ [*, *, o, o]
+    type ExplicitCaptureFromHeader<'a> = impl Sized + Captures<'i>; //~ ['i: *, 'a: *, 'a: o, 'i: o]
     //~^ ERROR: unconstrained opaque type
 
-    type ExplicitCaptureFromGat<'a> = impl Sized + Captures<'a>; //~ [*, *, o, o]
+    type ExplicitCaptureFromGat<'a> = impl Sized + Captures<'a>; //~ ['i: *, 'a: *, 'a: o, 'i: o]
     //~^ ERROR: unconstrained opaque type
 }
 
@@ -59,15 +59,15 @@ impl<'a> Nesting<'a> for &'a () {
     type Output = &'a ();
 }
 type NestedDeeply<'a> =
-    impl Nesting< //~ [*, o]
+    impl Nesting< //~ ['a: *, 'a: o]
         'a,
-        Output = impl Nesting< //~ [*, o]
+        Output = impl Nesting< //~ ['a: *, 'a: o]
             'a,
-            Output = impl Nesting< //~ [*, o]
+            Output = impl Nesting< //~ ['a: *, 'a: o]
                 'a,
-                Output = impl Nesting< //~ [*, o]
+                Output = impl Nesting< //~ ['a: *, 'a: o]
                     'a,
-                    Output = impl Nesting<'a> //~ [*, o]
+                    Output = impl Nesting<'a> //~ ['a: *, 'a: o]
                 >
             >,
         >,
diff --git a/tests/ui/type-alias-impl-trait/variance.stderr b/tests/ui/type-alias-impl-trait/variance.stderr
index e5ced7a498171..489dfe03d446c 100644
--- a/tests/ui/type-alias-impl-trait/variance.stderr
+++ b/tests/ui/type-alias-impl-trait/variance.stderr
@@ -110,73 +110,73 @@ LL |     type ExplicitCaptureFromGat<'a> = impl Sized + Captures<'a>;
    |
    = note: `ExplicitCaptureFromGat` must be used in combination with a concrete type within the same impl
 
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:8:29
    |
 LL | type NotCapturedEarly<'a> = impl Sized;
    |                             ^^^^^^^^^^
 
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:11:26
    |
 LL | type CapturedEarly<'a> = impl Sized + Captures<'a>;
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, o, o]
+error: ['a: *, 'b: o, 'a: o]
   --> $DIR/variance.rs:14:56
    |
 LL | type NotCapturedLate<'a> = dyn for<'b> Iterator<Item = impl Sized>;
    |                                                        ^^^^^^^^^^
 
-error: [*, o, o]
+error: ['a: *, 'b: o, 'a: o]
   --> $DIR/variance.rs:18:49
    |
 LL | type Captured<'a> = dyn for<'b> Iterator<Item = impl Sized + Captures<'a>>;
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, *, o, o, o]
+error: ['a: *, 'b: *, T: o, 'a: o, 'b: o]
   --> $DIR/variance.rs:22:27
    |
 LL | type Bar<'a, 'b: 'b, T> = impl Sized;
    |                           ^^^^^^^^^^
 
-error: [*, *, o, o]
+error: ['i: *, 'a: *, 'a: o, 'i: o]
   --> $DIR/variance.rs:34:32
    |
 LL |     type ImplicitCapture<'a> = impl Sized;
    |                                ^^^^^^^^^^
 
-error: [*, *, o, o]
+error: ['i: *, 'a: *, 'a: o, 'i: o]
   --> $DIR/variance.rs:37:42
    |
 LL |     type ExplicitCaptureFromHeader<'a> = impl Sized + Captures<'i>;
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, *, o, o]
+error: ['i: *, 'a: *, 'a: o, 'i: o]
   --> $DIR/variance.rs:40:39
    |
 LL |     type ExplicitCaptureFromGat<'a> = impl Sized + Captures<'a>;
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, *, o, o]
+error: ['i: *, 'a: *, 'a: o, 'i: o]
   --> $DIR/variance.rs:45:32
    |
 LL |     type ImplicitCapture<'a> = impl Sized;
    |                                ^^^^^^^^^^
 
-error: [*, *, o, o]
+error: ['i: *, 'a: *, 'a: o, 'i: o]
   --> $DIR/variance.rs:48:42
    |
 LL |     type ExplicitCaptureFromHeader<'a> = impl Sized + Captures<'i>;
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, *, o, o]
+error: ['i: *, 'a: *, 'a: o, 'i: o]
   --> $DIR/variance.rs:51:39
    |
 LL |     type ExplicitCaptureFromGat<'a> = impl Sized + Captures<'a>;
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:62:5
    |
 LL | /     impl Nesting<
@@ -188,7 +188,7 @@ LL | |         >,
 LL | |     >;
    | |_____^
 
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:64:18
    |
 LL |           Output = impl Nesting<
@@ -201,7 +201,7 @@ LL | |             >,
 LL | |         >,
    | |_________^
 
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:66:22
    |
 LL |               Output = impl Nesting<
@@ -214,7 +214,7 @@ LL | |                 >
 LL | |             >,
    | |_____________^
 
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:68:26
    |
 LL |                   Output = impl Nesting<
@@ -224,7 +224,7 @@ LL | |                     Output = impl Nesting<'a>
 LL | |                 >
    | |_________________^
 
-error: [*, o]
+error: ['a: *, 'a: o]
   --> $DIR/variance.rs:70:30
    |
 LL |                     Output = impl Nesting<'a>
diff --git a/tests/ui/variance/variance-associated-consts.rs b/tests/ui/variance/variance-associated-consts.rs
index 6a44a94df3fdd..97edb7e266ad0 100644
--- a/tests/ui/variance/variance-associated-consts.rs
+++ b/tests/ui/variance/variance-associated-consts.rs
@@ -10,7 +10,7 @@ trait Trait {
 }
 
 #[rustc_variance]
-struct Foo<T: Trait> { //~ ERROR [o]
+struct Foo<T: Trait> { //~ ERROR [T: o]
     field: [u8; <T as Trait>::Const]
     //~^ ERROR: unconstrained generic constant
 }
diff --git a/tests/ui/variance/variance-associated-consts.stderr b/tests/ui/variance/variance-associated-consts.stderr
index b955a7686c2a7..5c3ed93464ac6 100644
--- a/tests/ui/variance/variance-associated-consts.stderr
+++ b/tests/ui/variance/variance-associated-consts.stderr
@@ -9,7 +9,7 @@ help: try adding a `where` bound
 LL | struct Foo<T: Trait> where [(); <T as Trait>::Const]: {
    |                      ++++++++++++++++++++++++++++++++
 
-error: [o]
+error: [T: o]
   --> $DIR/variance-associated-consts.rs:13:1
    |
 LL | struct Foo<T: Trait> {
diff --git a/tests/ui/variance/variance-associated-types.rs b/tests/ui/variance/variance-associated-types.rs
index ecb0821827dc0..07ff41062e881 100644
--- a/tests/ui/variance/variance-associated-types.rs
+++ b/tests/ui/variance/variance-associated-types.rs
@@ -10,12 +10,12 @@ trait Trait<'a> {
 }
 
 #[rustc_variance]
-struct Foo<'a, T : Trait<'a>> { //~ ERROR [+, +]
+struct Foo<'a, T : Trait<'a>> { //~ ERROR ['a: +, T: +]
     field: (T, &'a ())
 }
 
 #[rustc_variance]
-struct Bar<'a, T : Trait<'a>> { //~ ERROR [o, o]
+struct Bar<'a, T : Trait<'a>> { //~ ERROR ['a: o, T: o]
     field: <T as Trait<'a>>::Type
 }
 
diff --git a/tests/ui/variance/variance-associated-types.stderr b/tests/ui/variance/variance-associated-types.stderr
index 70cb246f6e906..ca010b7e7ef40 100644
--- a/tests/ui/variance/variance-associated-types.stderr
+++ b/tests/ui/variance/variance-associated-types.stderr
@@ -1,10 +1,10 @@
-error: [+, +]
+error: ['a: +, T: +]
   --> $DIR/variance-associated-types.rs:13:1
    |
 LL | struct Foo<'a, T : Trait<'a>> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o, o]
+error: ['a: o, T: o]
   --> $DIR/variance-associated-types.rs:18:1
    |
 LL | struct Bar<'a, T : Trait<'a>> {
diff --git a/tests/ui/variance/variance-object-types.rs b/tests/ui/variance/variance-object-types.rs
index 6ded24cd1e9ed..fd03dec982492 100644
--- a/tests/ui/variance/variance-object-types.rs
+++ b/tests/ui/variance/variance-object-types.rs
@@ -4,7 +4,7 @@
 // For better or worse, associated types are invariant, and hence we
 // get an invariant result for `'a`.
 #[rustc_variance]
-struct Foo<'a> { //~ ERROR [o]
+struct Foo<'a> { //~ ERROR ['a: o]
     x: Box<dyn Fn(i32) -> &'a i32 + 'static>
 }
 
diff --git a/tests/ui/variance/variance-object-types.stderr b/tests/ui/variance/variance-object-types.stderr
index 963f3454e1baf..a6fb9b2403a6b 100644
--- a/tests/ui/variance/variance-object-types.stderr
+++ b/tests/ui/variance/variance-object-types.stderr
@@ -1,4 +1,4 @@
-error: [o]
+error: ['a: o]
   --> $DIR/variance-object-types.rs:7:1
    |
 LL | struct Foo<'a> {
diff --git a/tests/ui/variance/variance-regions-direct.rs b/tests/ui/variance/variance-regions-direct.rs
index f1763c403f1a1..2bcacec33ea5a 100644
--- a/tests/ui/variance/variance-regions-direct.rs
+++ b/tests/ui/variance/variance-regions-direct.rs
@@ -6,7 +6,7 @@
 // Regions that just appear in normal spots are contravariant:
 
 #[rustc_variance]
-struct Test2<'a, 'b, 'c> { //~ ERROR [+, +, +]
+struct Test2<'a, 'b, 'c> { //~ ERROR ['a: +, 'b: +, 'c: +]
     x: &'a isize,
     y: &'b [isize],
     c: &'c str
@@ -15,7 +15,7 @@ struct Test2<'a, 'b, 'c> { //~ ERROR [+, +, +]
 // Those same annotations in function arguments become covariant:
 
 #[rustc_variance]
-struct Test3<'a, 'b, 'c> { //~ ERROR [-, -, -]
+struct Test3<'a, 'b, 'c> { //~ ERROR ['a: -, 'b: -, 'c: -]
     x: extern "Rust" fn(&'a isize),
     y: extern "Rust" fn(&'b [isize]),
     c: extern "Rust" fn(&'c str),
@@ -24,7 +24,7 @@ struct Test3<'a, 'b, 'c> { //~ ERROR [-, -, -]
 // Mutability induces invariance:
 
 #[rustc_variance]
-struct Test4<'a, 'b:'a> { //~ ERROR [+, o]
+struct Test4<'a, 'b:'a> { //~ ERROR ['a: +, 'b: o]
     x: &'a mut &'b isize,
 }
 
@@ -32,7 +32,7 @@ struct Test4<'a, 'b:'a> { //~ ERROR [+, o]
 // contravariant context:
 
 #[rustc_variance]
-struct Test5<'a, 'b:'a> { //~ ERROR [-, o]
+struct Test5<'a, 'b:'a> { //~ ERROR ['a: -, 'b: o]
     x: extern "Rust" fn(&'a mut &'b isize),
 }
 
@@ -42,14 +42,14 @@ struct Test5<'a, 'b:'a> { //~ ERROR [-, o]
 // argument list occurs in an invariant context.
 
 #[rustc_variance]
-struct Test6<'a, 'b:'a> { //~ ERROR [+, o]
+struct Test6<'a, 'b:'a> { //~ ERROR ['a: +, 'b: o]
     x: &'a mut extern "Rust" fn(&'b isize),
 }
 
 // No uses at all is bivariant:
 
 #[rustc_variance]
-struct Test7<'a> { //~ ERROR [*]
+struct Test7<'a> { //~ ERROR ['a: *]
     //~^ ERROR: `'a` is never used
     x: isize
 }
@@ -57,7 +57,7 @@ struct Test7<'a> { //~ ERROR [*]
 // Try enums too.
 
 #[rustc_variance]
-enum Test8<'a, 'b, 'c:'b> { //~ ERROR [-, +, o]
+enum Test8<'a, 'b, 'c:'b> { //~ ERROR ['a: -, 'b: +, 'c: o]
     Test8A(extern "Rust" fn(&'a isize)),
     Test8B(&'b [isize]),
     Test8C(&'b mut &'c str),
diff --git a/tests/ui/variance/variance-regions-direct.stderr b/tests/ui/variance/variance-regions-direct.stderr
index edfc888f65667..45ce0303fb251 100644
--- a/tests/ui/variance/variance-regions-direct.stderr
+++ b/tests/ui/variance/variance-regions-direct.stderr
@@ -6,43 +6,43 @@ LL | struct Test7<'a> {
    |
    = help: consider removing `'a`, referring to it in a field, or using a marker such as `PhantomData`
 
-error: [+, +, +]
+error: ['a: +, 'b: +, 'c: +]
   --> $DIR/variance-regions-direct.rs:9:1
    |
 LL | struct Test2<'a, 'b, 'c> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [-, -, -]
+error: ['a: -, 'b: -, 'c: -]
   --> $DIR/variance-regions-direct.rs:18:1
    |
 LL | struct Test3<'a, 'b, 'c> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [+, o]
+error: ['a: +, 'b: o]
   --> $DIR/variance-regions-direct.rs:27:1
    |
 LL | struct Test4<'a, 'b:'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [-, o]
+error: ['a: -, 'b: o]
   --> $DIR/variance-regions-direct.rs:35:1
    |
 LL | struct Test5<'a, 'b:'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [+, o]
+error: ['a: +, 'b: o]
   --> $DIR/variance-regions-direct.rs:45:1
    |
 LL | struct Test6<'a, 'b:'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*]
+error: ['a: *]
   --> $DIR/variance-regions-direct.rs:52:1
    |
 LL | struct Test7<'a> {
    | ^^^^^^^^^^^^^^^^
 
-error: [-, +, o]
+error: ['a: -, 'b: +, 'c: o]
   --> $DIR/variance-regions-direct.rs:60:1
    |
 LL | enum Test8<'a, 'b, 'c:'b> {
diff --git a/tests/ui/variance/variance-regions-indirect.rs b/tests/ui/variance/variance-regions-indirect.rs
index 31e25641d8c3a..aaa4d3f877995 100644
--- a/tests/ui/variance/variance-regions-indirect.rs
+++ b/tests/ui/variance/variance-regions-indirect.rs
@@ -5,7 +5,7 @@
 #![feature(rustc_attrs)]
 
 #[rustc_variance]
-enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR [-, +, o, *]
+enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR ['a: -, 'b: +, 'c: o, 'd: *]
     //~^ ERROR: `'d` is never used
     Test8A(extern "Rust" fn(&'a isize)),
     Test8B(&'b [isize]),
@@ -13,25 +13,25 @@ enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR [-, +, o, *]
 }
 
 #[rustc_variance]
-struct Derived1<'w, 'x:'y, 'y, 'z> { //~ ERROR [*, o, +, -]
+struct Derived1<'w, 'x:'y, 'y, 'z> { //~ ERROR ['w: *, 'x: o, 'y: +, 'z: -]
     //~^ ERROR: `'w` is never used
     f: Base<'z, 'y, 'x, 'w>
 }
 
 #[rustc_variance] // Combine - and + to yield o
-struct Derived2<'a, 'b:'a, 'c> { //~ ERROR [o, o, *]
+struct Derived2<'a, 'b:'a, 'c> { //~ ERROR ['a: o, 'b: o, 'c: *]
     //~^ ERROR: `'c` is never used
     f: Base<'a, 'a, 'b, 'c>
 }
 
 #[rustc_variance] // Combine + and o to yield o (just pay attention to 'a here)
-struct Derived3<'a:'b, 'b, 'c> { //~ ERROR [o, +, *]
+struct Derived3<'a:'b, 'b, 'c> { //~ ERROR ['a: o, 'b: +, 'c: *]
     //~^ ERROR: `'c` is never used
     f: Base<'a, 'b, 'a, 'c>
 }
 
 #[rustc_variance] // Combine + and * to yield + (just pay attention to 'a here)
-struct Derived4<'a, 'b, 'c:'b> { //~ ERROR [-, +, o]
+struct Derived4<'a, 'b, 'c:'b> { //~ ERROR ['a: -, 'b: +, 'c: o]
     f: Base<'a, 'b, 'c, 'a>
 }
 
diff --git a/tests/ui/variance/variance-regions-indirect.stderr b/tests/ui/variance/variance-regions-indirect.stderr
index 901ec0c6a762b..ed839b3235009 100644
--- a/tests/ui/variance/variance-regions-indirect.stderr
+++ b/tests/ui/variance/variance-regions-indirect.stderr
@@ -30,31 +30,31 @@ LL | struct Derived3<'a:'b, 'b, 'c> {
    |
    = help: consider removing `'c`, referring to it in a field, or using a marker such as `PhantomData`
 
-error: [-, +, o, *]
+error: ['a: -, 'b: +, 'c: o, 'd: *]
   --> $DIR/variance-regions-indirect.rs:8:1
    |
 LL | enum Base<'a, 'b, 'c:'b, 'd> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, o, +, -]
+error: ['w: *, 'x: o, 'y: +, 'z: -]
   --> $DIR/variance-regions-indirect.rs:16:1
    |
 LL | struct Derived1<'w, 'x:'y, 'y, 'z> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o, o, *]
+error: ['a: o, 'b: o, 'c: *]
   --> $DIR/variance-regions-indirect.rs:22:1
    |
 LL | struct Derived2<'a, 'b:'a, 'c> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o, +, *]
+error: ['a: o, 'b: +, 'c: *]
   --> $DIR/variance-regions-indirect.rs:28:1
    |
 LL | struct Derived3<'a:'b, 'b, 'c> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [-, +, o]
+error: ['a: -, 'b: +, 'c: o]
   --> $DIR/variance-regions-indirect.rs:34:1
    |
 LL | struct Derived4<'a, 'b, 'c:'b> {
diff --git a/tests/ui/variance/variance-trait-bounds.rs b/tests/ui/variance/variance-trait-bounds.rs
index 25a01b160ddd1..f86fa2bbef7a0 100644
--- a/tests/ui/variance/variance-trait-bounds.rs
+++ b/tests/ui/variance/variance-trait-bounds.rs
@@ -13,24 +13,24 @@ trait Setter<T> {
 }
 
 #[rustc_variance]
-struct TestStruct<U,T:Setter<U>> { //~ ERROR [+, +]
+struct TestStruct<U,T:Setter<U>> { //~ ERROR [U: +, T: +]
     t: T, u: U
 }
 
 #[rustc_variance]
-enum TestEnum<U,T:Setter<U>> { //~ ERROR [*, +]
+enum TestEnum<U,T:Setter<U>> { //~ ERROR [U: *, T: +]
     //~^ ERROR: `U` is never used
     Foo(T)
 }
 
 #[rustc_variance]
-struct TestContraStruct<U,T:Setter<U>> { //~ ERROR [*, +]
+struct TestContraStruct<U,T:Setter<U>> { //~ ERROR [U: *, T: +]
     //~^ ERROR: `U` is never used
     t: T
 }
 
 #[rustc_variance]
-struct TestBox<U,T:Getter<U>+Setter<U>> { //~ ERROR [*, +]
+struct TestBox<U,T:Getter<U>+Setter<U>> { //~ ERROR [U: *, T: +]
     //~^ ERROR: `U` is never used
     t: T
 }
diff --git a/tests/ui/variance/variance-trait-bounds.stderr b/tests/ui/variance/variance-trait-bounds.stderr
index 95ed18c1ad2bf..49cee3cbeca75 100644
--- a/tests/ui/variance/variance-trait-bounds.stderr
+++ b/tests/ui/variance/variance-trait-bounds.stderr
@@ -25,25 +25,25 @@ LL | struct TestBox<U,T:Getter<U>+Setter<U>> {
    = help: consider removing `U`, referring to it in a field, or using a marker such as `PhantomData`
    = help: if you intended `U` to be a const parameter, use `const U: /* Type */` instead
 
-error: [+, +]
+error: [U: +, T: +]
   --> $DIR/variance-trait-bounds.rs:16:1
    |
 LL | struct TestStruct<U,T:Setter<U>> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, +]
+error: [U: *, T: +]
   --> $DIR/variance-trait-bounds.rs:21:1
    |
 LL | enum TestEnum<U,T:Setter<U>> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, +]
+error: [U: *, T: +]
   --> $DIR/variance-trait-bounds.rs:27:1
    |
 LL | struct TestContraStruct<U,T:Setter<U>> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [*, +]
+error: [U: *, T: +]
   --> $DIR/variance-trait-bounds.rs:33:1
    |
 LL | struct TestBox<U,T:Getter<U>+Setter<U>> {
diff --git a/tests/ui/variance/variance-trait-object-bound.rs b/tests/ui/variance/variance-trait-object-bound.rs
index 11303c4652005..ca80c6b6dce22 100644
--- a/tests/ui/variance/variance-trait-object-bound.rs
+++ b/tests/ui/variance/variance-trait-object-bound.rs
@@ -11,7 +11,7 @@ use std::mem;
 trait T { fn foo(&self); }
 
 #[rustc_variance]
-struct TOption<'a> { //~ ERROR [+]
+struct TOption<'a> { //~ ERROR ['a: +]
     v: Option<Box<dyn T + 'a>>,
 }
 
diff --git a/tests/ui/variance/variance-trait-object-bound.stderr b/tests/ui/variance/variance-trait-object-bound.stderr
index f0471a3461925..0af21ec12cc9b 100644
--- a/tests/ui/variance/variance-trait-object-bound.stderr
+++ b/tests/ui/variance/variance-trait-object-bound.stderr
@@ -1,4 +1,4 @@
-error: [+]
+error: ['a: +]
   --> $DIR/variance-trait-object-bound.rs:14:1
    |
 LL | struct TOption<'a> {
diff --git a/tests/ui/variance/variance-types-bounds.rs b/tests/ui/variance/variance-types-bounds.rs
index d1814dd97a0ad..f4738a2dae1ab 100644
--- a/tests/ui/variance/variance-types-bounds.rs
+++ b/tests/ui/variance/variance-types-bounds.rs
@@ -4,24 +4,24 @@
 #![feature(rustc_attrs)]
 
 #[rustc_variance]
-struct TestImm<A, B> { //~ ERROR [+, +]
+struct TestImm<A, B> { //~ ERROR [A: +, B: +]
     x: A,
     y: B,
 }
 
 #[rustc_variance]
-struct TestMut<A, B:'static> { //~ ERROR [+, o]
+struct TestMut<A, B:'static> { //~ ERROR [A: +, B: o]
     x: A,
     y: &'static mut B,
 }
 
 #[rustc_variance]
-struct TestIndirect<A:'static, B:'static> { //~ ERROR [+, o]
+struct TestIndirect<A:'static, B:'static> { //~ ERROR [A: +, B: o]
     m: TestMut<A, B>
 }
 
 #[rustc_variance]
-struct TestIndirect2<A:'static, B:'static> { //~ ERROR [o, o]
+struct TestIndirect2<A:'static, B:'static> { //~ ERROR [A: o, B: o]
     n: TestMut<A, B>,
     m: TestMut<B, A>
 }
@@ -35,7 +35,7 @@ trait Setter<A> {
 }
 
 #[rustc_variance]
-struct TestObject<A, R> { //~ ERROR [o, o]
+struct TestObject<A, R> { //~ ERROR [A: o, R: o]
     n: Box<dyn Setter<A>+Send>,
     m: Box<dyn Getter<R>+Send>,
 }
diff --git a/tests/ui/variance/variance-types-bounds.stderr b/tests/ui/variance/variance-types-bounds.stderr
index bb81644347693..408c2ae8d3682 100644
--- a/tests/ui/variance/variance-types-bounds.stderr
+++ b/tests/ui/variance/variance-types-bounds.stderr
@@ -1,28 +1,28 @@
-error: [+, +]
+error: [A: +, B: +]
   --> $DIR/variance-types-bounds.rs:7:1
    |
 LL | struct TestImm<A, B> {
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: [+, o]
+error: [A: +, B: o]
   --> $DIR/variance-types-bounds.rs:13:1
    |
 LL | struct TestMut<A, B:'static> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [+, o]
+error: [A: +, B: o]
   --> $DIR/variance-types-bounds.rs:19:1
    |
 LL | struct TestIndirect<A:'static, B:'static> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o, o]
+error: [A: o, B: o]
   --> $DIR/variance-types-bounds.rs:24:1
    |
 LL | struct TestIndirect2<A:'static, B:'static> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o, o]
+error: [A: o, R: o]
   --> $DIR/variance-types-bounds.rs:38:1
    |
 LL | struct TestObject<A, R> {
diff --git a/tests/ui/variance/variance-types.rs b/tests/ui/variance/variance-types.rs
index cfc03b754734d..aa336d1b424c1 100644
--- a/tests/ui/variance/variance-types.rs
+++ b/tests/ui/variance/variance-types.rs
@@ -7,32 +7,32 @@ use std::cell::Cell;
 // not considered bivariant.
 
 #[rustc_variance]
-struct InvariantMut<'a,A:'a,B:'a> { //~ ERROR [+, o, o]
+struct InvariantMut<'a,A:'a,B:'a> { //~ ERROR ['a: +, A: o, B: o]
     t: &'a mut (A,B)
 }
 
 #[rustc_variance]
-struct InvariantCell<A> { //~ ERROR [o]
+struct InvariantCell<A> { //~ ERROR [A: o]
     t: Cell<A>
 }
 
 #[rustc_variance]
-struct InvariantIndirect<A> { //~ ERROR [o]
+struct InvariantIndirect<A> { //~ ERROR [A: o]
     t: InvariantCell<A>
 }
 
 #[rustc_variance]
-struct Covariant<A> { //~ ERROR [+]
+struct Covariant<A> { //~ ERROR [A: +]
     t: A, u: fn() -> A
 }
 
 #[rustc_variance]
-struct Contravariant<A> { //~ ERROR [-]
+struct Contravariant<A> { //~ ERROR [A: -]
     t: fn(A)
 }
 
 #[rustc_variance]
-enum Enum<A,B,C> { //~ ERROR [+, -, o]
+enum Enum<A,B,C> { //~ ERROR [A: +, B: -, C: o]
     Foo(Covariant<A>),
     Bar(Contravariant<B>),
     Zed(Covariant<C>,Contravariant<C>)
diff --git a/tests/ui/variance/variance-types.stderr b/tests/ui/variance/variance-types.stderr
index 0fda4b8036e72..f2a6794942553 100644
--- a/tests/ui/variance/variance-types.stderr
+++ b/tests/ui/variance/variance-types.stderr
@@ -1,34 +1,34 @@
-error: [+, o, o]
+error: ['a: +, A: o, B: o]
   --> $DIR/variance-types.rs:10:1
    |
 LL | struct InvariantMut<'a,A:'a,B:'a> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o]
+error: [A: o]
   --> $DIR/variance-types.rs:15:1
    |
 LL | struct InvariantCell<A> {
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [o]
+error: [A: o]
   --> $DIR/variance-types.rs:20:1
    |
 LL | struct InvariantIndirect<A> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [+]
+error: [A: +]
   --> $DIR/variance-types.rs:25:1
    |
 LL | struct Covariant<A> {
    | ^^^^^^^^^^^^^^^^^^^
 
-error: [-]
+error: [A: -]
   --> $DIR/variance-types.rs:30:1
    |
 LL | struct Contravariant<A> {
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: [+, -, o]
+error: [A: +, B: -, C: o]
   --> $DIR/variance-types.rs:35:1
    |
 LL | enum Enum<A,B,C> {

From 681a866067610390f76e493e10f805d84a5ff459 Mon Sep 17 00:00:00 2001
From: Nicole LeGare <legaren@immunant.com>
Date: Fri, 23 Aug 2024 16:09:56 -0700
Subject: [PATCH 551/685] Add Trusty OS as tier 3 target

---
 compiler/rustc_target/src/spec/mod.rs         |  3 ++
 .../spec/targets/aarch64_unknown_trusty.rs    | 34 ++++++++++++
 .../src/spec/targets/armv7_unknown_trusty.rs  | 37 +++++++++++++
 src/doc/rustc/src/SUMMARY.md                  |  1 +
 src/doc/rustc/src/platform-support.md         |  2 +
 src/doc/rustc/src/platform-support/trusty.md  | 53 +++++++++++++++++++
 tests/assembly/targets/targets-elf.rs         |  6 +++
 tests/ui/check-cfg/well-known-values.stderr   |  4 +-
 8 files changed, 138 insertions(+), 2 deletions(-)
 create mode 100644 compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs
 create mode 100644 compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
 create mode 100644 src/doc/rustc/src/platform-support/trusty.md

diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 80f89a0ab2be0..d5f227a84a4ca 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -1750,6 +1750,9 @@ supported_targets! {
 
     ("x86_64-unikraft-linux-musl", x86_64_unikraft_linux_musl),
 
+    ("armv7-unknown-trusty", armv7_unknown_trusty),
+    ("aarch64-unknown-trusty", aarch64_unknown_trusty),
+
     ("riscv32i-unknown-none-elf", riscv32i_unknown_none_elf),
     ("riscv32im-risc0-zkvm-elf", riscv32im_risc0_zkvm_elf),
     ("riscv32im-unknown-none-elf", riscv32im_unknown_none_elf),
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs
new file mode 100644
index 0000000000000..1525faf9b7e1d
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs
@@ -0,0 +1,34 @@
+// Trusty OS target for AArch64.
+
+use crate::spec::{LinkSelfContainedDefault, PanicStrategy, RelroLevel, Target, TargetOptions};
+
+pub fn target() -> Target {
+    Target {
+        llvm_target: "aarch64-unknown-unknown-musl".into(),
+        metadata: crate::spec::TargetMetadata {
+            description: Some("ARM64 Trusty".into()),
+            tier: Some(2),
+            host_tools: Some(false),
+            std: Some(false),
+        },
+        pointer_width: 64,
+        data_layout: "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32".into(),
+        arch: "aarch64".into(),
+        options: TargetOptions {
+            features: "+neon,+fp-armv8,+reserve-x18".into(),
+            executables: true,
+            max_atomic_width: Some(128),
+            panic_strategy: PanicStrategy::Abort,
+            os: "trusty".into(),
+            position_independent_executables: true,
+            static_position_independent_executables: true,
+            crt_static_default: true,
+            crt_static_respected: true,
+            dynamic_linking: false,
+            link_self_contained: LinkSelfContainedDefault::InferredForMusl,
+            relro_level: RelroLevel::Full,
+            mcount: "\u{1}_mcount".into(),
+            ..Default::default()
+        },
+    }
+}
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
new file mode 100644
index 0000000000000..11784788651ee
--- /dev/null
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
@@ -0,0 +1,37 @@
+use crate::spec::{LinkSelfContainedDefault, PanicStrategy, RelroLevel, Target, TargetOptions};
+
+pub fn target() -> Target {
+    Target {
+        // It's important we use "gnueabi" and not "musleabi" here. LLVM uses it
+        // to determine the calling convention and float ABI, and it doesn't
+        // support the "musleabi" value.
+        llvm_target: "armv7-unknown-unknown-gnueabi".into(),
+        metadata: crate::spec::TargetMetadata {
+            description: Some("Armv7-A Trusty".into()),
+            tier: Some(2),
+            host_tools: Some(false),
+            std: Some(false),
+        },
+        pointer_width: 32,
+        data_layout: "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64".into(),
+        arch: "arm".into(),
+        options: TargetOptions {
+            abi: "eabi".into(),
+            features: "+v7,+thumb2,+soft-float,-neon,+reserve-x18".into(),
+            max_atomic_width: Some(64),
+            mcount: "\u{1}mcount".into(),
+            os: "trusty".into(),
+            link_self_contained: LinkSelfContainedDefault::InferredForMusl,
+            dynamic_linking: false,
+            executables: true,
+            crt_static_default: true,
+            crt_static_respected: true,
+            relro_level: RelroLevel::Full,
+            panic_strategy: PanicStrategy::Abort,
+            position_independent_executables: true,
+            static_position_independent_executables: true,
+
+            ..Default::default()
+        },
+    }
+}
diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 4e34e2667cfc0..b3a74a7716bb3 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -49,6 +49,7 @@
     - [aarch64-unknown-teeos](platform-support/aarch64-unknown-teeos.md)
     - [\*-espidf](platform-support/esp-idf.md)
     - [\*-unknown-fuchsia](platform-support/fuchsia.md)
+    - [\*-unknown-trusty](platform-support/trusty.md)
     - [\*-kmc-solid_\*](platform-support/kmc-solid.md)
     - [csky-unknown-linux-gnuabiv2\*](platform-support/csky-unknown-linux-gnuabiv2.md)
     - [hexagon-unknown-linux-musl](platform-support/hexagon-unknown-linux-musl.md)
diff --git a/src/doc/rustc/src/platform-support.md b/src/doc/rustc/src/platform-support.md
index dd478e9df379e..0d79e5f4114e3 100644
--- a/src/doc/rustc/src/platform-support.md
+++ b/src/doc/rustc/src/platform-support.md
@@ -264,6 +264,7 @@ target | std | host | notes
 [`aarch64-unknown-netbsd`](platform-support/netbsd.md) | ✓ | ✓ | ARM64 NetBSD
 [`aarch64-unknown-openbsd`](platform-support/openbsd.md) | ✓ | ✓ | ARM64 OpenBSD
 [`aarch64-unknown-redox`](platform-support/redox.md) | ✓ |  | ARM64 Redox OS
+[`aarch64-unknown-trusty`](platform-support/trusty.md) | ? |  |
 `aarch64-uwp-windows-msvc` | ✓ |  |
 [`aarch64-wrs-vxworks`](platform-support/vxworks.md) | ✓ |  | ARM64 VxWorks OS
 `aarch64_be-unknown-linux-gnu_ilp32` | ✓ | ✓ | ARM64 Linux (big-endian, ILP32 ABI)
@@ -283,6 +284,7 @@ target | std | host | notes
 [`armv7-unknown-linux-uclibceabihf`](platform-support/armv7-unknown-linux-uclibceabihf.md) | ✓ | ? | Armv7-A Linux with uClibc, hardfloat
 `armv7-unknown-freebsd` | ✓ | ✓ | Armv7-A FreeBSD
 [`armv7-unknown-netbsd-eabihf`](platform-support/netbsd.md) | ✓ | ✓ | Armv7-A NetBSD w/hard-float
+[`armv7-unknown-trusty`](platform-support/trusty.md) | ? |  |
 [`armv7-wrs-vxworks-eabihf`](platform-support/vxworks.md) | ✓ |  | Armv7-A for VxWorks
 [`armv7a-kmc-solid_asp3-eabi`](platform-support/kmc-solid.md) | ✓ |  | ARM SOLID with TOPPERS/ASP3
 [`armv7a-kmc-solid_asp3-eabihf`](platform-support/kmc-solid.md) | ✓ |  | ARM SOLID with TOPPERS/ASP3, hardfloat
diff --git a/src/doc/rustc/src/platform-support/trusty.md b/src/doc/rustc/src/platform-support/trusty.md
new file mode 100644
index 0000000000000..97a03d3de04c2
--- /dev/null
+++ b/src/doc/rustc/src/platform-support/trusty.md
@@ -0,0 +1,53 @@
+# `aarch64-unknown-trusty` and `armv7-unknown-trusty`
+
+**Tier: 3**
+
+[Trusty] is a secure Operating System that provides a Trusted Execution
+Environment (TEE) for Android.
+
+## Target maintainers
+
+- Nicole LeGare (@randomPoison)
+- Stephen Crane (@rinon)
+- As a fallback trusty-dev-team@google.com can be contacted
+
+## Requirements
+
+This target is cross-compiled. It has no special requirements for the host.
+
+It fully supports alloc with the default allocator, and partially supports std.
+Notably, most I/O functionality is not supported, e.g. filesystem support and
+networking support are not present and any APIs that rely on them will panic at
+runtime.
+
+Trusty uses the ELF file format.
+
+## Building the target
+
+The targets can be built by enabling them for a `rustc` build, for example:
+
+```toml
+[build]
+build-stage = 1
+target = ["aarch64-unknown-trusty", "armv7-unknown-trusty"]
+```
+
+## Building Rust programs
+
+There is currently no supported way to build a Trusty app with Cargo. You can
+follow the [Trusty build instructions] to build the Trusty kernel along with any
+Rust apps that are setup in the project.
+
+## Testing
+
+See the [Trusty build instructions] for information on how to build Rust code
+within the main Trusty project. The main project also includes infrastructure
+for testing Rust applications within a QEMU emulator.
+
+## Cross-compilation toolchains and C code
+
+See the [Trusty build instructions] for information on how C code is built
+within Trusty.
+
+[Trusty]: https://source.android.com/docs/security/features/trusty
+[Trusty build instructions]: https://source.android.com/docs/security/features/trusty/download-and-build
diff --git a/tests/assembly/targets/targets-elf.rs b/tests/assembly/targets/targets-elf.rs
index c3a083321e229..6f0a200a08cf3 100644
--- a/tests/assembly/targets/targets-elf.rs
+++ b/tests/assembly/targets/targets-elf.rs
@@ -66,6 +66,9 @@
 //@ revisions: aarch64_unknown_teeos
 //@ [aarch64_unknown_teeos] compile-flags: --target aarch64-unknown-teeos
 //@ [aarch64_unknown_teeos] needs-llvm-components: aarch64
+//@ revisions: aarch64_unknown_trusty
+//@ [aarch64_unknown_trusty] compile-flags: --target aarch64-unknown-trusty
+//@ [aarch64_unknown_trusty] needs-llvm-components: aarch64
 //@ revisions: aarch64_wrs_vxworks
 //@ [aarch64_wrs_vxworks] compile-flags: --target aarch64-wrs-vxworks
 //@ [aarch64_wrs_vxworks] needs-llvm-components: aarch64
@@ -153,6 +156,9 @@
 //@ revisions: armv7_unknown_netbsd_eabihf
 //@ [armv7_unknown_netbsd_eabihf] compile-flags: --target armv7-unknown-netbsd-eabihf
 //@ [armv7_unknown_netbsd_eabihf] needs-llvm-components: arm
+//@ revisions: armv7_unknown_trusty
+//@ [armv7_unknown_trusty] compile-flags: --target armv7-unknown-trusty
+//@ [armv7_unknown_trusty] needs-llvm-components: arm
 //@ revisions: armv7_wrs_vxworks_eabihf
 //@ [armv7_wrs_vxworks_eabihf] compile-flags: --target armv7-wrs-vxworks-eabihf
 //@ [armv7_wrs_vxworks_eabihf] needs-llvm-components: arm
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index d780e04e729a2..103a7564a0f87 100644
--- a/tests/ui/check-cfg/well-known-values.stderr
+++ b/tests/ui/check-cfg/well-known-values.stderr
@@ -201,7 +201,7 @@ warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
 LL |     target_os = "_UNEXPECTED_VALUE",
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `target_os` are: `aix`, `android`, `cuda`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `macos`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `redox`, `solaris`, `solid_asp3`, `teeos`, `tvos`, `uefi`, `unknown`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, and `zkvm`
+   = note: expected values for `target_os` are: `aix`, `android`, `cuda`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `macos`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `redox`, `solaris`, `solid_asp3`, `teeos`, `trusty`, `tvos`, `uefi`, `unknown`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, and `zkvm`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -285,7 +285,7 @@ LL | #[cfg(target_os = "linuz")] // testing that we suggest `linux`
    |                   |
    |                   help: there is a expected value with a similar name: `"linux"`
    |
-   = note: expected values for `target_os` are: `aix`, `android`, `cuda`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `macos`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `redox`, `solaris`, `solid_asp3`, `teeos`, `tvos`, `uefi`, `unknown`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, and `zkvm`
+   = note: expected values for `target_os` are: `aix`, `android`, `cuda`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `macos`, `netbsd`, `none`, `nto`, `nuttx`, `openbsd`, `psp`, `redox`, `solaris`, `solid_asp3`, `teeos`, `trusty`, `tvos`, `uefi`, `unknown`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, and `zkvm`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: 29 warnings emitted

From 1ed9ee7b035553dc8e719e959e1f3d03d5678a00 Mon Sep 17 00:00:00 2001
From: Nicole LeGare <legaren@immunant.com>
Date: Fri, 23 Aug 2024 16:26:20 -0700
Subject: [PATCH 552/685] Remove `reserve-x18` from armv7-unknown-trusty

---
 compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
index 11784788651ee..ae73de5e64dc5 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
@@ -17,7 +17,7 @@ pub fn target() -> Target {
         arch: "arm".into(),
         options: TargetOptions {
             abi: "eabi".into(),
-            features: "+v7,+thumb2,+soft-float,-neon,+reserve-x18".into(),
+            features: "+v7,+thumb2,+soft-float,-neon".into(),
             max_atomic_width: Some(64),
             mcount: "\u{1}mcount".into(),
             os: "trusty".into(),

From 32e34eef576e0fb54cab52e7ba32abe028200377 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <tshepang@gmail.com>
Date: Sat, 24 Aug 2024 03:11:00 +0200
Subject: [PATCH 553/685] make text more easy to read

---
 .../rustc/src/platform-support/wasm32-unknown-unknown.md    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
index ee37e5e90cfb4..dde915f316948 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -29,10 +29,10 @@ that not all uses of `wasm32-unknown-unknown` are using JavaScript and the web.
 
 ## Target maintainers
 
-When this target was added to the compiler platform-specific documentation here
+When this target was added to the compiler, platform-specific documentation here
 was not maintained at that time. This means that the list below is not
-exhaustive and there are more interested parties in this target. That being
-said since when this document was last updated those interested in maintaining
+exhaustive, and there are more interested parties in this target. That being
+said, when this document was last updated, those interested in maintaining
 this target are:
 
 - Alex Crichton, https://github.com/alexcrichton

From 70ba8c1820bd3e2f64324bc6a3472177f0f86c96 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <tshepang@gmail.com>
Date: Sat, 24 Aug 2024 05:32:52 +0200
Subject: [PATCH 554/685] format code in tests/ui/threads-sendsync

---
 .../threads-sendsync/child-outlives-parent.rs |  4 +-
 .../threads-sendsync/clone-with-exterior.rs   |  9 ++--
 tests/ui/threads-sendsync/comm.rs             |  4 +-
 tests/ui/threads-sendsync/issue-24313.rs      | 14 ++---
 tests/ui/threads-sendsync/issue-29488.rs      |  4 +-
 tests/ui/threads-sendsync/issue-4446.rs       |  7 ++-
 tests/ui/threads-sendsync/issue-4448.rs       |  2 +-
 tests/ui/threads-sendsync/issue-8827.rs       | 10 ++--
 tests/ui/threads-sendsync/issue-9396.rs       |  6 +--
 tests/ui/threads-sendsync/mpsc_stress.rs      | 17 ++----
 .../send-is-not-static-par-for.rs             | 17 +++---
 tests/ui/threads-sendsync/send-resource.rs    | 10 ++--
 .../threads-sendsync/send-type-inference.rs   |  6 +--
 tests/ui/threads-sendsync/send_str_hashmap.rs |  6 +--
 tests/ui/threads-sendsync/send_str_treemap.rs | 13 +++--
 tests/ui/threads-sendsync/sendable-class.rs   | 11 ++--
 .../ui/threads-sendsync/sendfn-is-a-block.rs  |  6 ++-
 .../sendfn-spawn-with-fn-arg.rs               | 15 ++++--
 tests/ui/threads-sendsync/spawn-fn.rs         |  6 +--
 tests/ui/threads-sendsync/spawn-types.rs      | 12 ++---
 tests/ui/threads-sendsync/spawn.rs            |  7 ++-
 tests/ui/threads-sendsync/spawn2.rs           |  2 +-
 tests/ui/threads-sendsync/sync-send-in-std.rs | 12 ++++-
 .../sync-send-iterators-in-libcollections.rs  | 20 +++----
 .../sync-send-iterators-in-libcore.rs         | 54 +++++++++++--------
 tests/ui/threads-sendsync/task-comm-0.rs      | 10 ++--
 tests/ui/threads-sendsync/task-comm-1.rs      | 10 ++--
 tests/ui/threads-sendsync/task-comm-10.rs     |  4 +-
 tests/ui/threads-sendsync/task-comm-11.rs     |  4 +-
 tests/ui/threads-sendsync/task-comm-12.rs     | 12 +++--
 tests/ui/threads-sendsync/task-comm-13.rs     |  7 ++-
 tests/ui/threads-sendsync/task-comm-14.rs     |  5 +-
 tests/ui/threads-sendsync/task-comm-15.rs     |  4 +-
 tests/ui/threads-sendsync/task-comm-16.rs     | 47 ++++++++--------
 tests/ui/threads-sendsync/task-comm-17.rs     |  5 +-
 tests/ui/threads-sendsync/task-comm-3.rs      | 15 +++---
 tests/ui/threads-sendsync/task-comm-4.rs      |  4 +-
 tests/ui/threads-sendsync/task-comm-5.rs      | 14 +++--
 tests/ui/threads-sendsync/task-comm-6.rs      |  5 +-
 tests/ui/threads-sendsync/task-comm-7.rs      | 20 ++++---
 tests/ui/threads-sendsync/task-comm-9.rs      | 13 +++--
 tests/ui/threads-sendsync/task-life-0.rs      |  6 +--
 .../task-spawn-move-and-copy.rs               |  2 +-
 tests/ui/threads-sendsync/task-stderr.rs      | 21 ++++----
 tests/ui/threads-sendsync/tcp-stress.rs       |  8 +--
 tests/ui/threads-sendsync/threads.rs          | 10 +++-
 .../tls-dtors-are-run-in-a-static-binary.rs   |  8 ++-
 tests/ui/threads-sendsync/tls-init-on-init.rs | 12 +++--
 tests/ui/threads-sendsync/tls-try-with.rs     | 14 ++---
 tests/ui/threads-sendsync/trivial-message.rs  |  6 +--
 tests/ui/threads-sendsync/unwind-resource.rs  |  6 +--
 tests/ui/threads-sendsync/yield.rs            |  6 ++-
 tests/ui/threads-sendsync/yield1.rs           |  4 +-
 tests/ui/threads-sendsync/yield2.rs           |  6 ++-
 54 files changed, 315 insertions(+), 247 deletions(-)

diff --git a/tests/ui/threads-sendsync/child-outlives-parent.rs b/tests/ui/threads-sendsync/child-outlives-parent.rs
index 213fd008cd3de..e965bac5713ce 100644
--- a/tests/ui/threads-sendsync/child-outlives-parent.rs
+++ b/tests/ui/threads-sendsync/child-outlives-parent.rs
@@ -6,8 +6,8 @@
 
 use std::thread;
 
-fn child2(_s: String) { }
+fn child2(_s: String) {}
 
 pub fn main() {
-    let _x = thread::spawn(move|| child2("hi".to_string()));
+    let _x = thread::spawn(move || child2("hi".to_string()));
 }
diff --git a/tests/ui/threads-sendsync/clone-with-exterior.rs b/tests/ui/threads-sendsync/clone-with-exterior.rs
index 67790367e27e4..9d5ac4b16aa66 100644
--- a/tests/ui/threads-sendsync/clone-with-exterior.rs
+++ b/tests/ui/threads-sendsync/clone-with-exterior.rs
@@ -7,14 +7,15 @@ use std::thread;
 
 struct Pair {
     a: isize,
-    b: isize
+    b: isize,
 }
 
 pub fn main() {
-    let z: Box<_> = Box::new(Pair { a : 10, b : 12});
+    let z: Box<_> = Box::new(Pair { a: 10, b: 12 });
 
-    thread::spawn(move|| {
+    thread::spawn(move || {
         assert_eq!(z.a, 10);
         assert_eq!(z.b, 12);
-    }).join();
+    })
+    .join();
 }
diff --git a/tests/ui/threads-sendsync/comm.rs b/tests/ui/threads-sendsync/comm.rs
index 0c37fda8a3931..3eb68707e78f1 100644
--- a/tests/ui/threads-sendsync/comm.rs
+++ b/tests/ui/threads-sendsync/comm.rs
@@ -2,12 +2,12 @@
 #![allow(unused_must_use)]
 //@ needs-threads
 
-use std::thread;
 use std::sync::mpsc::{channel, Sender};
+use std::thread;
 
 pub fn main() {
     let (tx, rx) = channel();
-    let t = thread::spawn(move || { child(&tx) });
+    let t = thread::spawn(move || child(&tx));
     let y = rx.recv().unwrap();
     println!("received");
     println!("{}", y);
diff --git a/tests/ui/threads-sendsync/issue-24313.rs b/tests/ui/threads-sendsync/issue-24313.rs
index 1ea862f1e7d6b..99c6c4a5e12de 100644
--- a/tests/ui/threads-sendsync/issue-24313.rs
+++ b/tests/ui/threads-sendsync/issue-24313.rs
@@ -2,14 +2,15 @@
 //@ needs-threads
 //@ ignore-sgx no processes
 
-use std::thread;
-use std::env;
 use std::process::Command;
+use std::{env, thread};
 
 struct Handle(i32);
 
 impl Drop for Handle {
-    fn drop(&mut self) { panic!(); }
+    fn drop(&mut self) {
+        panic!();
+    }
 }
 
 thread_local!(static HANDLE: Handle = Handle(0));
@@ -19,14 +20,15 @@ fn main() {
     if args.len() == 1 {
         let out = Command::new(&args[0]).arg("test").output().unwrap();
         let stderr = std::str::from_utf8(&out.stderr).unwrap();
-        assert!(stderr.contains("explicit panic"),
-                "bad failure message:\n{}\n", stderr);
+        assert!(stderr.contains("explicit panic"), "bad failure message:\n{}\n", stderr);
     } else {
         // TLS dtors are not always run on process exit
         thread::spawn(|| {
             HANDLE.with(|h| {
                 println!("{}", h.0);
             });
-        }).join().unwrap();
+        })
+        .join()
+        .unwrap();
     }
 }
diff --git a/tests/ui/threads-sendsync/issue-29488.rs b/tests/ui/threads-sendsync/issue-29488.rs
index fbbd6b02a067d..5ce27faed7635 100644
--- a/tests/ui/threads-sendsync/issue-29488.rs
+++ b/tests/ui/threads-sendsync/issue-29488.rs
@@ -19,5 +19,7 @@ fn main() {
     thread::spawn(|| {
         FOO.with(|_| {});
         println!("test1");
-    }).join().unwrap();
+    })
+    .join()
+    .unwrap();
 }
diff --git a/tests/ui/threads-sendsync/issue-4446.rs b/tests/ui/threads-sendsync/issue-4446.rs
index aa2de51974b37..5652ad7de55b5 100644
--- a/tests/ui/threads-sendsync/issue-4446.rs
+++ b/tests/ui/threads-sendsync/issue-4446.rs
@@ -9,7 +9,10 @@ pub fn main() {
 
     tx.send("hello, world").unwrap();
 
-    thread::spawn(move|| {
+    thread::spawn(move || {
         println!("{}", rx.recv().unwrap());
-    }).join().ok().unwrap();
+    })
+    .join()
+    .ok()
+    .unwrap();
 }
diff --git a/tests/ui/threads-sendsync/issue-4448.rs b/tests/ui/threads-sendsync/issue-4448.rs
index b8324a8c43fb5..1adebd1e25286 100644
--- a/tests/ui/threads-sendsync/issue-4448.rs
+++ b/tests/ui/threads-sendsync/issue-4448.rs
@@ -7,7 +7,7 @@ use std::thread;
 pub fn main() {
     let (tx, rx) = channel::<&'static str>();
 
-    let t = thread::spawn(move|| {
+    let t = thread::spawn(move || {
         assert_eq!(rx.recv().unwrap(), "hello, world");
     });
 
diff --git a/tests/ui/threads-sendsync/issue-8827.rs b/tests/ui/threads-sendsync/issue-8827.rs
index fa07a4ebc7d6d..57fc87db76869 100644
--- a/tests/ui/threads-sendsync/issue-8827.rs
+++ b/tests/ui/threads-sendsync/issue-8827.rs
@@ -1,12 +1,12 @@
 //@ run-pass
 //@ needs-threads
 
-use std::thread;
 use std::sync::mpsc::{channel, Receiver};
+use std::thread;
 
 fn periodical(n: isize) -> Receiver<bool> {
     let (chan, port) = channel();
-    thread::spawn(move|| {
+    thread::spawn(move || {
         loop {
             for _ in 1..n {
                 match chan.send(false) {
@@ -16,7 +16,7 @@ fn periodical(n: isize) -> Receiver<bool> {
             }
             match chan.send(true) {
                 Ok(()) => {}
-                Err(..) => break
+                Err(..) => break,
             }
         }
     });
@@ -25,7 +25,7 @@ fn periodical(n: isize) -> Receiver<bool> {
 
 fn integers() -> Receiver<isize> {
     let (chan, port) = channel();
-    thread::spawn(move|| {
+    thread::spawn(move || {
         let mut i = 1;
         loop {
             match chan.send(i) {
@@ -47,7 +47,7 @@ fn main() {
             (_, true, true) => println!("FizzBuzz"),
             (_, true, false) => println!("Fizz"),
             (_, false, true) => println!("Buzz"),
-            (i, false, false) => println!("{}", i)
+            (i, false, false) => println!("{}", i),
         }
     }
 }
diff --git a/tests/ui/threads-sendsync/issue-9396.rs b/tests/ui/threads-sendsync/issue-9396.rs
index 6b5907e5c1d09..b532ddf104dfd 100644
--- a/tests/ui/threads-sendsync/issue-9396.rs
+++ b/tests/ui/threads-sendsync/issue-9396.rs
@@ -3,12 +3,12 @@
 #![allow(deprecated)]
 //@ needs-threads
 
-use std::sync::mpsc::{TryRecvError, channel};
+use std::sync::mpsc::{channel, TryRecvError};
 use std::thread;
 
 pub fn main() {
     let (tx, rx) = channel();
-    let t = thread::spawn(move||{
+    let t = thread::spawn(move || {
         thread::sleep_ms(10);
         tx.send(()).unwrap();
     });
@@ -16,7 +16,7 @@ pub fn main() {
         match rx.try_recv() {
             Ok(()) => break,
             Err(TryRecvError::Empty) => {}
-            Err(TryRecvError::Disconnected) => unreachable!()
+            Err(TryRecvError::Disconnected) => unreachable!(),
         }
     }
     t.join();
diff --git a/tests/ui/threads-sendsync/mpsc_stress.rs b/tests/ui/threads-sendsync/mpsc_stress.rs
index f5354c60bfce9..fe0b47f3a842e 100644
--- a/tests/ui/threads-sendsync/mpsc_stress.rs
+++ b/tests/ui/threads-sendsync/mpsc_stress.rs
@@ -2,18 +2,12 @@
 //@ compile-flags:--test
 //@ needs-threads
 
-use std::sync::mpsc::channel;
-use std::sync::mpsc::TryRecvError;
-use std::sync::mpsc::RecvError;
-use std::sync::mpsc::RecvTimeoutError;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::mpsc::{channel, RecvError, RecvTimeoutError, TryRecvError};
 use std::sync::Arc;
-use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering;
-
 use std::thread;
 use std::time::Duration;
 
-
 /// Simple thread synchronization utility
 struct Barrier {
     // Not using mutex/condvar for precision
@@ -42,7 +36,6 @@ impl Barrier {
     }
 }
 
-
 fn shared_close_sender_does_not_lose_messages_iter() {
     let (tb, rb) = Barrier::new2();
 
@@ -71,7 +64,6 @@ fn shared_close_sender_does_not_lose_messages() {
     });
 }
 
-
 // https://github.com/rust-lang/rust/issues/39364
 fn concurrent_recv_timeout_and_upgrade_iter() {
     // 1 us
@@ -85,8 +77,8 @@ fn concurrent_recv_timeout_and_upgrade_iter() {
             match rx.recv_timeout(sleep) {
                 Ok(_) => {
                     break;
-                },
-                Err(_) => {},
+                }
+                Err(_) => {}
             }
         }
     });
@@ -105,7 +97,6 @@ fn concurrent_recv_timeout_and_upgrade() {
     });
 }
 
-
 fn concurrent_writes_iter() {
     const THREADS: usize = 4;
     const PER_THR: usize = 100;
diff --git a/tests/ui/threads-sendsync/send-is-not-static-par-for.rs b/tests/ui/threads-sendsync/send-is-not-static-par-for.rs
index b943b0c433da7..dd02166c0fa01 100644
--- a/tests/ui/threads-sendsync/send-is-not-static-par-for.rs
+++ b/tests/ui/threads-sendsync/send-is-not-static-par-for.rs
@@ -1,12 +1,13 @@
 //@ run-pass
 #![allow(unused_imports)]
-use std::thread;
 use std::sync::Mutex;
+use std::thread;
 
 fn par_for<I, F>(iter: I, f: F)
-    where I: Iterator,
-          I::Item: Send,
-          F: Fn(I::Item) + Sync
+where
+    I: Iterator,
+    I::Item: Send,
+    F: Fn(I::Item) + Sync,
 {
     for item in iter {
         f(item)
@@ -15,9 +16,7 @@ fn par_for<I, F>(iter: I, f: F)
 
 fn sum(x: &[i32]) {
     let sum_lengths = Mutex::new(0);
-    par_for(x.windows(4), |x| {
-        *sum_lengths.lock().unwrap() += x.len()
-    });
+    par_for(x.windows(4), |x| *sum_lengths.lock().unwrap() += x.len());
 
     assert_eq!(*sum_lengths.lock().unwrap(), (x.len() - 3) * 4);
 }
@@ -26,9 +25,7 @@ fn main() {
     let mut elements = [0; 20];
 
     // iterators over references into this stack frame
-    par_for(elements.iter_mut().enumerate(), |(i, x)| {
-        *x = i as i32
-    });
+    par_for(elements.iter_mut().enumerate(), |(i, x)| *x = i as i32);
 
     sum(&elements)
 }
diff --git a/tests/ui/threads-sendsync/send-resource.rs b/tests/ui/threads-sendsync/send-resource.rs
index 3e1532b3132ee..c02a3717d3d75 100644
--- a/tests/ui/threads-sendsync/send-resource.rs
+++ b/tests/ui/threads-sendsync/send-resource.rs
@@ -6,11 +6,11 @@
 //@ pretty-expanded FIXME #23616
 //@ needs-threads
 
-use std::thread;
 use std::sync::mpsc::channel;
+use std::thread;
 
 struct test {
-  f: isize,
+    f: isize,
 }
 
 impl Drop for test {
@@ -18,15 +18,13 @@ impl Drop for test {
 }
 
 fn test(f: isize) -> test {
-    test {
-        f: f
-    }
+    test { f: f }
 }
 
 pub fn main() {
     let (tx, rx) = channel();
 
-    let t = thread::spawn(move|| {
+    let t = thread::spawn(move || {
         let (tx2, rx2) = channel();
         tx.send(tx2).unwrap();
 
diff --git a/tests/ui/threads-sendsync/send-type-inference.rs b/tests/ui/threads-sendsync/send-type-inference.rs
index 287b3d567aec8..7608c19b5758e 100644
--- a/tests/ui/threads-sendsync/send-type-inference.rs
+++ b/tests/ui/threads-sendsync/send-type-inference.rs
@@ -9,11 +9,11 @@ use std::sync::mpsc::{channel, Sender};
 // tests that ctrl's type gets inferred properly
 struct Command<K, V> {
     key: K,
-    val: V
+    val: V,
 }
 
-fn cache_server<K:Send+'static,V:Send+'static>(mut tx: Sender<Sender<Command<K, V>>>) {
+fn cache_server<K: Send + 'static, V: Send + 'static>(mut tx: Sender<Sender<Command<K, V>>>) {
     let (tx1, _rx) = channel();
     tx.send(tx1);
 }
-pub fn main() { }
+pub fn main() {}
diff --git a/tests/ui/threads-sendsync/send_str_hashmap.rs b/tests/ui/threads-sendsync/send_str_hashmap.rs
index 9cbb0bed4473f..2675b16219094 100644
--- a/tests/ui/threads-sendsync/send_str_hashmap.rs
+++ b/tests/ui/threads-sendsync/send_str_hashmap.rs
@@ -1,9 +1,7 @@
 //@ run-pass
-use std::collections::HashMap;
 use std::borrow::Cow;
-
-use std::borrow::Cow::Borrowed as B;
-use std::borrow::Cow::Owned as O;
+use std::borrow::Cow::{Borrowed as B, Owned as O};
+use std::collections::HashMap;
 
 type SendStr = Cow<'static, str>;
 
diff --git a/tests/ui/threads-sendsync/send_str_treemap.rs b/tests/ui/threads-sendsync/send_str_treemap.rs
index cc1f560f69b2f..3e0eace339953 100644
--- a/tests/ui/threads-sendsync/send_str_treemap.rs
+++ b/tests/ui/threads-sendsync/send_str_treemap.rs
@@ -1,8 +1,7 @@
 //@ run-pass
-use std::collections::BTreeMap;
 use std::borrow::Cow;
-
-use std::borrow::Cow::{Owned as O, Borrowed as B};
+use std::borrow::Cow::{Borrowed as B, Owned as O};
+use std::collections::BTreeMap;
 
 type SendStr = Cow<'static, str>;
 
@@ -51,8 +50,8 @@ fn main() {
     assert_eq!(map.get(&O("def".to_string())), Some(&d));
 
     assert!(map.remove(&B("foo")).is_some());
-    assert_eq!(map.into_iter().map(|(k, v)| format!("{}{}", k, v))
-                              .collect::<Vec<String>>()
-                              .concat(),
-               "abc50bcd51cde52def53".to_string());
+    assert_eq!(
+        map.into_iter().map(|(k, v)| format!("{}{}", k, v)).collect::<Vec<String>>().concat(),
+        "abc50bcd51cde52def53".to_string()
+    );
 }
diff --git a/tests/ui/threads-sendsync/sendable-class.rs b/tests/ui/threads-sendsync/sendable-class.rs
index 3ee1b60a04a99..8e5e76d826a06 100644
--- a/tests/ui/threads-sendsync/sendable-class.rs
+++ b/tests/ui/threads-sendsync/sendable-class.rs
@@ -11,15 +11,12 @@
 use std::sync::mpsc::channel;
 
 struct foo {
-  i: isize,
-  j: char,
+    i: isize,
+    j: char,
 }
 
-fn foo(i:isize, j: char) -> foo {
-    foo {
-        i: i,
-        j: j
-    }
+fn foo(i: isize, j: char) -> foo {
+    foo { i: i, j: j }
 }
 
 pub fn main() {
diff --git a/tests/ui/threads-sendsync/sendfn-is-a-block.rs b/tests/ui/threads-sendsync/sendfn-is-a-block.rs
index f01b440424aaf..9afa1c47b65d9 100644
--- a/tests/ui/threads-sendsync/sendfn-is-a-block.rs
+++ b/tests/ui/threads-sendsync/sendfn-is-a-block.rs
@@ -1,7 +1,9 @@
 //@ run-pass
 
-
-fn test<F>(f: F) -> usize where F: FnOnce(usize) -> usize {
+fn test<F>(f: F) -> usize
+where
+    F: FnOnce(usize) -> usize,
+{
     return f(22);
 }
 
diff --git a/tests/ui/threads-sendsync/sendfn-spawn-with-fn-arg.rs b/tests/ui/threads-sendsync/sendfn-spawn-with-fn-arg.rs
index 63cf3ff40490d..79a71e968f98b 100644
--- a/tests/ui/threads-sendsync/sendfn-spawn-with-fn-arg.rs
+++ b/tests/ui/threads-sendsync/sendfn-spawn-with-fn-arg.rs
@@ -3,19 +3,24 @@
 
 use std::thread;
 
-pub fn main() { test05(); }
+pub fn main() {
+    test05();
+}
 
-fn test05_start<F:FnOnce(isize)>(f: F) {
+fn test05_start<F: FnOnce(isize)>(f: F) {
     f(22);
 }
 
 fn test05() {
     let three: Box<_> = Box::new(3);
-    let fn_to_send = move|n:isize| {
+    let fn_to_send = move |n: isize| {
         println!("{}", *three + n); // will copy x into the closure
         assert_eq!(*three, 3);
     };
-    thread::spawn(move|| {
+    thread::spawn(move || {
         test05_start(fn_to_send);
-    }).join().ok().unwrap();
+    })
+    .join()
+    .ok()
+    .unwrap();
 }
diff --git a/tests/ui/threads-sendsync/spawn-fn.rs b/tests/ui/threads-sendsync/spawn-fn.rs
index e4d83b53f3cfa..558c2d515aace 100644
--- a/tests/ui/threads-sendsync/spawn-fn.rs
+++ b/tests/ui/threads-sendsync/spawn-fn.rs
@@ -10,9 +10,9 @@ fn x(s: String, n: isize) {
 }
 
 pub fn main() {
-    let t1 = thread::spawn(|| x("hello from first spawned fn".to_string(), 65) );
-    let t2 = thread::spawn(|| x("hello from second spawned fn".to_string(), 66) );
-    let t3 = thread::spawn(|| x("hello from third spawned fn".to_string(), 67) );
+    let t1 = thread::spawn(|| x("hello from first spawned fn".to_string(), 65));
+    let t2 = thread::spawn(|| x("hello from second spawned fn".to_string(), 66));
+    let t3 = thread::spawn(|| x("hello from third spawned fn".to_string(), 67));
     let mut i = 30;
     while i > 0 {
         i = i - 1;
diff --git a/tests/ui/threads-sendsync/spawn-types.rs b/tests/ui/threads-sendsync/spawn-types.rs
index 2a7a9e2f49732..e53385aa7149b 100644
--- a/tests/ui/threads-sendsync/spawn-types.rs
+++ b/tests/ui/threads-sendsync/spawn-types.rs
@@ -4,13 +4,13 @@
 //@ needs-threads
 
 /*
-  Make sure we can spawn tasks that take different types of
-  parameters. This is based on a test case for #520 provided by Rob
-  Arnold.
- */
+ Make sure we can spawn tasks that take different types of
+ parameters. This is based on a test case for #520 provided by Rob
+ Arnold.
+*/
 
-use std::thread;
 use std::sync::mpsc::{channel, Sender};
+use std::thread;
 
 type ctx = Sender<isize>;
 
@@ -20,6 +20,6 @@ fn iotask(_tx: &ctx, ip: String) {
 
 pub fn main() {
     let (tx, _rx) = channel::<isize>();
-    let t = thread::spawn(move|| iotask(&tx, "localhost".to_string()) );
+    let t = thread::spawn(move || iotask(&tx, "localhost".to_string()));
     t.join().ok().unwrap();
 }
diff --git a/tests/ui/threads-sendsync/spawn.rs b/tests/ui/threads-sendsync/spawn.rs
index c7b344b9f7581..c9f7c40ddb886 100644
--- a/tests/ui/threads-sendsync/spawn.rs
+++ b/tests/ui/threads-sendsync/spawn.rs
@@ -4,7 +4,10 @@
 use std::thread;
 
 pub fn main() {
-    thread::spawn(move|| child(10)).join().ok().unwrap();
+    thread::spawn(move || child(10)).join().ok().unwrap();
 }
 
-fn child(i: isize) { println!("{}", i); assert_eq!(i, 10); }
+fn child(i: isize) {
+    println!("{}", i);
+    assert_eq!(i, 10);
+}
diff --git a/tests/ui/threads-sendsync/spawn2.rs b/tests/ui/threads-sendsync/spawn2.rs
index 8278fec1885b9..02dff2a3483dd 100644
--- a/tests/ui/threads-sendsync/spawn2.rs
+++ b/tests/ui/threads-sendsync/spawn2.rs
@@ -4,7 +4,7 @@
 use std::thread;
 
 pub fn main() {
-    let t = thread::spawn(move|| child((10, 20, 30, 40, 50, 60, 70, 80, 90)) );
+    let t = thread::spawn(move || child((10, 20, 30, 40, 50, 60, 70, 80, 90)));
     t.join().ok().unwrap(); // forget Err value, since it doesn't implement Debug
 }
 
diff --git a/tests/ui/threads-sendsync/sync-send-in-std.rs b/tests/ui/threads-sendsync/sync-send-in-std.rs
index 3a97cbb0c6843..ddf026236a8ed 100644
--- a/tests/ui/threads-sendsync/sync-send-in-std.rs
+++ b/tests/ui/threads-sendsync/sync-send-in-std.rs
@@ -6,8 +6,16 @@
 
 use std::net::ToSocketAddrs;
 
-fn is_sync<T>(_: T) where T: Sync {}
-fn is_send<T>(_: T) where T: Send {}
+fn is_sync<T>(_: T)
+where
+    T: Sync,
+{
+}
+fn is_send<T>(_: T)
+where
+    T: Send,
+{
+}
 
 macro_rules! all_sync_send {
     ($ctor:expr, $($iter:ident),+) => ({
diff --git a/tests/ui/threads-sendsync/sync-send-iterators-in-libcollections.rs b/tests/ui/threads-sendsync/sync-send-iterators-in-libcollections.rs
index 3b8fdb60acf5f..51d5e294b38aa 100644
--- a/tests/ui/threads-sendsync/sync-send-iterators-in-libcollections.rs
+++ b/tests/ui/threads-sendsync/sync-send-iterators-in-libcollections.rs
@@ -3,18 +3,20 @@
 #![allow(warnings)]
 #![feature(drain, collections_bound, btree_range)]
 
-use std::collections::BinaryHeap;
-use std::collections::{BTreeMap, BTreeSet};
-use std::collections::LinkedList;
-use std::collections::VecDeque;
-use std::collections::HashMap;
-use std::collections::HashSet;
-
+use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 use std::mem;
 use std::ops::Bound::Included;
 
-fn is_sync<T>(_: T) where T: Sync {}
-fn is_send<T>(_: T) where T: Send {}
+fn is_sync<T>(_: T)
+where
+    T: Sync,
+{
+}
+fn is_send<T>(_: T)
+where
+    T: Send,
+{
+}
 
 macro_rules! all_sync_send {
     ($ctor:expr, $($iter:ident),+) => ({
diff --git a/tests/ui/threads-sendsync/sync-send-iterators-in-libcore.rs b/tests/ui/threads-sendsync/sync-send-iterators-in-libcore.rs
index 4c77b5d2ad889..512c81a85fcaf 100644
--- a/tests/ui/threads-sendsync/sync-send-iterators-in-libcore.rs
+++ b/tests/ui/threads-sendsync/sync-send-iterators-in-libcore.rs
@@ -5,8 +5,16 @@
 
 use std::iter::{empty, once, repeat};
 
-fn is_sync<T>(_: T) where T: Sync {}
-fn is_send<T>(_: T) where T: Send {}
+fn is_sync<T>(_: T)
+where
+    T: Sync,
+{
+}
+fn is_send<T>(_: T)
+where
+    T: Send,
+{
+}
 
 macro_rules! all_sync_send {
     ($ctor:expr, $iter:ident) => ({
@@ -43,12 +51,12 @@ macro_rules! all_sync_send_mutable_ref {
 }
 
 macro_rules! is_sync_send {
-    ($ctor:expr) => ({
+    ($ctor:expr) => {{
         let x = $ctor;
         is_sync(x);
         let y = $ctor;
         is_send(y);
-    })
+    }};
 }
 
 fn main() {
@@ -63,24 +71,26 @@ fn main() {
 
     let a = [1];
     let b = [2];
-    all_sync_send!(a.iter(),
-                   cloned,
-                   cycle,
-                   chain([2].iter()),
-                   zip([2].iter()),
-                   map(|_| 1),
-                   filter(|_| true),
-                   filter_map(|_| Some(1)),
-                   enumerate,
-                   peekable,
-                   skip_while(|_| true),
-                   take_while(|_| true),
-                   skip(1),
-                   take(1),
-                   scan(1, |_, _| Some(1)),
-                   flat_map(|_| b.iter()),
-                   fuse,
-                   inspect(|_| ()));
+    all_sync_send!(
+        a.iter(),
+        cloned,
+        cycle,
+        chain([2].iter()),
+        zip([2].iter()),
+        map(|_| 1),
+        filter(|_| true),
+        filter_map(|_| Some(1)),
+        enumerate,
+        peekable,
+        skip_while(|_| true),
+        take_while(|_| true),
+        skip(1),
+        take(1),
+        scan(1, |_, _| Some(1)),
+        flat_map(|_| b.iter()),
+        fuse,
+        inspect(|_| ())
+    );
 
     is_sync_send!((1..).step_by(2));
     is_sync_send!((1..2).step_by(2));
diff --git a/tests/ui/threads-sendsync/task-comm-0.rs b/tests/ui/threads-sendsync/task-comm-0.rs
index 50f2b59189481..c4fe36e770d17 100644
--- a/tests/ui/threads-sendsync/task-comm-0.rs
+++ b/tests/ui/threads-sendsync/task-comm-0.rs
@@ -2,12 +2,14 @@
 #![allow(unused_must_use)]
 //@ needs-threads
 
-use std::thread;
 use std::sync::mpsc::{channel, Sender};
+use std::thread;
 
-pub fn main() { test05(); }
+pub fn main() {
+    test05();
+}
 
-fn test05_start(tx : &Sender<isize>) {
+fn test05_start(tx: &Sender<isize>) {
     tx.send(10).unwrap();
     println!("sent 10");
     tx.send(20).unwrap();
@@ -18,7 +20,7 @@ fn test05_start(tx : &Sender<isize>) {
 
 fn test05() {
     let (tx, rx) = channel();
-    let t = thread::spawn(move|| { test05_start(&tx) });
+    let t = thread::spawn(move || test05_start(&tx));
     let mut value: isize = rx.recv().unwrap();
     println!("{}", value);
     value = rx.recv().unwrap();
diff --git a/tests/ui/threads-sendsync/task-comm-1.rs b/tests/ui/threads-sendsync/task-comm-1.rs
index 41592bd916b4e..75d9e887cd124 100644
--- a/tests/ui/threads-sendsync/task-comm-1.rs
+++ b/tests/ui/threads-sendsync/task-comm-1.rs
@@ -4,11 +4,15 @@
 
 use std::thread;
 
-pub fn main() { test00(); }
+pub fn main() {
+    test00();
+}
 
-fn start() { println!("Started / Finished task."); }
+fn start() {
+    println!("Started / Finished task.");
+}
 
 fn test00() {
-    thread::spawn(move|| start() ).join();
+    thread::spawn(move || start()).join();
     println!("Completing.");
 }
diff --git a/tests/ui/threads-sendsync/task-comm-10.rs b/tests/ui/threads-sendsync/task-comm-10.rs
index 844652c0dde49..44c31aeed7765 100644
--- a/tests/ui/threads-sendsync/task-comm-10.rs
+++ b/tests/ui/threads-sendsync/task-comm-10.rs
@@ -3,8 +3,8 @@
 #![allow(unused_mut)]
 //@ needs-threads
 
-use std::thread;
 use std::sync::mpsc::{channel, Sender};
+use std::thread;
 
 fn start(tx: &Sender<Sender<String>>) {
     let (tx2, rx) = channel();
@@ -22,7 +22,7 @@ fn start(tx: &Sender<Sender<String>>) {
 
 pub fn main() {
     let (tx, rx) = channel();
-    let child = thread::spawn(move|| { start(&tx) });
+    let child = thread::spawn(move || start(&tx));
 
     let mut c = rx.recv().unwrap();
     c.send("A".to_string()).unwrap();
diff --git a/tests/ui/threads-sendsync/task-comm-11.rs b/tests/ui/threads-sendsync/task-comm-11.rs
index 199082fda96de..7c349c716fa35 100644
--- a/tests/ui/threads-sendsync/task-comm-11.rs
+++ b/tests/ui/threads-sendsync/task-comm-11.rs
@@ -13,9 +13,7 @@ fn start(tx: &Sender<Sender<isize>>) {
 
 pub fn main() {
     let (tx, rx) = channel();
-    let child = thread::spawn(move|| {
-        start(&tx)
-    });
+    let child = thread::spawn(move || start(&tx));
     let _tx = rx.recv().unwrap();
     child.join();
 }
diff --git a/tests/ui/threads-sendsync/task-comm-12.rs b/tests/ui/threads-sendsync/task-comm-12.rs
index 7be7ec4c988b1..95c5d5c45efc6 100644
--- a/tests/ui/threads-sendsync/task-comm-12.rs
+++ b/tests/ui/threads-sendsync/task-comm-12.rs
@@ -5,15 +5,17 @@
 
 use std::thread;
 
-pub fn main() { test00(); }
+pub fn main() {
+    test00();
+}
 
-fn start(_task_number: isize) { println!("Started / Finished task."); }
+fn start(_task_number: isize) {
+    println!("Started / Finished task.");
+}
 
 fn test00() {
     let i: isize = 0;
-    let mut result = thread::spawn(move|| {
-        start(i)
-    });
+    let mut result = thread::spawn(move || start(i));
 
     // Sleep long enough for the thread to finish.
     let mut i = 0_usize;
diff --git a/tests/ui/threads-sendsync/task-comm-13.rs b/tests/ui/threads-sendsync/task-comm-13.rs
index 414e6e0db76da..88ea3cbff0815 100644
--- a/tests/ui/threads-sendsync/task-comm-13.rs
+++ b/tests/ui/threads-sendsync/task-comm-13.rs
@@ -7,12 +7,15 @@ use std::thread;
 
 fn start(tx: &Sender<isize>, start: isize, number_of_messages: isize) {
     let mut i: isize = 0;
-    while i< number_of_messages { tx.send(start + i).unwrap(); i += 1; }
+    while i < number_of_messages {
+        tx.send(start + i).unwrap();
+        i += 1;
+    }
 }
 
 pub fn main() {
     println!("Check that we don't deadlock.");
     let (tx, rx) = channel();
-    let _ = thread::spawn(move|| { start(&tx, 0, 10) }).join();
+    let _ = thread::spawn(move || start(&tx, 0, 10)).join();
     println!("Joined task");
 }
diff --git a/tests/ui/threads-sendsync/task-comm-14.rs b/tests/ui/threads-sendsync/task-comm-14.rs
index 54deb221294ae..ff4ffd2968da3 100644
--- a/tests/ui/threads-sendsync/task-comm-14.rs
+++ b/tests/ui/threads-sendsync/task-comm-14.rs
@@ -13,7 +13,10 @@ pub fn main() {
     while (i > 0) {
         println!("{}", i);
         let tx = tx.clone();
-        thread::spawn({let i = i; move|| { child(i, &tx) }});
+        thread::spawn({
+            let i = i;
+            move || child(i, &tx)
+        });
         i = i - 1;
     }
 
diff --git a/tests/ui/threads-sendsync/task-comm-15.rs b/tests/ui/threads-sendsync/task-comm-15.rs
index f487bf3cc84b3..1308446893b86 100644
--- a/tests/ui/threads-sendsync/task-comm-15.rs
+++ b/tests/ui/threads-sendsync/task-comm-15.rs
@@ -20,9 +20,7 @@ pub fn main() {
     // the child's point of view the receiver may die. We should
     // drop messages on the floor in this case, and not crash!
     let (tx, rx) = channel();
-    let t = thread::spawn(move|| {
-        start(&tx, 10)
-    });
+    let t = thread::spawn(move || start(&tx, 10));
     rx.recv();
     t.join();
 }
diff --git a/tests/ui/threads-sendsync/task-comm-16.rs b/tests/ui/threads-sendsync/task-comm-16.rs
index 3b0fec11acd1b..e76f7bedc93f1 100644
--- a/tests/ui/threads-sendsync/task-comm-16.rs
+++ b/tests/ui/threads-sendsync/task-comm-16.rs
@@ -3,15 +3,19 @@
 #![allow(unused_parens)]
 #![allow(non_camel_case_types)]
 
-use std::sync::mpsc::channel;
 use std::cmp;
+use std::sync::mpsc::channel;
 
 // Tests of ports and channels on various types
 fn test_rec() {
-    struct R {val0: isize, val1: u8, val2: char}
+    struct R {
+        val0: isize,
+        val1: u8,
+        val2: char,
+    }
 
     let (tx, rx) = channel();
-    let r0: R = R {val0: 0, val1: 1, val2: '2'};
+    let r0: R = R { val0: 0, val1: 1, val2: '2' };
     tx.send(r0).unwrap();
     let mut r1: R;
     r1 = rx.recv().unwrap();
@@ -45,34 +49,29 @@ fn test_str() {
 enum t {
     tag1,
     tag2(isize),
-    tag3(isize, u8, char)
+    tag3(isize, u8, char),
 }
 
 impl cmp::PartialEq for t {
     fn eq(&self, other: &t) -> bool {
         match *self {
-            t::tag1 => {
-                match (*other) {
-                    t::tag1 => true,
-                    _ => false
-                }
-            }
-            t::tag2(e0a) => {
-                match (*other) {
-                    t::tag2(e0b) => e0a == e0b,
-                    _ => false
-                }
-            }
-            t::tag3(e0a, e1a, e2a) => {
-                match (*other) {
-                    t::tag3(e0b, e1b, e2b) =>
-                        e0a == e0b && e1a == e1b && e2a == e2b,
-                    _ => false
-                }
-            }
+            t::tag1 => match (*other) {
+                t::tag1 => true,
+                _ => false,
+            },
+            t::tag2(e0a) => match (*other) {
+                t::tag2(e0b) => e0a == e0b,
+                _ => false,
+            },
+            t::tag3(e0a, e1a, e2a) => match (*other) {
+                t::tag3(e0b, e1b, e2b) => e0a == e0b && e1a == e1b && e2a == e2b,
+                _ => false,
+            },
         }
     }
-    fn ne(&self, other: &t) -> bool { !(*self).eq(other) }
+    fn ne(&self, other: &t) -> bool {
+        !(*self).eq(other)
+    }
 }
 
 fn test_tag() {
diff --git a/tests/ui/threads-sendsync/task-comm-17.rs b/tests/ui/threads-sendsync/task-comm-17.rs
index 687322d4dc963..a545beee59913 100644
--- a/tests/ui/threads-sendsync/task-comm-17.rs
+++ b/tests/ui/threads-sendsync/task-comm-17.rs
@@ -9,9 +9,8 @@
 
 use std::thread;
 
-fn f() {
-}
+fn f() {}
 
 pub fn main() {
-    thread::spawn(move|| f() ).join();
+    thread::spawn(move || f()).join();
 }
diff --git a/tests/ui/threads-sendsync/task-comm-3.rs b/tests/ui/threads-sendsync/task-comm-3.rs
index 26f3eaf9dc6c4..565d97596c76b 100644
--- a/tests/ui/threads-sendsync/task-comm-3.rs
+++ b/tests/ui/threads-sendsync/task-comm-3.rs
@@ -2,10 +2,13 @@
 #![allow(unused_must_use)]
 //@ needs-threads
 
-use std::thread;
 use std::sync::mpsc::{channel, Sender};
+use std::thread;
 
-pub fn main() { println!("===== WITHOUT THREADS ====="); test00(); }
+pub fn main() {
+    println!("===== WITHOUT THREADS =====");
+    test00();
+}
 
 fn test00_start(ch: &Sender<isize>, message: isize, count: isize) {
     println!("Starting test00_start");
@@ -34,9 +37,7 @@ fn test00() {
         let tx = tx.clone();
         results.push(thread::spawn({
             let i = i;
-            move|| {
-                test00_start(&tx, i, number_of_messages)
-            }
+            move || test00_start(&tx, i, number_of_messages)
         }));
         i = i + 1;
     }
@@ -53,7 +54,9 @@ fn test00() {
     }
 
     // Join spawned threads...
-    for r in results { r.join(); }
+    for r in results {
+        r.join();
+    }
 
     println!("Completed: Final number is: ");
     println!("{}", sum);
diff --git a/tests/ui/threads-sendsync/task-comm-4.rs b/tests/ui/threads-sendsync/task-comm-4.rs
index 1210cee558211..6223f6a1ded11 100644
--- a/tests/ui/threads-sendsync/task-comm-4.rs
+++ b/tests/ui/threads-sendsync/task-comm-4.rs
@@ -3,7 +3,9 @@
 
 use std::sync::mpsc::channel;
 
-pub fn main() { test00(); }
+pub fn main() {
+    test00();
+}
 
 fn test00() {
     let mut r: isize = 0;
diff --git a/tests/ui/threads-sendsync/task-comm-5.rs b/tests/ui/threads-sendsync/task-comm-5.rs
index e07aa18c24dff..e008b28f56ca6 100644
--- a/tests/ui/threads-sendsync/task-comm-5.rs
+++ b/tests/ui/threads-sendsync/task-comm-5.rs
@@ -2,7 +2,9 @@
 
 use std::sync::mpsc::channel;
 
-pub fn main() { test00(); }
+pub fn main() {
+    test00();
+}
 
 fn test00() {
     let _r: isize = 0;
@@ -10,8 +12,14 @@ fn test00() {
     let (tx, rx) = channel();
     let number_of_messages: isize = 1000;
     let mut i: isize = 0;
-    while i < number_of_messages { tx.send(i + 0).unwrap(); i += 1; }
+    while i < number_of_messages {
+        tx.send(i + 0).unwrap();
+        i += 1;
+    }
     i = 0;
-    while i < number_of_messages { sum += rx.recv().unwrap(); i += 1; }
+    while i < number_of_messages {
+        sum += rx.recv().unwrap();
+        i += 1;
+    }
     assert_eq!(sum, number_of_messages * (number_of_messages - 1) / 2);
 }
diff --git a/tests/ui/threads-sendsync/task-comm-6.rs b/tests/ui/threads-sendsync/task-comm-6.rs
index 6a7dea63993d0..60697c908af47 100644
--- a/tests/ui/threads-sendsync/task-comm-6.rs
+++ b/tests/ui/threads-sendsync/task-comm-6.rs
@@ -4,7 +4,9 @@
 
 use std::sync::mpsc::channel;
 
-pub fn main() { test00(); }
+pub fn main() {
+    test00();
+}
 
 fn test00() {
     let mut r: isize = 0;
@@ -38,5 +40,4 @@ fn test00() {
     assert_eq!(sum, 1998000);
     // assert (sum == 4 * ((number_of_messages *
     //                   (number_of_messages - 1)) / 2));
-
 }
diff --git a/tests/ui/threads-sendsync/task-comm-7.rs b/tests/ui/threads-sendsync/task-comm-7.rs
index d9b322daa66bf..bb59e4b4a722a 100644
--- a/tests/ui/threads-sendsync/task-comm-7.rs
+++ b/tests/ui/threads-sendsync/task-comm-7.rs
@@ -6,12 +6,16 @@
 use std::sync::mpsc::{channel, Sender};
 use std::thread;
 
-pub fn main() { test00(); }
+pub fn main() {
+    test00();
+}
 
-fn test00_start(c: &Sender<isize>, start: isize,
-                number_of_messages: isize) {
+fn test00_start(c: &Sender<isize>, start: isize, number_of_messages: isize) {
     let mut i: isize = 0;
-    while i < number_of_messages { c.send(start + i).unwrap(); i += 1; }
+    while i < number_of_messages {
+        c.send(start + i).unwrap();
+        i += 1;
+    }
 }
 
 fn test00() {
@@ -21,19 +25,19 @@ fn test00() {
     let number_of_messages: isize = 10;
 
     let tx2 = tx.clone();
-    let t1 = thread::spawn(move|| {
+    let t1 = thread::spawn(move || {
         test00_start(&tx2, number_of_messages * 0, number_of_messages);
     });
     let tx2 = tx.clone();
-    let t2 = thread::spawn(move|| {
+    let t2 = thread::spawn(move || {
         test00_start(&tx2, number_of_messages * 1, number_of_messages);
     });
     let tx2 = tx.clone();
-    let t3 = thread::spawn(move|| {
+    let t3 = thread::spawn(move || {
         test00_start(&tx2, number_of_messages * 2, number_of_messages);
     });
     let tx2 = tx.clone();
-    let t4 = thread::spawn(move|| {
+    let t4 = thread::spawn(move || {
         test00_start(&tx2, number_of_messages * 3, number_of_messages);
     });
 
diff --git a/tests/ui/threads-sendsync/task-comm-9.rs b/tests/ui/threads-sendsync/task-comm-9.rs
index 3e617e4a40c28..2e1f3cb673aa3 100644
--- a/tests/ui/threads-sendsync/task-comm-9.rs
+++ b/tests/ui/threads-sendsync/task-comm-9.rs
@@ -2,14 +2,19 @@
 #![allow(unused_must_use)]
 //@ needs-threads
 
-use std::thread;
 use std::sync::mpsc::{channel, Sender};
+use std::thread;
 
-pub fn main() { test00(); }
+pub fn main() {
+    test00();
+}
 
 fn test00_start(c: &Sender<isize>, number_of_messages: isize) {
     let mut i: isize = 0;
-    while i < number_of_messages { c.send(i + 0).unwrap(); i += 1; }
+    while i < number_of_messages {
+        c.send(i + 0).unwrap();
+        i += 1;
+    }
 }
 
 fn test00() {
@@ -18,7 +23,7 @@ fn test00() {
     let (tx, rx) = channel();
     let number_of_messages: isize = 10;
 
-    let result = thread::spawn(move|| {
+    let result = thread::spawn(move || {
         test00_start(&tx, number_of_messages);
     });
 
diff --git a/tests/ui/threads-sendsync/task-life-0.rs b/tests/ui/threads-sendsync/task-life-0.rs
index d3eca5d371fb8..f08a281e76c6d 100644
--- a/tests/ui/threads-sendsync/task-life-0.rs
+++ b/tests/ui/threads-sendsync/task-life-0.rs
@@ -6,9 +6,7 @@
 use std::thread;
 
 pub fn main() {
-    thread::spawn(move|| child("Hello".to_string()) ).join();
+    thread::spawn(move || child("Hello".to_string())).join();
 }
 
-fn child(_s: String) {
-
-}
+fn child(_s: String) {}
diff --git a/tests/ui/threads-sendsync/task-spawn-move-and-copy.rs b/tests/ui/threads-sendsync/task-spawn-move-and-copy.rs
index ea1c6a9b1081b..07d1a3d5c36ef 100644
--- a/tests/ui/threads-sendsync/task-spawn-move-and-copy.rs
+++ b/tests/ui/threads-sendsync/task-spawn-move-and-copy.rs
@@ -2,8 +2,8 @@
 #![allow(unused_must_use)]
 //@ needs-threads
 
-use std::thread;
 use std::sync::mpsc::channel;
+use std::thread;
 
 pub fn main() {
     let (tx, rx) = channel::<usize>();
diff --git a/tests/ui/threads-sendsync/task-stderr.rs b/tests/ui/threads-sendsync/task-stderr.rs
index cad10c7a7922c..3934084e02a0a 100644
--- a/tests/ui/threads-sendsync/task-stderr.rs
+++ b/tests/ui/threads-sendsync/task-stderr.rs
@@ -4,20 +4,21 @@
 
 #![feature(internal_output_capture)]
 
-use std::io;
-use std::str;
 use std::sync::{Arc, Mutex};
-use std::thread;
+use std::{io, str, thread};
 
 fn main() {
     let data = Arc::new(Mutex::new(Vec::new()));
-    let res = thread::Builder::new().spawn({
-        let data = data.clone();
-        move || {
-            io::set_output_capture(Some(data));
-            panic!("Hello, world!")
-        }
-    }).unwrap().join();
+    let res = thread::Builder::new()
+        .spawn({
+            let data = data.clone();
+            move || {
+                io::set_output_capture(Some(data));
+                panic!("Hello, world!")
+            }
+        })
+        .unwrap()
+        .join();
     assert!(res.is_err());
 
     let output = data.lock().unwrap();
diff --git a/tests/ui/threads-sendsync/tcp-stress.rs b/tests/ui/threads-sendsync/tcp-stress.rs
index 429a465731408..b2f76a55fb976 100644
--- a/tests/ui/threads-sendsync/tcp-stress.rs
+++ b/tests/ui/threads-sendsync/tcp-stress.rs
@@ -8,14 +8,14 @@ use std::io::prelude::*;
 use std::net::{TcpListener, TcpStream};
 use std::process;
 use std::sync::mpsc::channel;
-use std::time::Duration;
 use std::thread::{self, Builder};
+use std::time::Duration;
 
 const TARGET_CNT: usize = 200;
 
 fn main() {
     // This test has a chance to time out, try to not let it time out
-    thread::spawn(move|| -> () {
+    thread::spawn(move || -> () {
         thread::sleep(Duration::from_secs(30));
         process::exit(1);
     });
@@ -38,12 +38,12 @@ fn main() {
     let mut spawned_cnt = 0;
     for _ in 0..TARGET_CNT {
         let tx = tx.clone();
-        let res = Builder::new().stack_size(64 * 1024).spawn(move|| {
+        let res = Builder::new().stack_size(64 * 1024).spawn(move || {
             match TcpStream::connect(addr) {
                 Ok(mut stream) => {
                     let _ = stream.write(&[1]);
                     let _ = stream.read(&mut [0]);
-                },
+                }
                 Err(..) => {}
             }
             tx.send(()).unwrap();
diff --git a/tests/ui/threads-sendsync/threads.rs b/tests/ui/threads-sendsync/threads.rs
index f3ed7890364b5..ad4e4774ea058 100644
--- a/tests/ui/threads-sendsync/threads.rs
+++ b/tests/ui/threads-sendsync/threads.rs
@@ -7,10 +7,16 @@ use std::thread;
 pub fn main() {
     let mut i = 10;
     while i > 0 {
-        thread::spawn({let i = i; move|| child(i)}).join();
+        thread::spawn({
+            let i = i;
+            move || child(i)
+        })
+        .join();
         i = i - 1;
     }
     println!("main thread exiting");
 }
 
-fn child(x: isize) { println!("{}", x); }
+fn child(x: isize) {
+    println!("{}", x);
+}
diff --git a/tests/ui/threads-sendsync/tls-dtors-are-run-in-a-static-binary.rs b/tests/ui/threads-sendsync/tls-dtors-are-run-in-a-static-binary.rs
index 8417665941232..983028681cde8 100644
--- a/tests/ui/threads-sendsync/tls-dtors-are-run-in-a-static-binary.rs
+++ b/tests/ui/threads-sendsync/tls-dtors-are-run-in-a-static-binary.rs
@@ -8,7 +8,9 @@ struct Foo;
 
 impl Drop for Foo {
     fn drop(&mut self) {
-        unsafe { HIT = true; }
+        unsafe {
+            HIT = true;
+        }
     }
 }
 
@@ -17,6 +19,8 @@ thread_local!(static FOO: Foo = Foo);
 fn main() {
     std::thread::spawn(|| {
         FOO.with(|_| {});
-    }).join().unwrap();
+    })
+    .join()
+    .unwrap();
     assert!(unsafe { HIT });
 }
diff --git a/tests/ui/threads-sendsync/tls-init-on-init.rs b/tests/ui/threads-sendsync/tls-init-on-init.rs
index fd764669e7f61..1cae19aae86c7 100644
--- a/tests/ui/threads-sendsync/tls-init-on-init.rs
+++ b/tests/ui/threads-sendsync/tls-init-on-init.rs
@@ -1,14 +1,14 @@
 //@ run-pass
 #![allow(stable_features)]
-
 //@ needs-threads
-
 #![feature(thread_local_try_with)]
 
-use std::thread;
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::thread;
 
-struct Foo { cnt: usize }
+struct Foo {
+    cnt: usize,
+}
 
 thread_local!(static FOO: Foo = Foo::init());
 
@@ -40,5 +40,7 @@ impl Drop for Foo {
 fn main() {
     thread::spawn(|| {
         FOO.with(|_| {});
-    }).join().unwrap();
+    })
+    .join()
+    .unwrap();
 }
diff --git a/tests/ui/threads-sendsync/tls-try-with.rs b/tests/ui/threads-sendsync/tls-try-with.rs
index 72cee219a0abd..04071e77daa48 100644
--- a/tests/ui/threads-sendsync/tls-try-with.rs
+++ b/tests/ui/threads-sendsync/tls-try-with.rs
@@ -1,8 +1,6 @@
 //@ run-pass
 #![allow(stable_features)]
-
 //@ needs-threads
-
 #![feature(thread_local_try_with)]
 
 use std::thread;
@@ -16,15 +14,17 @@ thread_local!(static FOO: Foo = Foo {});
 impl Drop for Foo {
     fn drop(&mut self) {
         assert!(FOO.try_with(|_| panic!("`try_with` closure run")).is_err());
-        unsafe { DROP_RUN = true; }
+        unsafe {
+            DROP_RUN = true;
+        }
     }
 }
 
 fn main() {
     thread::spawn(|| {
-        assert_eq!(FOO.try_with(|_| {
-            132
-        }).expect("`try_with` failed"), 132);
-    }).join().unwrap();
+        assert_eq!(FOO.try_with(|_| { 132 }).expect("`try_with` failed"), 132);
+    })
+    .join()
+    .unwrap();
     assert!(unsafe { DROP_RUN });
 }
diff --git a/tests/ui/threads-sendsync/trivial-message.rs b/tests/ui/threads-sendsync/trivial-message.rs
index 8165737364384..d76ba0009dca2 100644
--- a/tests/ui/threads-sendsync/trivial-message.rs
+++ b/tests/ui/threads-sendsync/trivial-message.rs
@@ -2,9 +2,9 @@
 
 #![allow(unused_must_use)]
 /*
-  This is about the simplest program that can successfully send a
-  message.
- */
+ This is about the simplest program that can successfully send a
+ message.
+*/
 
 use std::sync::mpsc::channel;
 
diff --git a/tests/ui/threads-sendsync/unwind-resource.rs b/tests/ui/threads-sendsync/unwind-resource.rs
index 3b1ab57b46e3e..ec27a1846fef2 100644
--- a/tests/ui/threads-sendsync/unwind-resource.rs
+++ b/tests/ui/threads-sendsync/unwind-resource.rs
@@ -21,9 +21,7 @@ impl Drop for complainer {
 
 fn complainer(tx: Sender<bool>) -> complainer {
     println!("Hello!");
-    complainer {
-        tx: tx
-    }
+    complainer { tx: tx }
 }
 
 fn f(tx: Sender<bool>) {
@@ -33,7 +31,7 @@ fn f(tx: Sender<bool>) {
 
 pub fn main() {
     let (tx, rx) = channel();
-    let t = thread::spawn(move|| f(tx.clone()));
+    let t = thread::spawn(move || f(tx.clone()));
     println!("hiiiiiiiii");
     assert!(rx.recv().unwrap());
     drop(t.join());
diff --git a/tests/ui/threads-sendsync/yield.rs b/tests/ui/threads-sendsync/yield.rs
index 99d14bd92eaa5..c2b10b901cf82 100644
--- a/tests/ui/threads-sendsync/yield.rs
+++ b/tests/ui/threads-sendsync/yield.rs
@@ -17,5 +17,9 @@ pub fn main() {
 }
 
 fn child() {
-    println!("4"); thread::yield_now(); println!("5"); thread::yield_now(); println!("6");
+    println!("4");
+    thread::yield_now();
+    println!("5");
+    thread::yield_now();
+    println!("6");
 }
diff --git a/tests/ui/threads-sendsync/yield1.rs b/tests/ui/threads-sendsync/yield1.rs
index c965d2fc3033e..441e93ecf9065 100644
--- a/tests/ui/threads-sendsync/yield1.rs
+++ b/tests/ui/threads-sendsync/yield1.rs
@@ -13,4 +13,6 @@ pub fn main() {
     result.join();
 }
 
-fn child() { println!("2"); }
+fn child() {
+    println!("2");
+}
diff --git a/tests/ui/threads-sendsync/yield2.rs b/tests/ui/threads-sendsync/yield2.rs
index 9502f0d33da51..2c24df44af249 100644
--- a/tests/ui/threads-sendsync/yield2.rs
+++ b/tests/ui/threads-sendsync/yield2.rs
@@ -4,5 +4,9 @@ use std::thread;
 
 pub fn main() {
     let mut i: isize = 0;
-    while i < 100 { i = i + 1; println!("{}", i); thread::yield_now(); }
+    while i < 100 {
+        i = i + 1;
+        println!("{}", i);
+        thread::yield_now();
+    }
 }

From f734f3d8e73f2118fdf4bdaf35e72ace8a442531 Mon Sep 17 00:00:00 2001
From: Tshepang Mbambo <tshepang@gmail.com>
Date: Sat, 24 Aug 2024 05:40:27 +0200
Subject: [PATCH 555/685] remove extraneous text

---
 src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
index dde915f316948..12b7817c38277 100644
--- a/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
+++ b/src/doc/rustc/src/platform-support/wasm32-unknown-unknown.md
@@ -32,8 +32,7 @@ that not all uses of `wasm32-unknown-unknown` are using JavaScript and the web.
 When this target was added to the compiler, platform-specific documentation here
 was not maintained at that time. This means that the list below is not
 exhaustive, and there are more interested parties in this target. That being
-said, when this document was last updated, those interested in maintaining
-this target are:
+said, those interested in maintaining this target are:
 
 - Alex Crichton, https://github.com/alexcrichton
 

From 9ccd7abefeba2bde9e3366b5bb3985375fb0b8e6 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Wed, 21 Aug 2024 22:32:03 -0700
Subject: [PATCH 556/685] library: Move unstable API of new_uninit to new
 features

- `new_zeroed` variants move to `new_zeroed_alloc`
- the `write` fn moves to `box_uninit_write`

The remainder will be stabilized in upcoming patches, as
it was decided to only stabilize `uninit*` and `assume_init`.
---
 compiler/rustc_index/src/lib.rs |  1 +
 library/alloc/src/boxed.rs      |  9 ++++++---
 library/alloc/src/rc.rs         |  6 ++++--
 library/alloc/src/sync.rs       | 10 ++++++----
 library/std/src/lib.rs          |  1 +
 5 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_index/src/lib.rs b/compiler/rustc_index/src/lib.rs
index b5e4f02a8d15c..b9d2a43206b1e 100644
--- a/compiler/rustc_index/src/lib.rs
+++ b/compiler/rustc_index/src/lib.rs
@@ -2,6 +2,7 @@
 #![cfg_attr(all(feature = "nightly", test), feature(stmt_expr_attributes))]
 #![cfg_attr(feature = "nightly", allow(internal_features))]
 #![cfg_attr(feature = "nightly", feature(extend_one, new_uninit, step_trait, test))]
+#![cfg_attr(feature = "nightly", feature(new_zeroed_alloc))]
 // tidy-alphabetical-end
 
 pub mod bit_set;
diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index 7de412595993a..c8e8d2a22ca48 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -293,6 +293,7 @@ impl<T> Box<T> {
     ///
     /// ```
     /// #![feature(new_uninit)]
+    /// #![feature(new_zeroed_alloc)]
     ///
     /// let zero = Box::<u32>::new_zeroed();
     /// let zero = unsafe { zero.assume_init() };
@@ -303,7 +304,7 @@ impl<T> Box<T> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
     #[must_use]
     pub fn new_zeroed() -> Box<mem::MaybeUninit<T>> {
         Self::new_zeroed_in(Global)
@@ -684,6 +685,7 @@ impl<T> Box<[T]> {
     /// # Examples
     ///
     /// ```
+    /// #![feature(new_zeroed_alloc)]
     /// #![feature(new_uninit)]
     ///
     /// let values = Box::<[u32]>::new_zeroed_slice(3);
@@ -694,7 +696,7 @@ impl<T> Box<[T]> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
     #[must_use]
     pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
         unsafe { RawVec::with_capacity_zeroed(len).into_box(len) }
@@ -955,6 +957,7 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
     /// # Examples
     ///
     /// ```
+    /// #![feature(box_uninit_write)]
     /// #![feature(new_uninit)]
     ///
     /// let big_box = Box::<[usize; 1024]>::new_uninit();
@@ -972,7 +975,7 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
     ///     assert_eq!(*x, i);
     /// }
     /// ```
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[unstable(feature = "box_uninit_write", issue = "129397")]
     #[inline]
     pub fn write(mut boxed: Self, value: T) -> Box<T, A> {
         unsafe {
diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index bdee06154faec..f153aa6d3be9a 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -539,6 +539,7 @@ impl<T> Rc<T> {
     /// # Examples
     ///
     /// ```
+    /// #![feature(new_zeroed_alloc)]
     /// #![feature(new_uninit)]
     ///
     /// use std::rc::Rc;
@@ -551,7 +552,7 @@ impl<T> Rc<T> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
     #[must_use]
     pub fn new_zeroed() -> Rc<mem::MaybeUninit<T>> {
         unsafe {
@@ -1000,6 +1001,7 @@ impl<T> Rc<[T]> {
     ///
     /// ```
     /// #![feature(new_uninit)]
+    /// #![feature(new_zeroed_alloc)]
     ///
     /// use std::rc::Rc;
     ///
@@ -1011,7 +1013,7 @@ impl<T> Rc<[T]> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
     #[must_use]
     pub fn new_zeroed_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
         unsafe {
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index 2c0d19b0ada09..4a3522f1a641b 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -542,6 +542,7 @@ impl<T> Arc<T> {
     /// # Examples
     ///
     /// ```
+    /// #![feature(new_zeroed_alloc)]
     /// #![feature(new_uninit)]
     ///
     /// use std::sync::Arc;
@@ -555,7 +556,7 @@ impl<T> Arc<T> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
     #[must_use]
     pub fn new_zeroed() -> Arc<mem::MaybeUninit<T>> {
         unsafe {
@@ -1134,6 +1135,7 @@ impl<T> Arc<[T]> {
     /// # Examples
     ///
     /// ```
+    /// #![feature(new_zeroed_alloc)]
     /// #![feature(new_uninit)]
     ///
     /// use std::sync::Arc;
@@ -1147,7 +1149,7 @@ impl<T> Arc<[T]> {
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[unstable(feature = "new_zeroed_alloc", issue = "129396")]
     #[must_use]
     pub fn new_zeroed_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
         unsafe {
@@ -1191,7 +1193,7 @@ impl<T, A: Allocator> Arc<[T], A> {
     /// assert_eq!(*values, [1, 2, 3])
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[unstable(feature = "allocator_api", issue = "32838")]
     #[inline]
     pub fn new_uninit_slice_in(len: usize, alloc: A) -> Arc<[mem::MaybeUninit<T>], A> {
         unsafe { Arc::from_ptr_in(Arc::allocate_for_slice_in(len, &alloc), alloc) }
@@ -1220,7 +1222,7 @@ impl<T, A: Allocator> Arc<[T], A> {
     ///
     /// [zeroed]: mem::MaybeUninit::zeroed
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[unstable(feature = "allocator_api", issue = "32838")]
     #[inline]
     pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Arc<[mem::MaybeUninit<T>], A> {
         unsafe {
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 2530a37638757..f65e9bc8d8b5a 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -363,6 +363,7 @@
 #![feature(get_mut_unchecked)]
 #![feature(map_try_insert)]
 #![feature(new_uninit)]
+#![feature(new_zeroed_alloc)]
 #![feature(slice_concat_trait)]
 #![feature(thin_box)]
 #![feature(try_reserve_kind)]

From 90b4e17a1f6604db7f55b45b8b70c2db0afcec14 Mon Sep 17 00:00:00 2001
From: Miguel Ojeda <ojeda@kernel.org>
Date: Fri, 23 Aug 2024 09:28:30 +0200
Subject: [PATCH 557/685] CI: rfl: move to temporary commit

Link: https://github.com/rust-lang/rust/pull/129416
Signed-off-by: Miguel Ojeda <ojeda@kernel.org>
---
 src/ci/docker/scripts/rfl-build.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/ci/docker/scripts/rfl-build.sh b/src/ci/docker/scripts/rfl-build.sh
index d690aac27fae6..389abb2fdd38c 100755
--- a/src/ci/docker/scripts/rfl-build.sh
+++ b/src/ci/docker/scripts/rfl-build.sh
@@ -2,7 +2,7 @@
 
 set -euo pipefail
 
-LINUX_VERSION=v6.11-rc1
+LINUX_VERSION=4c7864e81d8bbd51036dacf92fb0a400e13aaeee
 
 # Build rustc, rustdoc and cargo
 ../x.py build --stage 1 library rustdoc
@@ -28,7 +28,7 @@ rm -rf linux || true
 # Download Linux at a specific commit
 mkdir -p linux
 git -C linux init
-git -C linux remote add origin https://github.com/torvalds/linux.git
+git -C linux remote add origin https://github.com/Rust-for-Linux/linux.git
 git -C linux fetch --depth 1 origin ${LINUX_VERSION}
 git -C linux checkout FETCH_HEAD
 

From 378902e325e32de43ae0de2383ed458781be14d1 Mon Sep 17 00:00:00 2001
From: Deadbeef <ent3rm4n@gmail.com>
Date: Sat, 24 Aug 2024 14:21:55 +0800
Subject: [PATCH 558/685] remove invalid `TyCompat` relation for effects

---
 library/core/src/marker.rs                            |  1 -
 .../rfc-2632-const-trait-impl/super-traits-fail.rs    |  4 ++--
 .../super-traits-fail.stderr                          | 11 +++++++++++
 3 files changed, 13 insertions(+), 3 deletions(-)
 create mode 100644 tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail.stderr

diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 374fa086aecb7..5654f5aa4b8d2 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -1097,7 +1097,6 @@ pub mod effects {
     pub trait TyCompat<T: ?Sized> {}
 
     impl<T: ?Sized> TyCompat<T> for T {}
-    impl<T: ?Sized> TyCompat<T> for Maybe {}
     impl<T: ?Sized> TyCompat<Maybe> for T {}
 
     #[lang = "EffectsIntersection"]
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail.rs b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail.rs
index 637a24f53bc63..6c320c0462e16 100644
--- a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail.rs
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail.rs
@@ -1,4 +1,4 @@
-//@ check-pass
+//~ ERROR the trait bound
 //@ compile-flags: -Znext-solver
 
 #![allow(incomplete_features)]
@@ -17,6 +17,6 @@ impl Foo for S {
 }
 
 impl const Bar for S {}
-//FIXME ~^ ERROR the trait bound
+// FIXME(effects) bad span
 
 fn main() {}
diff --git a/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail.stderr b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail.stderr
new file mode 100644
index 0000000000000..9a907bbee0a78
--- /dev/null
+++ b/tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail.stderr
@@ -0,0 +1,11 @@
+error[E0277]: the trait bound `Maybe: TyCompat<<(Foo::{synthetic#0},) as std::marker::effects::Intersection>::Output>` is not satisfied
+   |
+note: required by a bound in `Bar::{synthetic#0}`
+  --> $DIR/super-traits-fail.rs:11:1
+   |
+LL | #[const_trait]
+   | ^^^^^^^^^^^^^^ required by this bound in `Bar::{synthetic#0}`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.

From f4fc3858bc58d2e51c545ba5b3cda592225e51fc Mon Sep 17 00:00:00 2001
From: Alexey Semenyuk <alexsemenyuk88@gmail.com>
Date: Sat, 24 Aug 2024 15:43:00 +0500
Subject: [PATCH 559/685] Fix suggestion unwrap_or_else

---
 .../src/methods/unnecessary_lazy_eval.rs      |   4 +-
 tests/ui/unnecessary_lazy_eval.stderr         | 566 ++++++++++++------
 .../ui/unnecessary_lazy_eval_unfixable.stderr |  35 +-
 3 files changed, 402 insertions(+), 203 deletions(-)

diff --git a/clippy_lints/src/methods/unnecessary_lazy_eval.rs b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
index 4429f0326058a..b84594c0da19f 100644
--- a/clippy_lints/src/methods/unnecessary_lazy_eval.rs
+++ b/clippy_lints/src/methods/unnecessary_lazy_eval.rs
@@ -64,9 +64,9 @@ pub(super) fn check<'tcx>(
                 // but prefer to avoid changing the signature of the function itself.
                 if let hir::ExprKind::MethodCall(.., span) = expr.kind {
                     span_lint_and_then(cx, UNNECESSARY_LAZY_EVALUATIONS, expr.span, msg, |diag| {
-                        diag.span_suggestion(
+                        diag.span_suggestion_verbose(
                             span,
-                            format!("use `{simplify_using}(..)` instead"),
+                            format!("use `{simplify_using}` instead"),
                             format!("{simplify_using}({})", snippet(cx, body_expr.span, "..")),
                             applicability,
                         );
diff --git a/tests/ui/unnecessary_lazy_eval.stderr b/tests/ui/unnecessary_lazy_eval.stderr
index fcd60f48bccdd..bcdf65b217e51 100644
--- a/tests/ui/unnecessary_lazy_eval.stderr
+++ b/tests/ui/unnecessary_lazy_eval.stderr
@@ -2,316 +2,432 @@ error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:83:13
    |
 LL |     let _ = opt.unwrap_or_else(|| 2);
-   |             ^^^^--------------------
-   |                 |
-   |                 help: use `unwrap_or(..)` instead: `unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_lazy_evaluations)]`
+help: use `unwrap_or` instead
+   |
+LL |     let _ = opt.unwrap_or(2);
+   |                 ~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:84:13
    |
 LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
-   |             ^^^^---------------------------------
-   |                 |
-   |                 help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = opt.unwrap_or(astronomers_pi);
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:85:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
-   |             ^^^^-------------------------------------
-   |                 |
-   |                 help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = opt.unwrap_or(ext_str.some_field);
+   |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:87:13
    |
 LL |     let _ = opt.and_then(|_| ext_opt);
-   |             ^^^^---------------------
-   |                 |
-   |                 help: use `and(..)` instead: `and(ext_opt)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `and` instead
+   |
+LL |     let _ = opt.and(ext_opt);
+   |                 ~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:88:13
    |
 LL |     let _ = opt.or_else(|| ext_opt);
-   |             ^^^^-------------------
-   |                 |
-   |                 help: use `or(..)` instead: `or(ext_opt)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _ = opt.or(ext_opt);
+   |                 ~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:89:13
    |
 LL |     let _ = opt.or_else(|| None);
-   |             ^^^^----------------
-   |                 |
-   |                 help: use `or(..)` instead: `or(None)`
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _ = opt.or(None);
+   |                 ~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:90:13
    |
 LL |     let _ = opt.get_or_insert_with(|| 2);
-   |             ^^^^------------------------
-   |                 |
-   |                 help: use `get_or_insert(..)` instead: `get_or_insert(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `get_or_insert` instead
+   |
+LL |     let _ = opt.get_or_insert(2);
+   |                 ~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:91:13
    |
 LL |     let _ = opt.ok_or_else(|| 2);
-   |             ^^^^----------------
-   |                 |
-   |                 help: use `ok_or(..)` instead: `ok_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `ok_or` instead
+   |
+LL |     let _ = opt.ok_or(2);
+   |                 ~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:92:13
    |
 LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
-   |             ^^^^^^^^^^^^^^^^^-------------------------------
-   |                              |
-   |                              help: use `unwrap_or(..)` instead: `unwrap_or(Some((1, 2)))`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = nested_tuple_opt.unwrap_or(Some((1, 2)));
+   |                              ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:93:13
    |
 LL |     let _ = cond.then(|| astronomers_pi);
-   |             ^^^^^-----------------------
-   |                  |
-   |                  help: use `then_some(..)` instead: `then_some(astronomers_pi)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _ = cond.then_some(astronomers_pi);
+   |                  ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:94:13
    |
 LL |     let _ = true.then(|| -> _ {});
-   |             ^^^^^----------------
-   |                  |
-   |                  help: use `then_some(..)` instead: `then_some({})`
+   |             ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _ = true.then_some({});
+   |                  ~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:95:13
    |
 LL |     let _ = true.then(|| {});
-   |             ^^^^^-----------
-   |                  |
-   |                  help: use `then_some(..)` instead: `then_some({})`
+   |             ^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _ = true.then_some({});
+   |                  ~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:99:13
    |
 LL |     let _ = Some(1).unwrap_or_else(|| *r);
-   |             ^^^^^^^^---------------------
-   |                     |
-   |                     help: use `unwrap_or(..)` instead: `unwrap_or(*r)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = Some(1).unwrap_or(*r);
+   |                     ~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:101:13
    |
 LL |     let _ = Some(1).unwrap_or_else(|| *b);
-   |             ^^^^^^^^---------------------
-   |                     |
-   |                     help: use `unwrap_or(..)` instead: `unwrap_or(*b)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = Some(1).unwrap_or(*b);
+   |                     ~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:103:13
    |
 LL |     let _ = Some(1).as_ref().unwrap_or_else(|| &r);
-   |             ^^^^^^^^^^^^^^^^^---------------------
-   |                              |
-   |                              help: use `unwrap_or(..)` instead: `unwrap_or(&r)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = Some(1).as_ref().unwrap_or(&r);
+   |                              ~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:104:13
    |
 LL |     let _ = Some(1).as_ref().unwrap_or_else(|| &b);
-   |             ^^^^^^^^^^^^^^^^^---------------------
-   |                              |
-   |                              help: use `unwrap_or(..)` instead: `unwrap_or(&b)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = Some(1).as_ref().unwrap_or(&b);
+   |                              ~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:107:13
    |
 LL |     let _ = Some(10).unwrap_or_else(|| 2);
-   |             ^^^^^^^^^--------------------
-   |                      |
-   |                      help: use `unwrap_or(..)` instead: `unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = Some(10).unwrap_or(2);
+   |                      ~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:108:13
    |
 LL |     let _ = Some(10).and_then(|_| ext_opt);
-   |             ^^^^^^^^^---------------------
-   |                      |
-   |                      help: use `and(..)` instead: `and(ext_opt)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `and` instead
+   |
+LL |     let _ = Some(10).and(ext_opt);
+   |                      ~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:109:28
    |
 LL |     let _: Option<usize> = None.or_else(|| ext_opt);
-   |                            ^^^^^-------------------
-   |                                 |
-   |                                 help: use `or(..)` instead: `or(ext_opt)`
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _: Option<usize> = None.or(ext_opt);
+   |                                 ~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:110:13
    |
 LL |     let _ = None.get_or_insert_with(|| 2);
-   |             ^^^^^------------------------
-   |                  |
-   |                  help: use `get_or_insert(..)` instead: `get_or_insert(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `get_or_insert` instead
+   |
+LL |     let _ = None.get_or_insert(2);
+   |                  ~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:111:35
    |
 LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
-   |                                   ^^^^^----------------
-   |                                        |
-   |                                        help: use `ok_or(..)` instead: `ok_or(2)`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `ok_or` instead
+   |
+LL |     let _: Result<usize, usize> = None.ok_or(2);
+   |                                        ~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:112:28
    |
 LL |     let _: Option<usize> = None.or_else(|| None);
-   |                            ^^^^^----------------
-   |                                 |
-   |                                 help: use `or(..)` instead: `or(None)`
+   |                            ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _: Option<usize> = None.or(None);
+   |                                 ~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:115:13
    |
 LL |     let _ = deep.0.unwrap_or_else(|| 2);
-   |             ^^^^^^^--------------------
-   |                    |
-   |                    help: use `unwrap_or(..)` instead: `unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = deep.0.unwrap_or(2);
+   |                    ~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:116:13
    |
 LL |     let _ = deep.0.and_then(|_| ext_opt);
-   |             ^^^^^^^---------------------
-   |                    |
-   |                    help: use `and(..)` instead: `and(ext_opt)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `and` instead
+   |
+LL |     let _ = deep.0.and(ext_opt);
+   |                    ~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:117:13
    |
 LL |     let _ = deep.0.or_else(|| None);
-   |             ^^^^^^^----------------
-   |                    |
-   |                    help: use `or(..)` instead: `or(None)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _ = deep.0.or(None);
+   |                    ~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:118:13
    |
 LL |     let _ = deep.0.get_or_insert_with(|| 2);
-   |             ^^^^^^^------------------------
-   |                    |
-   |                    help: use `get_or_insert(..)` instead: `get_or_insert(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `get_or_insert` instead
+   |
+LL |     let _ = deep.0.get_or_insert(2);
+   |                    ~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:119:13
    |
 LL |     let _ = deep.0.ok_or_else(|| 2);
-   |             ^^^^^^^----------------
-   |                    |
-   |                    help: use `ok_or(..)` instead: `ok_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `ok_or` instead
+   |
+LL |     let _ = deep.0.ok_or(2);
+   |                    ~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:150:28
    |
 LL |     let _: Option<usize> = None.or_else(|| Some(3));
-   |                            ^^^^^-------------------
-   |                                 |
-   |                                 help: use `or(..)` instead: `or(Some(3))`
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _: Option<usize> = None.or(Some(3));
+   |                                 ~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:151:13
    |
 LL |     let _ = deep.0.or_else(|| Some(3));
-   |             ^^^^^^^-------------------
-   |                    |
-   |                    help: use `or(..)` instead: `or(Some(3))`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _ = deep.0.or(Some(3));
+   |                    ~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Option::None`
   --> tests/ui/unnecessary_lazy_eval.rs:152:13
    |
 LL |     let _ = opt.or_else(|| Some(3));
-   |             ^^^^-------------------
-   |                 |
-   |                 help: use `or(..)` instead: `or(Some(3))`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _ = opt.or(Some(3));
+   |                 ~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval.rs:158:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| 2);
-   |             ^^^^^---------------------
-   |                  |
-   |                  help: use `unwrap_or(..)` instead: `unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = res2.unwrap_or(2);
+   |                  ~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval.rs:159:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
-   |             ^^^^^----------------------------------
-   |                  |
-   |                  help: use `unwrap_or(..)` instead: `unwrap_or(astronomers_pi)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = res2.unwrap_or(astronomers_pi);
+   |                  ~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval.rs:160:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
-   |             ^^^^^--------------------------------------
-   |                  |
-   |                  help: use `unwrap_or(..)` instead: `unwrap_or(ext_str.some_field)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = res2.unwrap_or(ext_str.some_field);
+   |                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval.rs:182:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
-   |                                   ^^^^--------------------
-   |                                       |
-   |                                       help: use `and(..)` instead: `and(Err(2))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `and` instead
+   |
+LL |     let _: Result<usize, usize> = res.and(Err(2));
+   |                                       ~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval.rs:183:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
-   |                                   ^^^^---------------------------------
-   |                                       |
-   |                                       help: use `and(..)` instead: `and(Err(astronomers_pi))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `and` instead
+   |
+LL |     let _: Result<usize, usize> = res.and(Err(astronomers_pi));
+   |                                       ~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval.rs:184:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
-   |                                   ^^^^-------------------------------------
-   |                                       |
-   |                                       help: use `and(..)` instead: `and(Err(ext_str.some_field))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `and` instead
+   |
+LL |     let _: Result<usize, usize> = res.and(Err(ext_str.some_field));
+   |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval.rs:186:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
-   |                                   ^^^^------------------
-   |                                       |
-   |                                       help: use `or(..)` instead: `or(Ok(2))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _: Result<usize, usize> = res.or(Ok(2));
+   |                                       ~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval.rs:187:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
-   |                                   ^^^^-------------------------------
-   |                                       |
-   |                                       help: use `or(..)` instead: `or(Ok(astronomers_pi))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _: Result<usize, usize> = res.or(Ok(astronomers_pi));
+   |                                       ~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval.rs:188:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
-   |                                   ^^^^-----------------------------------
-   |                                       |
-   |                                       help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `or` instead
+   |
+LL |     let _: Result<usize, usize> = res.or(Ok(ext_str.some_field));
+   |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval.rs:189:35
@@ -324,193 +440,265 @@ LL | |     // some lines
 ...  |
 LL | |     // some lines
 LL | |     or_else(|_| Ok(ext_str.some_field));
-   | |_____----------------------------------^
-   |       |
-   |       help: use `or(..)` instead: `or(Ok(ext_str.some_field))`
+   | |_______________________________________^
+   |
+help: use `or` instead
+   |
+LL |     or(Ok(ext_str.some_field));
+   |     ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:219:14
    |
 LL |     let _x = false.then(|| i32::MAX + 1);
-   |              ^^^^^^---------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(i32::MAX + 1)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(i32::MAX + 1);
+   |                    ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:221:14
    |
 LL |     let _x = false.then(|| i32::MAX * 2);
-   |              ^^^^^^---------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(i32::MAX * 2)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(i32::MAX * 2);
+   |                    ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:223:14
    |
 LL |     let _x = false.then(|| i32::MAX - 1);
-   |              ^^^^^^---------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(i32::MAX - 1)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(i32::MAX - 1);
+   |                    ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:225:14
    |
 LL |     let _x = false.then(|| i32::MIN - 1);
-   |              ^^^^^^---------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(i32::MIN - 1)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(i32::MIN - 1);
+   |                    ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:227:14
    |
 LL |     let _x = false.then(|| (1 + 2 * 3 - 2 / 3 + 9) << 2);
-   |              ^^^^^^-------------------------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some((1 + 2 * 3 - 2 / 3 + 9) << 2)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some((1 + 2 * 3 - 2 / 3 + 9) << 2);
+   |                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:229:14
    |
 LL |     let _x = false.then(|| 255u8 << 7);
-   |              ^^^^^^-------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(255u8 << 7)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(255u8 << 7);
+   |                    ~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:231:14
    |
 LL |     let _x = false.then(|| 255u8 << 8);
-   |              ^^^^^^-------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(255u8 << 8)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(255u8 << 8);
+   |                    ~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:233:14
    |
 LL |     let _x = false.then(|| 255u8 >> 8);
-   |              ^^^^^^-------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(255u8 >> 8)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(255u8 >> 8);
+   |                    ~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:236:14
    |
 LL |     let _x = false.then(|| i32::MAX + -1);
-   |              ^^^^^^----------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(i32::MAX + -1)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(i32::MAX + -1);
+   |                    ~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:238:14
    |
 LL |     let _x = false.then(|| -i32::MAX);
-   |              ^^^^^^------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(-i32::MAX)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(-i32::MAX);
+   |                    ~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:240:14
    |
 LL |     let _x = false.then(|| -i32::MIN);
-   |              ^^^^^^------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(-i32::MIN)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(-i32::MIN);
+   |                    ~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:243:14
    |
 LL |     let _x = false.then(|| 255 >> -7);
-   |              ^^^^^^------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(255 >> -7)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(255 >> -7);
+   |                    ~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:245:14
    |
 LL |     let _x = false.then(|| 255 << -1);
-   |              ^^^^^^------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(255 << -1)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(255 << -1);
+   |                    ~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:247:14
    |
 LL |     let _x = false.then(|| 1 / 0);
-   |              ^^^^^^--------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(1 / 0)`
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(1 / 0);
+   |                    ~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:249:14
    |
 LL |     let _x = false.then(|| x << -1);
-   |              ^^^^^^----------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(x << -1)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(x << -1);
+   |                    ~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:251:14
    |
 LL |     let _x = false.then(|| x << 2);
-   |              ^^^^^^---------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(x << 2)`
+   |              ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(x << 2);
+   |                    ~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:261:14
    |
 LL |     let _x = false.then(|| x / 0);
-   |              ^^^^^^--------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(x / 0)`
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(x / 0);
+   |                    ~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:263:14
    |
 LL |     let _x = false.then(|| x % 0);
-   |              ^^^^^^--------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(x % 0)`
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(x % 0);
+   |                    ~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:266:14
    |
 LL |     let _x = false.then(|| 1 / -1);
-   |              ^^^^^^---------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(1 / -1)`
+   |              ^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(1 / -1);
+   |                    ~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:268:14
    |
 LL |     let _x = false.then(|| i32::MIN / -1);
-   |              ^^^^^^----------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(i32::MIN / -1)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(i32::MIN / -1);
+   |                    ~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:271:14
    |
 LL |     let _x = false.then(|| i32::MIN / 0);
-   |              ^^^^^^---------------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(i32::MIN / 0)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(i32::MIN / 0);
+   |                    ~~~~~~~~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:273:14
    |
 LL |     let _x = false.then(|| 4 / 2);
-   |              ^^^^^^--------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(4 / 2)`
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(4 / 2);
+   |                    ~~~~~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval.rs:281:14
    |
 LL |     let _x = false.then(|| f1 + f2);
-   |              ^^^^^^----------------
-   |                    |
-   |                    help: use `then_some(..)` instead: `then_some(f1 + f2)`
+   |              ^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _x = false.then_some(f1 + f2);
+   |                    ~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 63 previous errors
 
diff --git a/tests/ui/unnecessary_lazy_eval_unfixable.stderr b/tests/ui/unnecessary_lazy_eval_unfixable.stderr
index b566b119571cb..390235b212474 100644
--- a/tests/ui/unnecessary_lazy_eval_unfixable.stderr
+++ b/tests/ui/unnecessary_lazy_eval_unfixable.stderr
@@ -2,36 +2,47 @@ error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval_unfixable.rs:13:13
    |
 LL |     let _ = Ok(1).unwrap_or_else(|()| 2);
-   |             ^^^^^^----------------------
-   |                   |
-   |                   help: use `unwrap_or(..)` instead: `unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_lazy_evaluations)]`
+help: use `unwrap_or` instead
+   |
+LL |     let _ = Ok(1).unwrap_or(2);
+   |                   ~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval_unfixable.rs:19:13
    |
 LL |     let _ = Ok(1).unwrap_or_else(|e::E| 2);
-   |             ^^^^^^------------------------
-   |                   |
-   |                   help: use `unwrap_or(..)` instead: `unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = Ok(1).unwrap_or(2);
+   |                   ~~~~~~~~~~~~
 
 error: unnecessary closure used to substitute value for `Result::Err`
   --> tests/ui/unnecessary_lazy_eval_unfixable.rs:21:13
    |
 LL |     let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2);
-   |             ^^^^^^-------------------------------------
-   |                   |
-   |                   help: use `unwrap_or(..)` instead: `unwrap_or(2)`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `unwrap_or` instead
+   |
+LL |     let _ = Ok(1).unwrap_or(2);
+   |                   ~~~~~~~~~~~~
 
 error: unnecessary closure used with `bool::then`
   --> tests/ui/unnecessary_lazy_eval_unfixable.rs:31:13
    |
 LL |     let _ = true.then(|| -> &[u8] { &[] });
-   |             ^^^^^-------------------------
-   |                  |
-   |                  help: use `then_some(..)` instead: `then_some({ &[] })`
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `then_some` instead
+   |
+LL |     let _ = true.then_some({ &[] });
+   |                  ~~~~~~~~~~~~~~~~~~
 
 error: aborting due to 4 previous errors
 

From 94aadf0f622d97db381ba711bf4f009a78bb7278 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Mon, 19 Aug 2024 23:00:37 +1000
Subject: [PATCH 560/685] Build `library/profiler_builtins` from `ci-llvm` if
 appropriate

---
 library/profiler_builtins/build.rs            | 12 +++--
 src/bootstrap/src/core/build_steps/compile.rs | 44 ++++++++++++++-----
 src/bootstrap/src/utils/change_tracker.rs     |  5 +++
 3 files changed, 45 insertions(+), 16 deletions(-)

diff --git a/library/profiler_builtins/build.rs b/library/profiler_builtins/build.rs
index 177b027e4f175..c1e0e5c1c8975 100644
--- a/library/profiler_builtins/build.rs
+++ b/library/profiler_builtins/build.rs
@@ -3,7 +3,7 @@
 //! See the build.rs for libcompiler_builtins crate for details.
 
 use std::env;
-use std::path::Path;
+use std::path::PathBuf;
 
 fn main() {
     println!("cargo:rerun-if-env-changed=LLVM_PROFILER_RT_LIB");
@@ -79,9 +79,13 @@ fn main() {
         cfg.define("COMPILER_RT_HAS_ATOMICS", Some("1"));
     }
 
-    // Note that this should exist if we're going to run (otherwise we just
-    // don't build profiler builtins at all).
-    let root = Path::new("../../src/llvm-project/compiler-rt");
+    // Get the LLVM `compiler-rt` directory from bootstrap.
+    println!("cargo:rerun-if-env-changed=RUST_COMPILER_RT_FOR_PROFILER");
+    let root = PathBuf::from(env::var("RUST_COMPILER_RT_FOR_PROFILER").unwrap_or_else(|_| {
+        let path = "../../src/llvm-project/compiler-rt";
+        println!("RUST_COMPILER_RT_FOR_PROFILER was not set; falling back to {path:?}");
+        path.to_owned()
+    }));
 
     let src_root = root.join("lib").join("profile");
     assert!(src_root.exists(), "profiler runtime source directory not found: {src_root:?}");
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 4353cfadd8d35..edf18e2ebf33b 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -199,16 +199,6 @@ impl Step for Std {
 
         builder.require_submodule("library/stdarch", None);
 
-        // Profiler information requires LLVM's compiler-rt
-        if builder.config.profiler {
-            builder.require_submodule(
-                "src/llvm-project",
-                Some(
-                    "The `build.profiler` config option requires `compiler-rt` sources from LLVM.",
-                ),
-            );
-        }
-
         let mut target_deps = builder.ensure(StartupObjects { compiler, target });
 
         let compiler_to_use = builder.compiler_for(compiler.stage, compiler.host, target);
@@ -466,6 +456,29 @@ pub fn std_crates_for_run_make(run: &RunConfig<'_>) -> Vec<String> {
     }
 }
 
+/// Tries to find LLVM's `compiler-rt` source directory, for building `library/profiler_builtins`.
+///
+/// Normally it lives in the `src/llvm-project` submodule, but if we will be using a
+/// downloaded copy of CI LLVM, then we try to use the `compiler-rt` sources from
+/// there instead, which lets us avoid checking out the LLVM submodule.
+fn compiler_rt_for_profiler(builder: &Builder<'_>) -> PathBuf {
+    // Try to use `compiler-rt` sources from downloaded CI LLVM, if possible.
+    if builder.config.llvm_from_ci {
+        // CI LLVM might not have been downloaded yet, so try to download it now.
+        builder.config.maybe_download_ci_llvm();
+        let ci_llvm_compiler_rt = builder.config.ci_llvm_root().join("compiler-rt");
+        if ci_llvm_compiler_rt.exists() {
+            return ci_llvm_compiler_rt;
+        }
+    }
+
+    // Otherwise, fall back to requiring the LLVM submodule.
+    builder.require_submodule("src/llvm-project", {
+        Some("The `build.profiler` config option requires `compiler-rt` sources from LLVM.")
+    });
+    builder.src.join("src/llvm-project/compiler-rt")
+}
+
 /// Configure cargo to compile the standard library, adding appropriate env vars
 /// and such.
 pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, cargo: &mut Cargo) {
@@ -473,8 +486,15 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, car
         cargo.env("MACOSX_DEPLOYMENT_TARGET", target);
     }
 
+    // Paths needed by `library/profiler_builtins/build.rs`.
     if let Some(path) = builder.config.profiler_path(target) {
         cargo.env("LLVM_PROFILER_RT_LIB", path);
+    } else if builder.config.profiler_enabled(target) {
+        let compiler_rt = compiler_rt_for_profiler(builder);
+        // Currently this is separate from the env var used by `compiler_builtins`
+        // (below) so that adding support for CI LLVM here doesn't risk breaking
+        // the compiler builtins. But they could be unified if desired.
+        cargo.env("RUST_COMPILER_RT_FOR_PROFILER", compiler_rt);
     }
 
     // Determine if we're going to compile in optimized C intrinsics to
@@ -507,8 +527,8 @@ pub fn std_cargo(builder: &Builder<'_>, target: TargetSelection, stage: u32, car
         );
         let compiler_builtins_root = builder.src.join("src/llvm-project/compiler-rt");
         assert!(compiler_builtins_root.exists());
-        // Note that `libprofiler_builtins/build.rs` also computes this so if
-        // you're changing something here please also change that.
+        // The path to `compiler-rt` is also used by `profiler_builtins` (above),
+        // so if you're changing something here please also change that as appropriate.
         cargo.env("RUST_COMPILER_RT_ROOT", &compiler_builtins_root);
         " compiler-builtins-c"
     } else {
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index c629f04c00ecd..51a25104e4cfb 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -230,4 +230,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Warning,
         summary: "./x test --rustc-args was renamed to --compiletest-rustc-args as it only applies there. ./x miri --rustc-args was also removed.",
     },
+    ChangeInfo {
+        change_id: 129295,
+        severity: ChangeSeverity::Info,
+        summary: "The `build.profiler` option now tries to use source code from `download-ci-llvm` if possible, instead of checking out the `src/llvm-project` submodule.",
+    },
 ];

From ec0e16a66571458dc5c296ccfa5e4d8bdcc2a2a8 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 24 Aug 2024 09:46:46 +0200
Subject: [PATCH 561/685] panicking: improve hint for Miri's RUST_BACKTRACE
 behavior

---
 library/std/src/panicking.rs                                    | 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/return_pointer_on_unwind.stderr   | 2 +-
 .../miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr   | 2 +-
 src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.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/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 +-
 src/tools/miri/tests/fail/terminate-terminator.stderr           | 2 +-
 src/tools/miri/tests/fail/unwind-action-terminate.stderr        | 2 +-
 src/tools/miri/tests/panic/alloc_error_handler_hook.stderr      | 2 +-
 src/tools/miri/tests/panic/alloc_error_handler_panic.stderr     | 2 +-
 src/tools/miri/tests/panic/div-by-zero-2.stderr                 | 2 +-
 .../panic/function_calls/exported_symbol_good_unwind.stderr     | 2 +-
 src/tools/miri/tests/panic/oob_subslice.stderr                  | 2 +-
 src/tools/miri/tests/panic/overflowing-lsh-neg.stderr           | 2 +-
 src/tools/miri/tests/panic/overflowing-rsh-1.stderr             | 2 +-
 src/tools/miri/tests/panic/overflowing-rsh-2.stderr             | 2 +-
 src/tools/miri/tests/panic/panic2.stderr                        | 2 +-
 src/tools/miri/tests/panic/panic3.stderr                        | 2 +-
 src/tools/miri/tests/panic/panic4.stderr                        | 2 +-
 src/tools/miri/tests/panic/transmute_fat2.stderr                | 2 +-
 src/tools/miri/tests/panic/unsupported_foreign_function.stderr  | 2 +-
 src/tools/miri/tests/panic/unsupported_syscall.stderr           | 2 +-
 src/tools/miri/tests/pass/panic/catch_panic.stderr              | 2 +-
 src/tools/miri/tests/pass/panic/concurrent-panic.stderr         | 2 +-
 src/tools/miri/tests/pass/panic/nested_panic_caught.stderr      | 2 +-
 src/tools/miri/tests/pass/panic/thread_panic.stderr             | 2 +-
 34 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/library/std/src/panicking.rs b/library/std/src/panicking.rs
index e818b448270dd..190eed94555ba 100644
--- a/library/std/src/panicking.rs
+++ b/library/std/src/panicking.rs
@@ -275,7 +275,7 @@ fn default_hook(info: &PanicHookInfo<'_>) {
                     if cfg!(miri) {
                         let _ = writeln!(
                             err,
-                            "note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` \
+                            "note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` \
                                 for the environment variable to have an effect"
                         );
                     }
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 42beed4ecdec3..a11a2b95689bb 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
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/exported_symbol_bad_unwind1.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 error: Undefined Behavior: unwinding past a stack frame that does not allow unwinding
   --> $DIR/exported_symbol_bad_unwind1.rs:LL:CC
    |
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 112a9687837ec..12425cc48927b 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
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/exported_symbol_bad_unwind2.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a function that cannot unwind
 stack backtrace:
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 112a9687837ec..12425cc48927b 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
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/exported_symbol_bad_unwind2.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a function that cannot unwind
 stack backtrace:
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 bc3e4858716e3..f9e299bf5d2e4 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
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/exported_symbol_bad_unwind2.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 error: Undefined Behavior: unwinding past a stack frame that does not allow unwinding
   --> $DIR/exported_symbol_bad_unwind2.rs:LL:CC
    |
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 a2fa4c1d590d0..83efc9974e895 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
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/return_pointer_on_unwind.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 error: Undefined Behavior: using uninitialized data, but this operation requires initialized memory
   --> $DIR/return_pointer_on_unwind.rs:LL:CC
    |
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 8dd76edafea20..67fd60e572ede 100644
--- a/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/uninit_uninhabited_type.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 aborted execution: attempted to instantiate uninhabited type `!`
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 thread caused non-unwinding panic. aborting.
 error: abnormal termination: the program aborted execution
   --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr b/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
index 55f66a275b6be..f89a1fc4bbb30 100644
--- a/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/zero_fn_ptr.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 aborted execution: attempted to zero-initialize type `fn()`, which is invalid
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 thread caused non-unwinding panic. aborting.
 error: abnormal termination: the program aborted execution
   --> RUSTLIB/std/src/sys/pal/PLATFORM/mod.rs:LL:CC
diff --git a/src/tools/miri/tests/fail/panic/bad_unwind.stderr b/src/tools/miri/tests/fail/panic/bad_unwind.stderr
index 230e8337c7cd1..c08fe5153b1fc 100644
--- a/src/tools/miri/tests/fail/panic/bad_unwind.stderr
+++ b/src/tools/miri/tests/fail/panic/bad_unwind.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/bad_unwind.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 error: Undefined Behavior: unwinding past a stack frame that does not allow unwinding
   --> $DIR/bad_unwind.rs:LL:CC
    |
diff --git a/src/tools/miri/tests/fail/panic/double_panic.stderr b/src/tools/miri/tests/fail/panic/double_panic.stderr
index 5829c1897bbab..0395fe418d93c 100644
--- a/src/tools/miri/tests/fail/panic/double_panic.stderr
+++ b/src/tools/miri/tests/fail/panic/double_panic.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/double_panic.rs:LL:CC:
 first
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 thread 'main' panicked at $DIR/double_panic.rs:LL:CC:
 second
 stack backtrace:
diff --git a/src/tools/miri/tests/fail/panic/panic_abort1.stderr b/src/tools/miri/tests/fail/panic/panic_abort1.stderr
index d4abf19cd1e5d..6c7cac23beccb 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort1.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort1.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/panic_abort1.rs:LL:CC:
 panicking from libstd
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 error: abnormal termination: the program aborted execution
   --> RUSTLIB/panic_abort/src/lib.rs:LL:CC
    |
diff --git a/src/tools/miri/tests/fail/panic/panic_abort2.stderr b/src/tools/miri/tests/fail/panic/panic_abort2.stderr
index 507f17abf4e7e..1eda5449d1b65 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort2.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort2.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/panic_abort2.rs:LL:CC:
 42-panicking from libstd
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 error: abnormal termination: the program aborted execution
   --> RUSTLIB/panic_abort/src/lib.rs:LL:CC
    |
diff --git a/src/tools/miri/tests/fail/panic/panic_abort3.stderr b/src/tools/miri/tests/fail/panic/panic_abort3.stderr
index a5d8b4d2eebd0..5c7c5e17beebb 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort3.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort3.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/panic_abort3.rs:LL:CC:
 panicking from libcore
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 error: abnormal termination: the program aborted execution
   --> RUSTLIB/panic_abort/src/lib.rs:LL:CC
    |
diff --git a/src/tools/miri/tests/fail/panic/panic_abort4.stderr b/src/tools/miri/tests/fail/panic/panic_abort4.stderr
index 62fbbf942cb07..c8104f570f633 100644
--- a/src/tools/miri/tests/fail/panic/panic_abort4.stderr
+++ b/src/tools/miri/tests/fail/panic/panic_abort4.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/panic_abort4.rs:LL:CC:
 42-panicking from libcore
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 error: abnormal termination: the program aborted execution
   --> RUSTLIB/panic_abort/src/lib.rs:LL:CC
    |
diff --git a/src/tools/miri/tests/fail/terminate-terminator.stderr b/src/tools/miri/tests/fail/terminate-terminator.stderr
index a5fa0b3e07a6e..6384689c56357 100644
--- a/src/tools/miri/tests/fail/terminate-terminator.stderr
+++ b/src/tools/miri/tests/fail/terminate-terminator.stderr
@@ -3,7 +3,7 @@ warning: You have explicitly enabled MIR optimizations, overriding Miri's defaul
 thread 'main' panicked at $DIR/terminate-terminator.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a function that cannot unwind
 stack backtrace:
diff --git a/src/tools/miri/tests/fail/unwind-action-terminate.stderr b/src/tools/miri/tests/fail/unwind-action-terminate.stderr
index 547d550d3d0d8..fd67bdf4a90bc 100644
--- a/src/tools/miri/tests/fail/unwind-action-terminate.stderr
+++ b/src/tools/miri/tests/fail/unwind-action-terminate.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/unwind-action-terminate.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 thread 'main' panicked at RUSTLIB/core/src/panicking.rs:LL:CC:
 panic in a function that cannot unwind
 stack backtrace:
diff --git a/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr b/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr
index 5b309ed09bb42..319a10febb372 100644
--- a/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr
+++ b/src/tools/miri/tests/panic/alloc_error_handler_hook.stderr
@@ -1,5 +1,5 @@
 thread 'main' panicked at $DIR/alloc_error_handler_hook.rs:LL:CC:
 alloc error hook called
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 yes we are unwinding!
diff --git a/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr b/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr
index 3d5457799f60d..2cdff03f10f09 100644
--- a/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr
+++ b/src/tools/miri/tests/panic/alloc_error_handler_panic.stderr
@@ -1,5 +1,5 @@
 thread 'main' panicked at RUSTLIB/std/src/alloc.rs:LL:CC:
 memory allocation of 4 bytes failed
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 yes we are unwinding!
diff --git a/src/tools/miri/tests/panic/div-by-zero-2.stderr b/src/tools/miri/tests/panic/div-by-zero-2.stderr
index f0b84ea6fd606..ed394f76b0e00 100644
--- a/src/tools/miri/tests/panic/div-by-zero-2.stderr
+++ b/src/tools/miri/tests/panic/div-by-zero-2.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/div-by-zero-2.rs:LL:CC:
 attempt to divide by zero
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr b/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr
index f77f6f01119ec..6733f2e42c1a7 100644
--- a/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr
+++ b/src/tools/miri/tests/panic/function_calls/exported_symbol_good_unwind.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/exported_symbol_good_unwind.rs:LL:CC:
 explicit panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 thread 'main' panicked at $DIR/exported_symbol_good_unwind.rs:LL:CC:
 explicit panic
 thread 'main' panicked at $DIR/exported_symbol_good_unwind.rs:LL:CC:
diff --git a/src/tools/miri/tests/panic/oob_subslice.stderr b/src/tools/miri/tests/panic/oob_subslice.stderr
index c116f8eb5250e..46f0f643a4728 100644
--- a/src/tools/miri/tests/panic/oob_subslice.stderr
+++ b/src/tools/miri/tests/panic/oob_subslice.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/oob_subslice.rs:LL:CC:
 range end index 5 out of range for slice of length 4
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr b/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr
index 1d057ea5eb4ba..be822bd02852f 100644
--- a/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr
+++ b/src/tools/miri/tests/panic/overflowing-lsh-neg.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/overflowing-lsh-neg.rs:LL:CC:
 attempt to shift left with overflow
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/overflowing-rsh-1.stderr b/src/tools/miri/tests/panic/overflowing-rsh-1.stderr
index d1a79400bfabe..fc090aba5fdb5 100644
--- a/src/tools/miri/tests/panic/overflowing-rsh-1.stderr
+++ b/src/tools/miri/tests/panic/overflowing-rsh-1.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/overflowing-rsh-1.rs:LL:CC:
 attempt to shift right with overflow
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/overflowing-rsh-2.stderr b/src/tools/miri/tests/panic/overflowing-rsh-2.stderr
index 612b0c0c4c21f..77160e1870f96 100644
--- a/src/tools/miri/tests/panic/overflowing-rsh-2.stderr
+++ b/src/tools/miri/tests/panic/overflowing-rsh-2.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/overflowing-rsh-2.rs:LL:CC:
 attempt to shift right with overflow
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/panic2.stderr b/src/tools/miri/tests/panic/panic2.stderr
index 792c71346fd6a..f7408310093d7 100644
--- a/src/tools/miri/tests/panic/panic2.stderr
+++ b/src/tools/miri/tests/panic/panic2.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/panic2.rs:LL:CC:
 42-panicking from libstd
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/panic3.stderr b/src/tools/miri/tests/panic/panic3.stderr
index f8016bc3912d2..32ba400e025c3 100644
--- a/src/tools/miri/tests/panic/panic3.stderr
+++ b/src/tools/miri/tests/panic/panic3.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/panic3.rs:LL:CC:
 panicking from libcore
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/panic4.stderr b/src/tools/miri/tests/panic/panic4.stderr
index 67410bf3b1a0e..a8a23ee3ce14f 100644
--- a/src/tools/miri/tests/panic/panic4.stderr
+++ b/src/tools/miri/tests/panic/panic4.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/panic4.rs:LL:CC:
 42-panicking from libcore
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/transmute_fat2.stderr b/src/tools/miri/tests/panic/transmute_fat2.stderr
index 2ee01d469312b..021ca1c4b3298 100644
--- a/src/tools/miri/tests/panic/transmute_fat2.stderr
+++ b/src/tools/miri/tests/panic/transmute_fat2.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/transmute_fat2.rs:LL:CC:
 index out of bounds: the len is 0 but the index is 0
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/unsupported_foreign_function.stderr b/src/tools/miri/tests/panic/unsupported_foreign_function.stderr
index d0a7d8dafc5a4..fcc4220bfceb8 100644
--- a/src/tools/miri/tests/panic/unsupported_foreign_function.stderr
+++ b/src/tools/miri/tests/panic/unsupported_foreign_function.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/unsupported_foreign_function.rs:LL:CC:
 unsupported Miri functionality: can't call foreign function `foo` on $OS
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/panic/unsupported_syscall.stderr b/src/tools/miri/tests/panic/unsupported_syscall.stderr
index f802159cb1cf8..660cfba8900f7 100644
--- a/src/tools/miri/tests/panic/unsupported_syscall.stderr
+++ b/src/tools/miri/tests/panic/unsupported_syscall.stderr
@@ -1,4 +1,4 @@
 thread 'main' panicked at $DIR/unsupported_syscall.rs:LL:CC:
 unsupported Miri functionality: can't execute syscall with ID 0
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
diff --git a/src/tools/miri/tests/pass/panic/catch_panic.stderr b/src/tools/miri/tests/pass/panic/catch_panic.stderr
index a472a5d80cb76..f61b39493ed17 100644
--- a/src/tools/miri/tests/pass/panic/catch_panic.stderr
+++ b/src/tools/miri/tests/pass/panic/catch_panic.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/catch_panic.rs:LL:CC:
 Hello from std::panic
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 Caught panic message (&str): Hello from std::panic
 thread 'main' panicked at $DIR/catch_panic.rs:LL:CC:
 Hello from std::panic: 1
diff --git a/src/tools/miri/tests/pass/panic/concurrent-panic.stderr b/src/tools/miri/tests/pass/panic/concurrent-panic.stderr
index b2a5cf4922c88..fe0d16ca78ac0 100644
--- a/src/tools/miri/tests/pass/panic/concurrent-panic.stderr
+++ b/src/tools/miri/tests/pass/panic/concurrent-panic.stderr
@@ -3,7 +3,7 @@ Thread 1 reported it has started
 thread '<unnamed>' panicked at $DIR/concurrent-panic.rs:LL:CC:
 panic in thread 2
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 Thread 2 blocking on thread 1
 Thread 2 reported it has started
 Unlocking mutex
diff --git a/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr b/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr
index 3efb4be40f911..a346d31f645eb 100644
--- a/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr
+++ b/src/tools/miri/tests/pass/panic/nested_panic_caught.stderr
@@ -1,7 +1,7 @@
 thread 'main' panicked at $DIR/nested_panic_caught.rs:LL:CC:
 once
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 thread 'main' panicked at $DIR/nested_panic_caught.rs:LL:CC:
 twice
 stack backtrace:
diff --git a/src/tools/miri/tests/pass/panic/thread_panic.stderr b/src/tools/miri/tests/pass/panic/thread_panic.stderr
index bdfe4f98ba369..0fde5922c192d 100644
--- a/src/tools/miri/tests/pass/panic/thread_panic.stderr
+++ b/src/tools/miri/tests/pass/panic/thread_panic.stderr
@@ -1,6 +1,6 @@
 thread '<unnamed>' panicked at $DIR/thread_panic.rs:LL:CC:
 Hello!
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
-note: in Miri, you may have to set `-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
+note: in Miri, you may have to set `MIRIFLAGS=-Zmiri-env-forward=RUST_BACKTRACE` for the environment variable to have an effect
 thread 'childthread' panicked at $DIR/thread_panic.rs:LL:CC:
 Hello, world!

From 493cf6a7e9919b6c56456c18331a6fc4da099f7e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 24 Aug 2024 14:11:28 +0200
Subject: [PATCH 562/685] interpret: ImmTy: tighten sanity checks in offset
 logic

---
 .../rustc_const_eval/src/interpret/operand.rs | 21 +++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/operand.rs b/compiler/rustc_const_eval/src/interpret/operand.rs
index ad87d6953d3f2..9a8ccaa7cc5ca 100644
--- a/compiler/rustc_const_eval/src/interpret/operand.rs
+++ b/compiler/rustc_const_eval/src/interpret/operand.rs
@@ -319,6 +319,7 @@ impl<'tcx, Prov: Provenance> ImmTy<'tcx, Prov> {
             // some fieldless enum variants can have non-zero size but still `Aggregate` ABI... try
             // to detect those here and also give them no data
             _ if matches!(layout.abi, Abi::Aggregate { .. })
+                && matches!(layout.variants, abi::Variants::Single { .. })
                 && matches!(&layout.fields, abi::FieldsShape::Arbitrary { offsets, .. } if offsets.len() == 0) =>
             {
                 Immediate::Uninit
@@ -328,8 +329,9 @@ impl<'tcx, Prov: Provenance> ImmTy<'tcx, Prov> {
                 assert_eq!(offset.bytes(), 0);
                 assert!(
                     match (self.layout.abi, layout.abi) {
-                        (Abi::Scalar(..), Abi::Scalar(..)) => true,
-                        (Abi::ScalarPair(..), Abi::ScalarPair(..)) => true,
+                        (Abi::Scalar(l), Abi::Scalar(r)) => l.size(cx) == r.size(cx),
+                        (Abi::ScalarPair(l1, l2), Abi::ScalarPair(r1, r2)) =>
+                            l1.size(cx) == r1.size(cx) && l2.size(cx) == r2.size(cx),
                         _ => false,
                     },
                     "cannot project into {} immediate with equally-sized field {}\nouter ABI: {:#?}\nfield ABI: {:#?}",
@@ -344,16 +346,23 @@ impl<'tcx, Prov: Provenance> ImmTy<'tcx, Prov> {
             (Immediate::ScalarPair(a_val, b_val), Abi::ScalarPair(a, b)) => {
                 assert_matches!(layout.abi, Abi::Scalar(..));
                 Immediate::from(if offset.bytes() == 0 {
-                    debug_assert_eq!(layout.size, a.size(cx));
+                    // It is "okay" to transmute from `usize` to a pointer (GVN relies on that).
+                    // So only compare the size.
+                    assert_eq!(layout.size, a.size(cx));
                     a_val
                 } else {
-                    debug_assert_eq!(offset, a.size(cx).align_to(b.align(cx).abi));
-                    debug_assert_eq!(layout.size, b.size(cx));
+                    assert_eq!(offset, a.size(cx).align_to(b.align(cx).abi));
+                    assert_eq!(layout.size, b.size(cx));
                     b_val
                 })
             }
             // everything else is a bug
-            _ => bug!("invalid field access on immediate {}, layout {:#?}", self, self.layout),
+            _ => bug!(
+                "invalid field access on immediate {} at offset {}, original layout {:#?}",
+                self,
+                offset.bytes(),
+                self.layout
+            ),
         };
 
         ImmTy::from_immediate(inner_val, layout)

From 53435501420733c79231653763c69c3bd2f8710f Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sat, 24 Aug 2024 17:14:31 +0200
Subject: [PATCH 563/685] const checking: properly compute the set of transient
 locals

---
 .../src/check_consts/check.rs                 | 62 ++++++++++++++-----
 1 file changed, 45 insertions(+), 17 deletions(-)

diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index 86a5afa65ba87..d7594c9ae75f6 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -1,6 +1,7 @@
 //! The `Visitor` responsible for actually checking a `mir::Body` for invalid operations.
 
 use std::assert_matches::assert_matches;
+use std::borrow::Cow;
 use std::mem;
 use std::ops::Deref;
 
@@ -15,7 +16,9 @@ use rustc_middle::mir::*;
 use rustc_middle::span_bug;
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::{self, Instance, InstanceKind, Ty, TyCtxt, TypeVisitableExt};
-use rustc_mir_dataflow::Analysis;
+use rustc_mir_dataflow::impls::MaybeStorageLive;
+use rustc_mir_dataflow::storage::always_storage_live_locals;
+use rustc_mir_dataflow::{Analysis, ResultsCursor};
 use rustc_span::{sym, Span, Symbol, DUMMY_SP};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::traits::{self, ObligationCauseCode, ObligationCtxt};
@@ -188,8 +191,9 @@ pub struct Checker<'mir, 'tcx> {
     /// The span of the current statement.
     span: Span,
 
-    /// A set that stores for each local whether it has a `StorageDead` for it somewhere.
-    local_has_storage_dead: Option<BitSet<Local>>,
+    /// A set that stores for each local whether it is "transient", i.e. guaranteed to be dead
+    /// when this MIR body returns.
+    transient_locals: Option<BitSet<Local>>,
 
     error_emitted: Option<ErrorGuaranteed>,
     secondary_errors: Vec<Diag<'tcx>>,
@@ -209,7 +213,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
             span: ccx.body.span,
             ccx,
             qualifs: Default::default(),
-            local_has_storage_dead: None,
+            transient_locals: None,
             error_emitted: None,
             secondary_errors: Vec::new(),
         }
@@ -264,23 +268,47 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
         }
     }
 
-    fn local_has_storage_dead(&mut self, local: Local) -> bool {
+    fn local_is_transient(&mut self, local: Local) -> bool {
         let ccx = self.ccx;
-        self.local_has_storage_dead
+        self.transient_locals
             .get_or_insert_with(|| {
-                struct StorageDeads {
-                    locals: BitSet<Local>,
+                // A local is "transient" if it is guaranteed dead at all `Return`.
+                // So first compute the say of "maybe live" locals at each program point.
+                let always_live_locals = &always_storage_live_locals(&ccx.body);
+                let maybe_storage_live = MaybeStorageLive::new(Cow::Borrowed(always_live_locals))
+                    .into_engine(ccx.tcx, &ccx.body)
+                    .iterate_to_fixpoint()
+                    .into_results_cursor(&ccx.body);
+
+                // And then check all `Return` in the MIR, and if a local is "maybe live" at a
+                // `Return` then it is definitely not transient.
+                struct TransientLocalVisitor<'a, 'tcx> {
+                    maybe_storage_live: ResultsCursor<'a, 'tcx, MaybeStorageLive<'a>>,
+                    transient: BitSet<Local>,
                 }
-                impl<'tcx> Visitor<'tcx> for StorageDeads {
-                    fn visit_statement(&mut self, stmt: &Statement<'tcx>, _: Location) {
-                        if let StatementKind::StorageDead(l) = stmt.kind {
-                            self.locals.insert(l);
+                impl<'a, 'tcx> Visitor<'tcx> for TransientLocalVisitor<'a, 'tcx> {
+                    fn visit_terminator(
+                        &mut self,
+                        terminator: &Terminator<'tcx>,
+                        location: Location,
+                    ) {
+                        if matches!(terminator.kind, TerminatorKind::Return) {
+                            self.maybe_storage_live.seek_after_primary_effect(location);
+                            for local in self.maybe_storage_live.get().iter() {
+                                // If a local may be live here, it is definitely not transient.
+                                self.transient.remove(local);
+                            }
                         }
                     }
                 }
-                let mut v = StorageDeads { locals: BitSet::new_empty(ccx.body.local_decls.len()) };
-                v.visit_body(ccx.body);
-                v.locals
+
+                let mut v = TransientLocalVisitor {
+                    maybe_storage_live,
+                    transient: BitSet::new_filled(ccx.body.local_decls.len()),
+                };
+                v.visit_body(&ccx.body);
+
+                v.transient
             })
             .contains(local)
     }
@@ -375,7 +403,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
                 // `StorageDead` in every control flow path leading to a `return` terminator.
                 // The good news is that interning will detect if any unexpected mutable
                 // pointer slips through.
-                if place.is_indirect() || self.local_has_storage_dead(place.local) {
+                if place.is_indirect() || self.local_is_transient(place.local) {
                     self.check_op(ops::TransientMutBorrow(kind));
                 } else {
                     self.check_op(ops::MutBorrow(kind));
@@ -526,7 +554,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                             // `StorageDead` in every control flow path leading to a `return` terminator.
                             // The good news is that interning will detect if any unexpected mutable
                             // pointer slips through.
-                            if self.local_has_storage_dead(place.local) {
+                            if self.local_is_transient(place.local) {
                                 self.check_op(ops::TransientCellBorrow);
                             } else {
                                 self.check_op(ops::CellBorrow);

From 53ce92770d0b1005cfc07cc8f14011339e2abc26 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Fri, 23 Aug 2024 01:12:57 +0300
Subject: [PATCH 564/685] Fix `elided_named_lifetimes` in code

---
 compiler/rustc_codegen_ssa/src/back/archive.rs            | 2 +-
 compiler/rustc_errors/src/markdown/parse.rs               | 2 +-
 compiler/rustc_errors/src/translation.rs                  | 2 +-
 compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs | 2 +-
 compiler/rustc_hir_typeck/src/coercion.rs                 | 2 +-
 compiler/rustc_hir_typeck/src/lib.rs                      | 7 +++++--
 compiler/rustc_interface/src/queries.rs                   | 2 +-
 compiler/rustc_metadata/src/rmeta/decoder.rs              | 2 +-
 compiler/rustc_middle/src/ty/generics.rs                  | 2 +-
 compiler/rustc_mir_build/src/errors.rs                    | 2 +-
 compiler/rustc_ty_utils/src/needs_drop.rs                 | 2 +-
 src/librustdoc/passes/collect_intra_doc_links.rs          | 2 +-
 src/tools/clippy/clippy_lints/src/unused_io_amount.rs     | 2 +-
 src/tools/miri/src/concurrency/thread.rs                  | 2 +-
 14 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/compiler/rustc_codegen_ssa/src/back/archive.rs b/compiler/rustc_codegen_ssa/src/back/archive.rs
index c8c1bd3e8f9c3..76a94de54339c 100644
--- a/compiler/rustc_codegen_ssa/src/back/archive.rs
+++ b/compiler/rustc_codegen_ssa/src/back/archive.rs
@@ -125,7 +125,7 @@ pub trait ArchiveBuilderBuilder {
         rlib: &'a Path,
         outdir: &Path,
         bundled_lib_file_names: &FxIndexSet<Symbol>,
-    ) -> Result<(), ExtractBundledLibsError<'_>> {
+    ) -> Result<(), ExtractBundledLibsError<'a>> {
         let archive_map = unsafe {
             Mmap::map(
                 File::open(rlib)
diff --git a/compiler/rustc_errors/src/markdown/parse.rs b/compiler/rustc_errors/src/markdown/parse.rs
index c44f136120a74..46f8959b6f246 100644
--- a/compiler/rustc_errors/src/markdown/parse.rs
+++ b/compiler/rustc_errors/src/markdown/parse.rs
@@ -80,7 +80,7 @@ pub fn entrypoint(txt: &str) -> MdStream<'_> {
 }
 
 /// Parse a buffer with specified context
-fn parse_recursive<'a>(buf: &'a [u8], ctx: Context) -> MdStream<'_> {
+fn parse_recursive<'a>(buf: &'a [u8], ctx: Context) -> MdStream<'a> {
     use ParseOpt as Po;
     use Prev::{Escape, Newline, Whitespace};
 
diff --git a/compiler/rustc_errors/src/translation.rs b/compiler/rustc_errors/src/translation.rs
index a44e794ee12ce..e0b64b276ebc6 100644
--- a/compiler/rustc_errors/src/translation.rs
+++ b/compiler/rustc_errors/src/translation.rs
@@ -59,7 +59,7 @@ pub trait Translate {
         &'a self,
         message: &'a DiagMessage,
         args: &'a FluentArgs<'_>,
-    ) -> Result<Cow<'_, str>, TranslateError<'_>> {
+    ) -> Result<Cow<'a, str>, TranslateError<'a>> {
         trace!(?message, ?args);
         let (identifier, attr) = match message {
             DiagMessage::Str(msg) | DiagMessage::Translated(msg) => {
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs b/compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs
index d1048b742a07b..c8b0f03a9290c 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of/opaque.rs
@@ -331,7 +331,7 @@ pub(super) fn find_opaque_ty_constraints_for_rpit<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
     owner_def_id: LocalDefId,
-) -> Ty<'_> {
+) -> Ty<'tcx> {
     let tables = tcx.typeck(owner_def_id);
 
     // Check that all of the opaques we inferred during HIR are compatible.
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 9b34c59f1f1b7..b47d8a97bceea 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -106,7 +106,7 @@ fn identity(_: Ty<'_>) -> Vec<Adjustment<'_>> {
     vec![]
 }
 
-fn simple<'tcx>(kind: Adjust<'tcx>) -> impl FnOnce(Ty<'tcx>) -> Vec<Adjustment<'_>> {
+fn simple<'tcx>(kind: Adjust<'tcx>) -> impl FnOnce(Ty<'tcx>) -> Vec<Adjustment<'tcx>> {
     move |target| vec![Adjustment { kind, target }]
 }
 
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 9ec101196a43f..8ff4c11f24a83 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -87,14 +87,17 @@ fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &UnordSet<LocalDef
     &tcx.typeck(def_id).used_trait_imports
 }
 
-fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckResults<'tcx> {
+fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx ty::TypeckResults<'tcx> {
     let fallback = move || tcx.type_of(def_id.to_def_id()).instantiate_identity();
     typeck_with_fallback(tcx, def_id, fallback, None)
 }
 
 /// Used only to get `TypeckResults` for type inference during error recovery.
 /// Currently only used for type inference of `static`s and `const`s to avoid type cycle errors.
-fn diagnostic_only_typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckResults<'tcx> {
+fn diagnostic_only_typeck<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    def_id: LocalDefId,
+) -> &'tcx ty::TypeckResults<'tcx> {
     let fallback = move || {
         let span = tcx.hir().span(tcx.local_def_id_to_hir_id(def_id));
         Ty::new_error_with_message(tcx, span, "diagnostic only typeck table used")
diff --git a/compiler/rustc_interface/src/queries.rs b/compiler/rustc_interface/src/queries.rs
index c5d56c15c6e2e..44e07b36b616b 100644
--- a/compiler/rustc_interface/src/queries.rs
+++ b/compiler/rustc_interface/src/queries.rs
@@ -98,7 +98,7 @@ impl<'tcx> Queries<'tcx> {
         self.parse.compute(|| passes::parse(&self.compiler.sess))
     }
 
-    pub fn global_ctxt(&'tcx self) -> Result<QueryResult<'_, &'tcx GlobalCtxt<'tcx>>> {
+    pub fn global_ctxt(&'tcx self) -> Result<QueryResult<'tcx, &'tcx GlobalCtxt<'tcx>>> {
         self.gcx.compute(|| {
             let krate = self.parse()?.steal();
 
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index 8c0ea3eaea913..a13eac08c9fd2 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -1487,7 +1487,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
             .decode((self, sess))
     }
 
-    fn get_foreign_modules(self, sess: &'a Session) -> impl Iterator<Item = ForeignModule> + '_ {
+    fn get_foreign_modules(self, sess: &'a Session) -> impl Iterator<Item = ForeignModule> + 'a {
         self.root.foreign_modules.decode((self, sess))
     }
 
diff --git a/compiler/rustc_middle/src/ty/generics.rs b/compiler/rustc_middle/src/ty/generics.rs
index 8cb8e9af11cf9..bbc696e0f0814 100644
--- a/compiler/rustc_middle/src/ty/generics.rs
+++ b/compiler/rustc_middle/src/ty/generics.rs
@@ -269,7 +269,7 @@ impl<'tcx> Generics {
     }
 
     /// Returns the `GenericParamDef` associated with this `ParamConst`.
-    pub fn const_param(&'tcx self, param: ParamConst, tcx: TyCtxt<'tcx>) -> &GenericParamDef {
+    pub fn const_param(&'tcx self, param: ParamConst, tcx: TyCtxt<'tcx>) -> &'tcx GenericParamDef {
         let param = self.param_at(param.index as usize, tcx);
         match param.kind {
             GenericParamDefKind::Const { .. } => param,
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index 843ac2eb240ad..7f9eefd1d52e3 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -493,7 +493,7 @@ pub(crate) struct NonExhaustivePatternsTypeNotEmpty<'p, 'tcx, 'm> {
 }
 
 impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for NonExhaustivePatternsTypeNotEmpty<'_, '_, '_> {
-    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'_, G> {
+    fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, G> {
         let mut diag =
             Diag::new(dcx, level, fluent::mir_build_non_exhaustive_patterns_type_not_empty);
         diag.span(self.scrut_span);
diff --git a/compiler/rustc_ty_utils/src/needs_drop.rs b/compiler/rustc_ty_utils/src/needs_drop.rs
index d274a934d5297..9a3956596d23f 100644
--- a/compiler/rustc_ty_utils/src/needs_drop.rs
+++ b/compiler/rustc_ty_utils/src/needs_drop.rs
@@ -366,7 +366,7 @@ fn adt_consider_insignificant_dtor<'tcx>(
 fn adt_drop_tys<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: DefId,
-) -> Result<&ty::List<Ty<'tcx>>, AlwaysRequiresDrop> {
+) -> Result<&'tcx ty::List<Ty<'tcx>>, AlwaysRequiresDrop> {
     // This is for the "adt_drop_tys" query, that considers all `Drop` impls, therefore all dtors are
     // significant.
     let adt_has_dtor =
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 5b96529fed70d..ab03f620230bd 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -53,7 +53,7 @@ fn filter_assoc_items_by_name_and_namespace<'a>(
     assoc_items_of: DefId,
     ident: Ident,
     ns: Namespace,
-) -> impl Iterator<Item = &ty::AssocItem> + 'a {
+) -> impl Iterator<Item = &'a ty::AssocItem> + 'a {
     tcx.associated_items(assoc_items_of).filter_by_name_unhygienic(ident.name).filter(move |item| {
         item.kind.namespace() == ns && tcx.hygienic_eq(ident, item.ident(tcx), assoc_items_of)
     })
diff --git a/src/tools/clippy/clippy_lints/src/unused_io_amount.rs b/src/tools/clippy/clippy_lints/src/unused_io_amount.rs
index 448946bd66d51..c6ca17175e213 100644
--- a/src/tools/clippy/clippy_lints/src/unused_io_amount.rs
+++ b/src/tools/clippy/clippy_lints/src/unused_io_amount.rs
@@ -235,7 +235,7 @@ fn unpack_match<'a>(mut expr: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
 
 /// If `expr` is an (e).await, return the inner expression "e" that's being
 /// waited on.  Otherwise return None.
-fn unpack_await<'a>(expr: &'a hir::Expr<'a>) -> &hir::Expr<'a> {
+fn unpack_await<'a>(expr: &'a hir::Expr<'a>) -> &'a hir::Expr<'a> {
     if let ExprKind::Match(expr, _, hir::MatchSource::AwaitDesugar) = expr.kind {
         if let ExprKind::Call(func, [ref arg_0, ..]) = expr.kind {
             if matches!(
diff --git a/src/tools/miri/src/concurrency/thread.rs b/src/tools/miri/src/concurrency/thread.rs
index f72591f0c4bdf..a4d3e3f7af3ce 100644
--- a/src/tools/miri/src/concurrency/thread.rs
+++ b/src/tools/miri/src/concurrency/thread.rs
@@ -1157,7 +1157,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
     }
 
     #[inline]
-    fn get_thread_name<'c>(&'c self, thread: ThreadId) -> Option<&[u8]>
+    fn get_thread_name<'c>(&'c self, thread: ThreadId) -> Option<&'c [u8]>
     where
         'tcx: 'c,
     {

From c36b5634cfde381fda497f71602158ce2c27ae5e Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sat, 24 Aug 2024 18:34:28 +0200
Subject: [PATCH 565/685] Update minifier to 0.3.1

---
 Cargo.lock                | 7 +++++--
 src/librustdoc/Cargo.toml | 2 +-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f2e2baea8e47c..724d7a0ed5512 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2230,9 +2230,12 @@ dependencies = [
 
 [[package]]
 name = "minifier"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95bbbf96b9ac3482c2a25450b67a15ed851319bc5fabf3b40742ea9066e84282"
+checksum = "9aa3f302fe0f8de065d4a2d1ed64f60204623cac58b80cd3c2a83a25d5a7d437"
+dependencies = [
+ "clap",
+]
 
 [[package]]
 name = "minimal-lexical"
diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index b3fccbf6456e0..34332de80b365 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -12,7 +12,7 @@ rinja = { version = "0.3", default-features = false, features = ["config"] }
 base64 = "0.21.7"
 itertools = "0.12"
 indexmap = "2"
-minifier = "0.3.0"
+minifier = "0.3.1"
 pulldown-cmark-old = { version = "0.9.6", package = "pulldown-cmark", default-features = false }
 regex = "1"
 rustdoc-json-types = { path = "../rustdoc-json-types" }

From 027c47983ee161f3346e6be39c14cfc33d03e169 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sat, 24 Aug 2024 12:35:35 -0400
Subject: [PATCH 566/685] update the doc comment on lintchecker b/c it parses
 html now

---
 src/tools/linkchecker/main.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/tools/linkchecker/main.rs b/src/tools/linkchecker/main.rs
index 72448c1180a97..fa77ab1e011cd 100644
--- a/src/tools/linkchecker/main.rs
+++ b/src/tools/linkchecker/main.rs
@@ -6,8 +6,10 @@
 //! script is to check all relative links in our documentation to make sure they
 //! actually point to a valid place.
 //!
-//! Currently this doesn't actually do any HTML parsing or anything fancy like
-//! that, it just has a simple "regex" to search for `href` and `id` tags.
+//! Currently uses a combination of HTML parsing to
+//! extract the `href` and `id` attributes,
+//! and regex search on the orignal markdown to handle intra-doc links.
+//!
 //! These values are then translated to file URLs if possible and then the
 //! destination is asserted to exist.
 //!

From bb17fda3845bda0da7bcdcf28cd17e4823e58c9d Mon Sep 17 00:00:00 2001
From: Camille GILLOT <gillot.camille@gmail.com>
Date: Wed, 3 Jul 2024 07:01:50 +0000
Subject: [PATCH 567/685] Do not call source_span when not tracking
 dependencies.

---
 compiler/rustc_interface/src/callbacks.rs | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_interface/src/callbacks.rs b/compiler/rustc_interface/src/callbacks.rs
index 786e2bb511ffd..f66b9eb3a2856 100644
--- a/compiler/rustc_interface/src/callbacks.rs
+++ b/compiler/rustc_interface/src/callbacks.rs
@@ -18,11 +18,19 @@ use rustc_query_system::dep_graph::dep_node::default_dep_kind_debug;
 use rustc_query_system::dep_graph::{DepContext, DepKind, DepNode};
 
 fn track_span_parent(def_id: rustc_span::def_id::LocalDefId) {
-    tls::with_opt(|tcx| {
-        if let Some(tcx) = tcx {
-            let _span = tcx.source_span(def_id);
-            // Sanity check: relative span's parent must be an absolute span.
-            debug_assert_eq!(_span.data_untracked().parent, None);
+    tls::with_context_opt(|icx| {
+        if let Some(icx) = icx {
+            // `track_span_parent` gets called a lot from HIR lowering code.
+            // Skip doing anything if we aren't tracking dependencies.
+            let tracks_deps = match icx.task_deps {
+                TaskDepsRef::Allow(..) => true,
+                TaskDepsRef::EvalAlways | TaskDepsRef::Ignore | TaskDepsRef::Forbid => false,
+            };
+            if tracks_deps {
+                let _span = icx.tcx.source_span(def_id);
+                // Sanity check: relative span's parent must be an absolute span.
+                debug_assert_eq!(_span.data_untracked().parent, None);
+            }
         }
     })
 }

From 147bb17f51b521269929f348b4b2a27afad8a273 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 24 Aug 2024 14:55:31 -0400
Subject: [PATCH 568/685] Rework how we emit errors for unresolved object
 lifetimes

---
 compiler/rustc_hir_analysis/src/collect.rs    |  2 +-
 .../src/hir_ty_lowering/mod.rs                |  7 ++--
 .../src/hir_ty_lowering/object_safety.rs      | 32 ++++++++++++-------
 3 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index f75954c9edfb7..9e6c431a6e6a3 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -392,7 +392,7 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
     }
 
     fn re_infer(&self, span: Span, reason: RegionInferReason<'_>) -> ty::Region<'tcx> {
-        if let RegionInferReason::BorrowedObjectLifetimeDefault = reason {
+        if let RegionInferReason::ObjectLifetimeDefault = reason {
             let e = struct_span_code_err!(
                 self.dcx(),
                 span,
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 5c8ecf254a54e..73baa05bce660 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -85,10 +85,9 @@ pub enum PredicateFilter {
 
 #[derive(Debug)]
 pub enum RegionInferReason<'a> {
-    /// Lifetime on a trait object behind a reference.
-    /// This allows inferring information from the reference.
-    BorrowedObjectLifetimeDefault,
-    /// A trait object's lifetime.
+    /// Lifetime on a trait object that is spelled explicitly, e.g. `+ 'a` or `+ '_`.
+    ExplicitObjectLifetime,
+    /// A trait object's lifetime when it is elided, e.g. `dyn Any`.
     ObjectLifetimeDefault,
     /// Generic lifetime parameter
     Param(&'a ty::GenericParamDef),
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
index 31d1750f33dfd..082fbb2c41835 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
@@ -30,7 +30,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         hir_id: hir::HirId,
         hir_trait_bounds: &[(hir::PolyTraitRef<'tcx>, hir::TraitBoundModifier)],
         lifetime: &hir::Lifetime,
-        borrowed: bool,
+        _borrowed: bool,
         representation: DynKind,
     ) -> Ty<'tcx> {
         let tcx = self.tcx();
@@ -325,22 +325,32 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         v.dedup();
         let existential_predicates = tcx.mk_poly_existential_predicates(&v);
 
-        // Use explicitly-specified region bound.
+        // Use explicitly-specified region bound, unless the bound is missing.
         let region_bound = if !lifetime.is_elided() {
-            self.lower_lifetime(lifetime, RegionInferReason::ObjectLifetimeDefault)
+            self.lower_lifetime(lifetime, RegionInferReason::ExplicitObjectLifetime)
         } else {
             self.compute_object_lifetime_bound(span, existential_predicates).unwrap_or_else(|| {
+                // Curiously, we prefer object lifetime default for `+ '_`...
                 if tcx.named_bound_var(lifetime.hir_id).is_some() {
-                    self.lower_lifetime(lifetime, RegionInferReason::ObjectLifetimeDefault)
+                    self.lower_lifetime(lifetime, RegionInferReason::ExplicitObjectLifetime)
                 } else {
-                    self.re_infer(
-                        span,
-                        if borrowed {
-                            RegionInferReason::ObjectLifetimeDefault
+                    let reason =
+                        if let hir::LifetimeName::ImplicitObjectLifetimeDefault = lifetime.res {
+                            if let hir::Node::Ty(hir::Ty {
+                                kind: hir::TyKind::Ref(parent_lifetime, _),
+                                ..
+                            }) = tcx.parent_hir_node(hir_id)
+                                && tcx.named_bound_var(parent_lifetime.hir_id).is_none()
+                            {
+                                // Parent lifetime must have failed to resolve. Don't emit a redundant error.
+                                RegionInferReason::ExplicitObjectLifetime
+                            } else {
+                                RegionInferReason::ObjectLifetimeDefault
+                            }
                         } else {
-                            RegionInferReason::BorrowedObjectLifetimeDefault
-                        },
-                    )
+                            RegionInferReason::ExplicitObjectLifetime
+                        };
+                    self.re_infer(span, reason)
                 }
             })
         };

From b9033bdd92aa697dee77fa581c22d418b5bdf308 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sat, 24 Aug 2024 19:44:12 +0300
Subject: [PATCH 569/685] New `#[rustc_pub_transparent]` attribute

---
 compiler/rustc_feature/src/builtin_attrs.rs   |  5 ++++
 compiler/rustc_passes/messages.ftl            |  4 +++
 compiler/rustc_passes/src/check_attr.rs       | 13 ++++++++++
 compiler/rustc_passes/src/errors.rs           |  9 +++++++
 compiler/rustc_span/src/symbol.rs             |  1 +
 library/core/src/cell.rs                      |  3 +++
 library/core/src/mem/manually_drop.rs         |  1 +
 library/core/src/mem/maybe_uninit.rs          |  1 +
 library/core/src/pin.rs                       |  1 +
 tests/ui/attributes/rustc_pub_transparent.rs  | 25 +++++++++++++++++++
 .../attributes/rustc_pub_transparent.stderr   | 23 +++++++++++++++++
 11 files changed, 86 insertions(+)
 create mode 100644 tests/ui/attributes/rustc_pub_transparent.rs
 create mode 100644 tests/ui/attributes/rustc_pub_transparent.stderr

diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index d4c54b67f24d5..2747a14d60a5c 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -641,6 +641,11 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         ErrorFollowing, EncodeCrossCrate::Yes,
         "rustc_deprecated_safe_2024 is supposed to be used in libstd only",
     ),
+    rustc_attr!(
+        rustc_pub_transparent, Normal, template!(Word),
+        WarnFollowing, EncodeCrossCrate::Yes,
+        "used internally to mark types with a `transparent` representation when it is guaranteed by the documentation",
+    ),
 
 
     // ==========================================================================
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index dfc726efeb998..b377c9f52d640 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -657,6 +657,10 @@ passes_rustc_lint_opt_ty =
     `#[rustc_lint_opt_ty]` should be applied to a struct
     .label = not a struct
 
+passes_rustc_pub_transparent =
+    attribute should be applied to `#[repr(transparent)]` types
+    .label = not a `#[repr(transparent)]` type
+
 passes_rustc_safe_intrinsic =
     attribute should be applied to intrinsic functions
     .label = not an intrinsic function
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index c93fb5c23b1c4..9ca4bb09b3e17 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -245,6 +245,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     self.check_coroutine(attr, target);
                 }
                 [sym::linkage, ..] => self.check_linkage(attr, span, target),
+                [sym::rustc_pub_transparent, ..] => self.check_rustc_pub_transparent( attr.span, span, attrs),
                 [
                     // ok
                     sym::allow
@@ -2381,6 +2382,18 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
         }
     }
+
+    fn check_rustc_pub_transparent(&self, attr_span: Span, span: Span, attrs: &[Attribute]) {
+        if !attrs
+            .iter()
+            .filter(|attr| attr.has_name(sym::repr))
+            .filter_map(|attr| attr.meta_item_list())
+            .flatten()
+            .any(|nmi| nmi.has_name(sym::transparent))
+        {
+            self.dcx().emit_err(errors::RustcPubTransparent { span, attr_span });
+        }
+    }
 }
 
 impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 1190e60f41f18..f6a57b7d0982d 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -622,6 +622,15 @@ pub struct RustcStdInternalSymbol {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_rustc_pub_transparent)]
+pub struct RustcPubTransparent {
+    #[primary_span]
+    pub attr_span: Span,
+    #[label]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_link_ordinal)]
 pub struct LinkOrdinal {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index a2e94492f8c23..491d31b387cf8 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1672,6 +1672,7 @@ symbols! {
         rustc_private,
         rustc_proc_macro_decls,
         rustc_promotable,
+        rustc_pub_transparent,
         rustc_reallocator,
         rustc_regions,
         rustc_reservation_impl,
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index d860f3415d982..5dd9721d3fee8 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -306,6 +306,7 @@ pub use once::OnceCell;
 /// See the [module-level documentation](self) for more.
 #[stable(feature = "rust1", since = "1.0.0")]
 #[repr(transparent)]
+#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
 pub struct Cell<T: ?Sized> {
     value: UnsafeCell<T>,
 }
@@ -2055,6 +2056,7 @@ impl<T: ?Sized + fmt::Display> fmt::Display for RefMut<'_, T> {
 #[lang = "unsafe_cell"]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[repr(transparent)]
+#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
 pub struct UnsafeCell<T: ?Sized> {
     value: T,
 }
@@ -2297,6 +2299,7 @@ impl<T> UnsafeCell<*mut T> {
 /// See [`UnsafeCell`] for details.
 #[unstable(feature = "sync_unsafe_cell", issue = "95439")]
 #[repr(transparent)]
+#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
 pub struct SyncUnsafeCell<T: ?Sized> {
     value: UnsafeCell<T>,
 }
diff --git a/library/core/src/mem/manually_drop.rs b/library/core/src/mem/manually_drop.rs
index 00c837041b697..be5cee2e85267 100644
--- a/library/core/src/mem/manually_drop.rs
+++ b/library/core/src/mem/manually_drop.rs
@@ -47,6 +47,7 @@ use crate::ptr;
 #[lang = "manually_drop"]
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]
+#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
 pub struct ManuallyDrop<T: ?Sized> {
     value: T,
 }
diff --git a/library/core/src/mem/maybe_uninit.rs b/library/core/src/mem/maybe_uninit.rs
index f920ab1792daf..c308def2f574a 100644
--- a/library/core/src/mem/maybe_uninit.rs
+++ b/library/core/src/mem/maybe_uninit.rs
@@ -237,6 +237,7 @@ use crate::{fmt, intrinsics, ptr, slice};
 #[lang = "maybe_uninit"]
 #[derive(Copy)]
 #[repr(transparent)]
+#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
 pub union MaybeUninit<T> {
     uninit: (),
     value: ManuallyDrop<T>,
diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 0569b8b762433..580e214e98b68 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1084,6 +1084,7 @@ use crate::{cmp, fmt};
 #[lang = "pin"]
 #[fundamental]
 #[repr(transparent)]
+#[cfg_attr(not(bootstrap), rustc_pub_transparent)]
 #[derive(Copy, Clone)]
 pub struct Pin<Ptr> {
     // FIXME(#93176): this field is made `#[unstable] #[doc(hidden)] pub` to:
diff --git a/tests/ui/attributes/rustc_pub_transparent.rs b/tests/ui/attributes/rustc_pub_transparent.rs
new file mode 100644
index 0000000000000..4508fa39baf8b
--- /dev/null
+++ b/tests/ui/attributes/rustc_pub_transparent.rs
@@ -0,0 +1,25 @@
+#![feature(rustc_attrs, transparent_unions)]
+
+#[rustc_pub_transparent]
+#[repr(transparent)]
+union E<T: Copy> {
+    value: T,
+    uninit: (),
+}
+
+#[repr(transparent)]
+#[rustc_pub_transparent]
+struct S<T>(T);
+
+#[rustc_pub_transparent] //~ ERROR attribute should be applied to `#[repr(transparent)]` types
+#[repr(C)]
+struct S1 {
+    A: u8,
+}
+
+#[rustc_pub_transparent] //~ ERROR attribute should be applied to `#[repr(transparent)]` types
+struct S2<T> {
+    value: T,
+}
+
+fn main() {}
diff --git a/tests/ui/attributes/rustc_pub_transparent.stderr b/tests/ui/attributes/rustc_pub_transparent.stderr
new file mode 100644
index 0000000000000..1d1f9437cb2c1
--- /dev/null
+++ b/tests/ui/attributes/rustc_pub_transparent.stderr
@@ -0,0 +1,23 @@
+error: attribute should be applied to `#[repr(transparent)]` types
+  --> $DIR/rustc_pub_transparent.rs:14:1
+   |
+LL |   #[rustc_pub_transparent]
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^
+LL |   #[repr(C)]
+LL | / struct S1 {
+LL | |     A: u8,
+LL | | }
+   | |_- not a `#[repr(transparent)]` type
+
+error: attribute should be applied to `#[repr(transparent)]` types
+  --> $DIR/rustc_pub_transparent.rs:20:1
+   |
+LL |   #[rustc_pub_transparent]
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^
+LL | / struct S2<T> {
+LL | |     value: T,
+LL | | }
+   | |_- not a `#[repr(transparent)]` type
+
+error: aborting due to 2 previous errors
+

From 06f2d73b2bd6f290a72d8041c957a08b3f6d50c7 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sat, 24 Aug 2024 20:39:26 +0300
Subject: [PATCH 570/685] repr_transparent_external_private_fields: treat
 `rustc_pub_transparent` types as local

---
 .../rustc_hir_analysis/src/check/check.rs     |  3 ++-
 ...ent-non-exhaustive-transparent-in-prose.rs | 25 +++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)
 create mode 100644 tests/ui/repr/repr-transparent-non-exhaustive-transparent-in-prose.rs

diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 14c5f8d9f16da..728c3790098e7 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -1259,7 +1259,8 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, adt: ty::AdtDef<'tcx>)
                 ty::Tuple(list) => list.iter().try_for_each(|t| check_non_exhaustive(tcx, t)),
                 ty::Array(ty, _) => check_non_exhaustive(tcx, *ty),
                 ty::Adt(def, args) => {
-                    if !def.did().is_local() {
+                    if !def.did().is_local() && !tcx.has_attr(def.did(), sym::rustc_pub_transparent)
+                    {
                         let non_exhaustive = def.is_variant_list_non_exhaustive()
                             || def
                                 .variants()
diff --git a/tests/ui/repr/repr-transparent-non-exhaustive-transparent-in-prose.rs b/tests/ui/repr/repr-transparent-non-exhaustive-transparent-in-prose.rs
new file mode 100644
index 0000000000000..6ab34719f0664
--- /dev/null
+++ b/tests/ui/repr/repr-transparent-non-exhaustive-transparent-in-prose.rs
@@ -0,0 +1,25 @@
+//@ check-pass
+
+#![feature(sync_unsafe_cell)]
+#![allow(unused)]
+#![deny(repr_transparent_external_private_fields)]
+
+// https://github.com/rust-lang/rust/issues/129470
+
+struct ZST;
+
+#[repr(transparent)]
+struct TransparentWithManuallyDropZST {
+    value: i32,
+    md: std::mem::ManuallyDrop<ZST>,
+    mu: std::mem::MaybeUninit<ZST>,
+    p: std::pin::Pin<ZST>,
+    pd: std::marker::PhantomData<ZST>,
+    pp: std::marker::PhantomPinned,
+    c: std::cell::Cell<ZST>,
+    uc: std::cell::UnsafeCell<ZST>,
+    suc: std::cell::SyncUnsafeCell<ZST>,
+    zst: ZST,
+}
+
+fn main() {}

From 0196e2d1dc50e43c6ae6132690e30d355ca56d67 Mon Sep 17 00:00:00 2001
From: Jason Newcomb <jsnewcomb@pm.me>
Date: Sat, 24 Aug 2024 16:31:55 -0400
Subject: [PATCH 571/685] Bump nightly version -> 2024-08-23

---
 rust-toolchain | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust-toolchain b/rust-toolchain
index 5fbe4e544a9e4..0be2e81810ebe 100644
--- a/rust-toolchain
+++ b/rust-toolchain
@@ -1,4 +1,4 @@
 [toolchain]
-channel = "nightly-2024-08-08"
+channel = "nightly-2024-08-23"
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"

From 300da9a910adda194898ee11c4f044956ee04563 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sat, 24 Aug 2024 20:36:56 +0000
Subject: [PATCH 572/685] only use rustc attr on nightly

---
 compiler/rustc_type_ir/src/search_graph/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index d47c9e725f350..418139c3aadc0 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -287,7 +287,7 @@ impl<X: Cx> NestedGoals<X> {
         }
     }
 
-    #[rustc_lint_query_instability]
+    #[cfg_attr(feature = "nightly", rustc_lint_query_instability)]
     #[allow(rustc::potential_query_instability)]
     fn iter(&self) -> impl Iterator<Item = (X::Input, UsageKind)> + '_ {
         self.nested_goals.iter().map(|(i, p)| (*i, *p))

From 3e2763a2155d9a11ed6aaed4e813f782dc53b095 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sat, 24 Aug 2024 20:38:11 +0000
Subject: [PATCH 573/685] add missing associated item

---
 compiler/rustc_type_ir/src/outlives.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/compiler/rustc_type_ir/src/outlives.rs b/compiler/rustc_type_ir/src/outlives.rs
index bfcea6a81d313..e8afaf1a4809a 100644
--- a/compiler/rustc_type_ir/src/outlives.rs
+++ b/compiler/rustc_type_ir/src/outlives.rs
@@ -68,6 +68,9 @@ struct OutlivesCollector<'a, I: Interner> {
 }
 
 impl<I: Interner> TypeVisitor<I> for OutlivesCollector<'_, I> {
+    #[cfg(not(feature = "nightly"))]
+    type Result = ();
+
     fn visit_ty(&mut self, ty: I::Ty) -> Self::Result {
         if !self.visited.insert(ty) {
             return;

From ad855fe6db641755c528fb5b1cc0308f3a4bf607 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sat, 24 Aug 2024 20:39:04 +0000
Subject: [PATCH 574/685] this needs the type for some reason

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

diff --git a/compiler/rustc_type_ir/src/elaborate.rs b/compiler/rustc_type_ir/src/elaborate.rs
index f30419c801f18..433c444e701cc 100644
--- a/compiler/rustc_type_ir/src/elaborate.rs
+++ b/compiler/rustc_type_ir/src/elaborate.rs
@@ -237,7 +237,7 @@ pub fn supertrait_def_ids<I: Interner>(
     cx: I,
     trait_def_id: I::DefId,
 ) -> impl Iterator<Item = I::DefId> {
-    let mut set = HashSet::default();
+    let mut set: HashSet<I::DefId> = HashSet::default();
     let mut stack = vec![trait_def_id];
 
     set.insert(trait_def_id);

From 902264b1a6c3d782df3242440cc6c5b866f982d0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sat, 24 Aug 2024 20:40:02 +0000
Subject: [PATCH 575/685] allow cfg(bootstrap) to avoid check-cfg warning on
 stable

---
 compiler/rustc_type_ir/Cargo.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/compiler/rustc_type_ir/Cargo.toml b/compiler/rustc_type_ir/Cargo.toml
index 2750838bbe99f..785fa5e386ae0 100644
--- a/compiler/rustc_type_ir/Cargo.toml
+++ b/compiler/rustc_type_ir/Cargo.toml
@@ -31,3 +31,6 @@ nightly = [
     "rustc_index/nightly",
     "rustc_ast_ir/nightly"
 ]
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bootstrap)'] }

From 6df0ccf49e7311ef0f81298edf0b77cd204c1ba3 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Sat, 24 Aug 2024 13:56:56 -0700
Subject: [PATCH 576/685] rustdoc: clean up tuple <-> primitive conversion docs

This adds a minor missing feature to `fake_variadic`,
so that it can render `impl From<(T,)> for [T; 1]` correctly.
---
 compiler/rustc_passes/src/check_attr.rs   |  10 ++
 library/core/src/tuple.rs                 |  36 ++++---
 src/librustdoc/html/format.rs             | 114 ++++++++++++++--------
 tests/rustdoc/primitive-tuple-variadic.rs |  17 ++++
 4 files changed, 122 insertions(+), 55 deletions(-)

diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index c93fb5c23b1c4..ffa406133cc43 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -951,6 +951,16 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         bare_fn_ty.decl.inputs.len() == 1
                     } else {
                         false
+                    }
+                    || if let Some(&[hir::GenericArg::Type(ty)]) = i
+                        .of_trait
+                        .as_ref()
+                        .and_then(|trait_ref| trait_ref.path.segments.last())
+                        .map(|last_segment| last_segment.args().args)
+                    {
+                        matches!(&ty.kind, hir::TyKind::Tup([_]))
+                    } else {
+                        false
                     };
                 if !is_valid {
                     self.dcx().emit_err(errors::DocFakeVariadicNotValid { span: meta.span() });
diff --git a/library/core/src/tuple.rs b/library/core/src/tuple.rs
index 65d4d5cf2ce41..9ec92e2845034 100644
--- a/library/core/src/tuple.rs
+++ b/library/core/src/tuple.rs
@@ -122,23 +122,29 @@ macro_rules! tuple_impls {
             }
         }
 
-        #[stable(feature = "array_tuple_conv", since = "1.71.0")]
-        impl<T> From<[T; ${count($T)}]> for ($(${ignore($T)} T,)+) {
-            #[inline]
-            #[allow(non_snake_case)]
-            fn from(array: [T; ${count($T)}]) -> Self {
-                let [$($T,)+] = array;
-                ($($T,)+)
+        maybe_tuple_doc! {
+            $($T)+ @
+            #[stable(feature = "array_tuple_conv", since = "1.71.0")]
+            impl<T> From<[T; ${count($T)}]> for ($(${ignore($T)} T,)+) {
+                #[inline]
+                #[allow(non_snake_case)]
+                fn from(array: [T; ${count($T)}]) -> Self {
+                    let [$($T,)+] = array;
+                    ($($T,)+)
+                }
             }
         }
 
-        #[stable(feature = "array_tuple_conv", since = "1.71.0")]
-        impl<T> From<($(${ignore($T)} T,)+)> for [T; ${count($T)}] {
-            #[inline]
-            #[allow(non_snake_case)]
-            fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
-                let ($($T,)+) = tuple;
-                [$($T,)+]
+        maybe_tuple_doc! {
+            $($T)+ @
+            #[stable(feature = "array_tuple_conv", since = "1.71.0")]
+            impl<T> From<($(${ignore($T)} T,)+)> for [T; ${count($T)}] {
+                #[inline]
+                #[allow(non_snake_case)]
+                fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
+                    let ($($T,)+) = tuple;
+                    [$($T,)+]
+                }
             }
         }
     }
@@ -148,7 +154,7 @@ macro_rules! tuple_impls {
 // Otherwise, it hides the docs entirely.
 macro_rules! maybe_tuple_doc {
     ($a:ident @ #[$meta:meta] $item:item) => {
-        #[doc(fake_variadic)]
+        #[cfg_attr(not(bootstrap), doc(fake_variadic))]
         #[doc = "This trait is implemented for tuples up to twelve items long."]
         #[$meta]
         $item
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 6357cfee141fd..5cbf8c5e19f45 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -1288,56 +1288,90 @@ impl clean::Impl {
                 if self.is_negative_trait_impl() {
                     write!(f, "!")?;
                 }
-                ty.print(cx).fmt(f)?;
+                if self.kind.is_fake_variadic()
+                    && let generics = ty.generics()
+                    && let &[inner_type] = generics.as_ref().map_or(&[][..], |v| &v[..])
+                {
+                    let last = ty.last();
+                    if f.alternate() {
+                        write!(f, "{}<", last)?;
+                        self.print_type(inner_type, f, use_absolute, cx)?;
+                        write!(f, ">")?;
+                    } else {
+                        write!(f, "{}&lt;", anchor(ty.def_id(), last, cx).to_string())?;
+                        self.print_type(inner_type, f, use_absolute, cx)?;
+                        write!(f, "&gt;")?;
+                    }
+                } else {
+                    ty.print(cx).fmt(f)?;
+                }
                 write!(f, " for ")?;
             }
 
-            if let clean::Type::Tuple(types) = &self.for_
-                && let [clean::Type::Generic(name)] = &types[..]
-                && (self.kind.is_fake_variadic() || self.kind.is_auto())
-            {
-                // Hardcoded anchor library/core/src/primitive_docs.rs
-                // Link should match `# Trait implementations`
-                primitive_link_fragment(
-                    f,
-                    PrimitiveType::Tuple,
-                    format_args!("({name}₁, {name}₂, …, {name}ₙ)"),
-                    "#trait-implementations-1",
-                    cx,
-                )?;
-            } else if let clean::BareFunction(bare_fn) = &self.for_
-                && let [clean::Argument { type_: clean::Type::Generic(name), .. }] =
-                    &bare_fn.decl.inputs.values[..]
-                && (self.kind.is_fake_variadic() || self.kind.is_auto())
-            {
-                // Hardcoded anchor library/core/src/primitive_docs.rs
-                // Link should match `# Trait implementations`
-
-                print_higher_ranked_params_with_space(&bare_fn.generic_params, cx).fmt(f)?;
-                bare_fn.safety.print_with_space().fmt(f)?;
-                print_abi_with_space(bare_fn.abi).fmt(f)?;
-                let ellipsis = if bare_fn.decl.c_variadic { ", ..." } else { "" };
-                primitive_link_fragment(
-                    f,
-                    PrimitiveType::Tuple,
-                    format_args!("fn({name}₁, {name}₂, …, {name}ₙ{ellipsis})"),
-                    "#trait-implementations-1",
-                    cx,
-                )?;
-                // Write output.
-                if !bare_fn.decl.output.is_unit() {
-                    write!(f, " -> ")?;
-                    fmt_type(&bare_fn.decl.output, f, use_absolute, cx)?;
-                }
-            } else if let Some(ty) = self.kind.as_blanket_ty() {
+            if let Some(ty) = self.kind.as_blanket_ty() {
                 fmt_type(ty, f, use_absolute, cx)?;
             } else {
-                fmt_type(&self.for_, f, use_absolute, cx)?;
+                self.print_type(&self.for_, f, use_absolute, cx)?;
             }
 
             print_where_clause(&self.generics, cx, 0, Ending::Newline).fmt(f)
         })
     }
+    fn print_type<'a, 'tcx: 'a>(
+        &self,
+        type_: &clean::Type,
+        f: &mut fmt::Formatter<'_>,
+        use_absolute: bool,
+        cx: &'a Context<'tcx>,
+    ) -> Result<(), fmt::Error> {
+        if let clean::Type::Tuple(types) = type_
+            && let [clean::Type::Generic(name)] = &types[..]
+            && (self.kind.is_fake_variadic() || self.kind.is_auto())
+        {
+            // Hardcoded anchor library/core/src/primitive_docs.rs
+            // Link should match `# Trait implementations`
+            primitive_link_fragment(
+                f,
+                PrimitiveType::Tuple,
+                format_args!("({name}₁, {name}₂, …, {name}ₙ)"),
+                "#trait-implementations-1",
+                cx,
+            )?;
+        } else if let clean::Type::Array(ty, len) = type_
+            && let clean::Type::Generic(name) = &**ty
+            && &len[..] == "1"
+            && (self.kind.is_fake_variadic() || self.kind.is_auto())
+        {
+            primitive_link(f, PrimitiveType::Array, format_args!("[{name}; N]"), cx)?;
+        } else if let clean::BareFunction(bare_fn) = &type_
+            && let [clean::Argument { type_: clean::Type::Generic(name), .. }] =
+                &bare_fn.decl.inputs.values[..]
+            && (self.kind.is_fake_variadic() || self.kind.is_auto())
+        {
+            // Hardcoded anchor library/core/src/primitive_docs.rs
+            // Link should match `# Trait implementations`
+
+            print_higher_ranked_params_with_space(&bare_fn.generic_params, cx).fmt(f)?;
+            bare_fn.safety.print_with_space().fmt(f)?;
+            print_abi_with_space(bare_fn.abi).fmt(f)?;
+            let ellipsis = if bare_fn.decl.c_variadic { ", ..." } else { "" };
+            primitive_link_fragment(
+                f,
+                PrimitiveType::Tuple,
+                format_args!("fn({name}₁, {name}₂, …, {name}ₙ{ellipsis})"),
+                "#trait-implementations-1",
+                cx,
+            )?;
+            // Write output.
+            if !bare_fn.decl.output.is_unit() {
+                write!(f, " -> ")?;
+                fmt_type(&bare_fn.decl.output, f, use_absolute, cx)?;
+            }
+        } else {
+            fmt_type(&type_, f, use_absolute, cx)?;
+        }
+        Ok(())
+    }
 }
 
 impl clean::Arguments {
diff --git a/tests/rustdoc/primitive-tuple-variadic.rs b/tests/rustdoc/primitive-tuple-variadic.rs
index 4b2fb786a8950..b15e996f929a9 100644
--- a/tests/rustdoc/primitive-tuple-variadic.rs
+++ b/tests/rustdoc/primitive-tuple-variadic.rs
@@ -16,3 +16,20 @@ pub trait Bar {}
 //@ has - '//section[@id="impl-Bar-for-(U,)"]/h3' 'impl<U: Foo> Bar for (U₁, U₂, …, Uₙ)'
 #[doc(fake_variadic)]
 impl<U: Foo> Bar for (U,) {}
+
+pub trait Baz<T> { fn baz(&self) -> T { todo!() } }
+
+//@ has foo/trait.Baz.html
+//@ has - '//section[@id="impl-Baz%3C(T,)%3E-for-%5BT;+1%5D"]/h3' 'impl<T> Baz<(T₁, T₂, …, Tₙ)> for [T; N]'
+#[doc(fake_variadic)]
+impl<T> Baz<(T,)> for [T; 1] {}
+
+//@ has foo/trait.Baz.html
+//@ has - '//section[@id="impl-Baz%3C%5BT;+1%5D%3E-for-(T,)"]/h3' 'impl<T> Baz<[T; N]> for (T₁, T₂, …, Tₙ)'
+#[doc(fake_variadic)]
+impl<T> Baz<[T; 1]> for (T,) {}
+
+//@ has foo/trait.Baz.html
+//@ has - '//section[@id="impl-Baz%3CT%3E-for-(T,)"]/h3' 'impl<T> Baz<T> for (T₁, T₂, …, Tₙ)'
+#[doc(fake_variadic)]
+impl<T> Baz<T> for (T,) {}

From 56adf87213b22ef848fb8afd3b8180c0455456d7 Mon Sep 17 00:00:00 2001
From: binarycat <binarycat@envs.net>
Date: Sat, 24 Aug 2024 12:41:40 -0400
Subject: [PATCH 577/685] rewrite extract_curl_version again

---
 src/bootstrap/src/core/download.rs | 25 +++++++++++--------------
 1 file changed, 11 insertions(+), 14 deletions(-)

diff --git a/src/bootstrap/src/core/download.rs b/src/bootstrap/src/core/download.rs
index fd6f17130ee91..b5c55854eff58 100644
--- a/src/bootstrap/src/core/download.rs
+++ b/src/bootstrap/src/core/download.rs
@@ -21,23 +21,20 @@ fn try_run(config: &Config, cmd: &mut Command) -> Result<(), ()> {
     config.try_run(cmd)
 }
 
-fn extract_curl_version(out: &[u8]) -> (u16, u16) {
-    let out = &out[5..];
-    let Some(i) = out.iter().position(|&x| x == b' ') else { return (0, 0) };
-    let out = &out[..i];
-    let Some(k) = out.iter().rev().position(|&x| x == b'.') else { return (0, 0) };
-    let out = &out[..out.len() - k - 1];
-    let Ok(s) = std::str::from_utf8(out) else { return (0, 0) };
-    let parts = s.split('.').collect::<Vec<_>>();
-    let [s_major, s_minor] = &parts[..] else { return (0, 0) };
-    let (Ok(major), Ok(minor)) = (s_major.parse(), s_minor.parse()) else { return (0, 0) };
-    (major, minor)
+fn extract_curl_version(out: &[u8]) -> semver::Version {
+    let out = String::from_utf8_lossy(out);
+    // The output should look like this: "curl <major>.<minor>.<patch> ..."
+    out.lines()
+        .next()
+        .and_then(|line| line.split(" ").nth(1))
+        .and_then(|version| semver::Version::parse(version).ok())
+        .unwrap_or(semver::Version::new(1, 0, 0))
 }
 
-fn curl_version() -> (u16, u16) {
+fn curl_version() -> semver::Version {
     let mut curl = Command::new("curl");
     curl.arg("-V");
-    let Ok(out) = curl.output() else { return (0, 0) };
+    let Ok(out) = curl.output() else { return semver::Version::new(1, 0, 0) };
     let out = out.stdout;
     extract_curl_version(&out)
 }
@@ -253,7 +250,7 @@ impl Config {
             curl.arg("--progress-bar");
         }
         // --retry-all-errors was added in 7.71.0, don't use it if curl is old.
-        if curl_version() > (7, 70) {
+        if curl_version() >= semver::Version::new(7, 71, 0) {
             curl.arg("--retry-all-errors");
         }
         curl.arg(url);

From ec67cdf98ac081e1392a324ec47a0543743f697e Mon Sep 17 00:00:00 2001
From: "rongfu.leng" <lenronfu@gmail.com>
Date: Thu, 27 Jun 2024 22:54:14 +0800
Subject: [PATCH 578/685] Enable f16 in assembly on aarch64 platforms that
 support it

Signed-off-by: rongfu.leng <lenronfu@gmail.com>
---
 compiler/rustc_target/src/asm/aarch64.rs |  6 ++---
 tests/assembly/asm/aarch64-types.rs      | 29 +++++++++++++++++++++++-
 tests/ui/asm/aarch64/type-check-3.stderr |  6 ++---
 tests/ui/asm/aarch64/type-f16.rs         | 21 +++++++++++++++++
 4 files changed, 55 insertions(+), 7 deletions(-)
 create mode 100644 tests/ui/asm/aarch64/type-f16.rs

diff --git a/compiler/rustc_target/src/asm/aarch64.rs b/compiler/rustc_target/src/asm/aarch64.rs
index 358efb4174df0..041582b7df97d 100644
--- a/compiler/rustc_target/src/asm/aarch64.rs
+++ b/compiler/rustc_target/src/asm/aarch64.rs
@@ -59,11 +59,11 @@ impl AArch64InlineAsmRegClass {
         _arch: InlineAsmArch,
     ) -> &'static [(InlineAsmType, Option<Symbol>)] {
         match self {
-            Self::reg => types! { _: I8, I16, I32, I64, F32, F64; },
+            Self::reg => types! { _: I8, I16, I32, I64, F16, F32, F64; },
             Self::vreg | Self::vreg_low16 => types! {
-                neon: I8, I16, I32, I64, F32, F64,
+                neon: I8, I16, I32, I64, F16, F32, F64,
                     VecI8(8), VecI16(4), VecI32(2), VecI64(1), VecF32(2), VecF64(1),
-                    VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF32(4), VecF64(2);
+                    VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(4),VecF16(8), VecF32(4), VecF64(2);
             },
             Self::preg => &[],
         }
diff --git a/tests/assembly/asm/aarch64-types.rs b/tests/assembly/asm/aarch64-types.rs
index 3e2a4773703a3..4b506f180d83e 100644
--- a/tests/assembly/asm/aarch64-types.rs
+++ b/tests/assembly/asm/aarch64-types.rs
@@ -5,7 +5,7 @@
 //@ [arm64ec] compile-flags: --target arm64ec-pc-windows-msvc
 //@ [arm64ec] needs-llvm-components: aarch64
 
-#![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_experimental_arch)]
+#![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_experimental_arch, f16)]
 #![crate_type = "rlib"]
 #![no_core]
 #![allow(asm_sub_register, non_camel_case_types)]
@@ -39,6 +39,10 @@ pub struct i32x2(i32, i32);
 #[repr(simd)]
 pub struct i64x1(i64);
 #[repr(simd)]
+pub struct f16x4(f16, f16, f16, f16);
+#[repr(simd)]
+pub struct f16x8(f16, f16, f16, f16, f16, f16, f16, f16);
+#[repr(simd)]
 pub struct f32x2(f32, f32);
 #[repr(simd)]
 pub struct f64x1(f64);
@@ -57,6 +61,7 @@ pub struct f64x2(f64, f64);
 
 impl Copy for i8 {}
 impl Copy for i16 {}
+impl Copy for f16 {}
 impl Copy for i32 {}
 impl Copy for f32 {}
 impl Copy for i64 {}
@@ -67,11 +72,13 @@ impl Copy for i16x4 {}
 impl Copy for i32x2 {}
 impl Copy for i64x1 {}
 impl Copy for f32x2 {}
+impl Copy for f16x4 {}
 impl Copy for f64x1 {}
 impl Copy for i8x16 {}
 impl Copy for i16x8 {}
 impl Copy for i32x4 {}
 impl Copy for i64x2 {}
+impl Copy for f16x8 {}
 impl Copy for f32x4 {}
 impl Copy for f64x2 {}
 
@@ -165,6 +172,12 @@ check!(reg_i16 i16 reg "mov" "");
 // CHECK: //NO_APP
 check!(reg_i32 i32 reg "mov" "");
 
+// CHECK-LABEL: reg_f16:
+// CHECK: @APP
+// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
+// CHECK: @NO_APP
+check!(reg_f16 f16 reg "mov");
+
 // CHECK-LABEL: {{("#)?}}reg_f32{{"?}}
 // CHECK: //APP
 // CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
@@ -255,6 +268,20 @@ check!(vreg_i32x2 i32x2 vreg "fmov" "s");
 // CHECK: //NO_APP
 check!(vreg_i64x1 i64x1 vreg "fmov" "s");
 
+// neon-LABEL: vreg_f16x4:
+// neon: @APP
+// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(vreg_f16x4 f16x4 vreg "vmov.f64");
+
+// neon-LABEL: vreg_f16x8:
+// neon: @APP
+// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
+// neon: @NO_APP
+#[cfg(neon)]
+check!(vreg_f16x8 f16x8 vreg "vmov");
+
 // CHECK-LABEL: {{("#)?}}vreg_f32x2{{"?}}
 // CHECK: //APP
 // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
diff --git a/tests/ui/asm/aarch64/type-check-3.stderr b/tests/ui/asm/aarch64/type-check-3.stderr
index 9e37bb4c203f5..4bd97b93867bb 100644
--- a/tests/ui/asm/aarch64/type-check-3.stderr
+++ b/tests/ui/asm/aarch64/type-check-3.stderr
@@ -95,7 +95,7 @@ error: type `i128` cannot be used with this register class
 LL |         asm!("{}", in(reg) 0i128);
    |                            ^^^^^
    |
-   = note: register class `reg` supports these types: i8, i16, i32, i64, f32, f64
+   = note: register class `reg` supports these types: i8, i16, i32, i64, f16, f32, f64
 
 error: type `float64x2_t` cannot be used with this register class
   --> $DIR/type-check-3.rs:75:28
@@ -103,7 +103,7 @@ error: type `float64x2_t` cannot be used with this register class
 LL |         asm!("{}", in(reg) f64x2);
    |                            ^^^^^
    |
-   = note: register class `reg` supports these types: i8, i16, i32, i64, f32, f64
+   = note: register class `reg` supports these types: i8, i16, i32, i64, f16, f32, f64
 
 error: type `Simd256bit` cannot be used with this register class
   --> $DIR/type-check-3.rs:77:29
@@ -111,7 +111,7 @@ error: type `Simd256bit` cannot be used with this register class
 LL |         asm!("{}", in(vreg) f64x4);
    |                             ^^^^^
    |
-   = note: register class `vreg` supports these types: i8, i16, i32, i64, f32, f64, i8x8, i16x4, i32x2, i64x1, f32x2, f64x1, i8x16, i16x8, i32x4, i64x2, f32x4, f64x2
+   = note: register class `vreg` supports these types: i8, i16, i32, i64, f16, f32, f64, i8x8, i16x4, i32x2, i64x1, f32x2, f64x1, i8x16, i16x8, i32x4, i64x2, f16x4, f16x8, f32x4, f64x2
 
 error: incompatible types for asm inout argument
   --> $DIR/type-check-3.rs:88:33
diff --git a/tests/ui/asm/aarch64/type-f16.rs b/tests/ui/asm/aarch64/type-f16.rs
new file mode 100644
index 0000000000000..763ea4684da37
--- /dev/null
+++ b/tests/ui/asm/aarch64/type-f16.rs
@@ -0,0 +1,21 @@
+//@ only-aarch64
+//@ run-pass
+
+#![feature(f16, f128)]
+use std::arch::asm;
+#[inline(never)]
+pub fn f32_to_f16_asm(a: f32) -> f16 {
+    let ret: f16;
+    unsafe {
+        asm!(
+        "fcvt    {ret:h}, {a:s}",
+        a = in(vreg) a,
+        ret = lateout(vreg) ret,
+        options(nomem, nostack),
+        );
+    }
+    ret
+}
+fn main() {
+    assert_eq!(f32_to_f16_asm(1.0 as f32), 1.0);
+}

From dbf06d21700aea3edf64875ab0e8573bf63c94e1 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 24 Aug 2024 17:53:42 -0400
Subject: [PATCH 579/685] Get rid of predicates_defined_on

---
 compiler/rustc_hir_analysis/src/collect.rs    | 31 +------------------
 .../src/collect/predicates_of.rs              | 25 ++++++++++++---
 compiler/rustc_middle/src/query/mod.rs        | 19 ------------
 .../bugs/cycle-iat-inside-of-adt.stderr       |  5 ---
 ...cycle-iat-inside-of-where-predicate.stderr |  5 ---
 5 files changed, 22 insertions(+), 63 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index f75954c9edfb7..6d092ccfdedc4 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -34,7 +34,7 @@ use rustc_infer::traits::ObligationCause;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::query::Providers;
 use rustc_middle::ty::util::{Discr, IntTypeExt};
-use rustc_middle::ty::{self, AdtKind, Const, IsSuggestable, Ty, TyCtxt, Upcast};
+use rustc_middle::ty::{self, AdtKind, Const, IsSuggestable, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{Span, DUMMY_SP};
@@ -70,7 +70,6 @@ pub fn provide(providers: &mut Providers) {
         impl_super_outlives: item_bounds::impl_super_outlives,
         generics_of: generics_of::generics_of,
         predicates_of: predicates_of::predicates_of,
-        predicates_defined_on,
         explicit_predicates_of: predicates_of::explicit_predicates_of,
         explicit_super_predicates_of: predicates_of::explicit_super_predicates_of,
         explicit_implied_predicates_of: predicates_of::explicit_implied_predicates_of,
@@ -1775,34 +1774,6 @@ fn early_bound_lifetimes_from_generics<'a, 'tcx: 'a>(
     })
 }
 
-/// Returns a list of type predicates for the definition with ID `def_id`, including inferred
-/// lifetime constraints. This includes all predicates returned by `explicit_predicates_of`, plus
-/// inferred constraints concerning which regions outlive other regions.
-#[instrument(level = "debug", skip(tcx))]
-fn predicates_defined_on(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicates<'_> {
-    let mut result = tcx.explicit_predicates_of(def_id);
-    debug!("predicates_defined_on: explicit_predicates_of({:?}) = {:?}", def_id, result);
-    let inferred_outlives = tcx.inferred_outlives_of(def_id);
-    if !inferred_outlives.is_empty() {
-        debug!(
-            "predicates_defined_on: inferred_outlives_of({:?}) = {:?}",
-            def_id, inferred_outlives,
-        );
-        let inferred_outlives_iter =
-            inferred_outlives.iter().map(|(clause, span)| ((*clause).upcast(tcx), *span));
-        if result.predicates.is_empty() {
-            result.predicates = tcx.arena.alloc_from_iter(inferred_outlives_iter);
-        } else {
-            result.predicates = tcx.arena.alloc_from_iter(
-                result.predicates.into_iter().copied().chain(inferred_outlives_iter),
-            );
-        }
-    }
-
-    debug!("predicates_defined_on({:?}) = {:?}", def_id, result);
-    result
-}
-
 fn compute_sig_of_foreign_fn_decl<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index 6ac4802b19514..bba8b0497be55 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -18,10 +18,26 @@ use crate::delegation::inherit_predicates_for_delegation_item;
 use crate::hir_ty_lowering::{HirTyLowerer, OnlySelfBounds, PredicateFilter, RegionInferReason};
 
 /// Returns a list of all type predicates (explicit and implicit) for the definition with
-/// ID `def_id`. This includes all predicates returned by `predicates_defined_on`, plus
-/// `Self: Trait` predicates for traits.
+/// ID `def_id`. This includes all predicates returned by `explicit_predicates_of`, plus
+/// inferred constraints concerning which regions outlive other regions.
+#[instrument(level = "debug", skip(tcx))]
 pub(super) fn predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredicates<'_> {
-    let mut result = tcx.predicates_defined_on(def_id);
+    let mut result = tcx.explicit_predicates_of(def_id);
+    debug!("predicates_of: explicit_predicates_of({:?}) = {:?}", def_id, result);
+
+    let inferred_outlives = tcx.inferred_outlives_of(def_id);
+    if !inferred_outlives.is_empty() {
+        debug!("predicates_of: inferred_outlives_of({:?}) = {:?}", def_id, inferred_outlives,);
+        let inferred_outlives_iter =
+            inferred_outlives.iter().map(|(clause, span)| ((*clause).upcast(tcx), *span));
+        if result.predicates.is_empty() {
+            result.predicates = tcx.arena.alloc_from_iter(inferred_outlives_iter);
+        } else {
+            result.predicates = tcx.arena.alloc_from_iter(
+                result.predicates.into_iter().copied().chain(inferred_outlives_iter),
+            );
+        }
+    }
 
     if tcx.is_trait(def_id) {
         // For traits, add `Self: Trait` predicate. This is
@@ -51,7 +67,8 @@ pub(super) fn predicates_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::GenericPredic
                 .chain(std::iter::once((ty::TraitRef::identity(tcx, def_id).upcast(tcx), span))),
         );
     }
-    debug!("predicates_of(def_id={:?}) = {:?}", def_id, result);
+
+    debug!("predicates_of({:?}) = {:?}", def_id, result);
     result
 }
 
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 75166624f95a4..d42bc78ccbb13 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -312,17 +312,6 @@ rustc_queries! {
     /// predicates (where-clauses) that must be proven true in order
     /// to reference it. This is almost always the "predicates query"
     /// that you want.
-    ///
-    /// `predicates_of` builds on `predicates_defined_on` -- in fact,
-    /// it is almost always the same as that query, except for the
-    /// case of traits. For traits, `predicates_of` contains
-    /// an additional `Self: Trait<...>` predicate that users don't
-    /// actually write. This reflects the fact that to invoke the
-    /// trait (e.g., via `Default::default`) you must supply types
-    /// that actually implement the trait. (However, this extra
-    /// predicate gets in the way of some checks, which are intended
-    /// to operate over only the actual where-clauses written by the
-    /// user.)
     query predicates_of(key: DefId) -> ty::GenericPredicates<'tcx> {
         desc { |tcx| "computing predicates of `{}`", tcx.def_path_str(key) }
         cache_on_disk_if { key.is_local() }
@@ -617,14 +606,6 @@ rustc_queries! {
         desc { "getting wasm import module map" }
     }
 
-    /// Maps from the `DefId` of an item (trait/struct/enum/fn) to the
-    /// predicates (where-clauses) directly defined on it. This is
-    /// equal to the `explicit_predicates_of` predicates plus the
-    /// `inferred_outlives_of` predicates.
-    query predicates_defined_on(key: DefId) -> ty::GenericPredicates<'tcx> {
-        desc { |tcx| "computing predicates of `{}`", tcx.def_path_str(key) }
-    }
-
     /// Returns everything that looks like a predicate written explicitly
     /// by the user on a trait item.
     ///
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 a495e94bd9ab3..cf5d8f614dda2 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
@@ -4,11 +4,6 @@ error[E0391]: cycle detected when computing predicates of `Foo`
 LL | struct Foo {
    | ^^^^^^^^^^
    |
-note: ...which requires computing predicates of `Foo`...
-  --> $DIR/cycle-iat-inside-of-adt.rs:7:1
-   |
-LL | struct Foo {
-   | ^^^^^^^^^^
 note: ...which requires computing inferred outlives predicates of `Foo`...
   --> $DIR/cycle-iat-inside-of-adt.rs:7:1
    |
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 e7292c08ebd0c..e97a5df9d4917 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
@@ -4,11 +4,6 @@ error[E0391]: cycle detected when computing predicates of `user`
 LL | fn user<T>() where S<T>::P: std::fmt::Debug {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: ...which requires computing predicates of `user`...
-  --> $DIR/cycle-iat-inside-of-where-predicate.rs:8:1
-   |
-LL | fn user<T>() where S<T>::P: std::fmt::Debug {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: ...which requires computing explicit predicates of `user`...
   --> $DIR/cycle-iat-inside-of-where-predicate.rs:8:1
    |

From abd44fc5f4211a0684da4b37a15c3d07b17a436e Mon Sep 17 00:00:00 2001
From: beetrees <b@beetr.ee>
Date: Sun, 25 Aug 2024 00:13:25 +0100
Subject: [PATCH 580/685] Add `f16` and `f128` inline ASM support for `aarch64`

---
 compiler/rustc_codegen_llvm/src/asm.rs   |  14 ++-
 compiler/rustc_target/src/asm/aarch64.rs |   6 +-
 tests/assembly/asm/aarch64-types.rs      | 133 ++++++++++++++++++-----
 tests/ui/asm/aarch64/type-check-3.stderr |   2 +-
 tests/ui/asm/aarch64/type-f16.rs         |  14 ++-
 5 files changed, 130 insertions(+), 39 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index f931698c38f91..1d91c3fb17ddc 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -913,8 +913,10 @@ fn llvm_asm_scalar_type<'ll>(cx: &CodegenCx<'ll, '_>, scalar: Scalar) -> &'ll Ty
         Primitive::Int(Integer::I16, _) => cx.type_i16(),
         Primitive::Int(Integer::I32, _) => cx.type_i32(),
         Primitive::Int(Integer::I64, _) => cx.type_i64(),
+        Primitive::Float(Float::F16) => cx.type_f16(),
         Primitive::Float(Float::F32) => cx.type_f32(),
         Primitive::Float(Float::F64) => cx.type_f64(),
+        Primitive::Float(Float::F128) => cx.type_f128(),
         // FIXME(erikdesjardins): handle non-default addrspace ptr sizes
         Primitive::Pointer(_) => cx.type_from_integer(dl.ptr_sized_integer()),
         _ => unreachable!(),
@@ -948,7 +950,9 @@ fn llvm_fixup_input<'ll, 'tcx>(
                 value
             }
         }
-        (InlineAsmRegClass::AArch64(AArch64InlineAsmRegClass::vreg_low16), Abi::Scalar(s)) => {
+        (InlineAsmRegClass::AArch64(AArch64InlineAsmRegClass::vreg_low16), Abi::Scalar(s))
+            if s.primitive() != Primitive::Float(Float::F128) =>
+        {
             let elem_ty = llvm_asm_scalar_type(bx.cx, s);
             let count = 16 / layout.size.bytes();
             let vec_ty = bx.cx.type_vector(elem_ty, count);
@@ -1090,7 +1094,9 @@ fn llvm_fixup_output<'ll, 'tcx>(
                 value
             }
         }
-        (InlineAsmRegClass::AArch64(AArch64InlineAsmRegClass::vreg_low16), Abi::Scalar(s)) => {
+        (InlineAsmRegClass::AArch64(AArch64InlineAsmRegClass::vreg_low16), Abi::Scalar(s))
+            if s.primitive() != Primitive::Float(Float::F128) =>
+        {
             value = bx.extract_element(value, bx.const_i32(0));
             if let Primitive::Pointer(_) = s.primitive() {
                 value = bx.inttoptr(value, layout.llvm_type(bx.cx));
@@ -1222,7 +1228,9 @@ fn llvm_fixup_output_type<'ll, 'tcx>(
                 layout.llvm_type(cx)
             }
         }
-        (InlineAsmRegClass::AArch64(AArch64InlineAsmRegClass::vreg_low16), Abi::Scalar(s)) => {
+        (InlineAsmRegClass::AArch64(AArch64InlineAsmRegClass::vreg_low16), Abi::Scalar(s))
+            if s.primitive() != Primitive::Float(Float::F128) =>
+        {
             let elem_ty = llvm_asm_scalar_type(cx, s);
             let count = 16 / layout.size.bytes();
             cx.type_vector(elem_ty, count)
diff --git a/compiler/rustc_target/src/asm/aarch64.rs b/compiler/rustc_target/src/asm/aarch64.rs
index 041582b7df97d..daf5162e8ac10 100644
--- a/compiler/rustc_target/src/asm/aarch64.rs
+++ b/compiler/rustc_target/src/asm/aarch64.rs
@@ -61,9 +61,9 @@ impl AArch64InlineAsmRegClass {
         match self {
             Self::reg => types! { _: I8, I16, I32, I64, F16, F32, F64; },
             Self::vreg | Self::vreg_low16 => types! {
-                neon: I8, I16, I32, I64, F16, F32, F64,
-                    VecI8(8), VecI16(4), VecI32(2), VecI64(1), VecF32(2), VecF64(1),
-                    VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(4),VecF16(8), VecF32(4), VecF64(2);
+                neon: I8, I16, I32, I64, F16, F32, F64, F128,
+                    VecI8(8), VecI16(4), VecI32(2), VecI64(1), VecF16(4), VecF32(2), VecF64(1),
+                    VecI8(16), VecI16(8), VecI32(4), VecI64(2), VecF16(8), VecF32(4), VecF64(2);
             },
             Self::preg => &[],
         }
diff --git a/tests/assembly/asm/aarch64-types.rs b/tests/assembly/asm/aarch64-types.rs
index 4b506f180d83e..f36345670e329 100644
--- a/tests/assembly/asm/aarch64-types.rs
+++ b/tests/assembly/asm/aarch64-types.rs
@@ -5,10 +5,12 @@
 //@ [arm64ec] compile-flags: --target arm64ec-pc-windows-msvc
 //@ [arm64ec] needs-llvm-components: aarch64
 
-#![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_experimental_arch, f16)]
+#![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_experimental_arch, f16, f128)]
 #![crate_type = "rlib"]
 #![no_core]
 #![allow(asm_sub_register, non_camel_case_types)]
+// FIXME(f16_f128): Only needed for FIXME in check! and check_reg!
+#![feature(auto_traits)]
 
 #[rustc_builtin_macro]
 macro_rules! asm {
@@ -41,8 +43,6 @@ pub struct i64x1(i64);
 #[repr(simd)]
 pub struct f16x4(f16, f16, f16, f16);
 #[repr(simd)]
-pub struct f16x8(f16, f16, f16, f16, f16, f16, f16, f16);
-#[repr(simd)]
 pub struct f32x2(f32, f32);
 #[repr(simd)]
 pub struct f64x1(f64);
@@ -55,6 +55,8 @@ pub struct i32x4(i32, i32, i32, i32);
 #[repr(simd)]
 pub struct i64x2(i64, i64);
 #[repr(simd)]
+pub struct f16x8(f16, f16, f16, f16, f16, f16, f16, f16);
+#[repr(simd)]
 pub struct f32x4(f32, f32, f32, f32);
 #[repr(simd)]
 pub struct f64x2(f64, f64);
@@ -66,13 +68,14 @@ impl Copy for i32 {}
 impl Copy for f32 {}
 impl Copy for i64 {}
 impl Copy for f64 {}
+impl Copy for f128 {}
 impl Copy for ptr {}
 impl Copy for i8x8 {}
 impl Copy for i16x4 {}
 impl Copy for i32x2 {}
 impl Copy for i64x1 {}
-impl Copy for f32x2 {}
 impl Copy for f16x4 {}
+impl Copy for f32x2 {}
 impl Copy for f64x1 {}
 impl Copy for i8x16 {}
 impl Copy for i16x8 {}
@@ -82,6 +85,12 @@ impl Copy for f16x8 {}
 impl Copy for f32x4 {}
 impl Copy for f64x2 {}
 
+// FIXME(f16_f128): Only needed for FIXME in check! and check_reg!
+#[lang = "freeze"]
+unsafe auto trait Freeze {}
+#[lang = "unpin"]
+auto trait Unpin {}
+
 extern "C" {
     fn extern_func();
     static extern_static: u8;
@@ -118,38 +127,44 @@ pub unsafe fn issue_75761() {
 
 macro_rules! check {
     ($func:ident $ty:ident $class:ident $mov:literal $modifier:literal) => {
+        // FIXME(f16_f128): Change back to `$func(x: $ty) -> $ty` once arm64ec can pass and return
+        // `f16` and `f128` without LLVM erroring.
+        // LLVM issue: <https://github.com/llvm/llvm-project/issues/94434>
         #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
+        pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
             // Hack to avoid function merging
             extern "Rust" {
                 fn dont_merge(s: &str);
             }
             dont_merge(stringify!($func));
 
+            let x = *inp;
             let y;
             asm!(
                 concat!($mov, " {:", $modifier, "}, {:", $modifier, "}"),
                 out($class) y,
                 in($class) x
             );
-            y
+            *out = y;
         }
     };
 }
 
 macro_rules! check_reg {
     ($func:ident $ty:ident $reg:tt $mov:literal) => {
+        // FIXME(f16_f128): See FIXME in `check!`
         #[no_mangle]
-        pub unsafe fn $func(x: $ty) -> $ty {
+        pub unsafe fn $func(inp: &$ty, out: &mut $ty) {
             // Hack to avoid function merging
             extern "Rust" {
                 fn dont_merge(s: &str);
             }
             dont_merge(stringify!($func));
 
+            let x = *inp;
             let y;
             asm!(concat!($mov, " ", $reg, ", ", $reg), lateout($reg) y, in($reg) x);
-            y
+            *out = y;
         }
     };
 }
@@ -166,18 +181,18 @@ check!(reg_i8 i8 reg "mov" "");
 // CHECK: //NO_APP
 check!(reg_i16 i16 reg "mov" "");
 
+// CHECK-LABEL: {{("#)?}}reg_f16{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check!(reg_f16 f16 reg "mov" "");
+
 // CHECK-LABEL: {{("#)?}}reg_i32{{"?}}
 // CHECK: //APP
 // CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
 // CHECK: //NO_APP
 check!(reg_i32 i32 reg "mov" "");
 
-// CHECK-LABEL: reg_f16:
-// CHECK: @APP
-// CHECK: mov {{[a-z0-9]+}}, {{[a-z0-9]+}}
-// CHECK: @NO_APP
-check!(reg_f16 f16 reg "mov");
-
 // CHECK-LABEL: {{("#)?}}reg_f32{{"?}}
 // CHECK: //APP
 // CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
@@ -214,6 +229,12 @@ check!(vreg_i8 i8 vreg "fmov" "s");
 // CHECK: //NO_APP
 check!(vreg_i16 i16 vreg "fmov" "s");
 
+// CHECK-LABEL: {{("#)?}}vreg_f16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f16 f16 vreg "fmov" "s");
+
 // CHECK-LABEL: {{("#)?}}vreg_i32{{"?}}
 // CHECK: //APP
 // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
@@ -238,6 +259,12 @@ check!(vreg_i64 i64 vreg "fmov" "s");
 // CHECK: //NO_APP
 check!(vreg_f64 f64 vreg "fmov" "s");
 
+// CHECK-LABEL: {{("#)?}}vreg_f128{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f128 f128 vreg "fmov" "s");
+
 // CHECK-LABEL: {{("#)?}}vreg_ptr{{"?}}
 // CHECK: //APP
 // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
@@ -268,19 +295,11 @@ check!(vreg_i32x2 i32x2 vreg "fmov" "s");
 // CHECK: //NO_APP
 check!(vreg_i64x1 i64x1 vreg "fmov" "s");
 
-// neon-LABEL: vreg_f16x4:
-// neon: @APP
-// neon: vmov.f64 d{{[0-9]+}}, d{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(vreg_f16x4 f16x4 vreg "vmov.f64");
-
-// neon-LABEL: vreg_f16x8:
-// neon: @APP
-// neon: vorr q{{[0-9]+}}, q{{[0-9]+}}, q{{[0-9]+}}
-// neon: @NO_APP
-#[cfg(neon)]
-check!(vreg_f16x8 f16x8 vreg "vmov");
+// CHECK-LABEL: {{("#)?}}vreg_f16x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f16x4 f16x4 vreg "fmov" "s");
 
 // CHECK-LABEL: {{("#)?}}vreg_f32x2{{"?}}
 // CHECK: //APP
@@ -318,6 +337,12 @@ check!(vreg_i32x4 i32x4 vreg "fmov" "s");
 // CHECK: //NO_APP
 check!(vreg_i64x2 i64x2 vreg "fmov" "s");
 
+// CHECK-LABEL: {{("#)?}}vreg_f16x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_f16x8 f16x8 vreg "fmov" "s");
+
 // CHECK-LABEL: {{("#)?}}vreg_f32x4{{"?}}
 // CHECK: //APP
 // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
@@ -342,6 +367,12 @@ check!(vreg_low16_i8 i8 vreg_low16 "fmov" "s");
 // CHECK: //NO_APP
 check!(vreg_low16_i16 i16 vreg_low16 "fmov" "s");
 
+// CHECK-LABEL: {{("#)?}}vreg_low16_f16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f16 f16 vreg_low16 "fmov" "s");
+
 // CHECK-LABEL: {{("#)?}}vreg_low16_f32{{"?}}
 // CHECK: //APP
 // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
@@ -360,6 +391,12 @@ check!(vreg_low16_i64 i64 vreg_low16 "fmov" "s");
 // CHECK: //NO_APP
 check!(vreg_low16_f64 f64 vreg_low16 "fmov" "s");
 
+// CHECK-LABEL: {{("#)?}}vreg_low16_f128{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f128 f128 vreg_low16 "fmov" "s");
+
 // CHECK-LABEL: {{("#)?}}vreg_low16_ptr{{"?}}
 // CHECK: //APP
 // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
@@ -390,6 +427,12 @@ check!(vreg_low16_i32x2 i32x2 vreg_low16 "fmov" "s");
 // CHECK: //NO_APP
 check!(vreg_low16_i64x1 i64x1 vreg_low16 "fmov" "s");
 
+// CHECK-LABEL: {{("#)?}}vreg_low16_f16x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f16x4 f16x4 vreg_low16 "fmov" "s");
+
 // CHECK-LABEL: {{("#)?}}vreg_low16_f32x2{{"?}}
 // CHECK: //APP
 // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
@@ -426,6 +469,12 @@ check!(vreg_low16_i32x4 i32x4 vreg_low16 "fmov" "s");
 // CHECK: //NO_APP
 check!(vreg_low16_i64x2 i64x2 vreg_low16 "fmov" "s");
 
+// CHECK-LABEL: {{("#)?}}vreg_low16_f16x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
+// CHECK: //NO_APP
+check!(vreg_low16_f16x8 f16x8 vreg_low16 "fmov" "s");
+
 // CHECK-LABEL: {{("#)?}}vreg_low16_f32x4{{"?}}
 // CHECK: //APP
 // CHECK: fmov s{{[0-9]+}}, s{{[0-9]+}}
@@ -450,6 +499,12 @@ check_reg!(x0_i8 i8 "x0" "mov");
 // CHECK: //NO_APP
 check_reg!(x0_i16 i16 "x0" "mov");
 
+// CHECK-LABEL: {{("#)?}}x0_f16{{"?}}
+// CHECK: //APP
+// CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
+// CHECK: //NO_APP
+check_reg!(x0_f16 f16 "x0" "mov");
+
 // CHECK-LABEL: {{("#)?}}x0_i32{{"?}}
 // CHECK: //APP
 // CHECK: mov x{{[0-9]+}}, x{{[0-9]+}}
@@ -492,6 +547,12 @@ check_reg!(v0_i8 i8 "s0" "fmov");
 // CHECK: //NO_APP
 check_reg!(v0_i16 i16 "s0" "fmov");
 
+// CHECK-LABEL: {{("#)?}}v0_f16{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f16 f16 "s0" "fmov");
+
 // CHECK-LABEL: {{("#)?}}v0_i32{{"?}}
 // CHECK: //APP
 // CHECK: fmov s0, s0
@@ -516,6 +577,12 @@ check_reg!(v0_i64 i64 "s0" "fmov");
 // CHECK: //NO_APP
 check_reg!(v0_f64 f64 "s0" "fmov");
 
+// CHECK-LABEL: {{("#)?}}v0_f128{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f128 f128 "s0" "fmov");
+
 // CHECK-LABEL: {{("#)?}}v0_ptr{{"?}}
 // CHECK: //APP
 // CHECK: fmov s0, s0
@@ -546,6 +613,12 @@ check_reg!(v0_i32x2 i32x2 "s0" "fmov");
 // CHECK: //NO_APP
 check_reg!(v0_i64x1 i64x1 "s0" "fmov");
 
+// CHECK-LABEL: {{("#)?}}v0_f16x4{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f16x4 f16x4 "s0" "fmov");
+
 // CHECK-LABEL: {{("#)?}}v0_f32x2{{"?}}
 // CHECK: //APP
 // CHECK: fmov s0, s0
@@ -582,6 +655,12 @@ check_reg!(v0_i32x4 i32x4 "s0" "fmov");
 // CHECK: //NO_APP
 check_reg!(v0_i64x2 i64x2 "s0" "fmov");
 
+// CHECK-LABEL: {{("#)?}}v0_f16x8{{"?}}
+// CHECK: //APP
+// CHECK: fmov s0, s0
+// CHECK: //NO_APP
+check_reg!(v0_f16x8 f16x8 "s0" "fmov");
+
 // CHECK-LABEL: {{("#)?}}v0_f32x4{{"?}}
 // CHECK: //APP
 // CHECK: fmov s0, s0
diff --git a/tests/ui/asm/aarch64/type-check-3.stderr b/tests/ui/asm/aarch64/type-check-3.stderr
index 4bd97b93867bb..9d84d2666b33c 100644
--- a/tests/ui/asm/aarch64/type-check-3.stderr
+++ b/tests/ui/asm/aarch64/type-check-3.stderr
@@ -111,7 +111,7 @@ error: type `Simd256bit` cannot be used with this register class
 LL |         asm!("{}", in(vreg) f64x4);
    |                             ^^^^^
    |
-   = note: register class `vreg` supports these types: i8, i16, i32, i64, f16, f32, f64, i8x8, i16x4, i32x2, i64x1, f32x2, f64x1, i8x16, i16x8, i32x4, i64x2, f16x4, f16x8, f32x4, f64x2
+   = note: register class `vreg` supports these types: i8, i16, i32, i64, f16, f32, f64, f128, i8x8, i16x4, i32x2, i64x1, f16x4, f32x2, f64x1, i8x16, i16x8, i32x4, i64x2, f16x8, f32x4, f64x2
 
 error: incompatible types for asm inout argument
   --> $DIR/type-check-3.rs:88:33
diff --git a/tests/ui/asm/aarch64/type-f16.rs b/tests/ui/asm/aarch64/type-f16.rs
index 763ea4684da37..e62d8130c933d 100644
--- a/tests/ui/asm/aarch64/type-f16.rs
+++ b/tests/ui/asm/aarch64/type-f16.rs
@@ -1,21 +1,25 @@
 //@ only-aarch64
 //@ run-pass
+//@ needs-asm-support
+
+#![feature(f16)]
 
-#![feature(f16, f128)]
 use std::arch::asm;
+
 #[inline(never)]
 pub fn f32_to_f16_asm(a: f32) -> f16 {
     let ret: f16;
     unsafe {
         asm!(
-        "fcvt    {ret:h}, {a:s}",
-        a = in(vreg) a,
-        ret = lateout(vreg) ret,
-        options(nomem, nostack),
+            "fcvt {ret:h}, {a:s}",
+            a = in(vreg) a,
+            ret = lateout(vreg) ret,
+            options(nomem, nostack),
         );
     }
     ret
 }
+
 fn main() {
     assert_eq!(f32_to_f16_asm(1.0 as f32), 1.0);
 }

From e7f11b6913eb1549847be2173a20d08f3cbf46ff Mon Sep 17 00:00:00 2001
From: mu001999 <mu001999@outlook.com>
Date: Thu, 8 Aug 2024 08:17:55 +0800
Subject: [PATCH 581/685] Removes dead code from the compiler

---
 compiler/rustc_incremental/messages.ftl                    | 2 --
 compiler/rustc_incremental/src/errors.rs                   | 7 -------
 compiler/rustc_passes/messages.ftl                         | 4 ----
 compiler/rustc_passes/src/errors.rs                        | 7 -------
 .../src/maybe_transmutable/query_context.rs                | 6 +-----
 library/alloc/tests/boxed.rs                               | 1 +
 6 files changed, 2 insertions(+), 25 deletions(-)

diff --git a/compiler/rustc_incremental/messages.ftl b/compiler/rustc_incremental/messages.ftl
index de2177ebb6e0f..2a65101d360d3 100644
--- a/compiler/rustc_incremental/messages.ftl
+++ b/compiler/rustc_incremental/messages.ftl
@@ -99,6 +99,4 @@ incremental_unrecognized_depnode = unrecognized `DepNode` variant: {$name}
 
 incremental_unrecognized_depnode_label = dep-node label `{$label}` not recognized
 
-incremental_write_dep_graph = failed to write dependency graph to `{$path}`: {$err}
-
 incremental_write_new = failed to write {$name} to `{$path}`: {$err}
diff --git a/compiler/rustc_incremental/src/errors.rs b/compiler/rustc_incremental/src/errors.rs
index b68c149d39823..c6f8b99bcd67b 100644
--- a/compiler/rustc_incremental/src/errors.rs
+++ b/compiler/rustc_incremental/src/errors.rs
@@ -272,13 +272,6 @@ pub struct LoadDepGraph {
     pub err: std::io::Error,
 }
 
-#[derive(Diagnostic)]
-#[diag(incremental_write_dep_graph)]
-pub struct WriteDepGraph<'a> {
-    pub path: &'a Path,
-    pub err: std::io::Error,
-}
-
 #[derive(Diagnostic)]
 #[diag(incremental_move_dep_graph)]
 pub struct MoveDepGraph<'a> {
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index dfc726efeb998..bdc229a6c09e4 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -481,10 +481,6 @@ passes_must_not_suspend =
     `must_not_suspend` attribute should be applied to a struct, enum, union, or trait
     .label = is not a struct, enum, union, or trait
 
-passes_must_use_async =
-    `must_use` attribute on `async` functions applies to the anonymous `Future` returned by the function, not the value within
-    .label = this attribute does nothing, the `Future`s returned by async functions are already `must_use`
-
 passes_must_use_no_effect =
     `#[must_use]` has no effect when applied to {$article} {$target}
 
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 1190e60f41f18..644ae23a761c3 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -371,13 +371,6 @@ pub struct FfiConstInvalidTarget {
     pub attr_span: Span,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(passes_must_use_async)]
-pub struct MustUseAsync {
-    #[label]
-    pub span: Span,
-}
-
 #[derive(LintDiagnostic)]
 #[diag(passes_must_use_no_effect)]
 pub struct MustUseNoEffect {
diff --git a/compiler/rustc_transmute/src/maybe_transmutable/query_context.rs b/compiler/rustc_transmute/src/maybe_transmutable/query_context.rs
index 95373916a71ae..f8b59bdf32684 100644
--- a/compiler/rustc_transmute/src/maybe_transmutable/query_context.rs
+++ b/compiler/rustc_transmute/src/maybe_transmutable/query_context.rs
@@ -4,7 +4,6 @@ use crate::layout;
 pub(crate) trait QueryContext {
     type Def: layout::Def;
     type Ref: layout::Ref;
-    type Scope: Copy;
 }
 
 #[cfg(test)]
@@ -28,20 +27,17 @@ pub(crate) mod test {
     impl QueryContext for UltraMinimal {
         type Def = Def;
         type Ref = !;
-        type Scope = ();
     }
 }
 
 #[cfg(feature = "rustc")]
 mod rustc {
-    use rustc_middle::ty::{Ty, TyCtxt};
+    use rustc_middle::ty::TyCtxt;
 
     use super::*;
 
     impl<'tcx> super::QueryContext for TyCtxt<'tcx> {
         type Def = layout::rustc::Def<'tcx>;
         type Ref = layout::rustc::Ref<'tcx>;
-
-        type Scope = Ty<'tcx>;
     }
 }
diff --git a/library/alloc/tests/boxed.rs b/library/alloc/tests/boxed.rs
index faee64b2f6738..bfc31a626fadd 100644
--- a/library/alloc/tests/boxed.rs
+++ b/library/alloc/tests/boxed.rs
@@ -59,6 +59,7 @@ fn box_deref_lval() {
     assert_eq!(x.get(), 1000);
 }
 
+#[allow(unused)]
 pub struct ConstAllocator;
 
 unsafe impl Allocator for ConstAllocator {

From 172c05cca2aef927a6379b404489c0fc0f143f0e Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 25 Aug 2024 11:42:20 +0200
Subject: [PATCH 582/685] only visit reachable blocks, do not use a visitor

---
 .../src/check_consts/check.rs                 | 44 +++++++------------
 1 file changed, 16 insertions(+), 28 deletions(-)

diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index d7594c9ae75f6..13afb1afa828e 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -18,7 +18,7 @@ use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::{self, Instance, InstanceKind, Ty, TyCtxt, TypeVisitableExt};
 use rustc_mir_dataflow::impls::MaybeStorageLive;
 use rustc_mir_dataflow::storage::always_storage_live_locals;
-use rustc_mir_dataflow::{Analysis, ResultsCursor};
+use rustc_mir_dataflow::Analysis;
 use rustc_span::{sym, Span, Symbol, DUMMY_SP};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::traits::{self, ObligationCauseCode, ObligationCtxt};
@@ -275,40 +275,28 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
                 // A local is "transient" if it is guaranteed dead at all `Return`.
                 // So first compute the say of "maybe live" locals at each program point.
                 let always_live_locals = &always_storage_live_locals(&ccx.body);
-                let maybe_storage_live = MaybeStorageLive::new(Cow::Borrowed(always_live_locals))
-                    .into_engine(ccx.tcx, &ccx.body)
-                    .iterate_to_fixpoint()
-                    .into_results_cursor(&ccx.body);
+                let mut maybe_storage_live =
+                    MaybeStorageLive::new(Cow::Borrowed(always_live_locals))
+                        .into_engine(ccx.tcx, &ccx.body)
+                        .iterate_to_fixpoint()
+                        .into_results_cursor(&ccx.body);
 
                 // And then check all `Return` in the MIR, and if a local is "maybe live" at a
                 // `Return` then it is definitely not transient.
-                struct TransientLocalVisitor<'a, 'tcx> {
-                    maybe_storage_live: ResultsCursor<'a, 'tcx, MaybeStorageLive<'a>>,
-                    transient: BitSet<Local>,
-                }
-                impl<'a, 'tcx> Visitor<'tcx> for TransientLocalVisitor<'a, 'tcx> {
-                    fn visit_terminator(
-                        &mut self,
-                        terminator: &Terminator<'tcx>,
-                        location: Location,
-                    ) {
-                        if matches!(terminator.kind, TerminatorKind::Return) {
-                            self.maybe_storage_live.seek_after_primary_effect(location);
-                            for local in self.maybe_storage_live.get().iter() {
-                                // If a local may be live here, it is definitely not transient.
-                                self.transient.remove(local);
-                            }
+                let mut transient = BitSet::new_filled(ccx.body.local_decls.len());
+                // Make sure to only visit reachable blocks, the dataflow engine can ICE otherwise.
+                for (bb, data) in traversal::reachable(&ccx.body) {
+                    if matches!(data.terminator().kind, TerminatorKind::Return) {
+                        let location = ccx.body.terminator_loc(bb);
+                        maybe_storage_live.seek_after_primary_effect(location);
+                        for local in maybe_storage_live.get().iter() {
+                            // If a local may be live here, it is definitely not transient.
+                            transient.remove(local);
                         }
                     }
                 }
 
-                let mut v = TransientLocalVisitor {
-                    maybe_storage_live,
-                    transient: BitSet::new_filled(ccx.body.local_decls.len()),
-                };
-                v.visit_body(&ccx.body);
-
-                v.transient
+                transient
             })
             .contains(local)
     }

From 74a21425cca6742f08a6df25bb153a3b7a43f56a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 25 Aug 2024 12:33:55 +0200
Subject: [PATCH 583/685] dont iterate over the bitset

---
 compiler/rustc_const_eval/src/check_consts/check.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index 13afb1afa828e..9f93776a7b9e2 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -289,10 +289,8 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
                     if matches!(data.terminator().kind, TerminatorKind::Return) {
                         let location = ccx.body.terminator_loc(bb);
                         maybe_storage_live.seek_after_primary_effect(location);
-                        for local in maybe_storage_live.get().iter() {
-                            // If a local may be live here, it is definitely not transient.
-                            transient.remove(local);
-                        }
+                        // If a local may be live here, it is definitely not transient.
+                        transient.subtract(maybe_storage_live.get());
                     }
                 }
 

From a772db420670b2d2c391311f184bc4b56baba59d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 25 Aug 2024 12:54:04 +0200
Subject: [PATCH 584/685] ub_checks intrinsics: fall back to cfg(ub_checks)

---
 library/core/src/intrinsics.rs | 4 ++--
 library/core/src/lib.rs        | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs
index bd99e90376aa5..8cb9accd59db4 100644
--- a/library/core/src/intrinsics.rs
+++ b/library/core/src/intrinsics.rs
@@ -2949,7 +2949,7 @@ pub const unsafe fn typed_swap<T>(x: *mut T, y: *mut T) {
 /// sysroot which is built without ub_checks but with `#[rustc_preserve_ub_checks]`.
 /// For code that gets monomorphized in the user crate (i.e., generic functions and functions with
 /// `#[inline]`), gating assertions on `ub_checks()` rather than `cfg!(ub_checks)` means that
-/// assertions are enabled whenever the *user crate* has UB checks enabled. However if the
+/// assertions are enabled whenever the *user crate* has UB checks enabled. However, if the
 /// user has UB checks disabled, the checks will still get optimized out. This intrinsic is
 /// primarily used by [`ub_checks::assert_unsafe_precondition`].
 #[rustc_const_unstable(feature = "const_ub_checks", issue = "none")]
@@ -2957,7 +2957,7 @@ pub const unsafe fn typed_swap<T>(x: *mut T, y: *mut T) {
 #[inline(always)]
 #[rustc_intrinsic]
 pub const fn ub_checks() -> bool {
-    cfg!(debug_assertions)
+    cfg!(ub_checks)
 }
 
 /// Allocates a block of memory at compile time.
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 7f0efede24048..06a745b690a4b 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -203,6 +203,7 @@
 #![feature(cfg_sanitize)]
 #![feature(cfg_target_has_atomic)]
 #![feature(cfg_target_has_atomic_equal_alignment)]
+#![feature(cfg_ub_checks)]
 #![feature(const_for)]
 #![feature(const_mut_refs)]
 #![feature(const_precise_live_drops)]

From c29e328f6a2a3667034dc668c810373db7a68857 Mon Sep 17 00:00:00 2001
From: Pavel Grigorenko <GrigorenkoPV@ya.ru>
Date: Sat, 24 Aug 2024 21:55:16 +0300
Subject: [PATCH 585/685] gitignore: ignore ICE reports regardless of directory

---
 .gitignore | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index a36cb51de33ff..2e6499081a634 100644
--- a/.gitignore
+++ b/.gitignore
@@ -56,7 +56,9 @@ build/
 /src/tools/x/target
 # Created by default with `src/ci/docker/run.sh`
 /obj/
-/rustc-ice*
+
+## ICE reports
+rustc-ice-*.txt
 
 ## Temporary files
 *~

From 5412499ad54b333b03a6aa798f19dc8552fb2936 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 25 Aug 2024 13:49:16 +0200
Subject: [PATCH 586/685] make it possible to enable const_precise_live_drops
 per-function

---
 .../src/check_consts/post_drop_elaboration.rs   | 10 ++++++++--
 ...rop-allow-const-fn-unstable.not_allow.stderr | 12 ++++++++++++
 .../precise-drop-allow-const-fn-unstable.rs     | 17 +++++++++++++++++
 3 files changed, 37 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/consts/precise-drop-allow-const-fn-unstable.not_allow.stderr
 create mode 100644 tests/ui/consts/precise-drop-allow-const-fn-unstable.rs

diff --git a/compiler/rustc_const_eval/src/check_consts/post_drop_elaboration.rs b/compiler/rustc_const_eval/src/check_consts/post_drop_elaboration.rs
index c4f06e5af0be5..f0998300dc843 100644
--- a/compiler/rustc_const_eval/src/check_consts/post_drop_elaboration.rs
+++ b/compiler/rustc_const_eval/src/check_consts/post_drop_elaboration.rs
@@ -9,13 +9,19 @@ use super::check::Qualifs;
 use super::ops::{self, NonConstOp};
 use super::qualifs::{NeedsNonConstDrop, Qualif};
 use super::ConstCx;
+use crate::check_consts::rustc_allow_const_fn_unstable;
 
 /// Returns `true` if we should use the more precise live drop checker that runs after drop
 /// elaboration.
 pub fn checking_enabled(ccx: &ConstCx<'_, '_>) -> bool {
-    // Const-stable functions must always use the stable live drop checker.
+    // Const-stable functions must always use the stable live drop checker...
     if ccx.is_const_stable_const_fn() {
-        return false;
+        // ...except if they have the feature flag set via `rustc_allow_const_fn_unstable`.
+        return rustc_allow_const_fn_unstable(
+            ccx.tcx,
+            ccx.body.source.def_id().expect_local(),
+            sym::const_precise_live_drops,
+        );
     }
 
     ccx.tcx.features().const_precise_live_drops
diff --git a/tests/ui/consts/precise-drop-allow-const-fn-unstable.not_allow.stderr b/tests/ui/consts/precise-drop-allow-const-fn-unstable.not_allow.stderr
new file mode 100644
index 0000000000000..6038c6d332fec
--- /dev/null
+++ b/tests/ui/consts/precise-drop-allow-const-fn-unstable.not_allow.stderr
@@ -0,0 +1,12 @@
+error[E0493]: destructor of `Option<T>` cannot be evaluated at compile-time
+  --> $DIR/precise-drop-allow-const-fn-unstable.rs:11:24
+   |
+LL | pub const fn unwrap<T>(this: Option<T>) -> T {
+   |                        ^^^^ the destructor for this type cannot be evaluated in constant functions
+...
+LL | }
+   | - value is dropped here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0493`.
diff --git a/tests/ui/consts/precise-drop-allow-const-fn-unstable.rs b/tests/ui/consts/precise-drop-allow-const-fn-unstable.rs
new file mode 100644
index 0000000000000..56155e519dca4
--- /dev/null
+++ b/tests/ui/consts/precise-drop-allow-const-fn-unstable.rs
@@ -0,0 +1,17 @@
+//@ revisions: allow not_allow
+//@ compile-flags: --crate-type=lib -Cinstrument-coverage  -Zno-profiler-runtime
+//@[allow] check-pass
+
+#![feature(staged_api, rustc_allow_const_fn_unstable)]
+#![stable(feature = "rust_test", since = "1.0.0")]
+
+#[stable(feature = "rust_test", since = "1.0.0")]
+#[rustc_const_stable(feature = "rust_test", since = "1.0.0")]
+#[cfg_attr(allow, rustc_allow_const_fn_unstable(const_precise_live_drops))]
+pub const fn unwrap<T>(this: Option<T>) -> T {
+//[not_allow]~^ ERROR: cannot be evaluated
+    match this {
+        Some(x) => x,
+        None => panic!(),
+    }
+}

From ba24121ad6fef48793b6069e68a65a5a491272ef Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 25 Aug 2024 13:50:07 +0200
Subject: [PATCH 587/685] tweak rustc_allow_const_fn_unstable hint, and add
 back test for stable-const-can-only-call-stable-const

---
 compiler/rustc_const_eval/messages.ftl         |  2 +-
 .../allow_const_fn_ptr_run_pass.rs             |  2 --
 .../min_const_fn_libstd_stability.rs           |  4 +++-
 .../min_const_fn_libstd_stability.stderr       | 18 +++++++++++++-----
 4 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index 1442f1832b9b5..d7d64180ec9c1 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -419,7 +419,7 @@ const_eval_unstable_const_fn = `{$def_path}` is not yet stable as a const fn
 const_eval_unstable_in_stable =
     const-stable function cannot use `#[feature({$gate})]`
     .unstable_sugg = if it is not part of the public API, make this function unstably const
-    .bypass_sugg = otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks
+    .bypass_sugg = otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (but requires team approval)
 
 const_eval_unterminated_c_string =
     reading a null-terminated string starting at {$pointer} with no null found before end of allocation
diff --git a/tests/ui/consts/min_const_fn/allow_const_fn_ptr_run_pass.rs b/tests/ui/consts/min_const_fn/allow_const_fn_ptr_run_pass.rs
index a97eeadd92f4e..fe92787aec11b 100644
--- a/tests/ui/consts/min_const_fn/allow_const_fn_ptr_run_pass.rs
+++ b/tests/ui/consts/min_const_fn/allow_const_fn_ptr_run_pass.rs
@@ -1,6 +1,4 @@
 //@ run-pass
-#![feature(rustc_allow_const_fn_unstable)]
-
 #![feature(rustc_attrs, staged_api)]
 #![stable(feature = "rust1", since = "1.0.0")]
 
diff --git a/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.rs b/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.rs
index dc653370e5162..480b16b28a501 100644
--- a/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.rs
+++ b/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.rs
@@ -28,9 +28,11 @@ const fn bar2() -> u32 { foo2() } //~ ERROR not yet stable as a const fn
 // conformity is required
 const fn bar3() -> u32 {
     let x = std::cell::Cell::new(0u32);
-    x.get()
+    x.get();
     //~^ ERROR const-stable function cannot use `#[feature(const_refs_to_cell)]`
     //~| ERROR cannot call non-const fn
+    foo()
+    //~^ ERROR is not yet stable as a const fn
 }
 
 // check whether this function cannot be called even with the feature gate active
diff --git a/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr b/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr
index e5f8fa25b64ab..019deda063c78 100644
--- a/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr
+++ b/tests/ui/consts/min_const_fn/min_const_fn_libstd_stability.stderr
@@ -17,7 +17,7 @@ LL | const fn bar2() -> u32 { foo2() }
 error: const-stable function cannot use `#[feature(const_refs_to_cell)]`
   --> $DIR/min_const_fn_libstd_stability.rs:31:5
    |
-LL |     x.get()
+LL |     x.get();
    |     ^
    |
 help: if it is not part of the public API, make this function unstably const
@@ -25,7 +25,7 @@ help: if it is not part of the public API, make this function unstably const
 LL + #[rustc_const_unstable(feature = "...", issue = "...")]
 LL | const fn bar3() -> u32 {
    |
-help: otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks
+help: otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (but requires team approval)
    |
 LL + #[rustc_allow_const_fn_unstable(const_refs_to_cell)]
 LL | const fn bar3() -> u32 {
@@ -34,19 +34,27 @@ LL | const fn bar3() -> u32 {
 error[E0015]: cannot call non-const fn `Cell::<u32>::get` in constant functions
   --> $DIR/min_const_fn_libstd_stability.rs:31:7
    |
-LL |     x.get()
+LL |     x.get();
    |       ^^^^^
    |
    = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
 
+error: `foo` is not yet stable as a const fn
+  --> $DIR/min_const_fn_libstd_stability.rs:34:5
+   |
+LL |     foo()
+   |     ^^^^^
+   |
+   = help: const-stable functions can only call other const-stable functions
+
 error: `foo2_gated` is not yet stable as a const fn
-  --> $DIR/min_const_fn_libstd_stability.rs:43:32
+  --> $DIR/min_const_fn_libstd_stability.rs:45:32
    |
 LL | const fn bar2_gated() -> u32 { foo2_gated() }
    |                                ^^^^^^^^^^^^
    |
    = help: const-stable functions can only call other const-stable functions
 
-error: aborting due to 5 previous errors
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0015`.

From 8750e2424744f6365fbbfd3a42059eb51091e736 Mon Sep 17 00:00:00 2001
From: surechen <chenshuo17@huawei.com>
Date: Thu, 22 Aug 2024 17:41:15 +0800
Subject: [PATCH 588/685] Fixing span manipulation and indentation of the
 suggestion introduced by #126187

According to comments:
https://github.com/rust-lang/rust/pull/128084#issuecomment-2295254576
https://github.com/rust-lang/rust/pull/126187/files#r1634897691
---
 .../src/error_reporting/traits/suggestions.rs | 11 +++++++---
 ...turn-from-residual-sugg-issue-125997.fixed | 18 ++++++----------
 ...urn-from-residual-sugg-issue-125997.stderr | 21 ++++++-------------
 .../ui/try-trait/try-operator-on-main.stderr  |  2 --
 4 files changed, 20 insertions(+), 32 deletions(-)

diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index a962be54c3d88..cc5b731a8d890 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -4667,10 +4667,15 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             if let hir::ExprKind::Block(b, _) = body.value.kind
                 && b.expr.is_none()
             {
+                // The span of '}' in the end of block.
+                let span = self.tcx.sess.source_map().end_point(b.span);
                 sugg_spans.push((
-                    // The span will point to the closing curly brace `}` of the block.
-                    b.span.shrink_to_hi().with_lo(b.span.hi() - BytePos(1)),
-                    "\n    Ok(())\n}".to_string(),
+                    span.shrink_to_lo(),
+                    format!(
+                        "{}{}",
+                        "    Ok(())\n",
+                        self.tcx.sess.source_map().indentation_before(span).unwrap_or_default(),
+                    ),
                 ));
             }
             err.multipart_suggestion_verbose(
diff --git a/tests/ui/return/return-from-residual-sugg-issue-125997.fixed b/tests/ui/return/return-from-residual-sugg-issue-125997.fixed
index a5a133998259b..43a9907a9b496 100644
--- a/tests/ui/return/return-from-residual-sugg-issue-125997.fixed
+++ b/tests/ui/return/return-from-residual-sugg-issue-125997.fixed
@@ -9,7 +9,6 @@ use std::io::prelude::*;
 fn test1() -> Result<(), Box<dyn std::error::Error>> {
     let mut _file = File::create("foo.txt")?;
     //~^ ERROR the `?` operator can only be used in a function
-
     Ok(())
 }
 
@@ -17,7 +16,6 @@ fn test2() -> Result<(), Box<dyn std::error::Error>> {
     let mut _file = File::create("foo.txt")?;
     //~^ ERROR the `?` operator can only be used in a function
     println!();
-
     Ok(())
 }
 
@@ -27,9 +25,8 @@ macro_rules! mac {
             let mut _file = File::create("foo.txt")?;
             //~^ ERROR the `?` operator can only be used in a function
             println!();
-        
-    Ok(())
-}
+            Ok(())
+        }
     };
 }
 
@@ -39,23 +36,20 @@ impl A {
     fn test4(&self) -> Result<(), Box<dyn std::error::Error>> {
         let mut _file = File::create("foo.txt")?;
         //~^ ERROR the `?` operator can only be used in a method
-    
-    Ok(())
-}
+        Ok(())
+    }
 
     fn test5(&self) -> Result<(), Box<dyn std::error::Error>> {
         let mut _file = File::create("foo.txt")?;
         //~^ ERROR the `?` operator can only be used in a method
         println!();
-    
-    Ok(())
-}
+        Ok(())
+    }
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut _file = File::create("foo.txt")?;
     //~^ ERROR the `?` operator can only be used in a function
     mac!();
-
     Ok(())
 }
diff --git a/tests/ui/return/return-from-residual-sugg-issue-125997.stderr b/tests/ui/return/return-from-residual-sugg-issue-125997.stderr
index a59f38c2ec644..e22f33fd242a6 100644
--- a/tests/ui/return/return-from-residual-sugg-issue-125997.stderr
+++ b/tests/ui/return/return-from-residual-sugg-issue-125997.stderr
@@ -12,9 +12,7 @@ help: consider adding return type
 LL ~ fn test1() -> Result<(), Box<dyn std::error::Error>> {
 LL |     let mut _file = File::create("foo.txt")?;
 LL |
-LL + 
 LL +     Ok(())
-LL + }
    |
 
 error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
@@ -32,9 +30,7 @@ LL ~ fn test2() -> Result<(), Box<dyn std::error::Error>> {
 LL |     let mut _file = File::create("foo.txt")?;
 LL |
 LL |     println!();
-LL + 
 LL +     Ok(())
-LL + }
    |
 
 error[E0277]: the `?` operator can only be used in a method that returns `Result` or `Option` (or another type that implements `FromResidual`)
@@ -51,9 +47,8 @@ help: consider adding return type
 LL ~     fn test4(&self) -> Result<(), Box<dyn std::error::Error>> {
 LL |         let mut _file = File::create("foo.txt")?;
 LL |
-LL ~     
-LL +     Ok(())
-LL + }
+LL ~         Ok(())
+LL ~     }
    |
 
 error[E0277]: the `?` operator can only be used in a method that returns `Result` or `Option` (or another type that implements `FromResidual`)
@@ -71,9 +66,8 @@ LL ~     fn test5(&self) -> Result<(), Box<dyn std::error::Error>> {
 LL |         let mut _file = File::create("foo.txt")?;
 LL |
 LL |         println!();
-LL ~     
-LL +     Ok(())
-LL + }
+LL ~         Ok(())
+LL ~     }
    |
 
 error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
@@ -91,9 +85,7 @@ LL ~ fn main() -> Result<(), Box<dyn std::error::Error>> {
 LL |     let mut _file = File::create("foo.txt")?;
 LL |
 LL |     mac!();
-LL + 
 LL +     Ok(())
-LL + }
    |
 
 error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
@@ -115,9 +107,8 @@ LL ~         fn test3() -> Result<(), Box<dyn std::error::Error>> {
 LL |             let mut _file = File::create("foo.txt")?;
 LL |
 LL |             println!();
-LL ~         
-LL +     Ok(())
-LL + }
+LL ~             Ok(())
+LL ~         }
    |
 
 error: aborting due to 6 previous errors
diff --git a/tests/ui/try-trait/try-operator-on-main.stderr b/tests/ui/try-trait/try-operator-on-main.stderr
index d22117165c12b..311e8076ed48e 100644
--- a/tests/ui/try-trait/try-operator-on-main.stderr
+++ b/tests/ui/try-trait/try-operator-on-main.stderr
@@ -14,9 +14,7 @@ LL ~ fn main() -> Result<(), Box<dyn std::error::Error>> {
 LL |     // error for a `Try` type on a non-`Try` fn
 ...
 LL |     try_trait_generic::<()>();
-LL + 
 LL +     Ok(())
-LL + }
    |
 
 error[E0277]: the `?` operator can only be applied to values that implement `Try`

From b581fed15ef93b4d048097afe728dd052e5668ea Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sun, 25 Aug 2024 16:18:59 +0200
Subject: [PATCH 589/685] Generate missing source link on impl associated types

---
 src/librustdoc/html/render/mod.rs          | 2 ++
 tests/rustdoc/anchors.no_type_anchor2.html | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index c1b2ee7d8ae92..47f321a4c4a2a 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -1730,6 +1730,7 @@ fn render_impl(
                 let source_id = format!("{item_type}.{name}");
                 let id = cx.derive_id(&source_id);
                 write!(w, "<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">");
+                render_rightside(w, cx, item, render_mode);
                 if trait_.is_some() {
                     // Anchors are only used on trait impls.
                     write!(w, "<a href=\"#{id}\" class=\"anchor\">§</a>");
@@ -1751,6 +1752,7 @@ fn render_impl(
                 let source_id = format!("{item_type}.{name}");
                 let id = cx.derive_id(&source_id);
                 write!(w, "<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">");
+                render_rightside(w, cx, item, render_mode);
                 if trait_.is_some() {
                     // Anchors are only used on trait impls.
                     write!(w, "<a href=\"#{id}\" class=\"anchor\">§</a>");
diff --git a/tests/rustdoc/anchors.no_type_anchor2.html b/tests/rustdoc/anchors.no_type_anchor2.html
index 71e93990e29e9..9127104ded4af 100644
--- a/tests/rustdoc/anchors.no_type_anchor2.html
+++ b/tests/rustdoc/anchors.no_type_anchor2.html
@@ -1 +1 @@
-<section id="associatedtype.Y" class="associatedtype"><h4 class="code-header">pub type <a href="#associatedtype.Y" class="associatedtype">Y</a> = <a class="primitive" href="{{channel}}/std/primitive.u32.html">u32</a></h4></section>
\ No newline at end of file
+<section id="associatedtype.Y" class="associatedtype"><a class="src rightside" href="../src/foo/anchors.rs.html#45">source</a><h4 class="code-header">pub type <a href="#associatedtype.Y" class="associatedtype">Y</a> = <a class="primitive" href="{{channel}}/std/primitive.u32.html">u32</a></h4></section>
\ No newline at end of file

From ca6be7414a4f01d4369ebc21773008532f8081ea Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sun, 25 Aug 2024 16:19:17 +0200
Subject: [PATCH 590/685] Add regression test for impl associated types source
 link

---
 tests/rustdoc/assoc-type-source-link.rs | 26 +++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 tests/rustdoc/assoc-type-source-link.rs

diff --git a/tests/rustdoc/assoc-type-source-link.rs b/tests/rustdoc/assoc-type-source-link.rs
new file mode 100644
index 0000000000000..34b156b964957
--- /dev/null
+++ b/tests/rustdoc/assoc-type-source-link.rs
@@ -0,0 +1,26 @@
+// This test ensures that the source links are generated for impl associated types.
+
+#![crate_name = "foo"]
+#![feature(inherent_associated_types)]
+#![allow(incomplete_features)]
+
+//@ has 'foo/struct.Bar.html'
+pub struct Bar;
+
+impl Bar {
+    //@ has - '//*[@id="implementations-list"]//*[@id="associatedtype.Y"]/a' 'source'
+    //@ has - '//*[@id="implementations-list"]//*[@id="associatedtype.Y"]/a/@href' \
+    // '../src/foo/assoc-type-source-link.rs.html#14'
+    pub type Y = u8;
+}
+
+pub trait Foo {
+    type Z;
+}
+
+impl Foo for Bar {
+    //@ has - '//*[@id="trait-implementations-list"]//*[@id="associatedtype.Z"]/a' 'source'
+    //@ has - '//*[@id="trait-implementations-list"]//*[@id="associatedtype.Z"]/a/@href' \
+    // '../src/foo/assoc-type-source-link.rs.html#25'
+    type Z = u8;
+}

From 3153b7d7b4e2d528e13c40559e644bfca0735389 Mon Sep 17 00:00:00 2001
From: Jack O'Connor <oconnor663@gmail.com>
Date: Sat, 24 Aug 2024 18:14:52 -0700
Subject: [PATCH 591/685] link to Future::poll from the Poll docs

The most important thing about Poll is that Future::poll returns it, but
previously the docs didn't emphasize this.
---
 library/core/src/task/poll.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/library/core/src/task/poll.rs b/library/core/src/task/poll.rs
index bfa1cf096e237..6aab22177ab9d 100644
--- a/library/core/src/task/poll.rs
+++ b/library/core/src/task/poll.rs
@@ -5,6 +5,8 @@ use crate::ops::{self, ControlFlow};
 
 /// Indicates whether a value is available or if the current task has been
 /// scheduled to receive a wakeup instead.
+///
+/// This is returned by [`Future::poll`](core::future::Future::poll).
 #[must_use = "this `Poll` may be a `Pending` variant, which should be handled"]
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 #[lang = "Poll"]

From 21dd88f963f8047fa6a3d0492fc7dcf86f5e5f4d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 25 Aug 2024 17:12:12 +0200
Subject: [PATCH 592/685] exit: explain our expectations for the exit handlers
 registered in a Rust program

---
 library/std/src/process.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/library/std/src/process.rs b/library/std/src/process.rs
index 9ffdebe1b6ffe..bbea27ebc1056 100644
--- a/library/std/src/process.rs
+++ b/library/std/src/process.rs
@@ -2296,6 +2296,15 @@ impl Child {
 /// }
 /// ```
 ///
+/// In its current implementation, this function will execute exit handlers registered with `atexit`
+/// as well as other platform-specific exit handlers (e.g. `fini` sections of ELF shared objects).
+/// This means that Rust requires that all exit handlers are safe to execute at any time. In
+/// particular, if an exit handler cleans up some state that might be concurrently accessed by other
+/// threads, it is required that the exit handler performs suitable synchronization with those
+/// threads. (The alternative to this requirement would be to not run exit handlers at all, which is
+/// considered undesirable. Note that returning from `main` also calls `exit`, so making `exit` an
+/// unsafe operation is not an option.)
+///
 /// ## Platform-specific behavior
 ///
 /// **Unix**: On Unix-like platforms, it is unlikely that all 32 bits of `exit`

From 687c8a1eabf039be5cccc9cfefb55dd825378b02 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Kr=C3=B6ning?=
 <martin.kroening@eonerc.rwth-aachen.de>
Date: Sun, 25 Aug 2024 20:49:23 +0200
Subject: [PATCH 593/685] pal/hermit: correctly round up microseconds in
 `Thread::sleep`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Martin Kröning <martin.kroening@eonerc.rwth-aachen.de>
---
 library/std/src/sys/pal/hermit/thread.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/library/std/src/sys/pal/hermit/thread.rs b/library/std/src/sys/pal/hermit/thread.rs
index 6321f92e3d9d0..bc70b3ac1705c 100644
--- a/library/std/src/sys/pal/hermit/thread.rs
+++ b/library/std/src/sys/pal/hermit/thread.rs
@@ -77,8 +77,10 @@ impl Thread {
 
     #[inline]
     pub fn sleep(dur: Duration) {
+        let micros = dur.as_micros() + if dur.subsec_nanos() % 1_000 > 0 { 1 } else { 0 };
+
         unsafe {
-            hermit_abi::usleep(dur.as_micros() as u64);
+            hermit_abi::usleep(micros as u64);
         }
     }
 

From b1c2c78d297029c610ed00d757c90739a59f2d2d Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 25 Aug 2024 14:52:53 -0400
Subject: [PATCH 594/685] Tweak some attributes to improve
 panic_immediate_abort

---
 library/core/src/panic/location.rs              | 1 +
 library/core/src/slice/mod.rs                   | 4 ++--
 library/core/src/slice/sort/shared/smallsort.rs | 3 ++-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/library/core/src/panic/location.rs b/library/core/src/panic/location.rs
index 930edffd50517..e2a842046a96d 100644
--- a/library/core/src/panic/location.rs
+++ b/library/core/src/panic/location.rs
@@ -195,6 +195,7 @@ impl<'a> Location<'a> {
 
 #[stable(feature = "panic_hook_display", since = "1.26.0")]
 impl fmt::Display for Location<'_> {
+    #[inline]
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(formatter, "{}:{}:{}", self.file, self.line, self.col)
     }
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index c76157720b705..c7918499d4ab9 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -3667,8 +3667,8 @@ impl<T> [T] {
     {
         // The panic code path was put into a cold function to not bloat the
         // call site.
-        #[inline(never)]
-        #[cold]
+        #[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
+        #[cfg_attr(feature = "panic_immediate_abort", inline)]
         #[track_caller]
         fn len_mismatch_fail(dst_len: usize, src_len: usize) -> ! {
             panic!(
diff --git a/library/core/src/slice/sort/shared/smallsort.rs b/library/core/src/slice/sort/shared/smallsort.rs
index db0c5c72822c0..fae628a7c1474 100644
--- a/library/core/src/slice/sort/shared/smallsort.rs
+++ b/library/core/src/slice/sort/shared/smallsort.rs
@@ -840,7 +840,8 @@ unsafe fn bidirectional_merge<T: FreezeMarker, F: FnMut(&T, &T) -> bool>(
     }
 }
 
-#[inline(never)]
+#[cfg_attr(not(feature = "panic_immediate_abort"), inline(never), cold)]
+#[cfg_attr(feature = "panic_immediate_abort", inline)]
 fn panic_on_ord_violation() -> ! {
     // This is indicative of a logic bug in the user-provided comparison function or Ord
     // implementation. They are expected to implement a total order as explained in the Ord

From 48f43fa0ed2f2e4ff2d9d53b9d72cfbc108a9034 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sun, 25 Aug 2024 16:02:11 -0400
Subject: [PATCH 595/685] Avoid taking reference of &TyKind

---
 compiler/rustc_borrowck/src/borrowck_errors.rs              | 2 +-
 compiler/rustc_borrowck/src/places_conflict.rs              | 2 +-
 compiler/rustc_const_eval/src/interpret/cast.rs             | 6 +++---
 compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs   | 2 +-
 compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs      | 2 +-
 compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs        | 4 ++--
 compiler/rustc_hir_typeck/src/method/suggest.rs             | 2 +-
 compiler/rustc_hir_typeck/src/pat.rs                        | 2 +-
 compiler/rustc_middle/src/ty/layout.rs                      | 2 +-
 compiler/rustc_middle/src/ty/util.rs                        | 2 +-
 compiler/rustc_mir_build/src/build/expr/as_constant.rs      | 2 +-
 compiler/rustc_mir_build/src/thir/constant.rs               | 2 +-
 compiler/rustc_monomorphize/src/collector.rs                | 4 ++--
 .../src/error_reporting/infer/suggest.rs                    | 2 +-
 14 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/compiler/rustc_borrowck/src/borrowck_errors.rs b/compiler/rustc_borrowck/src/borrowck_errors.rs
index 76e39fe94af43..70f89e80dc94d 100644
--- a/compiler/rustc_borrowck/src/borrowck_errors.rs
+++ b/compiler/rustc_borrowck/src/borrowck_errors.rs
@@ -290,7 +290,7 @@ impl<'infcx, 'tcx> crate::MirBorrowckCtxt<'_, '_, 'infcx, 'tcx> {
         ty: Ty<'_>,
         is_index: Option<bool>,
     ) -> Diag<'infcx> {
-        let type_name = match (&ty.kind(), is_index) {
+        let type_name = match (ty.kind(), is_index) {
             (&ty::Array(_, _), Some(true)) | (&ty::Array(_, _), None) => "array",
             (&ty::Slice(_), _) => "slice",
             _ => span_bug!(move_from_span, "this path should not cause illegal move"),
diff --git a/compiler/rustc_borrowck/src/places_conflict.rs b/compiler/rustc_borrowck/src/places_conflict.rs
index 42d0c2038f8bb..311f17f15b9ee 100644
--- a/compiler/rustc_borrowck/src/places_conflict.rs
+++ b/compiler/rustc_borrowck/src/places_conflict.rs
@@ -201,7 +201,7 @@ fn place_components_conflict<'tcx>(
 
             let base_ty = base.ty(body, tcx).ty;
 
-            match (elem, &base_ty.kind(), access) {
+            match (elem, base_ty.kind(), access) {
                 (_, _, Shallow(Some(ArtificialField::ArrayLength)))
                 | (_, _, Shallow(Some(ArtificialField::FakeBorrow))) => {
                     // The array length is like additional fields on the
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
index 4901e4b2a4158..e8c9f145eea55 100644
--- a/compiler/rustc_const_eval/src/interpret/cast.rs
+++ b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -388,7 +388,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         let (src_pointee_ty, dest_pointee_ty) =
             self.tcx.struct_lockstep_tails_for_codegen(source_ty, cast_ty, self.param_env);
 
-        match (&src_pointee_ty.kind(), &dest_pointee_ty.kind()) {
+        match (src_pointee_ty.kind(), dest_pointee_ty.kind()) {
             (&ty::Array(_, length), &ty::Slice(_)) => {
                 let ptr = self.read_pointer(src)?;
                 let val = Immediate::new_slice(
@@ -478,9 +478,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         dest: &PlaceTy<'tcx, M::Provenance>,
     ) -> InterpResult<'tcx> {
         trace!("Unsizing {:?} of type {} into {}", *src, src.layout.ty, cast_ty.ty);
-        match (&src.layout.ty.kind(), &cast_ty.ty.kind()) {
+        match (src.layout.ty.kind(), cast_ty.ty.kind()) {
             (&ty::Ref(_, s, _), &ty::Ref(_, c, _) | &ty::RawPtr(c, _))
-            | (&ty::RawPtr(s, _), &ty::RawPtr(c, _)) => self.unsize_into_ptr(src, dest, *s, *c),
+            | (&ty::RawPtr(s, _), &ty::RawPtr(c, _)) => self.unsize_into_ptr(src, dest, s, c),
             (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
                 assert_eq!(def_a, def_b); // implies same number of fields
 
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
index d77cbe3053653..af319fd53bde7 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -608,7 +608,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         let mut bound_span_label = |self_ty: Ty<'_>, obligation: &str, quiet: &str| {
             let msg = format!("`{}`", if obligation.len() > 50 { quiet } else { obligation });
-            match &self_ty.kind() {
+            match self_ty.kind() {
                 // Point at the type that couldn't satisfy the bound.
                 ty::Adt(def, _) => {
                     bound_spans.get_mut_or_insert_default(tcx.def_span(def.did())).push(msg)
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 5c8ecf254a54e..d1a0da47b3d18 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -1057,7 +1057,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         // Find the type of the associated item, and the trait where the associated
         // item is declared.
-        let bound = match (&qself_ty.kind(), qself_res) {
+        let bound = match (qself_ty.kind(), qself_res) {
             (_, Res::SelfTyAlias { alias_to: impl_def_id, is_trait_impl: true, .. }) => {
                 // `Self` in an impl of a trait -- we have a concrete self type and a
                 // trait reference.
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index 703273968c5bb..11c6e65a21101 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -2975,7 +2975,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let mut suffix_suggestion = sugg.clone();
         suffix_suggestion.push((
             if matches!(
-                (&expected_ty.kind(), &checked_ty.kind()),
+                (expected_ty.kind(), checked_ty.kind()),
                 (ty::Int(_) | ty::Uint(_), ty::Float(_))
             ) {
                 // Remove fractional part from literal, for example `42.0f32` into `42`
@@ -3077,7 +3077,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 err.multipart_suggestion_verbose(msg, suggestion, Applicability::MachineApplicable);
             };
 
-        match (&expected_ty.kind(), &checked_ty.kind()) {
+        match (expected_ty.kind(), checked_ty.kind()) {
             (ty::Int(exp), ty::Int(found)) => {
                 let (f2e_is_fallible, e2f_is_fallible) = match (exp.bit_width(), found.bit_width())
                 {
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 3df32dd85052b..ffd46ea13b908 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -1012,7 +1012,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 };
             let mut bound_span_label = |self_ty: Ty<'_>, obligation: &str, quiet: &str| {
                 let msg = format!("`{}`", if obligation.len() > 50 { quiet } else { obligation });
-                match &self_ty.kind() {
+                match self_ty.kind() {
                     // Point at the type that couldn't satisfy the bound.
                     ty::Adt(def, _) => {
                         bound_spans.get_mut_or_insert_default(tcx.def_span(def.did())).push(msg)
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index c4f74adb4207b..a8e5e09c8bbeb 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -1336,7 +1336,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // More generally, the expected type wants a tuple variant with one field of an
         // N-arity-tuple, e.g., `V_i((p_0, .., p_N))`. Meanwhile, the user supplied a pattern
         // with the subpatterns directly in the tuple variant pattern, e.g., `V_i(p_0, .., p_N)`.
-        let missing_parentheses = match (&expected.kind(), fields, had_err) {
+        let missing_parentheses = match (expected.kind(), fields, had_err) {
             // #67037: only do this if we could successfully type-check the expected type against
             // the tuple struct pattern. Otherwise the args could get out of range on e.g.,
             // `let P() = U;` where `P != U` with `struct P<T>(T);`.
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index 619981bf021e4..d0a9039441dc4 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -1104,7 +1104,7 @@ where
     }
 
     fn is_never(this: TyAndLayout<'tcx>) -> bool {
-        this.ty.kind() == &ty::Never
+        matches!(this.ty.kind(), ty::Never)
     }
 
     fn is_tuple(this: TyAndLayout<'tcx>) -> bool {
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 045c8ad39bee2..efbccca77c1f0 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -296,7 +296,7 @@ impl<'tcx> TyCtxt<'tcx> {
     ) -> (Ty<'tcx>, Ty<'tcx>) {
         let (mut a, mut b) = (source, target);
         loop {
-            match (&a.kind(), &b.kind()) {
+            match (a.kind(), b.kind()) {
                 (&ty::Adt(a_def, a_args), &ty::Adt(b_def, b_args))
                     if a_def == b_def && a_def.is_struct() =>
                 {
diff --git a/compiler/rustc_mir_build/src/build/expr/as_constant.rs b/compiler/rustc_mir_build/src/build/expr/as_constant.rs
index 4430aab73a819..4f1166f91118e 100644
--- a/compiler/rustc_mir_build/src/build/expr/as_constant.rs
+++ b/compiler/rustc_mir_build/src/build/expr/as_constant.rs
@@ -127,7 +127,7 @@ fn lit_to_mir_constant<'tcx>(
         Ok(ConstValue::Scalar(Scalar::from_uint(result, width)))
     };
 
-    let value = match (lit, &ty.kind()) {
+    let value = match (lit, ty.kind()) {
         (ast::LitKind::Str(s, _), ty::Ref(_, inner_ty, _)) if inner_ty.is_str() => {
             let s = s.as_str();
             let allocation = Allocation::from_bytes_byte_aligned_immutable(s.as_bytes());
diff --git a/compiler/rustc_mir_build/src/thir/constant.rs b/compiler/rustc_mir_build/src/thir/constant.rs
index 7b94867114d5a..b8877a64e47eb 100644
--- a/compiler/rustc_mir_build/src/thir/constant.rs
+++ b/compiler/rustc_mir_build/src/thir/constant.rs
@@ -29,7 +29,7 @@ pub(crate) fn lit_to_const<'tcx>(
             .unwrap_or_else(|| bug!("expected to create ScalarInt from uint {:?}", result)))
     };
 
-    let valtree = match (lit, &ty.kind()) {
+    let valtree = match (lit, ty.kind()) {
         (ast::LitKind::Str(s, _), ty::Ref(_, inner_ty, _)) if inner_ty.is_str() => {
             let str_bytes = s.as_str().as_bytes();
             ty::ValTree::from_raw_bytes(tcx, str_bytes)
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 77f6a1e17cefc..ff4207fbefda8 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -1035,9 +1035,9 @@ fn find_vtable_types_for_unsizing<'tcx>(
         }
     };
 
-    match (&source_ty.kind(), &target_ty.kind()) {
+    match (source_ty.kind(), target_ty.kind()) {
         (&ty::Ref(_, a, _), &ty::Ref(_, b, _) | &ty::RawPtr(b, _))
-        | (&ty::RawPtr(a, _), &ty::RawPtr(b, _)) => ptr_vtable(*a, *b),
+        | (&ty::RawPtr(a, _), &ty::RawPtr(b, _)) => ptr_vtable(a, b),
         (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) if def_a.is_box() && def_b.is_box() => {
             ptr_vtable(source_ty.boxed_ty(), target_ty.boxed_ty())
         }
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs
index 35f68a56d2ddc..ba656493d462d 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/suggest.rs
@@ -382,7 +382,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
         if !expected_inner.is_fn() || !found_inner.is_fn() {
             return;
         }
-        match (&expected_inner.kind(), &found_inner.kind()) {
+        match (expected_inner.kind(), found_inner.kind()) {
             (ty::FnPtr(sig_tys, hdr), ty::FnDef(did, args)) => {
                 let sig = sig_tys.with(*hdr);
                 let expected_sig = &(self.normalize_fn_sig)(sig);

From ecd2d115736581726ee9b77432561ea9480b3241 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 24 Aug 2024 15:03:51 -0400
Subject: [PATCH 596/685] Remove redundant flags that can be inferred from the
 HIR

---
 .../src/hir_ty_lowering/lint.rs               | 21 +++++++++++----
 .../src/hir_ty_lowering/mod.rs                | 27 ++++---------------
 .../src/hir_ty_lowering/object_safety.rs      |  1 -
 .../rustc_hir_typeck/src/fn_ctxt/_impl.rs     |  2 +-
 .../suggest-dyn-on-bare-trait-in-pat.rs       | 14 ++++++++++
 .../suggest-dyn-on-bare-trait-in-pat.stderr   | 14 ++++++++++
 6 files changed, 50 insertions(+), 29 deletions(-)
 create mode 100644 tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.rs
 create mode 100644 tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.stderr

diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs
index 6aff518390ffc..7be45463f1512 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs
@@ -15,11 +15,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     ///
     /// *Bare* trait object types are ones that aren't preceded by the keyword `dyn`.
     /// In edition 2021 and onward we emit a hard error for them.
-    pub(super) fn prohibit_or_lint_bare_trait_object_ty(
-        &self,
-        self_ty: &hir::Ty<'_>,
-        in_path: bool,
-    ) {
+    pub(super) fn prohibit_or_lint_bare_trait_object_ty(&self, self_ty: &hir::Ty<'_>) {
         let tcx = self.tcx();
 
         let hir::TyKind::TraitObject([poly_trait_ref, ..], _, TraitObjectSyntax::None) =
@@ -28,6 +24,21 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             return;
         };
 
+        let in_path = match tcx.parent_hir_node(self_ty.hir_id) {
+            hir::Node::Ty(hir::Ty {
+                kind: hir::TyKind::Path(hir::QPath::TypeRelative(qself, _)),
+                ..
+            })
+            | hir::Node::Expr(hir::Expr {
+                kind: hir::ExprKind::Path(hir::QPath::TypeRelative(qself, _)),
+                ..
+            })
+            | hir::Node::Pat(hir::Pat {
+                kind: hir::PatKind::Path(hir::QPath::TypeRelative(qself, _)),
+                ..
+            }) if qself.hir_id == self_ty.hir_id => true,
+            _ => false,
+        };
         let needs_bracket = in_path
             && !tcx
                 .sess
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 73baa05bce660..010d58bfb673c 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -1998,16 +1998,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         }
     }
 
-    /// Lower a type from the HIR to our internal notion of a type.
-    pub fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
-        self.lower_ty_common(hir_ty, false, false)
-    }
-
-    /// Lower a type inside of a path from the HIR to our internal notion of a type.
-    pub fn lower_ty_in_path(&self, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
-        self.lower_ty_common(hir_ty, false, true)
-    }
-
     fn lower_delegation_ty(&self, idx: hir::InferDelegationKind) -> Ty<'tcx> {
         let delegation_sig = self.tcx().inherit_sig_for_delegation_item(self.item_def_id());
         match idx {
@@ -2025,7 +2015,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     /// 2. `in_path`: Whether the type appears inside of a path.
     ///    Used to provide correct diagnostics for bare trait object types.
     #[instrument(level = "debug", skip(self), ret)]
-    fn lower_ty_common(&self, hir_ty: &hir::Ty<'tcx>, borrowed: bool, in_path: bool) -> Ty<'tcx> {
+    pub fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
         let tcx = self.tcx();
 
         let result_ty = match &hir_ty.kind {
@@ -2035,7 +2025,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             hir::TyKind::Ref(region, mt) => {
                 let r = self.lower_lifetime(region, RegionInferReason::Reference);
                 debug!(?r);
-                let t = self.lower_ty_common(mt.ty, true, false);
+                let t = self.lower_ty(mt.ty);
                 Ty::new_ref(tcx, r, t, mt.mutbl)
             }
             hir::TyKind::Never => tcx.types.never,
@@ -2064,20 +2054,13 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 )
             }
             hir::TyKind::TraitObject(bounds, lifetime, repr) => {
-                self.prohibit_or_lint_bare_trait_object_ty(hir_ty, in_path);
+                self.prohibit_or_lint_bare_trait_object_ty(hir_ty);
 
                 let repr = match repr {
                     TraitObjectSyntax::Dyn | TraitObjectSyntax::None => ty::Dyn,
                     TraitObjectSyntax::DynStar => ty::DynStar,
                 };
-                self.lower_trait_object_ty(
-                    hir_ty.span,
-                    hir_ty.hir_id,
-                    bounds,
-                    lifetime,
-                    borrowed,
-                    repr,
-                )
+                self.lower_trait_object_ty(hir_ty.span, hir_ty.hir_id, bounds, lifetime, repr)
             }
             hir::TyKind::Path(hir::QPath::Resolved(maybe_qself, path)) => {
                 debug!(?maybe_qself, ?path);
@@ -2105,7 +2088,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             }
             hir::TyKind::Path(hir::QPath::TypeRelative(qself, segment)) => {
                 debug!(?qself, ?segment);
-                let ty = self.lower_ty_common(qself, false, true);
+                let ty = self.lower_ty(qself);
                 self.lower_assoc_path(hir_ty.hir_id, hir_ty.span, ty, qself, segment, false)
                     .map(|(ty, _, _)| ty)
                     .unwrap_or_else(|guar| Ty::new_error(tcx, guar))
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
index 082fbb2c41835..52e167379b5dd 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
@@ -30,7 +30,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         hir_id: hir::HirId,
         hir_trait_bounds: &[(hir::PolyTraitRef<'tcx>, hir::TraitBoundModifier)],
         lifetime: &hir::Lifetime,
-        _borrowed: bool,
         representation: DynKind,
     ) -> Ty<'tcx> {
         let tcx = self.tcx();
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index b169f75796b3a..21e6ac9332cdf 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -798,7 +798,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // to be object-safe.
                 // We manually call `register_wf_obligation` in the success path
                 // below.
-                let ty = self.lowerer().lower_ty_in_path(qself);
+                let ty = self.lowerer().lower_ty(qself);
                 (LoweredTy::from_raw(self, span, ty), qself, segment)
             }
             QPath::LangItem(..) => {
diff --git a/tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.rs b/tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.rs
new file mode 100644
index 0000000000000..19b5edb620f6b
--- /dev/null
+++ b/tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.rs
@@ -0,0 +1,14 @@
+//@ edition: 2021
+
+trait Trait {}
+
+impl dyn Trait {
+    const CONST: () = ();
+}
+
+fn main() {
+    match () {
+        Trait::CONST => {}
+        //~^ ERROR trait objects must include the `dyn` keyword
+    }
+}
diff --git a/tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.stderr b/tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.stderr
new file mode 100644
index 0000000000000..4446a89b63b15
--- /dev/null
+++ b/tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.stderr
@@ -0,0 +1,14 @@
+error[E0782]: trait objects must include the `dyn` keyword
+  --> $DIR/suggest-dyn-on-bare-trait-in-pat.rs:11:9
+   |
+LL |         Trait::CONST => {}
+   |         ^^^^^
+   |
+help: add `dyn` keyword before this trait
+   |
+LL |         <dyn Trait>::CONST => {}
+   |         ++++      +
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0782`.

From 1c58522068f36625c5a0deaafdb1411aafe541f9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Sat, 24 Aug 2024 16:57:47 -0400
Subject: [PATCH 597/685] Use FxHasher on new solver unconditionally

---
 Cargo.lock                                    |  1 +
 compiler/rustc_type_ir/Cargo.toml             |  1 +
 compiler/rustc_type_ir/src/data_structures.rs | 15 +++++++++------
 3 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f2e2baea8e47c..24164470bf059 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4543,6 +4543,7 @@ dependencies = [
  "bitflags 2.6.0",
  "derive-where",
  "indexmap",
+ "rustc-hash",
  "rustc_ast_ir",
  "rustc_data_structures",
  "rustc_index",
diff --git a/compiler/rustc_type_ir/Cargo.toml b/compiler/rustc_type_ir/Cargo.toml
index 2750838bbe99f..0ffad8b87aafe 100644
--- a/compiler/rustc_type_ir/Cargo.toml
+++ b/compiler/rustc_type_ir/Cargo.toml
@@ -8,6 +8,7 @@ edition = "2021"
 bitflags = "2.4.1"
 derive-where = "1.2.7"
 indexmap = "2.0.0"
+rustc-hash = "1.1.0"
 rustc_ast_ir = { path = "../rustc_ast_ir", default-features = false }
 rustc_data_structures = { path = "../rustc_data_structures", optional = true }
 rustc_index = { path = "../rustc_index", default-features = false }
diff --git a/compiler/rustc_type_ir/src/data_structures.rs b/compiler/rustc_type_ir/src/data_structures.rs
index 4ca97c0c86c0f..96036e53b0abb 100644
--- a/compiler/rustc_type_ir/src/data_structures.rs
+++ b/compiler/rustc_type_ir/src/data_structures.rs
@@ -1,8 +1,13 @@
+use std::hash::BuildHasherDefault;
+
+use rustc_hash::FxHasher;
+pub use rustc_hash::{FxHashMap as HashMap, FxHashSet as HashSet};
+
+pub type IndexMap<K, V> = indexmap::IndexMap<K, V, BuildHasherDefault<FxHasher>>;
+pub type IndexSet<V> = indexmap::IndexSet<V, BuildHasherDefault<FxHasher>>;
+
 #[cfg(feature = "nightly")]
 mod impl_ {
-    pub use rustc_data_structures::fx::{
-        FxHashMap as HashMap, FxHashSet as HashSet, FxIndexMap as IndexMap, FxIndexSet as IndexSet,
-    };
     pub use rustc_data_structures::sso::{SsoHashMap, SsoHashSet};
     pub use rustc_data_structures::stack::ensure_sufficient_stack;
     pub use rustc_data_structures::sync::Lrc;
@@ -10,11 +15,9 @@ mod impl_ {
 
 #[cfg(not(feature = "nightly"))]
 mod impl_ {
-    pub use std::collections::{HashMap, HashMap as SsoHashMap, HashSet, HashSet as SsoHashSet};
+    pub use std::collections::{HashMap as SsoHashMap, HashSet as SsoHashSet};
     pub use std::sync::Arc as Lrc;
 
-    pub use indexmap::{IndexMap, IndexSet};
-
     #[inline]
     pub fn ensure_sufficient_stack<R>(f: impl FnOnce() -> R) -> R {
         f()

From edeefc532f645386db828a956cb50702e15f8b03 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Martin=20Kr=C3=B6ning?=
 <martin.kroening@eonerc.rwth-aachen.de>
Date: Mon, 26 Aug 2024 00:04:00 +0200
Subject: [PATCH 598/685] pal/hermit: saturate `usleep` microseconds at
 `u64::MAX`
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Martin Kröning <martin.kroening@eonerc.rwth-aachen.de>
---
 library/std/src/sys/pal/hermit/thread.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/library/std/src/sys/pal/hermit/thread.rs b/library/std/src/sys/pal/hermit/thread.rs
index bc70b3ac1705c..4c0c0919f4799 100644
--- a/library/std/src/sys/pal/hermit/thread.rs
+++ b/library/std/src/sys/pal/hermit/thread.rs
@@ -78,9 +78,10 @@ impl Thread {
     #[inline]
     pub fn sleep(dur: Duration) {
         let micros = dur.as_micros() + if dur.subsec_nanos() % 1_000 > 0 { 1 } else { 0 };
+        let micros = u64::try_from(micros).unwrap_or(u64::MAX);
 
         unsafe {
-            hermit_abi::usleep(micros as u64);
+            hermit_abi::usleep(micros);
         }
     }
 

From 5b374631df79f879560f3a4d041290e152c05ab0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sat, 10 Aug 2024 15:02:13 +0000
Subject: [PATCH 599/685] compiletest: implement `needs-lvm-zstd` directive

---
 src/tools/compiletest/src/command-list.rs |   1 +
 src/tools/compiletest/src/header.rs       | 101 ++++++++++++++++++++++
 src/tools/compiletest/src/header/needs.rs |  10 ++-
 3 files changed, 111 insertions(+), 1 deletion(-)

diff --git a/src/tools/compiletest/src/command-list.rs b/src/tools/compiletest/src/command-list.rs
index 7f8080235c870..a559d6f81a240 100644
--- a/src/tools/compiletest/src/command-list.rs
+++ b/src/tools/compiletest/src/command-list.rs
@@ -141,6 +141,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "needs-force-clang-based-tests",
     "needs-git-hash",
     "needs-llvm-components",
+    "needs-llvm-zstd",
     "needs-profiler-support",
     "needs-relocation-model-pic",
     "needs-run-enabled",
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index 1fc24301c85e6..933913eb47c34 100644
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -1203,6 +1203,107 @@ pub fn extract_llvm_version_from_binary(binary_path: &str) -> Option<u32> {
     None
 }
 
+/// For tests using the `needs-llvm-zstd` directive:
+/// - for local LLVM builds, try to find the static zstd library in the llvm-config system libs.
+/// - for `download-ci-llvm`, see if `lld` was built with zstd support.
+pub fn llvm_has_libzstd(config: &Config) -> bool {
+    // Strategy 1: works for local builds but not with `download-ci-llvm`.
+    //
+    // We check whether `llvm-config` returns the zstd library. Bootstrap's `llvm.libzstd` will only
+    // ask to statically link it when building LLVM, so we only check if the list of system libs
+    // contains a path to that static lib, and that it exists.
+    //
+    // See compiler/rustc_llvm/build.rs for more details and similar expectations.
+    fn is_zstd_in_config(llvm_bin_dir: &Path) -> Option<()> {
+        let llvm_config_path = llvm_bin_dir.join("llvm-config");
+        let output = Command::new(llvm_config_path).arg("--system-libs").output().ok()?;
+        assert!(output.status.success(), "running llvm-config --system-libs failed");
+
+        let libs = String::from_utf8(output.stdout).ok()?;
+        for lib in libs.split_whitespace() {
+            if lib.ends_with("libzstd.a") && Path::new(lib).exists() {
+                return Some(());
+            }
+        }
+
+        None
+    }
+
+    // Strategy 2: `download-ci-llvm`'s `llvm-config --system-libs` will not return any libs to
+    // use.
+    //
+    // The CI artifacts also don't contain the bootstrap config used to build them: otherwise we
+    // could have looked at the `llvm.libzstd` config.
+    //
+    // We infer whether `LLVM_ENABLE_ZSTD` was used to build LLVM as a byproduct of testing whether
+    // `lld` supports it. If not, an error will be emitted: "LLVM was not built with
+    // LLVM_ENABLE_ZSTD or did not find zstd at build time".
+    #[cfg(unix)]
+    fn is_lld_built_with_zstd(llvm_bin_dir: &Path) -> Option<()> {
+        let lld_path = llvm_bin_dir.join("lld");
+        if lld_path.exists() {
+            // We can't call `lld` as-is, it expects to be invoked by a compiler driver using a
+            // different name. Prepare a temporary symlink to do that.
+            let lld_symlink_path = llvm_bin_dir.join("ld.lld");
+            if !lld_symlink_path.exists() {
+                std::os::unix::fs::symlink(lld_path, &lld_symlink_path).ok()?;
+            }
+
+            // Run `lld` with a zstd flag. We expect this command to always error here, we don't
+            // want to link actual files and don't pass any.
+            let output = Command::new(&lld_symlink_path)
+                .arg("--compress-debug-sections=zstd")
+                .output()
+                .ok()?;
+            assert!(!output.status.success());
+
+            // Look for a specific error caused by LLVM not being built with zstd support. We could
+            // also look for the "no input files" message, indicating the zstd flag was accepted.
+            let stderr = String::from_utf8(output.stderr).ok()?;
+            let zstd_available = !stderr.contains("LLVM was not built with LLVM_ENABLE_ZSTD");
+
+            // We don't particularly need to clean the link up (so the previous commands could fail
+            // in theory but won't in practice), but we can try.
+            std::fs::remove_file(lld_symlink_path).ok()?;
+
+            if zstd_available {
+                return Some(());
+            }
+        }
+
+        None
+    }
+
+    #[cfg(not(unix))]
+    fn is_lld_built_with_zstd(_llvm_bin_dir: &Path) -> Option<()> {
+        None
+    }
+
+    if let Some(llvm_bin_dir) = &config.llvm_bin_dir {
+        // Strategy 1: for local LLVM builds.
+        if is_zstd_in_config(llvm_bin_dir).is_some() {
+            return true;
+        }
+
+        // Strategy 2: for LLVM artifacts built on CI via `download-ci-llvm`.
+        //
+        // It doesn't work for cases where the artifacts don't contain the linker, but it's
+        // best-effort: CI has `llvm.libzstd` and `lld` enabled on the x64 linux artifacts, so it
+        // will at least work there.
+        //
+        // If this can be improved and expanded to less common cases in the future, it should.
+        if config.target == "x86_64-unknown-linux-gnu"
+            && config.host == config.target
+            && is_lld_built_with_zstd(llvm_bin_dir).is_some()
+        {
+            return true;
+        }
+    }
+
+    // Otherwise, all hope is lost.
+    false
+}
+
 /// Takes a directive of the form "<version1> [- <version2>]",
 /// returns the numeric representation of <version1> and <version2> as
 /// tuple: (<version1> as u32, <version2> as u32)
diff --git a/src/tools/compiletest/src/header/needs.rs b/src/tools/compiletest/src/header/needs.rs
index 8f935d5b74441..e04abea0bf987 100644
--- a/src/tools/compiletest/src/header/needs.rs
+++ b/src/tools/compiletest/src/header/needs.rs
@@ -1,5 +1,5 @@
 use crate::common::{Config, Sanitizer};
-use crate::header::IgnoreDecision;
+use crate::header::{llvm_has_libzstd, IgnoreDecision};
 
 pub(super) fn handle_needs(
     cache: &CachedNeedsConditions,
@@ -144,6 +144,11 @@ pub(super) fn handle_needs(
             condition: cache.symlinks,
             ignore_reason: "ignored if symlinks are unavailable",
         },
+        Need {
+            name: "needs-llvm-zstd",
+            condition: cache.llvm_zstd,
+            ignore_reason: "ignored if LLVM wasn't build with zstd for ELF section compression",
+        },
     ];
 
     let (name, comment) = match ln.split_once([':', ' ']) {
@@ -210,6 +215,8 @@ pub(super) struct CachedNeedsConditions {
     rust_lld: bool,
     dlltool: bool,
     symlinks: bool,
+    /// Whether LLVM built with zstd, for the `needs-llvm-zstd` directive.
+    llvm_zstd: bool,
 }
 
 impl CachedNeedsConditions {
@@ -253,6 +260,7 @@ impl CachedNeedsConditions {
                 .join(if config.host.contains("windows") { "rust-lld.exe" } else { "rust-lld" })
                 .exists(),
 
+            llvm_zstd: llvm_has_libzstd(&config),
             dlltool: find_dlltool(&config),
             symlinks: has_symlinks(),
         }

From 79f3c51a01693b264419f74b5527c146b4d52e81 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sat, 10 Aug 2024 15:09:20 +0000
Subject: [PATCH 600/685] mark `rust-lld-compress-debug-sections` test as
 needing zstd

also make it fail if there's a compression issue
---
 .../rust-lld-compress-debug-sections/rmake.rs  | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/tests/run-make/rust-lld-compress-debug-sections/rmake.rs b/tests/run-make/rust-lld-compress-debug-sections/rmake.rs
index ea4997fab8099..9889659046ea7 100644
--- a/tests/run-make/rust-lld-compress-debug-sections/rmake.rs
+++ b/tests/run-make/rust-lld-compress-debug-sections/rmake.rs
@@ -1,12 +1,13 @@
 // Checks the `compress-debug-sections` option on rust-lld.
 
 //@ needs-rust-lld
+//@ needs-llvm-zstd
 //@ only-linux
 //@ ignore-cross-compile
 
 // FIXME: This test isn't comprehensive and isn't covering all possible combinations.
 
-use run_make_support::{assert_contains, llvm_readobj, run_in_tmpdir, rustc};
+use run_make_support::{llvm_readobj, run_in_tmpdir, rustc};
 
 fn check_compression(compression: &str, to_find: &str) {
     run_in_tmpdir(|| {
@@ -17,19 +18,8 @@ fn check_compression(compression: &str, to_find: &str) {
             .arg("-Cdebuginfo=full")
             .link_arg(&format!("-Wl,--compress-debug-sections={compression}"))
             .input("main.rs")
-            .run_unchecked();
-        let stderr = out.stderr_utf8();
-        if stderr.is_empty() {
-            llvm_readobj().arg("-t").arg("main").run().assert_stdout_contains(to_find);
-        } else {
-            assert_contains(
-                stderr,
-                format!(
-                    "LLVM was not built with LLVM_ENABLE_{to_find} \
-                     or did not find {compression} at build time"
-                ),
-            );
-        }
+            .run();
+        llvm_readobj().arg("-t").arg("main").run().assert_stdout_contains(to_find);
     });
 }
 

From 802222fefca2e374a254877c54beb051843cd974 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sat, 10 Aug 2024 16:22:04 +0000
Subject: [PATCH 601/685] prepare test for expanding scope

---
 .../main.rs                                                       | 0
 .../rmake.rs                                                      | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/run-make/{rust-lld-compress-debug-sections => compressed-debuginfo-zstd}/main.rs (100%)
 rename tests/run-make/{rust-lld-compress-debug-sections => compressed-debuginfo-zstd}/rmake.rs (100%)

diff --git a/tests/run-make/rust-lld-compress-debug-sections/main.rs b/tests/run-make/compressed-debuginfo-zstd/main.rs
similarity index 100%
rename from tests/run-make/rust-lld-compress-debug-sections/main.rs
rename to tests/run-make/compressed-debuginfo-zstd/main.rs
diff --git a/tests/run-make/rust-lld-compress-debug-sections/rmake.rs b/tests/run-make/compressed-debuginfo-zstd/rmake.rs
similarity index 100%
rename from tests/run-make/rust-lld-compress-debug-sections/rmake.rs
rename to tests/run-make/compressed-debuginfo-zstd/rmake.rs

From 1935e21029d28af3022064f57b36fff85b8db9d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sat, 10 Aug 2024 16:59:00 +0000
Subject: [PATCH 602/685] expand zstd debuginfo compression test

it now checks zlib and zstd, via rustc and rust-lld
---
 .../compressed-debuginfo-zstd/rmake.rs        | 33 +++++++++++++------
 1 file changed, 23 insertions(+), 10 deletions(-)

diff --git a/tests/run-make/compressed-debuginfo-zstd/rmake.rs b/tests/run-make/compressed-debuginfo-zstd/rmake.rs
index 9889659046ea7..8356373e949aa 100644
--- a/tests/run-make/compressed-debuginfo-zstd/rmake.rs
+++ b/tests/run-make/compressed-debuginfo-zstd/rmake.rs
@@ -1,24 +1,37 @@
-// Checks the `compress-debug-sections` option on rust-lld.
+// Checks debuginfo compression both for the always-enabled zlib, and when the optional zstd is
+// enabled:
+// - via rustc's `debuginfo-compression`,
+// - and via rust-lld's `compress-debug-sections`
 
-//@ needs-rust-lld
-//@ needs-llvm-zstd
+//@ needs-llvm-zstd: we want LLVM/LLD to be built with zstd support
+//@ needs-rust-lld: the system linker will most likely not support zstd
 //@ only-linux
 //@ ignore-cross-compile
 
-// FIXME: This test isn't comprehensive and isn't covering all possible combinations.
-
-use run_make_support::{llvm_readobj, run_in_tmpdir, rustc};
+use run_make_support::{llvm_readobj, run_in_tmpdir, Rustc};
 
 fn check_compression(compression: &str, to_find: &str) {
+    // check compressed debug sections via rustc flag
+    prepare_and_check(to_find, |rustc| {
+        rustc.arg(&format!("-Zdebuginfo-compression={compression}"))
+    });
+
+    // check compressed debug sections via rust-lld flag
+    prepare_and_check(to_find, |rustc| {
+        rustc.link_arg(&format!("-Wl,--compress-debug-sections={compression}"))
+    });
+}
+
+fn prepare_and_check<F: FnOnce(&mut Rustc) -> &mut Rustc>(to_find: &str, prepare_rustc: F) {
     run_in_tmpdir(|| {
-        let out = rustc()
+        let mut rustc = Rustc::new();
+        rustc
             .arg("-Zlinker-features=+lld")
             .arg("-Clink-self-contained=+linker")
             .arg("-Zunstable-options")
             .arg("-Cdebuginfo=full")
-            .link_arg(&format!("-Wl,--compress-debug-sections={compression}"))
-            .input("main.rs")
-            .run();
+            .input("main.rs");
+        prepare_rustc(&mut rustc).run();
         llvm_readobj().arg("-t").arg("main").run().assert_stdout_contains(to_find);
     });
 }

From 62c8c693bdda3932dbb049f8a2707f2f616d29eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sat, 10 Aug 2024 22:25:22 +0000
Subject: [PATCH 603/685] move and rename zstd script

move it where it's used, and name it like the other scripts
---
 src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile      | 6 +++---
 .../zstd.sh => host-x86_64/dist-x86_64-linux/build-zstd.sh} | 0
 2 files changed, 3 insertions(+), 3 deletions(-)
 rename src/ci/docker/{scripts/zstd.sh => host-x86_64/dist-x86_64-linux/build-zstd.sh} (100%)

diff --git a/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile b/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile
index 61e9694f1e2ae..e857f38e68a85 100644
--- a/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-x86_64-linux/Dockerfile
@@ -62,9 +62,9 @@ COPY host-x86_64/dist-x86_64-linux/build-clang.sh /tmp/
 RUN ./build-clang.sh
 ENV CC=clang CXX=clang++
 
-# rustc's LLVM needs zstd.
-COPY scripts/zstd.sh /tmp/
-RUN ./zstd.sh
+# Build zstd to enable `llvm.libzstd`.
+COPY host-x86_64/dist-x86_64-linux/build-zstd.sh /tmp/
+RUN ./build-zstd.sh
 
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
diff --git a/src/ci/docker/scripts/zstd.sh b/src/ci/docker/host-x86_64/dist-x86_64-linux/build-zstd.sh
similarity index 100%
rename from src/ci/docker/scripts/zstd.sh
rename to src/ci/docker/host-x86_64/dist-x86_64-linux/build-zstd.sh

From 7963beda2481deb5bd01286b61386d599536a3b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sun, 11 Aug 2024 15:02:13 +0000
Subject: [PATCH 604/685] strip whitespace for ignored tests reason comments

---
 src/tools/compiletest/src/header/needs.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tools/compiletest/src/header/needs.rs b/src/tools/compiletest/src/header/needs.rs
index e04abea0bf987..72b1b9c6d480a 100644
--- a/src/tools/compiletest/src/header/needs.rs
+++ b/src/tools/compiletest/src/header/needs.rs
@@ -174,7 +174,7 @@ pub(super) fn handle_needs(
             } else {
                 return IgnoreDecision::Ignore {
                     reason: if let Some(comment) = comment {
-                        format!("{} ({comment})", need.ignore_reason)
+                        format!("{} ({})", need.ignore_reason, comment.trim())
                     } else {
                         need.ignore_reason.into()
                     },

From 650ba7fdf001353664a60be43efb2d96c3c0295b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Sun, 11 Aug 2024 19:05:30 +0000
Subject: [PATCH 605/685] enable `llvm.libzstd` on test x64 linux builder

---
 src/ci/docker/host-x86_64/x86_64-gnu/Dockerfile | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/ci/docker/host-x86_64/x86_64-gnu/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu/Dockerfile
index 19683317126ab..83c2aa8cfb3b7 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu/Dockerfile
@@ -28,5 +28,6 @@ ENV RUST_CONFIGURE_ARGS \
  --build=x86_64-unknown-linux-gnu \
  --enable-sanitizers \
  --enable-profiler \
- --enable-compiler-docs
+ --enable-compiler-docs \
+ --set llvm.libzstd=true
 ENV SCRIPT python3 ../x.py --stage 2 test

From 5d83cb27c886137887c087fbce77032069f5ec8f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Rakic?= <remy.rakic+github@gmail.com>
Date: Tue, 20 Aug 2024 14:04:44 +0000
Subject: [PATCH 606/685] allow `llvm.libzstd` with `download-ci-llvm = true`

but warn about it
---
 src/bootstrap/src/core/config/config.rs | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index ce23b7735f8bd..bdfee55d8d183 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -1885,6 +1885,22 @@ impl Config {
                     warn("link-shared");
                 }
 
+                // FIXME(#129153): instead of all the ad-hoc `download-ci-llvm` checks that follow,
+                // use the `builder-config` present in tarballs since #128822 to compare the local
+                // config to the ones used to build the LLVM artifacts on CI, and only notify users
+                // if they've chosen a different value.
+
+                if libzstd.is_some() {
+                    println!(
+                        "WARNING: when using `download-ci-llvm`, the local `llvm.libzstd` option, \
+                        like almost all `llvm.*` options, will be ignored and set by the LLVM CI \
+                        artifacts builder config."
+                    );
+                    println!(
+                        "HELP: To use `llvm.libzstd` for LLVM/LLD builds, set `download-ci-llvm` option to false."
+                    );
+                }
+
                 // None of the LLVM options, except assertions, are supported
                 // when using downloaded LLVM. We could just ignore these but
                 // that's potentially confusing, so force them to not be
@@ -1894,7 +1910,6 @@ impl Config {
                 check_ci_llvm!(optimize_toml);
                 check_ci_llvm!(thin_lto);
                 check_ci_llvm!(release_debuginfo);
-                check_ci_llvm!(libzstd);
                 check_ci_llvm!(targets);
                 check_ci_llvm!(experimental_targets);
                 check_ci_llvm!(clang_cl);

From 4f3ef2ac90d957c5b36e1d7e662dba1f7b533db8 Mon Sep 17 00:00:00 2001
From: Ben Kimock <kimockb@gmail.com>
Date: Sun, 25 Aug 2024 17:53:53 -0400
Subject: [PATCH 607/685] Remove cfg(test) from library/core

---
 library/core/src/error.rs             |   3 -
 library/core/tests/lib.rs             |   1 -
 library/core/tests/num/int_macros.rs  | 759 +++++++++++++-------------
 library/core/tests/num/mod.rs         |   2 +-
 library/core/tests/num/uint_macros.rs | 543 +++++++++---------
 5 files changed, 649 insertions(+), 659 deletions(-)

diff --git a/library/core/src/error.rs b/library/core/src/error.rs
index 6cc91849e1dc9..cac00b37d1fa7 100644
--- a/library/core/src/error.rs
+++ b/library/core/src/error.rs
@@ -1,9 +1,6 @@
 #![doc = include_str!("error.md")]
 #![stable(feature = "error_in_core", since = "1.81.0")]
 
-#[cfg(test)]
-mod tests;
-
 use crate::any::TypeId;
 use crate::fmt::{Debug, Display, Formatter, Result};
 
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index 073429c7628f0..c205f028dd3a7 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -141,7 +141,6 @@ mod intrinsics;
 mod io;
 mod iter;
 mod lazy;
-#[cfg(test)]
 mod macros;
 mod manually_drop;
 mod mem;
diff --git a/library/core/tests/num/int_macros.rs b/library/core/tests/num/int_macros.rs
index 165d9a296176e..7cd3b54e3f39a 100644
--- a/library/core/tests/num/int_macros.rs
+++ b/library/core/tests/num/int_macros.rs
@@ -1,427 +1,424 @@
 macro_rules! int_module {
     ($T:ident) => {
-        #[cfg(test)]
-        mod tests {
-            use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
-            use core::$T::*;
-
-            use crate::num;
-
-            #[test]
-            fn test_overflows() {
-                assert!(MAX > 0);
-                assert!(MIN <= 0);
-                assert_eq!(MIN + MAX + 1, 0);
-            }
+        use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
+        use core::$T::*;
 
-            #[test]
-            fn test_num() {
-                num::test_num(10 as $T, 2 as $T);
-            }
+        use crate::num;
 
-            #[test]
-            fn test_rem_euclid() {
-                assert_eq!((-1 as $T).rem_euclid(MIN), MAX);
-            }
+        #[test]
+        fn test_overflows() {
+            assert!(MAX > 0);
+            assert!(MIN <= 0);
+            assert_eq!(MIN + MAX + 1, 0);
+        }
 
-            #[test]
-            pub fn test_abs() {
-                assert_eq!((1 as $T).abs(), 1 as $T);
-                assert_eq!((0 as $T).abs(), 0 as $T);
-                assert_eq!((-1 as $T).abs(), 1 as $T);
-            }
+        #[test]
+        fn test_num() {
+            num::test_num(10 as $T, 2 as $T);
+        }
 
-            #[test]
-            fn test_signum() {
-                assert_eq!((1 as $T).signum(), 1 as $T);
-                assert_eq!((0 as $T).signum(), 0 as $T);
-                assert_eq!((-0 as $T).signum(), 0 as $T);
-                assert_eq!((-1 as $T).signum(), -1 as $T);
-            }
+        #[test]
+        fn test_rem_euclid() {
+            assert_eq!((-1 as $T).rem_euclid(MIN), MAX);
+        }
 
-            #[test]
-            fn test_is_positive() {
-                assert!((1 as $T).is_positive());
-                assert!(!(0 as $T).is_positive());
-                assert!(!(-0 as $T).is_positive());
-                assert!(!(-1 as $T).is_positive());
-            }
+        #[test]
+        pub fn test_abs() {
+            assert_eq!((1 as $T).abs(), 1 as $T);
+            assert_eq!((0 as $T).abs(), 0 as $T);
+            assert_eq!((-1 as $T).abs(), 1 as $T);
+        }
 
-            #[test]
-            fn test_is_negative() {
-                assert!(!(1 as $T).is_negative());
-                assert!(!(0 as $T).is_negative());
-                assert!(!(-0 as $T).is_negative());
-                assert!((-1 as $T).is_negative());
-            }
+        #[test]
+        fn test_signum() {
+            assert_eq!((1 as $T).signum(), 1 as $T);
+            assert_eq!((0 as $T).signum(), 0 as $T);
+            assert_eq!((-0 as $T).signum(), 0 as $T);
+            assert_eq!((-1 as $T).signum(), -1 as $T);
+        }
 
-            #[test]
-            fn test_bitwise_operators() {
-                assert_eq!(0b1110 as $T, (0b1100 as $T).bitor(0b1010 as $T));
-                assert_eq!(0b1000 as $T, (0b1100 as $T).bitand(0b1010 as $T));
-                assert_eq!(0b0110 as $T, (0b1100 as $T).bitxor(0b1010 as $T));
-                assert_eq!(0b1110 as $T, (0b0111 as $T).shl(1));
-                assert_eq!(0b0111 as $T, (0b1110 as $T).shr(1));
-                assert_eq!(-(0b11 as $T) - (1 as $T), (0b11 as $T).not());
-            }
+        #[test]
+        fn test_is_positive() {
+            assert!((1 as $T).is_positive());
+            assert!(!(0 as $T).is_positive());
+            assert!(!(-0 as $T).is_positive());
+            assert!(!(-1 as $T).is_positive());
+        }
 
-            const A: $T = 0b0101100;
-            const B: $T = 0b0100001;
-            const C: $T = 0b1111001;
+        #[test]
+        fn test_is_negative() {
+            assert!(!(1 as $T).is_negative());
+            assert!(!(0 as $T).is_negative());
+            assert!(!(-0 as $T).is_negative());
+            assert!((-1 as $T).is_negative());
+        }
 
-            const _0: $T = 0;
-            const _1: $T = !0;
+        #[test]
+        fn test_bitwise_operators() {
+            assert_eq!(0b1110 as $T, (0b1100 as $T).bitor(0b1010 as $T));
+            assert_eq!(0b1000 as $T, (0b1100 as $T).bitand(0b1010 as $T));
+            assert_eq!(0b0110 as $T, (0b1100 as $T).bitxor(0b1010 as $T));
+            assert_eq!(0b1110 as $T, (0b0111 as $T).shl(1));
+            assert_eq!(0b0111 as $T, (0b1110 as $T).shr(1));
+            assert_eq!(-(0b11 as $T) - (1 as $T), (0b11 as $T).not());
+        }
 
-            #[test]
-            fn test_count_ones() {
-                assert_eq!(A.count_ones(), 3);
-                assert_eq!(B.count_ones(), 2);
-                assert_eq!(C.count_ones(), 5);
-            }
+        const A: $T = 0b0101100;
+        const B: $T = 0b0100001;
+        const C: $T = 0b1111001;
 
-            #[test]
-            fn test_count_zeros() {
-                assert_eq!(A.count_zeros(), $T::BITS - 3);
-                assert_eq!(B.count_zeros(), $T::BITS - 2);
-                assert_eq!(C.count_zeros(), $T::BITS - 5);
-            }
+        const _0: $T = 0;
+        const _1: $T = !0;
 
-            #[test]
-            fn test_leading_trailing_ones() {
-                let a: $T = 0b0101_1111;
-                assert_eq!(a.trailing_ones(), 5);
-                assert_eq!((!a).leading_ones(), $T::BITS - 7);
+        #[test]
+        fn test_count_ones() {
+            assert_eq!(A.count_ones(), 3);
+            assert_eq!(B.count_ones(), 2);
+            assert_eq!(C.count_ones(), 5);
+        }
 
-                assert_eq!(a.reverse_bits().leading_ones(), 5);
+        #[test]
+        fn test_count_zeros() {
+            assert_eq!(A.count_zeros(), $T::BITS - 3);
+            assert_eq!(B.count_zeros(), $T::BITS - 2);
+            assert_eq!(C.count_zeros(), $T::BITS - 5);
+        }
 
-                assert_eq!(_1.leading_ones(), $T::BITS);
-                assert_eq!(_1.trailing_ones(), $T::BITS);
+        #[test]
+        fn test_leading_trailing_ones() {
+            let a: $T = 0b0101_1111;
+            assert_eq!(a.trailing_ones(), 5);
+            assert_eq!((!a).leading_ones(), $T::BITS - 7);
 
-                assert_eq!((_1 << 1).trailing_ones(), 0);
-                assert_eq!(MAX.leading_ones(), 0);
+            assert_eq!(a.reverse_bits().leading_ones(), 5);
 
-                assert_eq!((_1 << 1).leading_ones(), $T::BITS - 1);
-                assert_eq!(MAX.trailing_ones(), $T::BITS - 1);
+            assert_eq!(_1.leading_ones(), $T::BITS);
+            assert_eq!(_1.trailing_ones(), $T::BITS);
 
-                assert_eq!(_0.leading_ones(), 0);
-                assert_eq!(_0.trailing_ones(), 0);
+            assert_eq!((_1 << 1).trailing_ones(), 0);
+            assert_eq!(MAX.leading_ones(), 0);
 
-                let x: $T = 0b0010_1100;
-                assert_eq!(x.leading_ones(), 0);
-                assert_eq!(x.trailing_ones(), 0);
-            }
+            assert_eq!((_1 << 1).leading_ones(), $T::BITS - 1);
+            assert_eq!(MAX.trailing_ones(), $T::BITS - 1);
 
-            #[test]
-            fn test_rotate() {
-                assert_eq!(A.rotate_left(6).rotate_right(2).rotate_right(4), A);
-                assert_eq!(B.rotate_left(3).rotate_left(2).rotate_right(5), B);
-                assert_eq!(C.rotate_left(6).rotate_right(2).rotate_right(4), C);
-
-                // Rotating these should make no difference
-                //
-                // We test using 124 bits because to ensure that overlong bit shifts do
-                // not cause undefined behaviour. See #10183.
-                assert_eq!(_0.rotate_left(124), _0);
-                assert_eq!(_1.rotate_left(124), _1);
-                assert_eq!(_0.rotate_right(124), _0);
-                assert_eq!(_1.rotate_right(124), _1);
-
-                // Rotating by 0 should have no effect
-                assert_eq!(A.rotate_left(0), A);
-                assert_eq!(B.rotate_left(0), B);
-                assert_eq!(C.rotate_left(0), C);
-                // Rotating by a multiple of word size should also have no effect
-                assert_eq!(A.rotate_left(128), A);
-                assert_eq!(B.rotate_left(128), B);
-                assert_eq!(C.rotate_left(128), C);
-            }
+            assert_eq!(_0.leading_ones(), 0);
+            assert_eq!(_0.trailing_ones(), 0);
 
-            #[test]
-            fn test_swap_bytes() {
-                assert_eq!(A.swap_bytes().swap_bytes(), A);
-                assert_eq!(B.swap_bytes().swap_bytes(), B);
-                assert_eq!(C.swap_bytes().swap_bytes(), C);
+            let x: $T = 0b0010_1100;
+            assert_eq!(x.leading_ones(), 0);
+            assert_eq!(x.trailing_ones(), 0);
+        }
 
-                // Swapping these should make no difference
-                assert_eq!(_0.swap_bytes(), _0);
-                assert_eq!(_1.swap_bytes(), _1);
-            }
+        #[test]
+        fn test_rotate() {
+            assert_eq!(A.rotate_left(6).rotate_right(2).rotate_right(4), A);
+            assert_eq!(B.rotate_left(3).rotate_left(2).rotate_right(5), B);
+            assert_eq!(C.rotate_left(6).rotate_right(2).rotate_right(4), C);
+
+            // Rotating these should make no difference
+            //
+            // We test using 124 bits because to ensure that overlong bit shifts do
+            // not cause undefined behaviour. See #10183.
+            assert_eq!(_0.rotate_left(124), _0);
+            assert_eq!(_1.rotate_left(124), _1);
+            assert_eq!(_0.rotate_right(124), _0);
+            assert_eq!(_1.rotate_right(124), _1);
+
+            // Rotating by 0 should have no effect
+            assert_eq!(A.rotate_left(0), A);
+            assert_eq!(B.rotate_left(0), B);
+            assert_eq!(C.rotate_left(0), C);
+            // Rotating by a multiple of word size should also have no effect
+            assert_eq!(A.rotate_left(128), A);
+            assert_eq!(B.rotate_left(128), B);
+            assert_eq!(C.rotate_left(128), C);
+        }
 
-            #[test]
-            fn test_le() {
-                assert_eq!($T::from_le(A.to_le()), A);
-                assert_eq!($T::from_le(B.to_le()), B);
-                assert_eq!($T::from_le(C.to_le()), C);
-                assert_eq!($T::from_le(_0), _0);
-                assert_eq!($T::from_le(_1), _1);
-                assert_eq!(_0.to_le(), _0);
-                assert_eq!(_1.to_le(), _1);
-            }
+        #[test]
+        fn test_swap_bytes() {
+            assert_eq!(A.swap_bytes().swap_bytes(), A);
+            assert_eq!(B.swap_bytes().swap_bytes(), B);
+            assert_eq!(C.swap_bytes().swap_bytes(), C);
 
-            #[test]
-            fn test_be() {
-                assert_eq!($T::from_be(A.to_be()), A);
-                assert_eq!($T::from_be(B.to_be()), B);
-                assert_eq!($T::from_be(C.to_be()), C);
-                assert_eq!($T::from_be(_0), _0);
-                assert_eq!($T::from_be(_1), _1);
-                assert_eq!(_0.to_be(), _0);
-                assert_eq!(_1.to_be(), _1);
-            }
+            // Swapping these should make no difference
+            assert_eq!(_0.swap_bytes(), _0);
+            assert_eq!(_1.swap_bytes(), _1);
+        }
 
-            #[test]
-            fn test_signed_checked_div() {
-                assert_eq!((10 as $T).checked_div(2), Some(5));
-                assert_eq!((5 as $T).checked_div(0), None);
-                assert_eq!(isize::MIN.checked_div(-1), None);
-            }
+        #[test]
+        fn test_le() {
+            assert_eq!($T::from_le(A.to_le()), A);
+            assert_eq!($T::from_le(B.to_le()), B);
+            assert_eq!($T::from_le(C.to_le()), C);
+            assert_eq!($T::from_le(_0), _0);
+            assert_eq!($T::from_le(_1), _1);
+            assert_eq!(_0.to_le(), _0);
+            assert_eq!(_1.to_le(), _1);
+        }
 
-            #[test]
-            fn test_saturating_abs() {
-                assert_eq!((0 as $T).saturating_abs(), 0);
-                assert_eq!((123 as $T).saturating_abs(), 123);
-                assert_eq!((-123 as $T).saturating_abs(), 123);
-                assert_eq!((MAX - 2).saturating_abs(), MAX - 2);
-                assert_eq!((MAX - 1).saturating_abs(), MAX - 1);
-                assert_eq!(MAX.saturating_abs(), MAX);
-                assert_eq!((MIN + 2).saturating_abs(), MAX - 1);
-                assert_eq!((MIN + 1).saturating_abs(), MAX);
-                assert_eq!(MIN.saturating_abs(), MAX);
-            }
+        #[test]
+        fn test_be() {
+            assert_eq!($T::from_be(A.to_be()), A);
+            assert_eq!($T::from_be(B.to_be()), B);
+            assert_eq!($T::from_be(C.to_be()), C);
+            assert_eq!($T::from_be(_0), _0);
+            assert_eq!($T::from_be(_1), _1);
+            assert_eq!(_0.to_be(), _0);
+            assert_eq!(_1.to_be(), _1);
+        }
 
-            #[test]
-            fn test_saturating_neg() {
-                assert_eq!((0 as $T).saturating_neg(), 0);
-                assert_eq!((123 as $T).saturating_neg(), -123);
-                assert_eq!((-123 as $T).saturating_neg(), 123);
-                assert_eq!((MAX - 2).saturating_neg(), MIN + 3);
-                assert_eq!((MAX - 1).saturating_neg(), MIN + 2);
-                assert_eq!(MAX.saturating_neg(), MIN + 1);
-                assert_eq!((MIN + 2).saturating_neg(), MAX - 1);
-                assert_eq!((MIN + 1).saturating_neg(), MAX);
-                assert_eq!(MIN.saturating_neg(), MAX);
-            }
+        #[test]
+        fn test_signed_checked_div() {
+            assert_eq!((10 as $T).checked_div(2), Some(5));
+            assert_eq!((5 as $T).checked_div(0), None);
+            assert_eq!(isize::MIN.checked_div(-1), None);
+        }
 
-            #[test]
-            fn test_from_str() {
-                fn from_str<T: std::str::FromStr>(t: &str) -> Option<T> {
-                    std::str::FromStr::from_str(t).ok()
-                }
-                assert_eq!(from_str::<$T>("0"), Some(0 as $T));
-                assert_eq!(from_str::<$T>("3"), Some(3 as $T));
-                assert_eq!(from_str::<$T>("10"), Some(10 as $T));
-                assert_eq!(from_str::<i32>("123456789"), Some(123456789 as i32));
-                assert_eq!(from_str::<$T>("00100"), Some(100 as $T));
-
-                assert_eq!(from_str::<$T>("-1"), Some(-1 as $T));
-                assert_eq!(from_str::<$T>("-3"), Some(-3 as $T));
-                assert_eq!(from_str::<$T>("-10"), Some(-10 as $T));
-                assert_eq!(from_str::<i32>("-123456789"), Some(-123456789 as i32));
-                assert_eq!(from_str::<$T>("-00100"), Some(-100 as $T));
-
-                assert_eq!(from_str::<$T>(""), None);
-                assert_eq!(from_str::<$T>(" "), None);
-                assert_eq!(from_str::<$T>("x"), None);
-            }
+        #[test]
+        fn test_saturating_abs() {
+            assert_eq!((0 as $T).saturating_abs(), 0);
+            assert_eq!((123 as $T).saturating_abs(), 123);
+            assert_eq!((-123 as $T).saturating_abs(), 123);
+            assert_eq!((MAX - 2).saturating_abs(), MAX - 2);
+            assert_eq!((MAX - 1).saturating_abs(), MAX - 1);
+            assert_eq!(MAX.saturating_abs(), MAX);
+            assert_eq!((MIN + 2).saturating_abs(), MAX - 1);
+            assert_eq!((MIN + 1).saturating_abs(), MAX);
+            assert_eq!(MIN.saturating_abs(), MAX);
+        }
 
-            #[test]
-            fn test_from_str_radix() {
-                assert_eq!($T::from_str_radix("123", 10), Ok(123 as $T));
-                assert_eq!($T::from_str_radix("1001", 2), Ok(9 as $T));
-                assert_eq!($T::from_str_radix("123", 8), Ok(83 as $T));
-                assert_eq!(i32::from_str_radix("123", 16), Ok(291 as i32));
-                assert_eq!(i32::from_str_radix("ffff", 16), Ok(65535 as i32));
-                assert_eq!(i32::from_str_radix("FFFF", 16), Ok(65535 as i32));
-                assert_eq!($T::from_str_radix("z", 36), Ok(35 as $T));
-                assert_eq!($T::from_str_radix("Z", 36), Ok(35 as $T));
-
-                assert_eq!($T::from_str_radix("-123", 10), Ok(-123 as $T));
-                assert_eq!($T::from_str_radix("-1001", 2), Ok(-9 as $T));
-                assert_eq!($T::from_str_radix("-123", 8), Ok(-83 as $T));
-                assert_eq!(i32::from_str_radix("-123", 16), Ok(-291 as i32));
-                assert_eq!(i32::from_str_radix("-ffff", 16), Ok(-65535 as i32));
-                assert_eq!(i32::from_str_radix("-FFFF", 16), Ok(-65535 as i32));
-                assert_eq!($T::from_str_radix("-z", 36), Ok(-35 as $T));
-                assert_eq!($T::from_str_radix("-Z", 36), Ok(-35 as $T));
-
-                assert_eq!($T::from_str_radix("Z", 35).ok(), None::<$T>);
-                assert_eq!($T::from_str_radix("-9", 2).ok(), None::<$T>);
-            }
+        #[test]
+        fn test_saturating_neg() {
+            assert_eq!((0 as $T).saturating_neg(), 0);
+            assert_eq!((123 as $T).saturating_neg(), -123);
+            assert_eq!((-123 as $T).saturating_neg(), 123);
+            assert_eq!((MAX - 2).saturating_neg(), MIN + 3);
+            assert_eq!((MAX - 1).saturating_neg(), MIN + 2);
+            assert_eq!(MAX.saturating_neg(), MIN + 1);
+            assert_eq!((MIN + 2).saturating_neg(), MAX - 1);
+            assert_eq!((MIN + 1).saturating_neg(), MAX);
+            assert_eq!(MIN.saturating_neg(), MAX);
+        }
 
-            #[test]
-            fn test_pow() {
-                let mut r = 2 as $T;
-                assert_eq!(r.pow(2), 4 as $T);
-                assert_eq!(r.pow(0), 1 as $T);
-                assert_eq!(r.wrapping_pow(2), 4 as $T);
-                assert_eq!(r.wrapping_pow(0), 1 as $T);
-                assert_eq!(r.checked_pow(2), Some(4 as $T));
-                assert_eq!(r.checked_pow(0), Some(1 as $T));
-                assert_eq!(r.overflowing_pow(2), (4 as $T, false));
-                assert_eq!(r.overflowing_pow(0), (1 as $T, false));
-                assert_eq!(r.saturating_pow(2), 4 as $T);
-                assert_eq!(r.saturating_pow(0), 1 as $T);
-
-                r = MAX;
-                // use `^` to represent .pow() with no overflow.
-                // if itest::MAX == 2^j-1, then itest is a `j` bit int,
-                // so that `itest::MAX*itest::MAX == 2^(2*j)-2^(j+1)+1`,
-                // thussaturating_pow the overflowing result is exactly 1.
-                assert_eq!(r.wrapping_pow(2), 1 as $T);
-                assert_eq!(r.checked_pow(2), None);
-                assert_eq!(r.overflowing_pow(2), (1 as $T, true));
-                assert_eq!(r.saturating_pow(2), MAX);
-                //test for negative exponent.
-                r = -2 as $T;
-                assert_eq!(r.pow(2), 4 as $T);
-                assert_eq!(r.pow(3), -8 as $T);
-                assert_eq!(r.pow(0), 1 as $T);
-                assert_eq!(r.wrapping_pow(2), 4 as $T);
-                assert_eq!(r.wrapping_pow(3), -8 as $T);
-                assert_eq!(r.wrapping_pow(0), 1 as $T);
-                assert_eq!(r.checked_pow(2), Some(4 as $T));
-                assert_eq!(r.checked_pow(3), Some(-8 as $T));
-                assert_eq!(r.checked_pow(0), Some(1 as $T));
-                assert_eq!(r.overflowing_pow(2), (4 as $T, false));
-                assert_eq!(r.overflowing_pow(3), (-8 as $T, false));
-                assert_eq!(r.overflowing_pow(0), (1 as $T, false));
-                assert_eq!(r.saturating_pow(2), 4 as $T);
-                assert_eq!(r.saturating_pow(3), -8 as $T);
-                assert_eq!(r.saturating_pow(0), 1 as $T);
+        #[test]
+        fn test_from_str() {
+            fn from_str<T: std::str::FromStr>(t: &str) -> Option<T> {
+                std::str::FromStr::from_str(t).ok()
             }
+            assert_eq!(from_str::<$T>("0"), Some(0 as $T));
+            assert_eq!(from_str::<$T>("3"), Some(3 as $T));
+            assert_eq!(from_str::<$T>("10"), Some(10 as $T));
+            assert_eq!(from_str::<i32>("123456789"), Some(123456789 as i32));
+            assert_eq!(from_str::<$T>("00100"), Some(100 as $T));
+
+            assert_eq!(from_str::<$T>("-1"), Some(-1 as $T));
+            assert_eq!(from_str::<$T>("-3"), Some(-3 as $T));
+            assert_eq!(from_str::<$T>("-10"), Some(-10 as $T));
+            assert_eq!(from_str::<i32>("-123456789"), Some(-123456789 as i32));
+            assert_eq!(from_str::<$T>("-00100"), Some(-100 as $T));
+
+            assert_eq!(from_str::<$T>(""), None);
+            assert_eq!(from_str::<$T>(" "), None);
+            assert_eq!(from_str::<$T>("x"), None);
+        }
 
-            #[test]
-            fn test_isqrt() {
-                assert_eq!($T::MIN.checked_isqrt(), None);
-                assert_eq!((-1 as $T).checked_isqrt(), None);
-                assert_eq!((0 as $T).isqrt(), 0 as $T);
-                assert_eq!((1 as $T).isqrt(), 1 as $T);
-                assert_eq!((2 as $T).isqrt(), 1 as $T);
-                assert_eq!((99 as $T).isqrt(), 9 as $T);
-                assert_eq!((100 as $T).isqrt(), 10 as $T);
-            }
+        #[test]
+        fn test_from_str_radix() {
+            assert_eq!($T::from_str_radix("123", 10), Ok(123 as $T));
+            assert_eq!($T::from_str_radix("1001", 2), Ok(9 as $T));
+            assert_eq!($T::from_str_radix("123", 8), Ok(83 as $T));
+            assert_eq!(i32::from_str_radix("123", 16), Ok(291 as i32));
+            assert_eq!(i32::from_str_radix("ffff", 16), Ok(65535 as i32));
+            assert_eq!(i32::from_str_radix("FFFF", 16), Ok(65535 as i32));
+            assert_eq!($T::from_str_radix("z", 36), Ok(35 as $T));
+            assert_eq!($T::from_str_radix("Z", 36), Ok(35 as $T));
+
+            assert_eq!($T::from_str_radix("-123", 10), Ok(-123 as $T));
+            assert_eq!($T::from_str_radix("-1001", 2), Ok(-9 as $T));
+            assert_eq!($T::from_str_radix("-123", 8), Ok(-83 as $T));
+            assert_eq!(i32::from_str_radix("-123", 16), Ok(-291 as i32));
+            assert_eq!(i32::from_str_radix("-ffff", 16), Ok(-65535 as i32));
+            assert_eq!(i32::from_str_radix("-FFFF", 16), Ok(-65535 as i32));
+            assert_eq!($T::from_str_radix("-z", 36), Ok(-35 as $T));
+            assert_eq!($T::from_str_radix("-Z", 36), Ok(-35 as $T));
+
+            assert_eq!($T::from_str_radix("Z", 35).ok(), None::<$T>);
+            assert_eq!($T::from_str_radix("-9", 2).ok(), None::<$T>);
+        }
 
-            #[cfg(not(miri))] // Miri is too slow
-            #[test]
-            fn test_lots_of_isqrt() {
-                let n_max: $T = (1024 * 1024).min($T::MAX as u128) as $T;
-                for n in 0..=n_max {
-                    let isqrt: $T = n.isqrt();
-
-                    assert!(isqrt.pow(2) <= n);
-                    let (square, overflow) = (isqrt + 1).overflowing_pow(2);
-                    assert!(overflow || square > n);
-                }
-
-                for n in ($T::MAX - 127)..=$T::MAX {
-                    let isqrt: $T = n.isqrt();
-
-                    assert!(isqrt.pow(2) <= n);
-                    let (square, overflow) = (isqrt + 1).overflowing_pow(2);
-                    assert!(overflow || square > n);
-                }
-            }
+        #[test]
+        fn test_pow() {
+            let mut r = 2 as $T;
+            assert_eq!(r.pow(2), 4 as $T);
+            assert_eq!(r.pow(0), 1 as $T);
+            assert_eq!(r.wrapping_pow(2), 4 as $T);
+            assert_eq!(r.wrapping_pow(0), 1 as $T);
+            assert_eq!(r.checked_pow(2), Some(4 as $T));
+            assert_eq!(r.checked_pow(0), Some(1 as $T));
+            assert_eq!(r.overflowing_pow(2), (4 as $T, false));
+            assert_eq!(r.overflowing_pow(0), (1 as $T, false));
+            assert_eq!(r.saturating_pow(2), 4 as $T);
+            assert_eq!(r.saturating_pow(0), 1 as $T);
+
+            r = MAX;
+            // use `^` to represent .pow() with no overflow.
+            // if itest::MAX == 2^j-1, then itest is a `j` bit int,
+            // so that `itest::MAX*itest::MAX == 2^(2*j)-2^(j+1)+1`,
+            // thussaturating_pow the overflowing result is exactly 1.
+            assert_eq!(r.wrapping_pow(2), 1 as $T);
+            assert_eq!(r.checked_pow(2), None);
+            assert_eq!(r.overflowing_pow(2), (1 as $T, true));
+            assert_eq!(r.saturating_pow(2), MAX);
+            //test for negative exponent.
+            r = -2 as $T;
+            assert_eq!(r.pow(2), 4 as $T);
+            assert_eq!(r.pow(3), -8 as $T);
+            assert_eq!(r.pow(0), 1 as $T);
+            assert_eq!(r.wrapping_pow(2), 4 as $T);
+            assert_eq!(r.wrapping_pow(3), -8 as $T);
+            assert_eq!(r.wrapping_pow(0), 1 as $T);
+            assert_eq!(r.checked_pow(2), Some(4 as $T));
+            assert_eq!(r.checked_pow(3), Some(-8 as $T));
+            assert_eq!(r.checked_pow(0), Some(1 as $T));
+            assert_eq!(r.overflowing_pow(2), (4 as $T, false));
+            assert_eq!(r.overflowing_pow(3), (-8 as $T, false));
+            assert_eq!(r.overflowing_pow(0), (1 as $T, false));
+            assert_eq!(r.saturating_pow(2), 4 as $T);
+            assert_eq!(r.saturating_pow(3), -8 as $T);
+            assert_eq!(r.saturating_pow(0), 1 as $T);
+        }
 
-            #[test]
-            fn test_div_floor() {
-                let a: $T = 8;
-                let b = 3;
-                assert_eq!(a.div_floor(b), 2);
-                assert_eq!(a.div_floor(-b), -3);
-                assert_eq!((-a).div_floor(b), -3);
-                assert_eq!((-a).div_floor(-b), 2);
-            }
+        #[test]
+        fn test_isqrt() {
+            assert_eq!($T::MIN.checked_isqrt(), None);
+            assert_eq!((-1 as $T).checked_isqrt(), None);
+            assert_eq!((0 as $T).isqrt(), 0 as $T);
+            assert_eq!((1 as $T).isqrt(), 1 as $T);
+            assert_eq!((2 as $T).isqrt(), 1 as $T);
+            assert_eq!((99 as $T).isqrt(), 9 as $T);
+            assert_eq!((100 as $T).isqrt(), 10 as $T);
+        }
 
-            #[test]
-            fn test_div_ceil() {
-                let a: $T = 8;
-                let b = 3;
-                assert_eq!(a.div_ceil(b), 3);
-                assert_eq!(a.div_ceil(-b), -2);
-                assert_eq!((-a).div_ceil(b), -2);
-                assert_eq!((-a).div_ceil(-b), 3);
-            }
+        #[cfg(not(miri))] // Miri is too slow
+        #[test]
+        fn test_lots_of_isqrt() {
+            let n_max: $T = (1024 * 1024).min($T::MAX as u128) as $T;
+            for n in 0..=n_max {
+                let isqrt: $T = n.isqrt();
 
-            #[test]
-            fn test_next_multiple_of() {
-                assert_eq!((16 as $T).next_multiple_of(8), 16);
-                assert_eq!((23 as $T).next_multiple_of(8), 24);
-                assert_eq!((16 as $T).next_multiple_of(-8), 16);
-                assert_eq!((23 as $T).next_multiple_of(-8), 16);
-                assert_eq!((-16 as $T).next_multiple_of(8), -16);
-                assert_eq!((-23 as $T).next_multiple_of(8), -16);
-                assert_eq!((-16 as $T).next_multiple_of(-8), -16);
-                assert_eq!((-23 as $T).next_multiple_of(-8), -24);
-                assert_eq!(MIN.next_multiple_of(-1), MIN);
+                assert!(isqrt.pow(2) <= n);
+                let (square, overflow) = (isqrt + 1).overflowing_pow(2);
+                assert!(overflow || square > n);
             }
 
-            #[test]
-            fn test_checked_next_multiple_of() {
-                assert_eq!((16 as $T).checked_next_multiple_of(8), Some(16));
-                assert_eq!((23 as $T).checked_next_multiple_of(8), Some(24));
-                assert_eq!((16 as $T).checked_next_multiple_of(-8), Some(16));
-                assert_eq!((23 as $T).checked_next_multiple_of(-8), Some(16));
-                assert_eq!((-16 as $T).checked_next_multiple_of(8), Some(-16));
-                assert_eq!((-23 as $T).checked_next_multiple_of(8), Some(-16));
-                assert_eq!((-16 as $T).checked_next_multiple_of(-8), Some(-16));
-                assert_eq!((-23 as $T).checked_next_multiple_of(-8), Some(-24));
-                assert_eq!((1 as $T).checked_next_multiple_of(0), None);
-                assert_eq!(MAX.checked_next_multiple_of(2), None);
-                assert_eq!(MIN.checked_next_multiple_of(-3), None);
-                assert_eq!(MIN.checked_next_multiple_of(-1), Some(MIN));
-            }
+            for n in ($T::MAX - 127)..=$T::MAX {
+                let isqrt: $T = n.isqrt();
 
-            #[test]
-            fn test_carrying_add() {
-                assert_eq!($T::MAX.carrying_add(1, false), ($T::MIN, true));
-                assert_eq!($T::MAX.carrying_add(0, true), ($T::MIN, true));
-                assert_eq!($T::MAX.carrying_add(1, true), ($T::MIN + 1, true));
-                assert_eq!($T::MAX.carrying_add(-1, false), ($T::MAX - 1, false));
-                assert_eq!($T::MAX.carrying_add(-1, true), ($T::MAX, false)); // no intermediate overflow
-                assert_eq!($T::MIN.carrying_add(-1, false), ($T::MAX, true));
-                assert_eq!($T::MIN.carrying_add(-1, true), ($T::MIN, false)); // no intermediate overflow
-                assert_eq!((0 as $T).carrying_add($T::MAX, true), ($T::MIN, true));
-                assert_eq!((0 as $T).carrying_add($T::MIN, true), ($T::MIN + 1, false));
+                assert!(isqrt.pow(2) <= n);
+                let (square, overflow) = (isqrt + 1).overflowing_pow(2);
+                assert!(overflow || square > n);
             }
+        }
 
-            #[test]
-            fn test_borrowing_sub() {
-                assert_eq!($T::MIN.borrowing_sub(1, false), ($T::MAX, true));
-                assert_eq!($T::MIN.borrowing_sub(0, true), ($T::MAX, true));
-                assert_eq!($T::MIN.borrowing_sub(1, true), ($T::MAX - 1, true));
-                assert_eq!($T::MIN.borrowing_sub(-1, false), ($T::MIN + 1, false));
-                assert_eq!($T::MIN.borrowing_sub(-1, true), ($T::MIN, false)); // no intermediate overflow
-                assert_eq!($T::MAX.borrowing_sub(-1, false), ($T::MIN, true));
-                assert_eq!($T::MAX.borrowing_sub(-1, true), ($T::MAX, false)); // no intermediate overflow
-                assert_eq!((0 as $T).borrowing_sub($T::MIN, false), ($T::MIN, true));
-                assert_eq!((0 as $T).borrowing_sub($T::MIN, true), ($T::MAX, false));
-            }
+        #[test]
+        fn test_div_floor() {
+            let a: $T = 8;
+            let b = 3;
+            assert_eq!(a.div_floor(b), 2);
+            assert_eq!(a.div_floor(-b), -3);
+            assert_eq!((-a).div_floor(b), -3);
+            assert_eq!((-a).div_floor(-b), 2);
+        }
 
-            #[test]
-            fn test_midpoint() {
-                assert_eq!(<$T>::midpoint(1, 3), 2);
-                assert_eq!(<$T>::midpoint(3, 1), 2);
-
-                assert_eq!(<$T>::midpoint(0, 0), 0);
-                assert_eq!(<$T>::midpoint(0, 2), 1);
-                assert_eq!(<$T>::midpoint(2, 0), 1);
-                assert_eq!(<$T>::midpoint(2, 2), 2);
-
-                assert_eq!(<$T>::midpoint(1, 4), 2);
-                assert_eq!(<$T>::midpoint(4, 1), 2);
-                assert_eq!(<$T>::midpoint(3, 4), 3);
-                assert_eq!(<$T>::midpoint(4, 3), 3);
-
-                assert_eq!(<$T>::midpoint(<$T>::MIN, <$T>::MAX), -1);
-                assert_eq!(<$T>::midpoint(<$T>::MAX, <$T>::MIN), -1);
-                assert_eq!(<$T>::midpoint(<$T>::MIN, <$T>::MIN), <$T>::MIN);
-                assert_eq!(<$T>::midpoint(<$T>::MAX, <$T>::MAX), <$T>::MAX);
-
-                assert_eq!(<$T>::midpoint(<$T>::MIN, 6), <$T>::MIN / 2 + 3);
-                assert_eq!(<$T>::midpoint(6, <$T>::MIN), <$T>::MIN / 2 + 3);
-                assert_eq!(<$T>::midpoint(<$T>::MAX, 6), <$T>::MAX / 2 + 3);
-                assert_eq!(<$T>::midpoint(6, <$T>::MAX), <$T>::MAX / 2 + 3);
-            }
+        #[test]
+        fn test_div_ceil() {
+            let a: $T = 8;
+            let b = 3;
+            assert_eq!(a.div_ceil(b), 3);
+            assert_eq!(a.div_ceil(-b), -2);
+            assert_eq!((-a).div_ceil(b), -2);
+            assert_eq!((-a).div_ceil(-b), 3);
+        }
+
+        #[test]
+        fn test_next_multiple_of() {
+            assert_eq!((16 as $T).next_multiple_of(8), 16);
+            assert_eq!((23 as $T).next_multiple_of(8), 24);
+            assert_eq!((16 as $T).next_multiple_of(-8), 16);
+            assert_eq!((23 as $T).next_multiple_of(-8), 16);
+            assert_eq!((-16 as $T).next_multiple_of(8), -16);
+            assert_eq!((-23 as $T).next_multiple_of(8), -16);
+            assert_eq!((-16 as $T).next_multiple_of(-8), -16);
+            assert_eq!((-23 as $T).next_multiple_of(-8), -24);
+            assert_eq!(MIN.next_multiple_of(-1), MIN);
+        }
+
+        #[test]
+        fn test_checked_next_multiple_of() {
+            assert_eq!((16 as $T).checked_next_multiple_of(8), Some(16));
+            assert_eq!((23 as $T).checked_next_multiple_of(8), Some(24));
+            assert_eq!((16 as $T).checked_next_multiple_of(-8), Some(16));
+            assert_eq!((23 as $T).checked_next_multiple_of(-8), Some(16));
+            assert_eq!((-16 as $T).checked_next_multiple_of(8), Some(-16));
+            assert_eq!((-23 as $T).checked_next_multiple_of(8), Some(-16));
+            assert_eq!((-16 as $T).checked_next_multiple_of(-8), Some(-16));
+            assert_eq!((-23 as $T).checked_next_multiple_of(-8), Some(-24));
+            assert_eq!((1 as $T).checked_next_multiple_of(0), None);
+            assert_eq!(MAX.checked_next_multiple_of(2), None);
+            assert_eq!(MIN.checked_next_multiple_of(-3), None);
+            assert_eq!(MIN.checked_next_multiple_of(-1), Some(MIN));
+        }
+
+        #[test]
+        fn test_carrying_add() {
+            assert_eq!($T::MAX.carrying_add(1, false), ($T::MIN, true));
+            assert_eq!($T::MAX.carrying_add(0, true), ($T::MIN, true));
+            assert_eq!($T::MAX.carrying_add(1, true), ($T::MIN + 1, true));
+            assert_eq!($T::MAX.carrying_add(-1, false), ($T::MAX - 1, false));
+            assert_eq!($T::MAX.carrying_add(-1, true), ($T::MAX, false)); // no intermediate overflow
+            assert_eq!($T::MIN.carrying_add(-1, false), ($T::MAX, true));
+            assert_eq!($T::MIN.carrying_add(-1, true), ($T::MIN, false)); // no intermediate overflow
+            assert_eq!((0 as $T).carrying_add($T::MAX, true), ($T::MIN, true));
+            assert_eq!((0 as $T).carrying_add($T::MIN, true), ($T::MIN + 1, false));
+        }
+
+        #[test]
+        fn test_borrowing_sub() {
+            assert_eq!($T::MIN.borrowing_sub(1, false), ($T::MAX, true));
+            assert_eq!($T::MIN.borrowing_sub(0, true), ($T::MAX, true));
+            assert_eq!($T::MIN.borrowing_sub(1, true), ($T::MAX - 1, true));
+            assert_eq!($T::MIN.borrowing_sub(-1, false), ($T::MIN + 1, false));
+            assert_eq!($T::MIN.borrowing_sub(-1, true), ($T::MIN, false)); // no intermediate overflow
+            assert_eq!($T::MAX.borrowing_sub(-1, false), ($T::MIN, true));
+            assert_eq!($T::MAX.borrowing_sub(-1, true), ($T::MAX, false)); // no intermediate overflow
+            assert_eq!((0 as $T).borrowing_sub($T::MIN, false), ($T::MIN, true));
+            assert_eq!((0 as $T).borrowing_sub($T::MIN, true), ($T::MAX, false));
+        }
+
+        #[test]
+        fn test_midpoint() {
+            assert_eq!(<$T>::midpoint(1, 3), 2);
+            assert_eq!(<$T>::midpoint(3, 1), 2);
+
+            assert_eq!(<$T>::midpoint(0, 0), 0);
+            assert_eq!(<$T>::midpoint(0, 2), 1);
+            assert_eq!(<$T>::midpoint(2, 0), 1);
+            assert_eq!(<$T>::midpoint(2, 2), 2);
+
+            assert_eq!(<$T>::midpoint(1, 4), 2);
+            assert_eq!(<$T>::midpoint(4, 1), 2);
+            assert_eq!(<$T>::midpoint(3, 4), 3);
+            assert_eq!(<$T>::midpoint(4, 3), 3);
+
+            assert_eq!(<$T>::midpoint(<$T>::MIN, <$T>::MAX), -1);
+            assert_eq!(<$T>::midpoint(<$T>::MAX, <$T>::MIN), -1);
+            assert_eq!(<$T>::midpoint(<$T>::MIN, <$T>::MIN), <$T>::MIN);
+            assert_eq!(<$T>::midpoint(<$T>::MAX, <$T>::MAX), <$T>::MAX);
+
+            assert_eq!(<$T>::midpoint(<$T>::MIN, 6), <$T>::MIN / 2 + 3);
+            assert_eq!(<$T>::midpoint(6, <$T>::MIN), <$T>::MIN / 2 + 3);
+            assert_eq!(<$T>::midpoint(<$T>::MAX, 6), <$T>::MAX / 2 + 3);
+            assert_eq!(<$T>::midpoint(6, <$T>::MAX), <$T>::MAX / 2 + 3);
         }
     };
 }
diff --git a/library/core/tests/num/mod.rs b/library/core/tests/num/mod.rs
index 53ff5ab1cedd1..dad46ad88fe19 100644
--- a/library/core/tests/num/mod.rs
+++ b/library/core/tests/num/mod.rs
@@ -178,7 +178,7 @@ fn test_can_not_overflow() {
 
     // Check u128 separately:
     for base in 2..=36 {
-        let num = u128::MAX as u128;
+        let num = <u128>::MAX;
         let max_len_string = format_radix(num, base as u128);
         // base 16 fits perfectly for u128 and won't overflow:
         assert_eq!(can_overflow::<u128>(base, &max_len_string), base != 16);
diff --git a/library/core/tests/num/uint_macros.rs b/library/core/tests/num/uint_macros.rs
index d009ad89d5ce7..f4fa789461eb8 100644
--- a/library/core/tests/num/uint_macros.rs
+++ b/library/core/tests/num/uint_macros.rs
@@ -1,320 +1,317 @@
 macro_rules! uint_module {
     ($T:ident) => {
-        #[cfg(test)]
-        mod tests {
-            use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
-            use core::$T::*;
-            use std::str::FromStr;
-
-            use crate::num;
-
-            #[test]
-            fn test_overflows() {
-                assert!(MAX > 0);
-                assert!(MIN <= 0);
-                assert!((MIN + MAX).wrapping_add(1) == 0);
-            }
+        use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
+        use core::$T::*;
+        use std::str::FromStr;
 
-            #[test]
-            fn test_num() {
-                num::test_num(10 as $T, 2 as $T);
-            }
+        use crate::num;
 
-            #[test]
-            fn test_bitwise_operators() {
-                assert!(0b1110 as $T == (0b1100 as $T).bitor(0b1010 as $T));
-                assert!(0b1000 as $T == (0b1100 as $T).bitand(0b1010 as $T));
-                assert!(0b0110 as $T == (0b1100 as $T).bitxor(0b1010 as $T));
-                assert!(0b1110 as $T == (0b0111 as $T).shl(1));
-                assert!(0b0111 as $T == (0b1110 as $T).shr(1));
-                assert!(MAX - (0b1011 as $T) == (0b1011 as $T).not());
-            }
+        #[test]
+        fn test_overflows() {
+            assert!(MAX > 0);
+            assert!(MIN <= 0);
+            assert!((MIN + MAX).wrapping_add(1) == 0);
+        }
 
-            const A: $T = 0b0101100;
-            const B: $T = 0b0100001;
-            const C: $T = 0b1111001;
+        #[test]
+        fn test_num() {
+            num::test_num(10 as $T, 2 as $T);
+        }
 
-            const _0: $T = 0;
-            const _1: $T = !0;
+        #[test]
+        fn test_bitwise_operators() {
+            assert!(0b1110 as $T == (0b1100 as $T).bitor(0b1010 as $T));
+            assert!(0b1000 as $T == (0b1100 as $T).bitand(0b1010 as $T));
+            assert!(0b0110 as $T == (0b1100 as $T).bitxor(0b1010 as $T));
+            assert!(0b1110 as $T == (0b0111 as $T).shl(1));
+            assert!(0b0111 as $T == (0b1110 as $T).shr(1));
+            assert!(MAX - (0b1011 as $T) == (0b1011 as $T).not());
+        }
 
-            #[test]
-            fn test_count_ones() {
-                assert!(A.count_ones() == 3);
-                assert!(B.count_ones() == 2);
-                assert!(C.count_ones() == 5);
-            }
+        const A: $T = 0b0101100;
+        const B: $T = 0b0100001;
+        const C: $T = 0b1111001;
 
-            #[test]
-            fn test_count_zeros() {
-                assert!(A.count_zeros() == $T::BITS - 3);
-                assert!(B.count_zeros() == $T::BITS - 2);
-                assert!(C.count_zeros() == $T::BITS - 5);
-            }
+        const _0: $T = 0;
+        const _1: $T = !0;
 
-            #[test]
-            fn test_leading_trailing_ones() {
-                let a: $T = 0b0101_1111;
-                assert_eq!(a.trailing_ones(), 5);
-                assert_eq!((!a).leading_ones(), $T::BITS - 7);
+        #[test]
+        fn test_count_ones() {
+            assert!(A.count_ones() == 3);
+            assert!(B.count_ones() == 2);
+            assert!(C.count_ones() == 5);
+        }
 
-                assert_eq!(a.reverse_bits().leading_ones(), 5);
+        #[test]
+        fn test_count_zeros() {
+            assert!(A.count_zeros() == $T::BITS - 3);
+            assert!(B.count_zeros() == $T::BITS - 2);
+            assert!(C.count_zeros() == $T::BITS - 5);
+        }
 
-                assert_eq!(_1.leading_ones(), $T::BITS);
-                assert_eq!(_1.trailing_ones(), $T::BITS);
+        #[test]
+        fn test_leading_trailing_ones() {
+            let a: $T = 0b0101_1111;
+            assert_eq!(a.trailing_ones(), 5);
+            assert_eq!((!a).leading_ones(), $T::BITS - 7);
 
-                assert_eq!((_1 << 1).trailing_ones(), 0);
-                assert_eq!((_1 >> 1).leading_ones(), 0);
+            assert_eq!(a.reverse_bits().leading_ones(), 5);
 
-                assert_eq!((_1 << 1).leading_ones(), $T::BITS - 1);
-                assert_eq!((_1 >> 1).trailing_ones(), $T::BITS - 1);
+            assert_eq!(_1.leading_ones(), $T::BITS);
+            assert_eq!(_1.trailing_ones(), $T::BITS);
 
-                assert_eq!(_0.leading_ones(), 0);
-                assert_eq!(_0.trailing_ones(), 0);
+            assert_eq!((_1 << 1).trailing_ones(), 0);
+            assert_eq!((_1 >> 1).leading_ones(), 0);
 
-                let x: $T = 0b0010_1100;
-                assert_eq!(x.leading_ones(), 0);
-                assert_eq!(x.trailing_ones(), 0);
-            }
+            assert_eq!((_1 << 1).leading_ones(), $T::BITS - 1);
+            assert_eq!((_1 >> 1).trailing_ones(), $T::BITS - 1);
 
-            #[test]
-            fn test_rotate() {
-                assert_eq!(A.rotate_left(6).rotate_right(2).rotate_right(4), A);
-                assert_eq!(B.rotate_left(3).rotate_left(2).rotate_right(5), B);
-                assert_eq!(C.rotate_left(6).rotate_right(2).rotate_right(4), C);
-
-                // Rotating these should make no difference
-                //
-                // We test using 124 bits because to ensure that overlong bit shifts do
-                // not cause undefined behaviour. See #10183.
-                assert_eq!(_0.rotate_left(124), _0);
-                assert_eq!(_1.rotate_left(124), _1);
-                assert_eq!(_0.rotate_right(124), _0);
-                assert_eq!(_1.rotate_right(124), _1);
-
-                // Rotating by 0 should have no effect
-                assert_eq!(A.rotate_left(0), A);
-                assert_eq!(B.rotate_left(0), B);
-                assert_eq!(C.rotate_left(0), C);
-                // Rotating by a multiple of word size should also have no effect
-                assert_eq!(A.rotate_left(128), A);
-                assert_eq!(B.rotate_left(128), B);
-                assert_eq!(C.rotate_left(128), C);
-            }
+            assert_eq!(_0.leading_ones(), 0);
+            assert_eq!(_0.trailing_ones(), 0);
 
-            #[test]
-            fn test_swap_bytes() {
-                assert_eq!(A.swap_bytes().swap_bytes(), A);
-                assert_eq!(B.swap_bytes().swap_bytes(), B);
-                assert_eq!(C.swap_bytes().swap_bytes(), C);
+            let x: $T = 0b0010_1100;
+            assert_eq!(x.leading_ones(), 0);
+            assert_eq!(x.trailing_ones(), 0);
+        }
 
-                // Swapping these should make no difference
-                assert_eq!(_0.swap_bytes(), _0);
-                assert_eq!(_1.swap_bytes(), _1);
-            }
+        #[test]
+        fn test_rotate() {
+            assert_eq!(A.rotate_left(6).rotate_right(2).rotate_right(4), A);
+            assert_eq!(B.rotate_left(3).rotate_left(2).rotate_right(5), B);
+            assert_eq!(C.rotate_left(6).rotate_right(2).rotate_right(4), C);
+
+            // Rotating these should make no difference
+            //
+            // We test using 124 bits because to ensure that overlong bit shifts do
+            // not cause undefined behaviour. See #10183.
+            assert_eq!(_0.rotate_left(124), _0);
+            assert_eq!(_1.rotate_left(124), _1);
+            assert_eq!(_0.rotate_right(124), _0);
+            assert_eq!(_1.rotate_right(124), _1);
+
+            // Rotating by 0 should have no effect
+            assert_eq!(A.rotate_left(0), A);
+            assert_eq!(B.rotate_left(0), B);
+            assert_eq!(C.rotate_left(0), C);
+            // Rotating by a multiple of word size should also have no effect
+            assert_eq!(A.rotate_left(128), A);
+            assert_eq!(B.rotate_left(128), B);
+            assert_eq!(C.rotate_left(128), C);
+        }
 
-            #[test]
-            fn test_reverse_bits() {
-                assert_eq!(A.reverse_bits().reverse_bits(), A);
-                assert_eq!(B.reverse_bits().reverse_bits(), B);
-                assert_eq!(C.reverse_bits().reverse_bits(), C);
+        #[test]
+        fn test_swap_bytes() {
+            assert_eq!(A.swap_bytes().swap_bytes(), A);
+            assert_eq!(B.swap_bytes().swap_bytes(), B);
+            assert_eq!(C.swap_bytes().swap_bytes(), C);
 
-                // Swapping these should make no difference
-                assert_eq!(_0.reverse_bits(), _0);
-                assert_eq!(_1.reverse_bits(), _1);
-            }
+            // Swapping these should make no difference
+            assert_eq!(_0.swap_bytes(), _0);
+            assert_eq!(_1.swap_bytes(), _1);
+        }
 
-            #[test]
-            fn test_le() {
-                assert_eq!($T::from_le(A.to_le()), A);
-                assert_eq!($T::from_le(B.to_le()), B);
-                assert_eq!($T::from_le(C.to_le()), C);
-                assert_eq!($T::from_le(_0), _0);
-                assert_eq!($T::from_le(_1), _1);
-                assert_eq!(_0.to_le(), _0);
-                assert_eq!(_1.to_le(), _1);
-            }
+        #[test]
+        fn test_reverse_bits() {
+            assert_eq!(A.reverse_bits().reverse_bits(), A);
+            assert_eq!(B.reverse_bits().reverse_bits(), B);
+            assert_eq!(C.reverse_bits().reverse_bits(), C);
 
-            #[test]
-            fn test_be() {
-                assert_eq!($T::from_be(A.to_be()), A);
-                assert_eq!($T::from_be(B.to_be()), B);
-                assert_eq!($T::from_be(C.to_be()), C);
-                assert_eq!($T::from_be(_0), _0);
-                assert_eq!($T::from_be(_1), _1);
-                assert_eq!(_0.to_be(), _0);
-                assert_eq!(_1.to_be(), _1);
-            }
+            // Swapping these should make no difference
+            assert_eq!(_0.reverse_bits(), _0);
+            assert_eq!(_1.reverse_bits(), _1);
+        }
 
-            #[test]
-            fn test_unsigned_checked_div() {
-                assert!((10 as $T).checked_div(2) == Some(5));
-                assert!((5 as $T).checked_div(0) == None);
-            }
+        #[test]
+        fn test_le() {
+            assert_eq!($T::from_le(A.to_le()), A);
+            assert_eq!($T::from_le(B.to_le()), B);
+            assert_eq!($T::from_le(C.to_le()), C);
+            assert_eq!($T::from_le(_0), _0);
+            assert_eq!($T::from_le(_1), _1);
+            assert_eq!(_0.to_le(), _0);
+            assert_eq!(_1.to_le(), _1);
+        }
 
-            fn from_str<T: FromStr>(t: &str) -> Option<T> {
-                FromStr::from_str(t).ok()
-            }
+        #[test]
+        fn test_be() {
+            assert_eq!($T::from_be(A.to_be()), A);
+            assert_eq!($T::from_be(B.to_be()), B);
+            assert_eq!($T::from_be(C.to_be()), C);
+            assert_eq!($T::from_be(_0), _0);
+            assert_eq!($T::from_be(_1), _1);
+            assert_eq!(_0.to_be(), _0);
+            assert_eq!(_1.to_be(), _1);
+        }
 
-            #[test]
-            pub fn test_from_str() {
-                assert_eq!(from_str::<$T>("0"), Some(0 as $T));
-                assert_eq!(from_str::<$T>("3"), Some(3 as $T));
-                assert_eq!(from_str::<$T>("10"), Some(10 as $T));
-                assert_eq!(from_str::<u32>("123456789"), Some(123456789 as u32));
-                assert_eq!(from_str::<$T>("00100"), Some(100 as $T));
-
-                assert_eq!(from_str::<$T>(""), None);
-                assert_eq!(from_str::<$T>(" "), None);
-                assert_eq!(from_str::<$T>("x"), None);
-            }
+        #[test]
+        fn test_unsigned_checked_div() {
+            assert!((10 as $T).checked_div(2) == Some(5));
+            assert!((5 as $T).checked_div(0) == None);
+        }
 
-            #[test]
-            pub fn test_parse_bytes() {
-                assert_eq!($T::from_str_radix("123", 10), Ok(123 as $T));
-                assert_eq!($T::from_str_radix("1001", 2), Ok(9 as $T));
-                assert_eq!($T::from_str_radix("123", 8), Ok(83 as $T));
-                assert_eq!(u16::from_str_radix("123", 16), Ok(291 as u16));
-                assert_eq!(u16::from_str_radix("ffff", 16), Ok(65535 as u16));
-                assert_eq!($T::from_str_radix("z", 36), Ok(35 as $T));
-
-                assert_eq!($T::from_str_radix("Z", 10).ok(), None::<$T>);
-                assert_eq!($T::from_str_radix("_", 2).ok(), None::<$T>);
-            }
+        fn from_str<T: FromStr>(t: &str) -> Option<T> {
+            FromStr::from_str(t).ok()
+        }
 
-            #[test]
-            fn test_pow() {
-                let mut r = 2 as $T;
-                assert_eq!(r.pow(2), 4 as $T);
-                assert_eq!(r.pow(0), 1 as $T);
-                assert_eq!(r.wrapping_pow(2), 4 as $T);
-                assert_eq!(r.wrapping_pow(0), 1 as $T);
-                assert_eq!(r.checked_pow(2), Some(4 as $T));
-                assert_eq!(r.checked_pow(0), Some(1 as $T));
-                assert_eq!(r.overflowing_pow(2), (4 as $T, false));
-                assert_eq!(r.overflowing_pow(0), (1 as $T, false));
-                assert_eq!(r.saturating_pow(2), 4 as $T);
-                assert_eq!(r.saturating_pow(0), 1 as $T);
-
-                r = MAX;
-                // use `^` to represent .pow() with no overflow.
-                // if itest::MAX == 2^j-1, then itest is a `j` bit int,
-                // so that `itest::MAX*itest::MAX == 2^(2*j)-2^(j+1)+1`,
-                // thussaturating_pow the overflowing result is exactly 1.
-                assert_eq!(r.wrapping_pow(2), 1 as $T);
-                assert_eq!(r.checked_pow(2), None);
-                assert_eq!(r.overflowing_pow(2), (1 as $T, true));
-                assert_eq!(r.saturating_pow(2), MAX);
-            }
+        #[test]
+        pub fn test_from_str() {
+            assert_eq!(from_str::<$T>("0"), Some(0 as $T));
+            assert_eq!(from_str::<$T>("3"), Some(3 as $T));
+            assert_eq!(from_str::<$T>("10"), Some(10 as $T));
+            assert_eq!(from_str::<u32>("123456789"), Some(123456789 as u32));
+            assert_eq!(from_str::<$T>("00100"), Some(100 as $T));
+
+            assert_eq!(from_str::<$T>(""), None);
+            assert_eq!(from_str::<$T>(" "), None);
+            assert_eq!(from_str::<$T>("x"), None);
+        }
 
-            #[test]
-            fn test_isqrt() {
-                assert_eq!((0 as $T).isqrt(), 0 as $T);
-                assert_eq!((1 as $T).isqrt(), 1 as $T);
-                assert_eq!((2 as $T).isqrt(), 1 as $T);
-                assert_eq!((99 as $T).isqrt(), 9 as $T);
-                assert_eq!((100 as $T).isqrt(), 10 as $T);
-                assert_eq!($T::MAX.isqrt(), (1 << ($T::BITS / 2)) - 1);
-            }
+        #[test]
+        pub fn test_parse_bytes() {
+            assert_eq!($T::from_str_radix("123", 10), Ok(123 as $T));
+            assert_eq!($T::from_str_radix("1001", 2), Ok(9 as $T));
+            assert_eq!($T::from_str_radix("123", 8), Ok(83 as $T));
+            assert_eq!(u16::from_str_radix("123", 16), Ok(291 as u16));
+            assert_eq!(u16::from_str_radix("ffff", 16), Ok(65535 as u16));
+            assert_eq!($T::from_str_radix("z", 36), Ok(35 as $T));
+
+            assert_eq!($T::from_str_radix("Z", 10).ok(), None::<$T>);
+            assert_eq!($T::from_str_radix("_", 2).ok(), None::<$T>);
+        }
 
-            #[cfg(not(miri))] // Miri is too slow
-            #[test]
-            fn test_lots_of_isqrt() {
-                let n_max: $T = (1024 * 1024).min($T::MAX as u128) as $T;
-                for n in 0..=n_max {
-                    let isqrt: $T = n.isqrt();
+        #[test]
+        fn test_pow() {
+            let mut r = 2 as $T;
+            assert_eq!(r.pow(2), 4 as $T);
+            assert_eq!(r.pow(0), 1 as $T);
+            assert_eq!(r.wrapping_pow(2), 4 as $T);
+            assert_eq!(r.wrapping_pow(0), 1 as $T);
+            assert_eq!(r.checked_pow(2), Some(4 as $T));
+            assert_eq!(r.checked_pow(0), Some(1 as $T));
+            assert_eq!(r.overflowing_pow(2), (4 as $T, false));
+            assert_eq!(r.overflowing_pow(0), (1 as $T, false));
+            assert_eq!(r.saturating_pow(2), 4 as $T);
+            assert_eq!(r.saturating_pow(0), 1 as $T);
+
+            r = MAX;
+            // use `^` to represent .pow() with no overflow.
+            // if itest::MAX == 2^j-1, then itest is a `j` bit int,
+            // so that `itest::MAX*itest::MAX == 2^(2*j)-2^(j+1)+1`,
+            // thussaturating_pow the overflowing result is exactly 1.
+            assert_eq!(r.wrapping_pow(2), 1 as $T);
+            assert_eq!(r.checked_pow(2), None);
+            assert_eq!(r.overflowing_pow(2), (1 as $T, true));
+            assert_eq!(r.saturating_pow(2), MAX);
+        }
 
-                    assert!(isqrt.pow(2) <= n);
-                    assert!(isqrt + 1 == (1 as $T) << ($T::BITS / 2) || (isqrt + 1).pow(2) > n);
-                }
+        #[test]
+        fn test_isqrt() {
+            assert_eq!((0 as $T).isqrt(), 0 as $T);
+            assert_eq!((1 as $T).isqrt(), 1 as $T);
+            assert_eq!((2 as $T).isqrt(), 1 as $T);
+            assert_eq!((99 as $T).isqrt(), 9 as $T);
+            assert_eq!((100 as $T).isqrt(), 10 as $T);
+            assert_eq!($T::MAX.isqrt(), (1 << ($T::BITS / 2)) - 1);
+        }
 
-                for n in ($T::MAX - 255)..=$T::MAX {
-                    let isqrt: $T = n.isqrt();
+        #[cfg(not(miri))] // Miri is too slow
+        #[test]
+        fn test_lots_of_isqrt() {
+            let n_max: $T = (1024 * 1024).min($T::MAX as u128) as $T;
+            for n in 0..=n_max {
+                let isqrt: $T = n.isqrt();
 
-                    assert!(isqrt.pow(2) <= n);
-                    assert!(isqrt + 1 == (1 as $T) << ($T::BITS / 2) || (isqrt + 1).pow(2) > n);
-                }
+                assert!(isqrt.pow(2) <= n);
+                assert!(isqrt + 1 == (1 as $T) << ($T::BITS / 2) || (isqrt + 1).pow(2) > n);
             }
 
-            #[test]
-            fn test_div_floor() {
-                assert_eq!((8 as $T).div_floor(3), 2);
-            }
+            for n in ($T::MAX - 255)..=$T::MAX {
+                let isqrt: $T = n.isqrt();
 
-            #[test]
-            fn test_div_ceil() {
-                assert_eq!((8 as $T).div_ceil(3), 3);
+                assert!(isqrt.pow(2) <= n);
+                assert!(isqrt + 1 == (1 as $T) << ($T::BITS / 2) || (isqrt + 1).pow(2) > n);
             }
+        }
 
-            #[test]
-            fn test_next_multiple_of() {
-                assert_eq!((16 as $T).next_multiple_of(8), 16);
-                assert_eq!((23 as $T).next_multiple_of(8), 24);
-                assert_eq!(MAX.next_multiple_of(1), MAX);
-            }
+        #[test]
+        fn test_div_floor() {
+            assert_eq!((8 as $T).div_floor(3), 2);
+        }
 
-            #[test]
-            fn test_checked_next_multiple_of() {
-                assert_eq!((16 as $T).checked_next_multiple_of(8), Some(16));
-                assert_eq!((23 as $T).checked_next_multiple_of(8), Some(24));
-                assert_eq!((1 as $T).checked_next_multiple_of(0), None);
-                assert_eq!(MAX.checked_next_multiple_of(2), None);
-            }
+        #[test]
+        fn test_div_ceil() {
+            assert_eq!((8 as $T).div_ceil(3), 3);
+        }
 
-            #[test]
-            fn test_is_next_multiple_of() {
-                assert!((12 as $T).is_multiple_of(4));
-                assert!(!(12 as $T).is_multiple_of(5));
-                assert!((0 as $T).is_multiple_of(0));
-                assert!(!(12 as $T).is_multiple_of(0));
-            }
+        #[test]
+        fn test_next_multiple_of() {
+            assert_eq!((16 as $T).next_multiple_of(8), 16);
+            assert_eq!((23 as $T).next_multiple_of(8), 24);
+            assert_eq!(MAX.next_multiple_of(1), MAX);
+        }
 
-            #[test]
-            fn test_carrying_add() {
-                assert_eq!($T::MAX.carrying_add(1, false), (0, true));
-                assert_eq!($T::MAX.carrying_add(0, true), (0, true));
-                assert_eq!($T::MAX.carrying_add(1, true), (1, true));
+        #[test]
+        fn test_checked_next_multiple_of() {
+            assert_eq!((16 as $T).checked_next_multiple_of(8), Some(16));
+            assert_eq!((23 as $T).checked_next_multiple_of(8), Some(24));
+            assert_eq!((1 as $T).checked_next_multiple_of(0), None);
+            assert_eq!(MAX.checked_next_multiple_of(2), None);
+        }
 
-                assert_eq!($T::MIN.carrying_add($T::MAX, false), ($T::MAX, false));
-                assert_eq!($T::MIN.carrying_add(0, true), (1, false));
-                assert_eq!($T::MIN.carrying_add($T::MAX, true), (0, true));
-            }
+        #[test]
+        fn test_is_next_multiple_of() {
+            assert!((12 as $T).is_multiple_of(4));
+            assert!(!(12 as $T).is_multiple_of(5));
+            assert!((0 as $T).is_multiple_of(0));
+            assert!(!(12 as $T).is_multiple_of(0));
+        }
 
-            #[test]
-            fn test_borrowing_sub() {
-                assert_eq!($T::MIN.borrowing_sub(1, false), ($T::MAX, true));
-                assert_eq!($T::MIN.borrowing_sub(0, true), ($T::MAX, true));
-                assert_eq!($T::MIN.borrowing_sub(1, true), ($T::MAX - 1, true));
+        #[test]
+        fn test_carrying_add() {
+            assert_eq!($T::MAX.carrying_add(1, false), (0, true));
+            assert_eq!($T::MAX.carrying_add(0, true), (0, true));
+            assert_eq!($T::MAX.carrying_add(1, true), (1, true));
 
-                assert_eq!($T::MAX.borrowing_sub($T::MAX, false), (0, false));
-                assert_eq!($T::MAX.borrowing_sub(0, true), ($T::MAX - 1, false));
-                assert_eq!($T::MAX.borrowing_sub($T::MAX, true), ($T::MAX, true));
-            }
+            assert_eq!($T::MIN.carrying_add($T::MAX, false), ($T::MAX, false));
+            assert_eq!($T::MIN.carrying_add(0, true), (1, false));
+            assert_eq!($T::MIN.carrying_add($T::MAX, true), (0, true));
+        }
 
-            #[test]
-            fn test_midpoint() {
-                assert_eq!(<$T>::midpoint(1, 3), 2);
-                assert_eq!(<$T>::midpoint(3, 1), 2);
-
-                assert_eq!(<$T>::midpoint(0, 0), 0);
-                assert_eq!(<$T>::midpoint(0, 2), 1);
-                assert_eq!(<$T>::midpoint(2, 0), 1);
-                assert_eq!(<$T>::midpoint(2, 2), 2);
-
-                assert_eq!(<$T>::midpoint(1, 4), 2);
-                assert_eq!(<$T>::midpoint(4, 1), 2);
-                assert_eq!(<$T>::midpoint(3, 4), 3);
-                assert_eq!(<$T>::midpoint(4, 3), 3);
-
-                assert_eq!(<$T>::midpoint(<$T>::MIN, <$T>::MAX), (<$T>::MAX - <$T>::MIN) / 2);
-                assert_eq!(<$T>::midpoint(<$T>::MAX, <$T>::MIN), (<$T>::MAX - <$T>::MIN) / 2);
-                assert_eq!(<$T>::midpoint(<$T>::MIN, <$T>::MIN), <$T>::MIN);
-                assert_eq!(<$T>::midpoint(<$T>::MAX, <$T>::MAX), <$T>::MAX);
-
-                assert_eq!(<$T>::midpoint(<$T>::MIN, 6), <$T>::MIN / 2 + 3);
-                assert_eq!(<$T>::midpoint(6, <$T>::MIN), <$T>::MIN / 2 + 3);
-                assert_eq!(<$T>::midpoint(<$T>::MAX, 6), (<$T>::MAX - <$T>::MIN) / 2 + 3);
-                assert_eq!(<$T>::midpoint(6, <$T>::MAX), (<$T>::MAX - <$T>::MIN) / 2 + 3);
-            }
+        #[test]
+        fn test_borrowing_sub() {
+            assert_eq!($T::MIN.borrowing_sub(1, false), ($T::MAX, true));
+            assert_eq!($T::MIN.borrowing_sub(0, true), ($T::MAX, true));
+            assert_eq!($T::MIN.borrowing_sub(1, true), ($T::MAX - 1, true));
+
+            assert_eq!($T::MAX.borrowing_sub($T::MAX, false), (0, false));
+            assert_eq!($T::MAX.borrowing_sub(0, true), ($T::MAX - 1, false));
+            assert_eq!($T::MAX.borrowing_sub($T::MAX, true), ($T::MAX, true));
+        }
+
+        #[test]
+        fn test_midpoint() {
+            assert_eq!(<$T>::midpoint(1, 3), 2);
+            assert_eq!(<$T>::midpoint(3, 1), 2);
+
+            assert_eq!(<$T>::midpoint(0, 0), 0);
+            assert_eq!(<$T>::midpoint(0, 2), 1);
+            assert_eq!(<$T>::midpoint(2, 0), 1);
+            assert_eq!(<$T>::midpoint(2, 2), 2);
+
+            assert_eq!(<$T>::midpoint(1, 4), 2);
+            assert_eq!(<$T>::midpoint(4, 1), 2);
+            assert_eq!(<$T>::midpoint(3, 4), 3);
+            assert_eq!(<$T>::midpoint(4, 3), 3);
+
+            assert_eq!(<$T>::midpoint(<$T>::MIN, <$T>::MAX), (<$T>::MAX - <$T>::MIN) / 2);
+            assert_eq!(<$T>::midpoint(<$T>::MAX, <$T>::MIN), (<$T>::MAX - <$T>::MIN) / 2);
+            assert_eq!(<$T>::midpoint(<$T>::MIN, <$T>::MIN), <$T>::MIN);
+            assert_eq!(<$T>::midpoint(<$T>::MAX, <$T>::MAX), <$T>::MAX);
+
+            assert_eq!(<$T>::midpoint(<$T>::MIN, 6), <$T>::MIN / 2 + 3);
+            assert_eq!(<$T>::midpoint(6, <$T>::MIN), <$T>::MIN / 2 + 3);
+            assert_eq!(<$T>::midpoint(<$T>::MAX, 6), (<$T>::MAX - <$T>::MIN) / 2 + 3);
+            assert_eq!(<$T>::midpoint(6, <$T>::MAX), (<$T>::MAX - <$T>::MIN) / 2 + 3);
         }
     };
 }

From c31b9fa42556bc5961b779122522b569b2845a47 Mon Sep 17 00:00:00 2001
From: bohan <bohan-zhang@foxmail.com>
Date: Mon, 26 Aug 2024 09:24:42 +0800
Subject: [PATCH 608/685] mv `build_reduced_graph_for_external_crate_res` into
 Resolver

---
 .../rustc_resolve/src/build_reduced_graph.rs  | 139 +++++++++---------
 1 file changed, 71 insertions(+), 68 deletions(-)

diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index fee42ba87c95b..2ac7b200452f4 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -197,8 +197,77 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
     pub(crate) fn build_reduced_graph_external(&mut self, module: Module<'a>) {
         for child in self.tcx.module_children(module.def_id()) {
             let parent_scope = ParentScope::module(module, self);
-            BuildReducedGraphVisitor { r: self, parent_scope }
-                .build_reduced_graph_for_external_crate_res(child);
+            self.build_reduced_graph_for_external_crate_res(child, parent_scope)
+        }
+    }
+
+    /// Builds the reduced graph for a single item in an external crate.
+    fn build_reduced_graph_for_external_crate_res(
+        &mut self,
+        child: &ModChild,
+        parent_scope: ParentScope<'a>,
+    ) {
+        let parent = parent_scope.module;
+        let ModChild { ident, res, vis, ref reexport_chain } = *child;
+        let span = self.def_span(
+            reexport_chain
+                .first()
+                .and_then(|reexport| reexport.id())
+                .unwrap_or_else(|| res.def_id()),
+        );
+        let res = res.expect_non_local();
+        let expansion = parent_scope.expansion;
+        // Record primary definitions.
+        match res {
+            Res::Def(DefKind::Mod | DefKind::Enum | DefKind::Trait, def_id) => {
+                let module = self.expect_module(def_id);
+                self.define(parent, ident, TypeNS, (module, vis, span, expansion));
+            }
+            Res::Def(
+                DefKind::Struct
+                | DefKind::Union
+                | DefKind::Variant
+                | DefKind::TyAlias
+                | DefKind::ForeignTy
+                | DefKind::OpaqueTy
+                | DefKind::TraitAlias
+                | DefKind::AssocTy,
+                _,
+            )
+            | Res::PrimTy(..)
+            | Res::ToolMod => self.define(parent, ident, TypeNS, (res, vis, span, expansion)),
+            Res::Def(
+                DefKind::Fn
+                | DefKind::AssocFn
+                | DefKind::Static { .. }
+                | DefKind::Const
+                | DefKind::AssocConst
+                | DefKind::Ctor(..),
+                _,
+            ) => self.define(parent, ident, ValueNS, (res, vis, span, expansion)),
+            Res::Def(DefKind::Macro(..), _) | Res::NonMacroAttr(..) => {
+                self.define(parent, ident, MacroNS, (res, vis, span, expansion))
+            }
+            Res::Def(
+                DefKind::TyParam
+                | DefKind::ConstParam
+                | DefKind::ExternCrate
+                | DefKind::Use
+                | DefKind::ForeignMod
+                | DefKind::AnonConst
+                | DefKind::InlineConst
+                | DefKind::Field
+                | DefKind::LifetimeParam
+                | DefKind::GlobalAsm
+                | DefKind::Closure
+                | DefKind::Impl { .. },
+                _,
+            )
+            | Res::Local(..)
+            | Res::SelfTyParam { .. }
+            | Res::SelfTyAlias { .. }
+            | Res::SelfCtor(..)
+            | Res::Err => bug!("unexpected resolution: {:?}", res),
         }
     }
 }
@@ -967,72 +1036,6 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
         }
     }
 
-    /// Builds the reduced graph for a single item in an external crate.
-    fn build_reduced_graph_for_external_crate_res(&mut self, child: &ModChild) {
-        let parent = self.parent_scope.module;
-        let ModChild { ident, res, vis, ref reexport_chain } = *child;
-        let span = self.r.def_span(
-            reexport_chain
-                .first()
-                .and_then(|reexport| reexport.id())
-                .unwrap_or_else(|| res.def_id()),
-        );
-        let res = res.expect_non_local();
-        let expansion = self.parent_scope.expansion;
-        // Record primary definitions.
-        match res {
-            Res::Def(DefKind::Mod | DefKind::Enum | DefKind::Trait, def_id) => {
-                let module = self.r.expect_module(def_id);
-                self.r.define(parent, ident, TypeNS, (module, vis, span, expansion));
-            }
-            Res::Def(
-                DefKind::Struct
-                | DefKind::Union
-                | DefKind::Variant
-                | DefKind::TyAlias
-                | DefKind::ForeignTy
-                | DefKind::OpaqueTy
-                | DefKind::TraitAlias
-                | DefKind::AssocTy,
-                _,
-            )
-            | Res::PrimTy(..)
-            | Res::ToolMod => self.r.define(parent, ident, TypeNS, (res, vis, span, expansion)),
-            Res::Def(
-                DefKind::Fn
-                | DefKind::AssocFn
-                | DefKind::Static { .. }
-                | DefKind::Const
-                | DefKind::AssocConst
-                | DefKind::Ctor(..),
-                _,
-            ) => self.r.define(parent, ident, ValueNS, (res, vis, span, expansion)),
-            Res::Def(DefKind::Macro(..), _) | Res::NonMacroAttr(..) => {
-                self.r.define(parent, ident, MacroNS, (res, vis, span, expansion))
-            }
-            Res::Def(
-                DefKind::TyParam
-                | DefKind::ConstParam
-                | DefKind::ExternCrate
-                | DefKind::Use
-                | DefKind::ForeignMod
-                | DefKind::AnonConst
-                | DefKind::InlineConst
-                | DefKind::Field
-                | DefKind::LifetimeParam
-                | DefKind::GlobalAsm
-                | DefKind::Closure
-                | DefKind::Impl { .. },
-                _,
-            )
-            | Res::Local(..)
-            | Res::SelfTyParam { .. }
-            | Res::SelfTyAlias { .. }
-            | Res::SelfCtor(..)
-            | Res::Err => bug!("unexpected resolution: {:?}", res),
-        }
-    }
-
     fn add_macro_use_binding(
         &mut self,
         name: Symbol,

From 6982785f18de964e8f678ad3af7fb0af5d01daa8 Mon Sep 17 00:00:00 2001
From: Travis Cross <tc@traviscross.com>
Date: Mon, 26 Aug 2024 06:46:56 +0000
Subject: [PATCH 609/685] Tie `impl_trait_overcaptures` lint to Rust 2024

The `impl_trait_overcaptures` lint is part of the migration to Rust
2024 and the Lifetime Capture Rules 2024.  Now that we've stabilized
precise capturing (RFC 3617), let's tie this lint to the
`rust_2024_compatibility` lint group.
---
 .../rustc_lint/src/impl_trait_overcaptures.rs | 10 ++++++----
 .../precise-capturing/overcaptures-2024.fixed |  4 ++++
 .../precise-capturing/overcaptures-2024.rs    |  4 ++++
 .../overcaptures-2024.stderr                  | 20 +++++++++++++------
 4 files changed, 28 insertions(+), 10 deletions(-)

diff --git a/compiler/rustc_lint/src/impl_trait_overcaptures.rs b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
index 990fb2d16f9dd..49767842266cc 100644
--- a/compiler/rustc_lint/src/impl_trait_overcaptures.rs
+++ b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
@@ -10,7 +10,9 @@ use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
 use rustc_middle::ty::{
     self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
 };
+use rustc_session::lint::FutureIncompatibilityReason;
 use rustc_session::{declare_lint, declare_lint_pass};
+use rustc_span::edition::Edition;
 use rustc_span::Span;
 
 use crate::{fluent_generated as fluent, LateContext, LateLintPass};
@@ -54,10 +56,10 @@ declare_lint! {
     pub IMPL_TRAIT_OVERCAPTURES,
     Allow,
     "`impl Trait` will capture more lifetimes than possibly intended in edition 2024",
-    //@future_incompatible = FutureIncompatibleInfo {
-    //    reason: FutureIncompatibilityReason::EditionSemanticsChange(Edition::Edition2024),
-    //    reference: "<FIXME>",
-    //};
+    @future_incompatible = FutureIncompatibleInfo {
+        reason: FutureIncompatibilityReason::EditionSemanticsChange(Edition::Edition2024),
+        reference: "<https://doc.rust-lang.org/nightly/edition-guide/rust-2024/rpit-lifetime-capture.html>",
+    };
 }
 
 declare_lint! {
diff --git a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.fixed b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.fixed
index 6bca8ef12ecc3..89a3f3136c82a 100644
--- a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.fixed
+++ b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.fixed
@@ -5,14 +5,17 @@
 
 fn named<'a>(x: &'a i32) -> impl Sized + use<> { *x }
 //~^ ERROR `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+//~| WARN this changes meaning in Rust 2024
 
 fn implicit(x: &i32) -> impl Sized + use<> { *x }
 //~^ ERROR `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+//~| WARN this changes meaning in Rust 2024
 
 struct W;
 impl W {
     fn hello(&self, x: &i32) -> impl Sized + '_ + use<'_> { self }
     //~^ ERROR `impl Sized + '_` will capture more lifetimes than possibly intended in edition 2024
+    //~| WARN this changes meaning in Rust 2024
 }
 
 trait Higher<'a> {
@@ -24,5 +27,6 @@ impl Higher<'_> for () {
 
 fn hrtb() -> impl for<'a> Higher<'a, Output = impl Sized + use<>> {}
 //~^ ERROR `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+//~| WARN this changes meaning in Rust 2024
 
 fn main() {}
diff --git a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.rs b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.rs
index 5b6726b49e025..18c04f9f799cb 100644
--- a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.rs
+++ b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.rs
@@ -5,14 +5,17 @@
 
 fn named<'a>(x: &'a i32) -> impl Sized { *x }
 //~^ ERROR `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+//~| WARN this changes meaning in Rust 2024
 
 fn implicit(x: &i32) -> impl Sized { *x }
 //~^ ERROR `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+//~| WARN this changes meaning in Rust 2024
 
 struct W;
 impl W {
     fn hello(&self, x: &i32) -> impl Sized + '_ { self }
     //~^ ERROR `impl Sized + '_` will capture more lifetimes than possibly intended in edition 2024
+    //~| WARN this changes meaning in Rust 2024
 }
 
 trait Higher<'a> {
@@ -24,5 +27,6 @@ impl Higher<'_> for () {
 
 fn hrtb() -> impl for<'a> Higher<'a, Output = impl Sized> {}
 //~^ ERROR `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+//~| WARN this changes meaning in Rust 2024
 
 fn main() {}
diff --git a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.stderr b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.stderr
index fec640aa83aa9..94dafb04d64ad 100644
--- a/tests/ui/impl-trait/precise-capturing/overcaptures-2024.stderr
+++ b/tests/ui/impl-trait/precise-capturing/overcaptures-2024.stderr
@@ -4,6 +4,8 @@ error: `impl Sized` will capture more lifetimes than possibly intended in editio
 LL | fn named<'a>(x: &'a i32) -> impl Sized { *x }
    |                             ^^^^^^^^^^
    |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/rpit-lifetime-capture.html>
 note: specifically, this lifetime is in scope but not mentioned in the type's bounds
   --> $DIR/overcaptures-2024.rs:6:10
    |
@@ -21,13 +23,15 @@ LL | fn named<'a>(x: &'a i32) -> impl Sized + use<> { *x }
    |                                        +++++++
 
 error: `impl Sized` will capture more lifetimes than possibly intended in edition 2024
-  --> $DIR/overcaptures-2024.rs:9:25
+  --> $DIR/overcaptures-2024.rs:10:25
    |
 LL | fn implicit(x: &i32) -> impl Sized { *x }
    |                         ^^^^^^^^^^
    |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/rpit-lifetime-capture.html>
 note: specifically, this lifetime is in scope but not mentioned in the type's bounds
-  --> $DIR/overcaptures-2024.rs:9:16
+  --> $DIR/overcaptures-2024.rs:10:16
    |
 LL | fn implicit(x: &i32) -> impl Sized { *x }
    |                ^
@@ -38,13 +42,15 @@ LL | fn implicit(x: &i32) -> impl Sized + use<> { *x }
    |                                    +++++++
 
 error: `impl Sized + '_` will capture more lifetimes than possibly intended in edition 2024
-  --> $DIR/overcaptures-2024.rs:14:33
+  --> $DIR/overcaptures-2024.rs:16:33
    |
 LL |     fn hello(&self, x: &i32) -> impl Sized + '_ { self }
    |                                 ^^^^^^^^^^^^^^^
    |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/rpit-lifetime-capture.html>
 note: specifically, this lifetime is in scope but not mentioned in the type's bounds
-  --> $DIR/overcaptures-2024.rs:14:24
+  --> $DIR/overcaptures-2024.rs:16:24
    |
 LL |     fn hello(&self, x: &i32) -> impl Sized + '_ { self }
    |                        ^
@@ -55,13 +61,15 @@ LL |     fn hello(&self, x: &i32) -> impl Sized + '_ + use<'_> { self }
    |                                                 +++++++++
 
 error: `impl Sized` will capture more lifetimes than possibly intended in edition 2024
-  --> $DIR/overcaptures-2024.rs:25:47
+  --> $DIR/overcaptures-2024.rs:28:47
    |
 LL | fn hrtb() -> impl for<'a> Higher<'a, Output = impl Sized> {}
    |                                               ^^^^^^^^^^
    |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/rpit-lifetime-capture.html>
 note: specifically, this lifetime is in scope but not mentioned in the type's bounds
-  --> $DIR/overcaptures-2024.rs:25:23
+  --> $DIR/overcaptures-2024.rs:28:23
    |
 LL | fn hrtb() -> impl for<'a> Higher<'a, Output = impl Sized> {}
    |                       ^^

From 7ea2981605ef13f713f42e877c4c31b059cb1ebe Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 26 Aug 2024 13:48:19 +0200
Subject: [PATCH 610/685] const-eval: do not make UbChecks behavior depend on
 current crate's flags

---
 compiler/rustc_const_eval/src/interpret/machine.rs  | 10 ++++++++++
 compiler/rustc_const_eval/src/interpret/operator.rs |  2 +-
 src/tools/miri/src/machine.rs                       |  4 ++++
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
index 761ab81e22842..d30bd6c70138a 100644
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -280,6 +280,9 @@ pub trait Machine<'tcx>: Sized {
         Ok(())
     }
 
+    /// Determines the result of a `NullaryOp::UbChecks` invocation.
+    fn ub_checks(_ecx: &InterpCx<'tcx, Self>) -> InterpResult<'tcx, bool>;
+
     /// Called when the interpreter encounters a `StatementKind::ConstEvalCounter` instruction.
     /// You can use this to detect long or endlessly running programs.
     #[inline]
@@ -627,6 +630,13 @@ pub macro compile_time_machine(<$tcx: lifetime>) {
         match fn_val {}
     }
 
+    #[inline(always)]
+    fn ub_checks(_ecx: &InterpCx<$tcx, Self>) -> InterpResult<$tcx, bool> {
+        // We can't look at `tcx.sess` here as that can differ across crates, which can lead to
+        // unsound differences in evaluating the same constant at different instantiation sites.
+        Ok(true)
+    }
+
     #[inline(always)]
     fn adjust_global_allocation<'b>(
         _ecx: &InterpCx<$tcx, Self>,
diff --git a/compiler/rustc_const_eval/src/interpret/operator.rs b/compiler/rustc_const_eval/src/interpret/operator.rs
index 2f860f9f942b2..e9ba12dbcc4ea 100644
--- a/compiler/rustc_const_eval/src/interpret/operator.rs
+++ b/compiler/rustc_const_eval/src/interpret/operator.rs
@@ -512,7 +512,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                     self.tcx.offset_of_subfield(self.param_env, layout, fields.iter()).bytes();
                 ImmTy::from_uint(val, usize_layout())
             }
-            UbChecks => ImmTy::from_bool(self.tcx.sess.ub_checks(), *self.tcx),
+            UbChecks => ImmTy::from_bool(M::ub_checks(self)?, *self.tcx),
         })
     }
 }
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index a7493d48d6a2d..f97b716e0b806 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1060,6 +1060,10 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         ecx.generate_nan(inputs)
     }
 
+    fn ub_checks(ecx: &InterpCx<'tcx, Self>) -> InterpResult<'tcx, bool> {
+        Ok(ecx.tcx.sess.ub_checks())
+    }
+
     fn thread_local_static_pointer(
         ecx: &mut MiriInterpCx<'tcx>,
         def_id: DefId,

From 7a290fce907da1cda0687fe5e48372c08fe40ab8 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 26 Aug 2024 17:01:46 +0200
Subject: [PATCH 611/685] interpret: do not make const-eval query result depend
 on tcx.sess

---
 compiler/rustc_const_eval/messages.ftl        |  3 --
 .../rustc_const_eval/src/interpret/call.rs    | 44 +++----------------
 .../rustc_const_eval/src/interpret/machine.rs | 22 +++++++---
 src/tools/miri/src/machine.rs                 | 42 +++++++++++++++---
 .../target_feature_wasm.rs                    |  4 +-
 .../const-eval/const_fn_target_feature.rs     |  4 +-
 .../const-eval/const_fn_target_feature.stderr |  9 ----
 .../const_fn_target_feature_wasm.rs           |  4 +-
 8 files changed, 70 insertions(+), 62 deletions(-)
 rename src/tools/miri/tests/{pass/function_calls => panic}/target_feature_wasm.rs (61%)
 delete mode 100644 tests/ui/consts/const-eval/const_fn_target_feature.stderr

diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index d7d64180ec9c1..db788b6b15199 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -402,9 +402,6 @@ const_eval_unallowed_mutable_refs =
 const_eval_unallowed_op_in_const_context =
     {$msg}
 
-const_eval_unavailable_target_features_for_fn =
-    calling a function that requires unavailable target features: {$unavailable_feats}
-
 const_eval_uninhabited_enum_variant_read =
     read discriminant of an uninhabited enum variant
 const_eval_uninhabited_enum_variant_written =
diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index 917a2fa7c6dd4..4b21a3a6a3df6 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -311,34 +311,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         Ok(())
     }
 
-    fn check_fn_target_features(&self, instance: ty::Instance<'tcx>) -> InterpResult<'tcx, ()> {
-        // Calling functions with `#[target_feature]` is not unsafe on WASM, see #84988
-        let attrs = self.tcx.codegen_fn_attrs(instance.def_id());
-        if !self.tcx.sess.target.is_like_wasm
-            && attrs
-                .target_features
-                .iter()
-                .any(|feature| !self.tcx.sess.target_features.contains(&feature.name))
-        {
-            throw_ub_custom!(
-                fluent::const_eval_unavailable_target_features_for_fn,
-                unavailable_feats = attrs
-                    .target_features
-                    .iter()
-                    .filter(|&feature| !feature.implied
-                        && !self.tcx.sess.target_features.contains(&feature.name))
-                    .fold(String::new(), |mut s, feature| {
-                        if !s.is_empty() {
-                            s.push_str(", ");
-                        }
-                        s.push_str(feature.name.as_str());
-                        s
-                    }),
-            );
-        }
-        Ok(())
-    }
-
     /// The main entry point for creating a new stack frame: performs ABI checks and initializes
     /// arguments.
     #[instrument(skip(self), level = "trace")]
@@ -360,20 +332,18 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             throw_unsup_format!("calling a c-variadic function is not supported");
         }
 
-        if M::enforce_abi(self) {
-            if caller_fn_abi.conv != callee_fn_abi.conv {
-                throw_ub_custom!(
-                    fluent::const_eval_incompatible_calling_conventions,
-                    callee_conv = format!("{:?}", callee_fn_abi.conv),
-                    caller_conv = format!("{:?}", caller_fn_abi.conv),
-                )
-            }
+        if caller_fn_abi.conv != callee_fn_abi.conv {
+            throw_ub_custom!(
+                fluent::const_eval_incompatible_calling_conventions,
+                callee_conv = format!("{:?}", callee_fn_abi.conv),
+                caller_conv = format!("{:?}", caller_fn_abi.conv),
+            )
         }
 
         // Check that all target features required by the callee (i.e., from
         // the attribute `#[target_feature(enable = ...)]`) are enabled at
         // compile time.
-        self.check_fn_target_features(instance)?;
+        M::check_fn_target_features(self, instance)?;
 
         if !callee_fn_abi.can_unwind {
             // The callee cannot unwind, so force the `Unreachable` unwind handling.
diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
index 761ab81e22842..1c71780bb450a 100644
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -173,11 +173,6 @@ pub trait Machine<'tcx>: Sized {
         false
     }
 
-    /// Whether function calls should be [ABI](CallAbi)-checked.
-    fn enforce_abi(_ecx: &InterpCx<'tcx, Self>) -> bool {
-        true
-    }
-
     /// Whether Assert(OverflowNeg) and Assert(Overflow) MIR terminators should actually
     /// check for overflow.
     fn ignore_optional_overflow_checks(_ecx: &InterpCx<'tcx, Self>) -> bool;
@@ -238,6 +233,13 @@ pub trait Machine<'tcx>: Sized {
         unwind: mir::UnwindAction,
     ) -> InterpResult<'tcx, Option<ty::Instance<'tcx>>>;
 
+    /// Check whether the given function may be executed on the current machine, in terms of the
+    /// target features is requires.
+    fn check_fn_target_features(
+        _ecx: &InterpCx<'tcx, Self>,
+        _instance: ty::Instance<'tcx>,
+    ) -> InterpResult<'tcx>;
+
     /// Called to evaluate `Assert` MIR terminators that trigger a panic.
     fn assert_panic(
         ecx: &mut InterpCx<'tcx, Self>,
@@ -614,6 +616,16 @@ pub macro compile_time_machine(<$tcx: lifetime>) {
         unreachable!("unwinding cannot happen during compile-time evaluation")
     }
 
+    #[inline(always)]
+    fn check_fn_target_features(
+        _ecx: &InterpCx<$tcx, Self>,
+        _instance: ty::Instance<$tcx>,
+    ) -> InterpResult<$tcx> {
+        // For now we don't do any checking here. We can't use `tcx.sess` because that can differ
+        // between crates, and we need to ensure that const-eval always behaves the same.
+        Ok(())
+    }
+
     #[inline(always)]
     fn call_extra_fn(
         _ecx: &mut InterpCx<$tcx, Self>,
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index a7493d48d6a2d..8d4866517f2b2 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -946,16 +946,48 @@ impl<'tcx> Machine<'tcx> for MiriMachine<'tcx> {
         ecx.machine.validation == ValidationMode::Deep
     }
 
-    #[inline(always)]
-    fn enforce_abi(_ecx: &MiriInterpCx<'tcx>) -> bool {
-        true
-    }
-
     #[inline(always)]
     fn ignore_optional_overflow_checks(ecx: &MiriInterpCx<'tcx>) -> bool {
         !ecx.tcx.sess.overflow_checks()
     }
 
+    fn check_fn_target_features(
+        ecx: &MiriInterpCx<'tcx>,
+        instance: ty::Instance<'tcx>,
+    ) -> InterpResult<'tcx> {
+        let attrs = ecx.tcx.codegen_fn_attrs(instance.def_id());
+        if attrs
+            .target_features
+            .iter()
+            .any(|feature| !ecx.tcx.sess.target_features.contains(&feature.name))
+        {
+            let unavailable = attrs
+                .target_features
+                .iter()
+                .filter(|&feature| {
+                    !feature.implied && !ecx.tcx.sess.target_features.contains(&feature.name)
+                })
+                .fold(String::new(), |mut s, feature| {
+                    if !s.is_empty() {
+                        s.push_str(", ");
+                    }
+                    s.push_str(feature.name.as_str());
+                    s
+                });
+            let msg = format!(
+                "calling a function that requires unavailable target features: {unavailable}"
+            );
+            // On WASM, this is not UB, but instead gets rejected during validation of the module
+            // (see #84988).
+            if ecx.tcx.sess.target.is_like_wasm {
+                throw_machine_stop!(TerminationInfo::Abort(msg));
+            } else {
+                throw_ub_format!("{msg}");
+            }
+        }
+        Ok(())
+    }
+
     #[inline(always)]
     fn find_mir_or_eval_fn(
         ecx: &mut MiriInterpCx<'tcx>,
diff --git a/src/tools/miri/tests/pass/function_calls/target_feature_wasm.rs b/src/tools/miri/tests/panic/target_feature_wasm.rs
similarity index 61%
rename from src/tools/miri/tests/pass/function_calls/target_feature_wasm.rs
rename to src/tools/miri/tests/panic/target_feature_wasm.rs
index 5056f32de445e..c67d2983f78fc 100644
--- a/src/tools/miri/tests/pass/function_calls/target_feature_wasm.rs
+++ b/src/tools/miri/tests/panic/target_feature_wasm.rs
@@ -2,7 +2,9 @@
 //@compile-flags: -C target-feature=-simd128
 
 fn main() {
-    // Calling functions with `#[target_feature]` is not unsound on WASM, see #84988
+    // Calling functions with `#[target_feature]` is not unsound on WASM, see #84988.
+    // But if the compiler actually uses the target feature, it will lead to an error when the module is loaded.
+    // We emulate this with an "unsupported" error.
     assert!(!cfg!(target_feature = "simd128"));
     simd128_fn();
 }
diff --git a/tests/ui/consts/const-eval/const_fn_target_feature.rs b/tests/ui/consts/const-eval/const_fn_target_feature.rs
index ee669abb51e59..8db41ba11c048 100644
--- a/tests/ui/consts/const-eval/const_fn_target_feature.rs
+++ b/tests/ui/consts/const-eval/const_fn_target_feature.rs
@@ -1,6 +1,7 @@
 //@ only-x86_64
 // Set the base cpu explicitly, in case the default has been changed.
 //@ compile-flags: -C target-cpu=x86-64 -C target-feature=+ssse3
+//@ check-pass
 
 #![crate_type = "lib"]
 
@@ -9,7 +10,8 @@ const A: () = unsafe { ssse3_fn() };
 
 // error (avx2 not enabled at compile time)
 const B: () = unsafe { avx2_fn() };
-//~^ ERROR evaluation of constant value failed
+// FIXME: currently we do not detect this UB, since we don't want the result of const-eval
+// to depend on `tcx.sess` which can differ between crates in a crate graph.
 
 #[target_feature(enable = "ssse3")]
 const unsafe fn ssse3_fn() {}
diff --git a/tests/ui/consts/const-eval/const_fn_target_feature.stderr b/tests/ui/consts/const-eval/const_fn_target_feature.stderr
deleted file mode 100644
index d3a00b57ebb50..0000000000000
--- a/tests/ui/consts/const-eval/const_fn_target_feature.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0080]: evaluation of constant value failed
-  --> $DIR/const_fn_target_feature.rs:11:24
-   |
-LL | const B: () = unsafe { avx2_fn() };
-   |                        ^^^^^^^^^ calling a function that requires unavailable target features: avx2
-
-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_fn_target_feature_wasm.rs b/tests/ui/consts/const-eval/const_fn_target_feature_wasm.rs
index deed09e4b2af7..8ddfe61943cb7 100644
--- a/tests/ui/consts/const-eval/const_fn_target_feature_wasm.rs
+++ b/tests/ui/consts/const-eval/const_fn_target_feature_wasm.rs
@@ -7,7 +7,9 @@
 #[cfg(target_feature = "simd128")]
 compile_error!("simd128 target feature should be disabled");
 
-// Calling functions with `#[target_feature]` is not unsound on WASM, see #84988
+// Calling functions with `#[target_feature]` is not unsound on WASM, see #84988.
+// (It can still lead to a runtime error though so we'd be in our right to abort execution,
+// just not to declare it UB.)
 const A: () = simd128_fn();
 
 #[target_feature(enable = "simd128")]

From fe2975076f1f84ff892cf95655268985e3550948 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 25 Aug 2024 16:03:29 +0200
Subject: [PATCH 612/685] float types: document NaN bit pattern guarantees

---
 library/core/src/num/f128.rs       | 30 ++++++++-----
 library/core/src/num/f16.rs        | 30 ++++++++-----
 library/core/src/num/f32.rs        | 14 +++---
 library/core/src/num/f64.rs        | 14 +++---
 library/core/src/primitive_docs.rs | 71 ++++++++++++++++++++++++++++++
 5 files changed, 123 insertions(+), 36 deletions(-)

diff --git a/library/core/src/num/f128.rs b/library/core/src/num/f128.rs
index 38e69e7641ab4..d4236e47bfe3b 100644
--- a/library/core/src/num/f128.rs
+++ b/library/core/src/num/f128.rs
@@ -454,11 +454,14 @@ impl f128 {
     }
 
     /// Returns `true` if `self` has a positive sign, including `+0.0`, NaNs with
-    /// positive sign bit and positive infinity. Note that IEEE 754 doesn't assign any
-    /// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
-    /// the bit pattern of NaNs are conserved over arithmetic operations, the result of
-    /// `is_sign_positive` on a NaN might produce an unexpected result in some cases.
-    /// See [explanation of NaN as a special value](f128) for more info.
+    /// positive sign bit and positive infinity.
+    ///
+    /// Note that IEEE 754 doesn't assign any meaning to the sign bit in case of
+    /// a NaN, and as Rust doesn't guarantee that the bit pattern of NaNs are
+    /// conserved over arithmetic operations, the result of `is_sign_positive` on
+    /// a NaN might produce an unexpected or non-portable result. See the [specification
+    /// of NaN bit patterns](f32#nan-bit-patterns) for more info. Use `self.signum() == 1.0`
+    /// if you need fully portable behavior (will return `false` for all NaNs).
     ///
     /// ```
     /// #![feature(f128)]
@@ -477,11 +480,14 @@ impl f128 {
     }
 
     /// Returns `true` if `self` has a negative sign, including `-0.0`, NaNs with
-    /// negative sign bit and negative infinity. Note that IEEE 754 doesn't assign any
-    /// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
-    /// the bit pattern of NaNs are conserved over arithmetic operations, the result of
-    /// `is_sign_negative` on a NaN might produce an unexpected result in some cases.
-    /// See [explanation of NaN as a special value](f128) for more info.
+    /// negative sign bit and negative infinity.
+    ///
+    /// Note that IEEE 754 doesn't assign any meaning to the sign bit in case of
+    /// a NaN, and as Rust doesn't guarantee that the bit pattern of NaNs are
+    /// conserved over arithmetic operations, the result of `is_sign_negative` on
+    /// a NaN might produce an unexpected or non-portable result. See the [specification
+    /// of NaN bit patterns](f32#nan-bit-patterns) for more info. Use `self.signum() == -1.0`
+    /// if you need fully portable behavior (will return `false` for all NaNs).
     ///
     /// ```
     /// #![feature(f128)]
@@ -750,7 +756,7 @@ impl f128 {
     /// Note that this follows the semantics specified in IEEE 754-2019.
     ///
     /// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
-    /// operand is conserved; see [explanation of NaN as a special value](f128) for more info.
+    /// operand is conserved; see the [specification of NaN bit patterns](f32#nan-bit-patterns) for more info.
     #[inline]
     #[unstable(feature = "f128", issue = "116909")]
     // #[unstable(feature = "float_minimum_maximum", issue = "91079")]
@@ -791,7 +797,7 @@ impl f128 {
     /// Note that this follows the semantics specified in IEEE 754-2019.
     ///
     /// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
-    /// operand is conserved; see [explanation of NaN as a special value](f128) for more info.
+    /// operand is conserved; see the [specification of NaN bit patterns](f32#nan-bit-patterns) for more info.
     #[inline]
     #[unstable(feature = "f128", issue = "116909")]
     // #[unstable(feature = "float_minimum_maximum", issue = "91079")]
diff --git a/library/core/src/num/f16.rs b/library/core/src/num/f16.rs
index bb0cc1c60ba5a..1e2f841aca733 100644
--- a/library/core/src/num/f16.rs
+++ b/library/core/src/num/f16.rs
@@ -464,11 +464,14 @@ impl f16 {
     }
 
     /// Returns `true` if `self` has a positive sign, including `+0.0`, NaNs with
-    /// positive sign bit and positive infinity. Note that IEEE 754 doesn't assign any
-    /// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
-    /// the bit pattern of NaNs are conserved over arithmetic operations, the result of
-    /// `is_sign_positive` on a NaN might produce an unexpected result in some cases.
-    /// See [explanation of NaN as a special value](f16) for more info.
+    /// positive sign bit and positive infinity.
+    ///
+    /// Note that IEEE 754 doesn't assign any meaning to the sign bit in case of
+    /// a NaN, and as Rust doesn't guarantee that the bit pattern of NaNs are
+    /// conserved over arithmetic operations, the result of `is_sign_positive` on
+    /// a NaN might produce an unexpected or non-portable result. See the [specification
+    /// of NaN bit patterns](f32#nan-bit-patterns) for more info. Use `self.signum() == 1.0`
+    /// if you need fully portable behavior (will return `false` for all NaNs).
     ///
     /// ```
     /// #![feature(f16)]
@@ -490,11 +493,14 @@ impl f16 {
     }
 
     /// Returns `true` if `self` has a negative sign, including `-0.0`, NaNs with
-    /// negative sign bit and negative infinity. Note that IEEE 754 doesn't assign any
-    /// meaning to the sign bit in case of a NaN, and as Rust doesn't guarantee that
-    /// the bit pattern of NaNs are conserved over arithmetic operations, the result of
-    /// `is_sign_negative` on a NaN might produce an unexpected result in some cases.
-    /// See [explanation of NaN as a special value](f16) for more info.
+    /// negative sign bit and negative infinity.
+    ///
+    /// Note that IEEE 754 doesn't assign any meaning to the sign bit in case of
+    /// a NaN, and as Rust doesn't guarantee that the bit pattern of NaNs are
+    /// conserved over arithmetic operations, the result of `is_sign_negative` on
+    /// a NaN might produce an unexpected or non-portable result. See the [specification
+    /// of NaN bit patterns](f32#nan-bit-patterns) for more info. Use `self.signum() == -1.0`
+    /// if you need fully portable behavior (will return `false` for all NaNs).
     ///
     /// ```
     /// #![feature(f16)]
@@ -762,7 +768,7 @@ impl f16 {
     /// Note that this follows the semantics specified in IEEE 754-2019.
     ///
     /// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
-    /// operand is conserved; see [explanation of NaN as a special value](f16) for more info.
+    /// operand is conserved; see the [specification of NaN bit patterns](f32#nan-bit-patterns) for more info.
     #[inline]
     #[unstable(feature = "f16", issue = "116909")]
     // #[unstable(feature = "float_minimum_maximum", issue = "91079")]
@@ -802,7 +808,7 @@ impl f16 {
     /// Note that this follows the semantics specified in IEEE 754-2019.
     ///
     /// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
-    /// operand is conserved; see [explanation of NaN as a special value](f16) for more info.
+    /// operand is conserved; see the [specification of NaN bit patterns](f32#nan-bit-patterns) for more info.
     #[inline]
     #[unstable(feature = "f16", issue = "116909")]
     // #[unstable(feature = "float_minimum_maximum", issue = "91079")]
diff --git a/library/core/src/num/f32.rs b/library/core/src/num/f32.rs
index 719727e2f1e0a..c1adcc753f2e5 100644
--- a/library/core/src/num/f32.rs
+++ b/library/core/src/num/f32.rs
@@ -700,8 +700,9 @@ impl f32 {
     /// Note that IEEE 754 doesn't assign any meaning to the sign bit in case of
     /// a NaN, and as Rust doesn't guarantee that the bit pattern of NaNs are
     /// conserved over arithmetic operations, the result of `is_sign_positive` on
-    /// a NaN might produce an unexpected result in some cases. See [explanation
-    /// of NaN as a special value](f32) for more info.
+    /// a NaN might produce an unexpected or non-portable result. See the [specification
+    /// of NaN bit patterns](f32#nan-bit-patterns) for more info. Use `self.signum() == 1.0`
+    /// if you need fully portable behavior (will return `false` for all NaNs).
     ///
     /// ```
     /// let f = 7.0_f32;
@@ -724,8 +725,9 @@ impl f32 {
     /// Note that IEEE 754 doesn't assign any meaning to the sign bit in case of
     /// a NaN, and as Rust doesn't guarantee that the bit pattern of NaNs are
     /// conserved over arithmetic operations, the result of `is_sign_negative` on
-    /// a NaN might produce an unexpected result in some cases. See [explanation
-    /// of NaN as a special value](f32) for more info.
+    /// a NaN might produce an unexpected or non-portable result. See the [specification
+    /// of NaN bit patterns](f32#nan-bit-patterns) for more info. Use `self.signum() == -1.0`
+    /// if you need fully portable behavior (will return `false` for all NaNs).
     ///
     /// ```
     /// let f = 7.0f32;
@@ -954,7 +956,7 @@ impl f32 {
     /// Note that this follows the semantics specified in IEEE 754-2019.
     ///
     /// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
-    /// operand is conserved; see [explanation of NaN as a special value](f32) for more info.
+    /// operand is conserved; see the [specification of NaN bit patterns](f32#nan-bit-patterns) for more info.
     #[must_use = "this returns the result of the comparison, without modifying either input"]
     #[unstable(feature = "float_minimum_maximum", issue = "91079")]
     #[inline]
@@ -989,7 +991,7 @@ impl f32 {
     /// Note that this follows the semantics specified in IEEE 754-2019.
     ///
     /// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
-    /// operand is conserved; see [explanation of NaN as a special value](f32) for more info.
+    /// operand is conserved; see the [specification of NaN bit patterns](f32#nan-bit-patterns) for more info.
     #[must_use = "this returns the result of the comparison, without modifying either input"]
     #[unstable(feature = "float_minimum_maximum", issue = "91079")]
     #[inline]
diff --git a/library/core/src/num/f64.rs b/library/core/src/num/f64.rs
index 85eb152ad1f19..e6406771ad333 100644
--- a/library/core/src/num/f64.rs
+++ b/library/core/src/num/f64.rs
@@ -695,8 +695,9 @@ impl f64 {
     /// Note that IEEE 754 doesn't assign any meaning to the sign bit in case of
     /// a NaN, and as Rust doesn't guarantee that the bit pattern of NaNs are
     /// conserved over arithmetic operations, the result of `is_sign_positive` on
-    /// a NaN might produce an unexpected result in some cases. See [explanation
-    /// of NaN as a special value](f32) for more info.
+    /// a NaN might produce an unexpected or non-portable result. See the [specification
+    /// of NaN bit patterns](f32#nan-bit-patterns) for more info. Use `self.signum() == 1.0`
+    /// if you need fully portable behavior (will return `false` for all NaNs).
     ///
     /// ```
     /// let f = 7.0_f64;
@@ -728,8 +729,9 @@ impl f64 {
     /// Note that IEEE 754 doesn't assign any meaning to the sign bit in case of
     /// a NaN, and as Rust doesn't guarantee that the bit pattern of NaNs are
     /// conserved over arithmetic operations, the result of `is_sign_negative` on
-    /// a NaN might produce an unexpected result in some cases. See [explanation
-    /// of NaN as a special value](f32) for more info.
+    /// a NaN might produce an unexpected or non-portable result. See the [specification
+    /// of NaN bit patterns](f32#nan-bit-patterns) for more info. Use `self.signum() == -1.0`
+    /// if you need fully portable behavior (will return `false` for all NaNs).
     ///
     /// ```
     /// let f = 7.0_f64;
@@ -968,7 +970,7 @@ impl f64 {
     /// Note that this follows the semantics specified in IEEE 754-2019.
     ///
     /// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
-    /// operand is conserved; see [explanation of NaN as a special value](f32) for more info.
+    /// operand is conserved; see the [specification of NaN bit patterns](f32#nan-bit-patterns) for more info.
     #[must_use = "this returns the result of the comparison, without modifying either input"]
     #[unstable(feature = "float_minimum_maximum", issue = "91079")]
     #[inline]
@@ -1003,7 +1005,7 @@ impl f64 {
     /// Note that this follows the semantics specified in IEEE 754-2019.
     ///
     /// Also note that "propagation" of NaNs here doesn't necessarily mean that the bitpattern of a NaN
-    /// operand is conserved; see [explanation of NaN as a special value](f32) for more info.
+    /// operand is conserved; see the [specification of NaN bit patterns](f32#nan-bit-patterns) for more info.
     #[must_use = "this returns the result of the comparison, without modifying either input"]
     #[unstable(feature = "float_minimum_maximum", issue = "91079")]
     #[inline]
diff --git a/library/core/src/primitive_docs.rs b/library/core/src/primitive_docs.rs
index 09ebef89fb0c2..e0593b1c0e75d 100644
--- a/library/core/src/primitive_docs.rs
+++ b/library/core/src/primitive_docs.rs
@@ -1190,6 +1190,11 @@ mod prim_f16 {}
 ///     portable or even fully deterministic! This means that there may be some
 ///     surprising results upon inspecting the bit patterns,
 ///     as the same calculations might produce NaNs with different bit patterns.
+///     This also affects the sign of the NaN: checking `is_sign_positive` or `is_sign_negative` on
+///     a NaN is the most common way to run into these surprising results.
+///     (Checking `x >= 0.0` or `x <= 0.0` avoids those surprises, but also how negative/positive
+///     zero are treated.)
+///     See the section below for what exactly is guaranteed about the bit pattern of a NaN.
 ///
 /// When a primitive operation (addition, subtraction, multiplication, or
 /// division) is performed on this type, the result is rounded according to the
@@ -1211,6 +1216,72 @@ mod prim_f16 {}
 /// *[See also the `std::f32::consts` module](crate::f32::consts).*
 ///
 /// [wikipedia]: https://en.wikipedia.org/wiki/Single-precision_floating-point_format
+///
+/// # NaN bit patterns
+///
+/// This section defines the possible NaN bit patterns returned by non-"bitwise" floating point
+/// operations. The bitwise operations are unary `-`, `abs`, `copysign`; those are guaranteed to
+/// exactly preserve the bit pattern of their input except for possibly changing the sign bit.
+///
+/// A floating-point NaN value consists of:
+/// - a sign bit
+/// - a quiet/signaling bit
+/// - a payload, which makes up the rest of the significand (i.e., the mantissa) except for the
+///   quiet/signaling bit.
+///
+/// Rust assumes that the quiet/signaling bit being set to `1` indicates a quiet NaN (QNaN), and a
+/// value of `0` indicates a signaling NaN (SNaN). In the following we will hence just call it the
+/// "quiet bit".
+///
+/// The following rules apply when a NaN value is returned: the result has a non-deterministic sign.
+/// The quiet bit and payload are non-deterministically chosen from the following set of options:
+///
+/// - **Preferred NaN**: The quiet bit is set and the payload is all-zero.
+/// - **Quieting NaN propagation**: The quiet bit is set and the payload is copied from any input
+///   operand that is a NaN. If the inputs and outputs do not have the same payload size (i.e., for
+///   `as` casts), then
+///   - If the output is smaller than the input, low-order bits of the payload get dropped.
+///   - If the output is larger than the input, the payload gets filled up with 0s in the low-order
+///     bits.
+/// - **Unchanged NaN propagation**: The quiet bit and payload are copied from any input operand
+///   that is a NaN. If the inputs and outputs do not have the same size (i.e., for `as` casts), the
+///   same rules as for "quieting NaN propagation" apply, with one caveat: if the output is smaller
+///   than the input, droppig the low-order bits may result in a payload of 0; a payload of 0 is not
+///   possible with a signaling NaN (the all-0 significand encodes an infinity) so unchanged NaN
+///   propagation cannot occur with some inputs.
+/// - **Target-specific NaN**: The quiet bit is set and the payload is picked from a target-specific
+///   set of "extra" possible NaN payloads. The set can depend on the input operand values. This set
+///   is empty on x86, ARM, and RISC-V (32bit and 64bit), but can be non-empty on other
+///   architectures. Targets where this set is non-empty should document this in a suitable
+///   location, e.g. their platform support page. (For instance, on wasm, if any input NaN does not
+///   have the preferred all-zero payload or any input NaN is an SNaN, then this set contains all
+///   possible payloads; otherwise, it is empty. On SPARC, this set consists of the all-one
+///   payload.)
+///
+/// In particular, if all input NaNs are quiet (or if there are no input NaNs), then the output NaN
+/// is definitely quiet. Signaling NaN outputs can only occur if they are provided as an input
+/// value. Similarly, if all input NaNs are preferred (or if there are no input NaNs) and the target
+/// does not have any "extra" NaN payloads, then the output NaN is guaranteed to be preferred.
+///
+/// The non-deterministic choice happens when the operation is executed; i.e., the result of a
+/// NaN-producing floating point operation is a stable bit pattern (looking at these bits multiple
+/// times will yield consistent results), but running the same operation twice with the same inputs
+/// can produce different results.
+///
+/// These guarantees are neither stronger nor weaker than those of IEEE 754: IEEE 754 guarantees
+/// that an operation never returns a signaling NaN, whereas it is possible for operations like
+/// `SNAN * 1.0` to return a signaling NaN in Rust. Conversely, IEEE 754 makes no statement at all
+/// about which quiet NaN is returned, whereas Rust restricts the set of possible results to the
+/// ones listed above.
+///
+/// Unless noted otherwise, the same rules also apply to NaNs returned by other library functions
+/// (e.g. `min`, `minimum`, `max`, `maximum`); other aspects of their semantics and which IEEE 754
+/// operation they correspond to are documented with the respective functions.
+///
+/// When a floating-point operation is executed in `const` context, the same rules apply: no
+/// guarantee is made about which of the NaN bit patterns described above will be returned. The
+/// result does not have to match what happens when executing the same code at runtime, and the
+/// result can vary depending on factors such as compiler version and flags.
 #[stable(feature = "rust1", since = "1.0.0")]
 mod prim_f32 {}
 

From 53d4544628c0134a6b4d7edd971539dd8e655269 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 26 Aug 2024 17:16:53 +0200
Subject: [PATCH 613/685] move per-target NaN info into a table

---
 library/core/src/primitive_docs.rs | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/library/core/src/primitive_docs.rs b/library/core/src/primitive_docs.rs
index e0593b1c0e75d..7f35c7789e281 100644
--- a/library/core/src/primitive_docs.rs
+++ b/library/core/src/primitive_docs.rs
@@ -1250,13 +1250,8 @@ mod prim_f16 {}
 ///   possible with a signaling NaN (the all-0 significand encodes an infinity) so unchanged NaN
 ///   propagation cannot occur with some inputs.
 /// - **Target-specific NaN**: The quiet bit is set and the payload is picked from a target-specific
-///   set of "extra" possible NaN payloads. The set can depend on the input operand values. This set
-///   is empty on x86, ARM, and RISC-V (32bit and 64bit), but can be non-empty on other
-///   architectures. Targets where this set is non-empty should document this in a suitable
-///   location, e.g. their platform support page. (For instance, on wasm, if any input NaN does not
-///   have the preferred all-zero payload or any input NaN is an SNaN, then this set contains all
-///   possible payloads; otherwise, it is empty. On SPARC, this set consists of the all-one
-///   payload.)
+///   set of "extra" possible NaN payloads. The set can depend on the input operand values.
+///   See the table below for the concrete NaNs this set contains on various targets.
 ///
 /// In particular, if all input NaNs are quiet (or if there are no input NaNs), then the output NaN
 /// is definitely quiet. Signaling NaN outputs can only occur if they are provided as an input
@@ -1282,6 +1277,18 @@ mod prim_f16 {}
 /// guarantee is made about which of the NaN bit patterns described above will be returned. The
 /// result does not have to match what happens when executing the same code at runtime, and the
 /// result can vary depending on factors such as compiler version and flags.
+///
+/// ### Target-specific "extra" NaN values
+// FIXME: Is there a better place to put this?
+///
+/// | `target_arch` | Extra payloads possible on this platform |
+/// |---------------|---------|
+/// | `x86`, `x86_64`, `arm`, `aarch64`, `riscv32`, `riscv64` | None |
+/// | `sparc`, `sparc64` | The all-one payload |
+/// | `wasm32`, `wasm64` | If all input NaNs are quiet with all-zero payload: None.<br> Otherwise: all possible payloads. |
+///
+/// For targets not in this table, all payloads are possible.
+
 #[stable(feature = "rust1", since = "1.0.0")]
 mod prim_f32 {}
 

From 0c7d6c45e6b664fa4875741e78d185845d374f07 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Mon, 26 Aug 2024 17:25:24 +0200
Subject: [PATCH 614/685] also update copysign docs

---
 library/std/src/f128.rs | 10 +++++-----
 library/std/src/f16.rs  | 10 +++++-----
 library/std/src/f32.rs  | 10 +++++-----
 library/std/src/f64.rs  | 10 +++++-----
 4 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/library/std/src/f128.rs b/library/std/src/f128.rs
index f6df6259137bf..506d708d0d2eb 100644
--- a/library/std/src/f128.rs
+++ b/library/std/src/f128.rs
@@ -248,11 +248,11 @@ impl f128 {
     /// Returns a number composed of the magnitude of `self` and the sign of
     /// `sign`.
     ///
-    /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise
-    /// equal to `-self`. If `self` is a NaN, then a NaN with the sign bit of
-    /// `sign` is returned. Note, however, that conserving the sign bit on NaN
-    /// across arithmetical operations is not generally guaranteed.
-    /// See [explanation of NaN as a special value](primitive@f128) for more info.
+    /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise equal to `-self`.
+    /// If `self` is a NaN, then a NaN with the same payload as `self` and the sign bit of `sign` is
+    /// returned. Note, however, that conserving the sign bit on NaN across arithmetical operations
+    /// is not generally guaranteed. See [specification of NaN bit
+    /// patterns](primitive@f32#nan-bit-patterns) for more info.
     ///
     /// # Examples
     ///
diff --git a/library/std/src/f16.rs b/library/std/src/f16.rs
index 10908332762d5..033a3d4500932 100644
--- a/library/std/src/f16.rs
+++ b/library/std/src/f16.rs
@@ -247,11 +247,11 @@ impl f16 {
     /// Returns a number composed of the magnitude of `self` and the sign of
     /// `sign`.
     ///
-    /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise
-    /// equal to `-self`. If `self` is a NaN, then a NaN with the sign bit of
-    /// `sign` is returned. Note, however, that conserving the sign bit on NaN
-    /// across arithmetical operations is not generally guaranteed.
-    /// See [explanation of NaN as a special value](primitive@f16) for more info.
+    /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise equal to `-self`.
+    /// If `self` is a NaN, then a NaN with the same payload as `self` and the sign bit of `sign` is
+    /// returned. Note, however, that conserving the sign bit on NaN across arithmetical operations
+    /// is not generally guaranteed. See [specification of NaN bit
+    /// patterns](primitive@f32#nan-bit-patterns) for more info.
     ///
     /// # Examples
     ///
diff --git a/library/std/src/f32.rs b/library/std/src/f32.rs
index 12433d25bfa45..35c2a77b5338d 100644
--- a/library/std/src/f32.rs
+++ b/library/std/src/f32.rs
@@ -226,11 +226,11 @@ impl f32 {
     /// Returns a number composed of the magnitude of `self` and the sign of
     /// `sign`.
     ///
-    /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise
-    /// equal to `-self`. If `self` is a NaN, then a NaN with the sign bit of
-    /// `sign` is returned. Note, however, that conserving the sign bit on NaN
-    /// across arithmetical operations is not generally guaranteed.
-    /// See [explanation of NaN as a special value](primitive@f32) for more info.
+    /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise equal to `-self`.
+    /// If `self` is a NaN, then a NaN with the same payload as `self` and the sign bit of `sign` is
+    /// returned. Note, however, that conserving the sign bit on NaN across arithmetical operations
+    /// is not generally guaranteed. See [specification of NaN bit
+    /// patterns](primitive@f32#nan-bit-patterns) for more info.
     ///
     /// # Examples
     ///
diff --git a/library/std/src/f64.rs b/library/std/src/f64.rs
index a343e19173e59..c177f74a97e15 100644
--- a/library/std/src/f64.rs
+++ b/library/std/src/f64.rs
@@ -226,11 +226,11 @@ impl f64 {
     /// Returns a number composed of the magnitude of `self` and the sign of
     /// `sign`.
     ///
-    /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise
-    /// equal to `-self`. If `self` is a NaN, then a NaN with the sign bit of
-    /// `sign` is returned. Note, however, that conserving the sign bit on NaN
-    /// across arithmetical operations is not generally guaranteed.
-    /// See [explanation of NaN as a special value](primitive@f32) for more info.
+    /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise equal to `-self`.
+    /// If `self` is a NaN, then a NaN with the same payload as `self` and the sign bit of `sign` is
+    /// returned. Note, however, that conserving the sign bit on NaN across arithmetical operations
+    /// is not generally guaranteed. See [specification of NaN bit
+    /// patterns](primitive@f32#nan-bit-patterns) for more info.
     ///
     /// # Examples
     ///

From 834d615397ea9f95ac2d420cbd0f5bcb27464673 Mon Sep 17 00:00:00 2001
From: rustbot <47979223+rustbot@users.noreply.github.com>
Date: Mon, 26 Aug 2024 13:00:51 -0400
Subject: [PATCH 615/685] Update books

---
 src/doc/book            | 2 +-
 src/doc/edition-guide   | 2 +-
 src/doc/embedded-book   | 2 +-
 src/doc/nomicon         | 2 +-
 src/doc/reference       | 2 +-
 src/doc/rust-by-example | 2 +-
 src/doc/rustc-dev-guide | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/doc/book b/src/doc/book
index 04bc1396bb857..e7d217be2a75e 160000
--- a/src/doc/book
+++ b/src/doc/book
@@ -1 +1 @@
-Subproject commit 04bc1396bb857f35b5dda1d773c9571e1f253304
+Subproject commit e7d217be2a75ef1753f0988d6ccaba4d7e376259
diff --git a/src/doc/edition-guide b/src/doc/edition-guide
index aeeb287d41a03..eeba2cb9c37ab 160000
--- a/src/doc/edition-guide
+++ b/src/doc/edition-guide
@@ -1 +1 @@
-Subproject commit aeeb287d41a0332c210da122bea8e0e91844ab3e
+Subproject commit eeba2cb9c37ab74118a4fb5e5233f7397e4a91f8
diff --git a/src/doc/embedded-book b/src/doc/embedded-book
index 019f3928d8b93..ff5d61d56f11e 160000
--- a/src/doc/embedded-book
+++ b/src/doc/embedded-book
@@ -1 +1 @@
-Subproject commit 019f3928d8b939ec71b63722dcc2e46330156441
+Subproject commit ff5d61d56f11e1986bfa9652c6aff7731576c37d
diff --git a/src/doc/nomicon b/src/doc/nomicon
index 6ecf95c5f2bfa..14649f15d232d 160000
--- a/src/doc/nomicon
+++ b/src/doc/nomicon
@@ -1 +1 @@
-Subproject commit 6ecf95c5f2bfa0e6314dfe282bf775fd1405f7e9
+Subproject commit 14649f15d232d509478206ee9ed5105641aa60d0
diff --git a/src/doc/reference b/src/doc/reference
index 62cd0df95061b..f0f6155220ca3 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit 62cd0df95061ba0ac886333f5cd7f3012f149da1
+Subproject commit f0f6155220ca307881f185e44d0c325c5af75ad2
diff --git a/src/doc/rust-by-example b/src/doc/rust-by-example
index 8f94061936e49..859786c5bc993 160000
--- a/src/doc/rust-by-example
+++ b/src/doc/rust-by-example
@@ -1 +1 @@
-Subproject commit 8f94061936e492159f4f6c09c0f917a7521893ff
+Subproject commit 859786c5bc99301bbc22fc631a5c2b341860da08
diff --git a/src/doc/rustc-dev-guide b/src/doc/rustc-dev-guide
index 43d83780db545..fa928a6d19e16 160000
--- a/src/doc/rustc-dev-guide
+++ b/src/doc/rustc-dev-guide
@@ -1 +1 @@
-Subproject commit 43d83780db545a1ed6d45773312fc578987e3968
+Subproject commit fa928a6d19e1666d8d811dfe3fd35cdad3b4e459

From 00c435d9b37540d16489862446d934e98e58dfb1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Sun, 18 Aug 2024 18:59:26 +0000
Subject: [PATCH 616/685] Do not ICE on non-ADT rcvr type when looking for
 crate version collision

When looking for multiple versions of the same crate, do not blindly construct the receiver type.

Follow up to #128786. Fix #129205.
---
 .../rustc_hir_typeck/src/method/suggest.rs    | 14 ++++++++------
 .../missing-method-on-type-parameter.rs       |  6 ++++++
 .../missing-method-on-type-parameter.stderr   | 19 +++++++++++++++++++
 3 files changed, 33 insertions(+), 6 deletions(-)
 create mode 100644 tests/ui/methods/missing-method-on-type-parameter.rs
 create mode 100644 tests/ui/methods/missing-method-on-type-parameter.stderr

diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index ffd46ea13b908..8b8bb29dacdbd 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -3498,7 +3498,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 err,
                                 pick.item.def_id,
                                 rcvr.hir_id,
-                                *rcvr_ty,
+                                Some(*rcvr_ty),
                             );
                         if pick.autoderefs == 0 && !trait_in_other_version_found {
                             err.span_label(
@@ -3689,8 +3689,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         if let SelfSource::QPath(ty) = source
             && !valid_out_of_scope_traits.is_empty()
             && let hir::TyKind::Path(path) = ty.kind
-            && let hir::QPath::Resolved(_, path) = path
-            && let Some(def_id) = path.res.opt_def_id()
+            && let hir::QPath::Resolved(..) = path
             && let Some(assoc) = self
                 .tcx
                 .associated_items(valid_out_of_scope_traits[0])
@@ -3700,7 +3699,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // See if the `Type::function(val)` where `function` wasn't found corresponds to a
             // `Trait` that is imported directly, but `Type` came from a different version of the
             // same crate.
-            let rcvr_ty = self.tcx.type_of(def_id).instantiate_identity();
+
+            let rcvr_ty = self.node_ty_opt(ty.hir_id);
             trait_in_other_version_found = self.detect_and_explain_multiple_crate_versions(
                 err,
                 assoc.def_id,
@@ -4080,7 +4080,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         err: &mut Diag<'_>,
         item_def_id: DefId,
         hir_id: hir::HirId,
-        rcvr_ty: Ty<'_>,
+        rcvr_ty: Option<Ty<'_>>,
     ) -> bool {
         let hir_id = self.tcx.parent_hir_id(hir_id);
         let Some(traits) = self.tcx.in_scope_traits(hir_id) else { return false };
@@ -4110,8 +4110,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let mut multi_span: MultiSpan = trait_span.into();
         multi_span.push_span_label(trait_span, format!("this is the trait that is needed"));
         let descr = self.tcx.associated_item(item_def_id).descr();
+        let rcvr_ty =
+            rcvr_ty.map(|t| format!("`{t}`")).unwrap_or_else(|| "the receiver".to_string());
         multi_span
-            .push_span_label(item_span, format!("the {descr} is available for `{rcvr_ty}` here"));
+            .push_span_label(item_span, format!("the {descr} is available for {rcvr_ty} here"));
         for (def_id, import_def_id) in candidates {
             if let Some(import_def_id) = import_def_id {
                 multi_span.push_span_label(
diff --git a/tests/ui/methods/missing-method-on-type-parameter.rs b/tests/ui/methods/missing-method-on-type-parameter.rs
new file mode 100644
index 0000000000000..cbcbeea4d4cd0
--- /dev/null
+++ b/tests/ui/methods/missing-method-on-type-parameter.rs
@@ -0,0 +1,6 @@
+// Regression test for https://github.com/rust-lang/rust/issues/129205
+fn x<T: Copy>() {
+    T::try_from(); //~ ERROR E0599
+}
+
+fn main() {}
diff --git a/tests/ui/methods/missing-method-on-type-parameter.stderr b/tests/ui/methods/missing-method-on-type-parameter.stderr
new file mode 100644
index 0000000000000..c53d7afe4e2d9
--- /dev/null
+++ b/tests/ui/methods/missing-method-on-type-parameter.stderr
@@ -0,0 +1,19 @@
+error[E0599]: no function or associated item named `try_from` found for type parameter `T` in the current scope
+  --> $DIR/missing-method-on-type-parameter.rs:3:8
+   |
+LL | fn x<T: Copy>() {
+   |      - function or associated item `try_from` not found for this type parameter
+LL |     T::try_from();
+   |        ^^^^^^^^ function or associated item not found in `T`
+   |
+   = help: items from traits can only be used if the trait is in scope
+help: there is an associated function `from` with a similar name
+  --> $SRC_DIR/core/src/convert/mod.rs:LL:COL
+help: trait `TryFrom` which provides `try_from` is implemented but not in scope; perhaps you want to import it
+   |
+LL + use std::convert::TryFrom;
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0599`.

From 4a088d90708830ac6217554545badb89904f19b0 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 26 Aug 2024 13:07:01 -0400
Subject: [PATCH 617/685] Remove crashes from type_of on resolution that
 doesn't have a type_of

---
 tests/crashes/129205.rs |  5 -----
 tests/crashes/129216.rs | 12 ------------
 2 files changed, 17 deletions(-)
 delete mode 100644 tests/crashes/129205.rs
 delete mode 100644 tests/crashes/129216.rs

diff --git a/tests/crashes/129205.rs b/tests/crashes/129205.rs
deleted file mode 100644
index f328fca247ac5..0000000000000
--- a/tests/crashes/129205.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-//@ known-bug: rust-lang/rust#129205
-
-fn x<T: Copy>() {
-    T::try_from();
-}
diff --git a/tests/crashes/129216.rs b/tests/crashes/129216.rs
deleted file mode 100644
index 0ad6bc5c71baf..0000000000000
--- a/tests/crashes/129216.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-//@ known-bug: rust-lang/rust#129216
-//@ only-linux
-
-trait Mirror {
-    type Assoc;
-}
-
-struct Foo;
-
-fn main() {
-    <Foo as Mirror>::Assoc::new();
-}

From a673e4fd4a8bbd323b6b734cf0147fc1a077082b Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Mon, 26 Aug 2024 10:12:50 -0700
Subject: [PATCH 618/685] Update src/tools/rustbook/Cargo.lock

---
 src/tools/rustbook/Cargo.lock | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tools/rustbook/Cargo.lock b/src/tools/rustbook/Cargo.lock
index 3b859fe98c5ab..1394675a9dc60 100644
--- a/src/tools/rustbook/Cargo.lock
+++ b/src/tools/rustbook/Cargo.lock
@@ -690,6 +690,7 @@ dependencies = [
  "mdbook",
  "once_cell",
  "pathdiff",
+ "pulldown-cmark",
  "regex",
  "semver",
  "serde_json",

From ebf46f760774f63a8025f1ead3cf359e88aaa103 Mon Sep 17 00:00:00 2001
From: Santiago Pastorino <spastorino@gmail.com>
Date: Thu, 18 Jul 2024 12:44:59 -0300
Subject: [PATCH 619/685] Add unsafe to extern blocks in style guide

---
 src/doc/style-guide/src/items.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/doc/style-guide/src/items.md b/src/doc/style-guide/src/items.md
index 8e1b1d80fb644..5ea8b6cd54294 100644
--- a/src/doc/style-guide/src/items.md
+++ b/src/doc/style-guide/src/items.md
@@ -449,8 +449,8 @@ entries, format it across multiple lines as with a type alias.
 ## extern items
 
 When writing extern items (such as `extern "C" fn`), always specify the ABI.
-For example, write `extern "C" fn foo ...`, not `extern fn foo ...`, or
-`extern "C" { ... }`.
+For example, write `extern "C" fn foo ...` or `unsafe extern "C" { ...}`
+and avoid `extern fn foo ...` and `unsafe extern { ... }`.
 
 ## Imports (`use` statements)
 

From 5d0ce4c3918b1d5cd925c945ecf37f49bf11d4e4 Mon Sep 17 00:00:00 2001
From: Nicole LeGare <legaren@immunant.com>
Date: Mon, 26 Aug 2024 12:22:17 -0700
Subject: [PATCH 620/685] Note that std support is WIP

---
 src/doc/rustc/src/platform-support/trusty.md | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/doc/rustc/src/platform-support/trusty.md b/src/doc/rustc/src/platform-support/trusty.md
index 97a03d3de04c2..dec3b96ff6449 100644
--- a/src/doc/rustc/src/platform-support/trusty.md
+++ b/src/doc/rustc/src/platform-support/trusty.md
@@ -13,12 +13,10 @@ Environment (TEE) for Android.
 
 ## Requirements
 
-This target is cross-compiled. It has no special requirements for the host.
+These targets are cross-compiled. They have no special requirements for the host.
 
-It fully supports alloc with the default allocator, and partially supports std.
-Notably, most I/O functionality is not supported, e.g. filesystem support and
-networking support are not present and any APIs that rely on them will panic at
-runtime.
+Support for the standard library is work-in-progress. It is expected that
+they will support alloc with the default allocator, and partially support std.
 
 Trusty uses the ELF file format.
 

From b11e0a883b0e932edb79ebba17e09952c8eb0084 Mon Sep 17 00:00:00 2001
From: Josh Stone <cuviper@gmail.com>
Date: Mon, 26 Aug 2024 12:36:58 -0700
Subject: [PATCH 621/685] Apply suggestions from code review

---
 library/core/src/ptr/const_ptr.rs | 4 ++--
 library/core/src/ptr/mod.rs       | 2 +-
 library/core/src/ptr/mut_ptr.rs   | 8 ++++----
 library/core/src/ptr/non_null.rs  | 4 ++--
 4 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs
index d7eea937ef847..77fb2e8abb9f0 100644
--- a/library/core/src/ptr/const_ptr.rs
+++ b/library/core/src/ptr/const_ptr.rs
@@ -286,7 +286,7 @@ impl<T: ?Sized> *const T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that
-    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     ///
     /// # Examples
     ///
@@ -317,7 +317,7 @@ impl<T: ?Sized> *const T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     ///
     /// # Examples
     ///
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index a7d6602287b90..338659c46ed9c 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -72,7 +72,7 @@
 //! * The pointer must point to a valid value of type `T`.
 //!   This means that the created reference can only refer to
 //!   uninitialized memory through careful use of `MaybeUninit`,
-//!   or if the uninitialized memory is entirly contained within
+//!   or if the uninitialized memory is entirely contained within
 //!   padding bytes, since
 //!   [padding has the same validity invariant as `MaybeUninit`][ucg-pad].
 //!
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
index d7bb18590ed5e..64ed5a98bce8e 100644
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -247,7 +247,7 @@ impl<T: ?Sized> *mut T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     ///
     /// # Examples
     ///
@@ -296,7 +296,7 @@ impl<T: ?Sized> *mut T {
     ///
     /// # Safety
     ///
-    /// When calling this method, you have to ensure that the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// When calling this method, you have to ensure that the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     ///
     /// # Examples
     ///
@@ -616,7 +616,7 @@ impl<T: ?Sized> *mut T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that
-    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     ///
     /// # Examples
     ///
@@ -651,7 +651,7 @@ impl<T: ?Sized> *mut T {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that *either* the pointer is null *or*
-    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     #[inline]
     #[unstable(feature = "ptr_as_uninit", issue = "75402")]
     #[rustc_const_unstable(feature = "const_ptr_as_ref", issue = "91822")]
diff --git a/library/core/src/ptr/non_null.rs b/library/core/src/ptr/non_null.rs
index 5d5d9d401a295..ee9f23d61c787 100644
--- a/library/core/src/ptr/non_null.rs
+++ b/library/core/src/ptr/non_null.rs
@@ -342,7 +342,7 @@ impl<T: ?Sized> NonNull<T> {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that
-    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     ///
     /// # Examples
     ///
@@ -379,7 +379,7 @@ impl<T: ?Sized> NonNull<T> {
     /// # Safety
     ///
     /// When calling this method, you have to ensure that
-    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion)
+    /// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
     /// # Examples
     ///
     /// ```

From 4e1555462f136d3d1f312537d189c9b8d7bc921a Mon Sep 17 00:00:00 2001
From: bjorn3 <17426603+bjorn3@users.noreply.github.com>
Date: Mon, 26 Aug 2024 19:52:14 +0000
Subject: [PATCH 622/685] Remove a couple of unused feature enables

---
 compiler/rustc_infer/src/lib.rs  | 2 --
 compiler/rustc_macros/src/lib.rs | 2 --
 2 files changed, 4 deletions(-)

diff --git a/compiler/rustc_infer/src/lib.rs b/compiler/rustc_infer/src/lib.rs
index 25ac8ba974bb6..30dc666128cb1 100644
--- a/compiler/rustc_infer/src/lib.rs
+++ b/compiler/rustc_infer/src/lib.rs
@@ -27,8 +27,6 @@
 #![feature(iterator_try_collect)]
 #![feature(let_chains)]
 #![feature(rustdoc_internals)]
-#![feature(try_blocks)]
-#![feature(yeet_expr)]
 #![recursion_limit = "512"] // For rustdoc
 // tidy-alphabetical-end
 
diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs
index c59f86b0a9bbe..929bc2df6f6b5 100644
--- a/compiler/rustc_macros/src/lib.rs
+++ b/compiler/rustc_macros/src/lib.rs
@@ -1,7 +1,5 @@
 // tidy-alphabetical-start
-#![allow(internal_features)]
 #![allow(rustc::default_hash_types)]
-#![feature(allow_internal_unstable)]
 #![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(never_type)]

From b4d3fa4829c5366d1b7837f0d73c67def517b66d Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 26 Aug 2024 14:41:21 -0400
Subject: [PATCH 623/685] Remove ParamMode::ExplicitNamed

---
 compiler/rustc_ast_lowering/src/item.rs | 13 +------------
 compiler/rustc_ast_lowering/src/lib.rs  |  2 --
 2 files changed, 1 insertion(+), 14 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index eef87879c2492..258a6cdf60e8b 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -764,18 +764,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         &mut self,
         (index, f): (usize, &FieldDef),
     ) -> hir::FieldDef<'hir> {
-        let ty = if let TyKind::Path(qself, path) = &f.ty.kind {
-            let t = self.lower_path_ty(
-                &f.ty,
-                qself,
-                path,
-                ParamMode::ExplicitNamed, // no `'_` in declarations (Issue #61124)
-                ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy),
-            );
-            self.arena.alloc(t)
-        } else {
-            self.lower_ty(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy))
-        };
+        let ty = self.lower_ty(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy));
         let hir_id = self.lower_node_id(f.id);
         self.lower_attrs(hir_id, &f.attrs);
         hir::FieldDef {
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 4b8c47ac4b411..b968860a85e6a 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -481,8 +481,6 @@ pub fn lower_to_hir(tcx: TyCtxt<'_>, (): ()) -> hir::Crate<'_> {
 enum ParamMode {
     /// Any path in a type context.
     Explicit,
-    /// Path in a type definition, where the anonymous lifetime `'_` is not allowed.
-    ExplicitNamed,
     /// The `module::Type` in `module::Type::method` in an expression.
     Optional,
 }

From 2db1d2e261187fd8031af91b6af168100f453e4f Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 26 Aug 2024 13:59:21 -0400
Subject: [PATCH 624/685] Rename ParenthesizedGenericArgs to GenericArgsMode

---
 compiler/rustc_ast_lowering/src/delegation.rs |  4 +-
 compiler/rustc_ast_lowering/src/expr.rs       |  4 +-
 compiler/rustc_ast_lowering/src/lib.rs        |  2 +-
 compiler/rustc_ast_lowering/src/path.rs       | 37 +++++++++----------
 4 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/compiler/rustc_ast_lowering/src/delegation.rs b/compiler/rustc_ast_lowering/src/delegation.rs
index 9c073130827c8..800773482041a 100644
--- a/compiler/rustc_ast_lowering/src/delegation.rs
+++ b/compiler/rustc_ast_lowering/src/delegation.rs
@@ -51,7 +51,7 @@ use rustc_span::Span;
 use rustc_target::spec::abi;
 use {rustc_ast as ast, rustc_hir as hir};
 
-use super::{ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs};
+use super::{GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode};
 use crate::{ImplTraitPosition, ResolverAstLoweringExt};
 
 pub(crate) struct DelegationResults<'hir> {
@@ -323,7 +323,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 delegation.path.span,
                 ast_segment,
                 ParamMode::Optional,
-                ParenthesizedGenericArgs::Err,
+                GenericArgsMode::Err,
                 ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                 None,
             );
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index bb86e5c9325f9..a6c7714a182bf 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -20,7 +20,7 @@ use super::errors::{
     NeverPatternWithBody, NeverPatternWithGuard, UnderscoreExprLhsAssign,
 };
 use super::{
-    ImplTraitContext, LoweringContext, ParamMode, ParenthesizedGenericArgs, ResolverAstLoweringExt,
+    GenericArgsMode, ImplTraitContext, LoweringContext, ParamMode, ResolverAstLoweringExt,
 };
 use crate::errors::YieldInClosure;
 use crate::{fluent_generated, FnDeclKind, ImplTraitPosition};
@@ -107,7 +107,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         e.span,
                         seg,
                         ParamMode::Optional,
-                        ParenthesizedGenericArgs::Err,
+                        GenericArgsMode::Err,
                         ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                         // Method calls can't have bound modifiers
                         None,
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index 4b8c47ac4b411..939517d7ef5a0 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -487,7 +487,7 @@ enum ParamMode {
     Optional,
 }
 
-enum ParenthesizedGenericArgs {
+enum GenericArgsMode {
     ParenSugar,
     Err,
 }
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index 077b06acd7c8c..2ab30eff6d864 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -15,8 +15,8 @@ use super::errors::{
     GenericTypeWithParentheses, UseAngleBrackets,
 };
 use super::{
-    GenericArgsCtor, ImplTraitContext, LifetimeRes, LoweringContext, ParamMode,
-    ParenthesizedGenericArgs, ResolverAstLoweringExt,
+    GenericArgsCtor, GenericArgsMode, ImplTraitContext, LifetimeRes, LoweringContext, ParamMode,
+    ResolverAstLoweringExt,
 };
 use crate::ImplTraitPosition;
 
@@ -90,10 +90,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         _ => param_mode,
                     };
 
-                    let parenthesized_generic_args = match base_res {
+                    let generic_args_mode = match base_res {
                         // `a::b::Trait(Args)`
                         Res::Def(DefKind::Trait, _) if i + 1 == proj_start => {
-                            ParenthesizedGenericArgs::ParenSugar
+                            GenericArgsMode::ParenSugar
                         }
                         // `a::b::Trait(Args)::TraitItem`
                         Res::Def(DefKind::AssocFn, _)
@@ -101,19 +101,19 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         | Res::Def(DefKind::AssocTy, _)
                             if i + 2 == proj_start =>
                         {
-                            ParenthesizedGenericArgs::ParenSugar
+                            GenericArgsMode::ParenSugar
                         }
                         // Avoid duplicated errors.
-                        Res::Err => ParenthesizedGenericArgs::ParenSugar,
+                        Res::Err => GenericArgsMode::ParenSugar,
                         // An error
-                        _ => ParenthesizedGenericArgs::Err,
+                        _ => GenericArgsMode::Err,
                     };
 
                     self.lower_path_segment(
                         p.span,
                         segment,
                         param_mode,
-                        parenthesized_generic_args,
+                        generic_args_mode,
                         itctx,
                         bound_modifier_allowed_features.clone(),
                     )
@@ -168,7 +168,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 p.span,
                 segment,
                 param_mode,
-                ParenthesizedGenericArgs::Err,
+                GenericArgsMode::Err,
                 itctx,
                 None,
             ));
@@ -210,7 +210,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     p.span,
                     segment,
                     param_mode,
-                    ParenthesizedGenericArgs::Err,
+                    GenericArgsMode::Err,
                     ImplTraitContext::Disallowed(ImplTraitPosition::Path),
                     None,
                 )
@@ -224,7 +224,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         path_span: Span,
         segment: &PathSegment,
         param_mode: ParamMode,
-        parenthesized_generic_args: ParenthesizedGenericArgs,
+        generic_args_mode: GenericArgsMode,
         itctx: ImplTraitContext,
         // Additional features ungated with a bound modifier like `async`.
         // This is passed down to the implicit associated type binding in
@@ -237,14 +237,13 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 GenericArgs::AngleBracketed(data) => {
                     self.lower_angle_bracketed_parameter_data(data, param_mode, itctx)
                 }
-                GenericArgs::Parenthesized(data) => match parenthesized_generic_args {
-                    ParenthesizedGenericArgs::ParenSugar => self
-                        .lower_parenthesized_parameter_data(
-                            data,
-                            itctx,
-                            bound_modifier_allowed_features,
-                        ),
-                    ParenthesizedGenericArgs::Err => {
+                GenericArgs::Parenthesized(data) => match generic_args_mode {
+                    GenericArgsMode::ParenSugar => self.lower_parenthesized_parameter_data(
+                        data,
+                        itctx,
+                        bound_modifier_allowed_features,
+                    ),
+                    GenericArgsMode::Err => {
                         // Suggest replacing parentheses with angle brackets `Trait(params...)` to `Trait<params...>`
                         let sub = if !data.inputs.is_empty() {
                             // Start of the span to the 1st character of 1st argument

From 4609841c078cde37c0e2ffb481059cb1bd330233 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Thu, 1 Aug 2024 13:05:17 -0400
Subject: [PATCH 625/685] Stop using a special inner body for the coroutine
 by-move body for async closures

---
 .../rustc_const_eval/src/interpret/call.rs    |   1 -
 compiler/rustc_hir/src/def.rs                 |  11 +-
 .../rustc_hir_analysis/src/check/wfcheck.rs   |   3 +-
 compiler/rustc_hir_analysis/src/lib.rs        |   4 -
 compiler/rustc_interface/src/passes.rs        |  16 ++
 compiler/rustc_metadata/src/rmeta/encoder.rs  |  39 ++-
 compiler/rustc_metadata/src/rmeta/table.rs    |   1 +
 compiler/rustc_middle/src/hir/map/mod.rs      |   2 +-
 compiler/rustc_middle/src/mir/mod.rs          |  17 --
 compiler/rustc_middle/src/mir/mono.rs         |   1 -
 compiler/rustc_middle/src/mir/visit.rs        |   1 -
 compiler/rustc_middle/src/query/mod.rs        |  15 +
 compiler/rustc_middle/src/ty/context.rs       |  18 ++
 compiler/rustc_middle/src/ty/instance.rs      |  16 +-
 compiler/rustc_middle/src/ty/mod.rs           |   4 +-
 compiler/rustc_mir_transform/src/coroutine.rs |   2 +-
 .../src/coroutine/by_move_body.rs             | 264 +++++++++---------
 compiler/rustc_mir_transform/src/inline.rs    |   1 -
 .../rustc_mir_transform/src/inline/cycle.rs   |   1 -
 compiler/rustc_mir_transform/src/lib.rs       |  42 ++-
 .../rustc_mir_transform/src/pass_manager.rs   |   6 -
 compiler/rustc_mir_transform/src/shim.rs      |  12 +-
 compiler/rustc_mir_transform/src/validate.rs  |  19 --
 compiler/rustc_monomorphize/src/collector.rs  |   1 -
 .../rustc_monomorphize/src/partitioning.rs    |   2 -
 .../rustc_monomorphize/src/polymorphize.rs    |   2 +-
 compiler/rustc_privacy/src/lib.rs             |   3 +-
 .../rustc_resolve/src/build_reduced_graph.rs  |   1 +
 .../rustc_smir/src/rustc_smir/convert/ty.rs   |   1 -
 compiler/rustc_smir/src/rustc_smir/mod.rs     |   4 +-
 compiler/rustc_symbol_mangling/src/legacy.rs  |   3 -
 compiler/rustc_symbol_mangling/src/v0.rs      |   1 -
 compiler/rustc_ty_utils/src/abi.rs            |  33 ---
 compiler/rustc_ty_utils/src/implied_bounds.rs |   3 +-
 compiler/rustc_ty_utils/src/opaque_types.rs   |   3 +-
 compiler/rustc_ty_utils/src/sig_types.rs      |   2 +-
 src/librustdoc/formats/item_type.rs           |   3 +-
 .../passes/collect_intra_doc_links.rs         |   4 +-
 .../lint/unused/lint-unused-variables.stderr  |  12 +-
 .../param-attrs-cfg.stderr                    |  12 +-
 40 files changed, 283 insertions(+), 303 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/call.rs b/compiler/rustc_const_eval/src/interpret/call.rs
index 917a2fa7c6dd4..f99283c49f5ab 100644
--- a/compiler/rustc_const_eval/src/interpret/call.rs
+++ b/compiler/rustc_const_eval/src/interpret/call.rs
@@ -576,7 +576,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             | ty::InstanceKind::ReifyShim(..)
             | ty::InstanceKind::ClosureOnceShim { .. }
             | ty::InstanceKind::ConstructCoroutineInClosureShim { .. }
-            | ty::InstanceKind::CoroutineKindShim { .. }
             | ty::InstanceKind::FnPtrShim(..)
             | ty::InstanceKind::DropGlue(..)
             | ty::InstanceKind::CloneShim(..)
diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index 59204d799281f..b329432d1e1c0 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -133,6 +133,9 @@ pub enum DefKind {
     /// we treat them all the same, and code which needs to distinguish them can match
     /// or `hir::ClosureKind` or `type_of`.
     Closure,
+    /// The definition of a synthetic coroutine body created by the lowering of a
+    /// coroutine-closure, such as an async closure.
+    SyntheticCoroutineBody,
 }
 
 impl DefKind {
@@ -177,6 +180,7 @@ impl DefKind {
             DefKind::Closure => "closure",
             DefKind::ExternCrate => "extern crate",
             DefKind::GlobalAsm => "global assembly block",
+            DefKind::SyntheticCoroutineBody => "synthetic mir body",
         }
     }
 
@@ -236,7 +240,8 @@ impl DefKind {
             | DefKind::ForeignMod
             | DefKind::GlobalAsm
             | DefKind::Impl { .. }
-            | DefKind::OpaqueTy => None,
+            | DefKind::OpaqueTy
+            | DefKind::SyntheticCoroutineBody => None,
         }
     }
 
@@ -276,6 +281,7 @@ impl DefKind {
             DefKind::GlobalAsm => DefPathData::GlobalAsm,
             DefKind::Impl { .. } => DefPathData::Impl,
             DefKind::Closure => DefPathData::Closure,
+            DefKind::SyntheticCoroutineBody => DefPathData::Closure,
         }
     }
 
@@ -291,7 +297,8 @@ impl DefKind {
             | DefKind::AssocFn
             | DefKind::Ctor(..)
             | DefKind::Closure
-            | DefKind::Static { .. } => true,
+            | DefKind::Static { .. }
+            | DefKind::SyntheticCoroutineBody => true,
             DefKind::Mod
             | DefKind::Struct
             | DefKind::Union
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index fb9bcc113c64c..cb66179ec8047 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -2174,7 +2174,8 @@ fn lint_redundant_lifetimes<'tcx>(
         | DefKind::Field
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
-        | DefKind::Closure => return,
+        | DefKind::Closure
+        | DefKind::SyntheticCoroutineBody => return,
     }
 
     // The ordering of this lifetime map is a bit subtle.
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index 291d57f2a176f..6dbaf4fcffa73 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -200,10 +200,6 @@ pub fn check_crate(tcx: TyCtxt<'_>) {
         }
     });
 
-    // Freeze definitions as we don't add new ones at this point. This improves performance by
-    // allowing lock-free access to them.
-    tcx.untracked().definitions.freeze();
-
     // FIXME: Remove this when we implement creating `DefId`s
     // for anon constants during their parents' typeck.
     // Typeck all body owners in parallel will produce queries
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index 96a6f52d60b6c..2a4367965eef3 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -784,7 +784,22 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
             }
         );
     });
+
     rustc_hir_analysis::check_crate(tcx);
+    sess.time("MIR_coroutine_by_move_body", || {
+        tcx.hir().par_body_owners(|def_id| {
+            if tcx.needs_coroutine_by_move_body_def_id(def_id) {
+                tcx.ensure_with_value().coroutine_by_move_body_def_id(def_id);
+            }
+        });
+    });
+    // Freeze definitions as we don't add new ones at this point.
+    // We need to wait until now since we synthesize a by-move body
+    // This improves performance by allowing lock-free access to them.
+    // FIXME(async_closures): We could force `coroutine_by_move_body_def_id`
+    // immediately after typeck, then freeze after that.
+    tcx.untracked().definitions.freeze();
+
     sess.time("MIR_borrow_checking", || {
         tcx.hir().par_body_owners(|def_id| {
             // Run unsafety check because it's responsible for stealing and
@@ -816,6 +831,7 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
             );
         }
     });
+
     sess.time("layout_testing", || layout_test::test_layout(tcx));
     sess.time("abi_testing", || abi_test::test_abi(tcx));
 
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index 0d83f8c6c5c93..3125fb245e7e3 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -872,7 +872,8 @@ fn should_encode_span(def_kind: DefKind) -> bool {
         | DefKind::OpaqueTy
         | DefKind::Field
         | DefKind::Impl { .. }
-        | DefKind::Closure => true,
+        | DefKind::Closure
+        | DefKind::SyntheticCoroutineBody => true,
         DefKind::ForeignMod | DefKind::GlobalAsm => false,
     }
 }
@@ -902,6 +903,7 @@ fn should_encode_attrs(def_kind: DefKind) -> bool {
         // https://github.com/model-checking/kani and is not a performance
         // or maintenance issue for us.
         DefKind::Closure => true,
+        DefKind::SyntheticCoroutineBody => false,
         DefKind::TyParam
         | DefKind::ConstParam
         | DefKind::Ctor(..)
@@ -948,7 +950,8 @@ fn should_encode_expn_that_defined(def_kind: DefKind) -> bool {
         | DefKind::Field
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
-        | DefKind::Closure => false,
+        | DefKind::Closure
+        | DefKind::SyntheticCoroutineBody => false,
     }
 }
 
@@ -984,7 +987,8 @@ fn should_encode_visibility(def_kind: DefKind) -> bool {
         | DefKind::GlobalAsm
         | DefKind::Impl { .. }
         | DefKind::Closure
-        | DefKind::ExternCrate => false,
+        | DefKind::ExternCrate
+        | DefKind::SyntheticCoroutineBody => false,
     }
 }
 
@@ -1019,7 +1023,8 @@ fn should_encode_stability(def_kind: DefKind) -> bool {
         | DefKind::InlineConst
         | DefKind::GlobalAsm
         | DefKind::Closure
-        | DefKind::ExternCrate => false,
+        | DefKind::ExternCrate
+        | DefKind::SyntheticCoroutineBody => false,
     }
 }
 
@@ -1061,6 +1066,8 @@ fn should_encode_mir(
         }
         // Coroutines require optimized MIR to compute layout.
         DefKind::Closure if tcx.is_coroutine(def_id.to_def_id()) => (false, true),
+        // FIXME: lol
+        DefKind::SyntheticCoroutineBody => (false, true),
         // Full-fledged functions + closures
         DefKind::AssocFn | DefKind::Fn | DefKind::Closure => {
             let generics = tcx.generics_of(def_id);
@@ -1109,7 +1116,8 @@ fn should_encode_variances<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, def_kind: Def
         | DefKind::InlineConst
         | DefKind::GlobalAsm
         | DefKind::Closure
-        | DefKind::ExternCrate => false,
+        | DefKind::ExternCrate
+        | DefKind::SyntheticCoroutineBody => false,
         DefKind::TyAlias => tcx.type_alias_is_lazy(def_id),
     }
 }
@@ -1137,7 +1145,8 @@ fn should_encode_generics(def_kind: DefKind) -> bool {
         | DefKind::Impl { .. }
         | DefKind::Field
         | DefKind::TyParam
-        | DefKind::Closure => true,
+        | DefKind::Closure
+        | DefKind::SyntheticCoroutineBody => true,
         DefKind::Mod
         | DefKind::ForeignMod
         | DefKind::ConstParam
@@ -1168,7 +1177,8 @@ fn should_encode_type(tcx: TyCtxt<'_>, def_id: LocalDefId, def_kind: DefKind) ->
         | DefKind::Closure
         | DefKind::ConstParam
         | DefKind::AnonConst
-        | DefKind::InlineConst => true,
+        | DefKind::InlineConst
+        | DefKind::SyntheticCoroutineBody => true,
 
         DefKind::OpaqueTy => {
             let origin = tcx.opaque_type_origin(def_id);
@@ -1240,7 +1250,8 @@ fn should_encode_fn_sig(def_kind: DefKind) -> bool {
         | DefKind::Use
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
-        | DefKind::ExternCrate => false,
+        | DefKind::ExternCrate
+        | DefKind::SyntheticCoroutineBody => false,
     }
 }
 
@@ -1277,7 +1288,8 @@ fn should_encode_constness(def_kind: DefKind) -> bool {
         | DefKind::Use
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
-        | DefKind::ExternCrate => false,
+        | DefKind::ExternCrate
+        | DefKind::SyntheticCoroutineBody => false,
     }
 }
 
@@ -1310,7 +1322,8 @@ fn should_encode_const(def_kind: DefKind) -> bool {
         | DefKind::Use
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
-        | DefKind::ExternCrate => false,
+        | DefKind::ExternCrate
+        | DefKind::SyntheticCoroutineBody => false,
     }
 }
 
@@ -1366,6 +1379,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 let def_span = tcx.def_span(local_id);
                 record!(self.tables.def_span[def_id] <- def_span);
             }
+            // FIXME(async_closures): We should just use `tcx.attrs` rather than going
+            // through the HIR. Historically, though, this has been inefficient apparently.
+            // For now, it's kind of pointless to fix, because coroutine-closures' coroutine
+            // bodies have no attrs anyways.
             if should_encode_attrs(def_kind) {
                 self.encode_attrs(local_id);
             }
@@ -1458,7 +1475,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                     record!(self.tables.associated_type_for_effects[def_id] <- assoc_def_id);
                 }
             }
-            if def_kind == DefKind::Closure
+            if let DefKind::Closure | DefKind::SyntheticCoroutineBody = def_kind
                 && let Some(coroutine_kind) = self.tcx.coroutine_kind(def_id)
             {
                 self.tables.coroutine_kind.set(def_id.index, Some(coroutine_kind))
diff --git a/compiler/rustc_metadata/src/rmeta/table.rs b/compiler/rustc_metadata/src/rmeta/table.rs
index 617372a97b5b2..3a6f3543317f6 100644
--- a/compiler/rustc_metadata/src/rmeta/table.rs
+++ b/compiler/rustc_metadata/src/rmeta/table.rs
@@ -171,6 +171,7 @@ fixed_size_enum! {
         ( Macro(MacroKind::Bang)                   )
         ( Macro(MacroKind::Attr)                   )
         ( Macro(MacroKind::Derive)                 )
+        ( SyntheticCoroutineBody                   )
     }
 }
 
diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs
index 0f85998204ccb..3d346b9cc5d0a 100644
--- a/compiler/rustc_middle/src/hir/map/mod.rs
+++ b/compiler/rustc_middle/src/hir/map/mod.rs
@@ -307,7 +307,7 @@ impl<'hir> Map<'hir> {
             }
             DefKind::InlineConst => BodyOwnerKind::Const { inline: true },
             DefKind::Ctor(..) | DefKind::Fn | DefKind::AssocFn => BodyOwnerKind::Fn,
-            DefKind::Closure => BodyOwnerKind::Closure,
+            DefKind::Closure | DefKind::SyntheticCoroutineBody => BodyOwnerKind::Closure,
             DefKind::Static { safety: _, mutability, nested: false } => {
                 BodyOwnerKind::Static(mutability)
             }
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 5b2aac781ebad..7b90191503702 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -267,18 +267,6 @@ pub struct CoroutineInfo<'tcx> {
     /// Coroutine drop glue. This field is populated after the state transform pass.
     pub coroutine_drop: Option<Body<'tcx>>,
 
-    /// The body of the coroutine, modified to take its upvars by move rather than by ref.
-    ///
-    /// This is used by coroutine-closures, which must return a different flavor of coroutine
-    /// when called using `AsyncFnOnce::call_once`. It is produced by the `ByMoveBody` pass which
-    /// is run right after building the initial MIR, and will only be populated for coroutines
-    /// which come out of the async closure desugaring.
-    ///
-    /// This body should be processed in lockstep with the containing body -- any optimization
-    /// passes, etc, should be applied to this body as well. This is done automatically if
-    /// using `run_passes`.
-    pub by_move_body: Option<Body<'tcx>>,
-
     /// The layout of a coroutine. This field is populated after the state transform pass.
     pub coroutine_layout: Option<CoroutineLayout<'tcx>>,
 
@@ -298,7 +286,6 @@ impl<'tcx> CoroutineInfo<'tcx> {
             coroutine_kind,
             yield_ty: Some(yield_ty),
             resume_ty: Some(resume_ty),
-            by_move_body: None,
             coroutine_drop: None,
             coroutine_layout: None,
         }
@@ -665,10 +652,6 @@ impl<'tcx> Body<'tcx> {
         self.coroutine.as_ref().and_then(|coroutine| coroutine.coroutine_drop.as_ref())
     }
 
-    pub fn coroutine_by_move_body(&self) -> Option<&Body<'tcx>> {
-        self.coroutine.as_ref()?.by_move_body.as_ref()
-    }
-
     #[inline]
     pub fn coroutine_kind(&self) -> Option<CoroutineKind> {
         self.coroutine.as_ref().map(|coroutine| coroutine.coroutine_kind)
diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs
index 336a9388a561e..1d94c364ae3af 100644
--- a/compiler/rustc_middle/src/mir/mono.rs
+++ b/compiler/rustc_middle/src/mir/mono.rs
@@ -415,7 +415,6 @@ impl<'tcx> CodegenUnit<'tcx> {
                             | InstanceKind::Virtual(..)
                             | InstanceKind::ClosureOnceShim { .. }
                             | InstanceKind::ConstructCoroutineInClosureShim { .. }
-                            | InstanceKind::CoroutineKindShim { .. }
                             | InstanceKind::DropGlue(..)
                             | InstanceKind::CloneShim(..)
                             | InstanceKind::ThreadLocalShim(..)
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
index bfb129495ce83..64898a8495e26 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -349,7 +349,6 @@ macro_rules! make_mir_visitor {
                             coroutine_closure_def_id: _def_id,
                             receiver_by_ref: _,
                         } |
-                        ty::InstanceKind::CoroutineKindShim { coroutine_def_id: _def_id } |
                         ty::InstanceKind::AsyncDropGlueCtorShim(_def_id, None) |
                         ty::InstanceKind::DropGlue(_def_id, None) => {}
 
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 75166624f95a4..b748f85253f10 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -326,6 +326,7 @@ rustc_queries! {
     query predicates_of(key: DefId) -> ty::GenericPredicates<'tcx> {
         desc { |tcx| "computing predicates of `{}`", tcx.def_path_str(key) }
         cache_on_disk_if { key.is_local() }
+        feedable
     }
 
     query opaque_types_defined_by(
@@ -498,6 +499,7 @@ rustc_queries! {
     /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/mir/construction.html
     query mir_built(key: LocalDefId) -> &'tcx Steal<mir::Body<'tcx>> {
         desc { |tcx| "building MIR for `{}`", tcx.def_path_str(key) }
+        feedable
     }
 
     /// Try to build an abstract representation of the given constant.
@@ -742,6 +744,7 @@ rustc_queries! {
     query constness(key: DefId) -> hir::Constness {
         desc { |tcx| "checking if item is const: `{}`", tcx.def_path_str(key) }
         separate_provide_extern
+        feedable
     }
 
     query asyncness(key: DefId) -> ty::Asyncness {
@@ -760,10 +763,22 @@ rustc_queries! {
         desc { |tcx| "checking if item is promotable: `{}`", tcx.def_path_str(key) }
     }
 
+    /// The body of the coroutine, modified to take its upvars by move rather than by ref.
+    ///
+    /// This is used by coroutine-closures, which must return a different flavor of coroutine
+    /// when called using `AsyncFnOnce::call_once`. It is produced by the `ByMoveBody` pass which
+    /// is run right after building the initial MIR, and will only be populated for coroutines
+    /// which come out of the async closure desugaring.
+    query coroutine_by_move_body_def_id(def_id: DefId) -> DefId {
+        desc { |tcx| "looking up the coroutine by-move body for `{}`", tcx.def_path_str(def_id) }
+        separate_provide_extern
+    }
+
     /// Returns `Some(coroutine_kind)` if the node pointed to by `def_id` is a coroutine.
     query coroutine_kind(def_id: DefId) -> Option<hir::CoroutineKind> {
         desc { |tcx| "looking up coroutine kind of `{}`", tcx.def_path_str(def_id) }
         separate_provide_extern
+        feedable
     }
 
     query coroutine_for_closure(def_id: DefId) -> DefId {
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index cad3515f06809..8effb67a1f695 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -1579,6 +1579,12 @@ impl<'tcx> TyCtxt<'tcx> {
         )
     }
 
+    // Whether the body owner is synthetic, which in this case means it does not correspond to
+    // meaningful HIR. This is currently used to skip over MIR borrowck.
+    pub fn is_synthetic_mir(self, def_id: impl Into<DefId>) -> bool {
+        matches!(self.def_kind(def_id.into()), DefKind::SyntheticCoroutineBody)
+    }
+
     /// Returns `true` if the node pointed to by `def_id` is a general coroutine that implements `Coroutine`.
     /// This means it is neither an `async` or `gen` construct.
     pub fn is_general_coroutine(self, def_id: DefId) -> bool {
@@ -3168,6 +3174,18 @@ impl<'tcx> TyCtxt<'tcx> {
         self.impl_trait_header(def_id).map_or(ty::ImplPolarity::Positive, |h| h.polarity)
     }
 
+    pub fn needs_coroutine_by_move_body_def_id(self, def_id: LocalDefId) -> bool {
+        if let Some(hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure)) =
+            self.coroutine_kind(def_id)
+            && let ty::Coroutine(_, args) = self.type_of(def_id).instantiate_identity().kind()
+            && args.as_coroutine().kind_ty().to_opt_closure_kind() != Some(ty::ClosureKind::FnOnce)
+        {
+            true
+        } else {
+            false
+        }
+    }
+
     /// Whether this is a trait implementation that has `#[diagnostic::do_not_recommend]`
     pub fn do_not_recommend_impl(self, def_id: DefId) -> bool {
         matches!(self.def_kind(def_id), DefKind::Impl { of_trait: true })
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index ecb3943e78836..7d5f0f1e9c415 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -141,14 +141,6 @@ pub enum InstanceKind<'tcx> {
         receiver_by_ref: bool,
     },
 
-    /// `<[coroutine] as Future>::poll`, but for coroutines produced when `AsyncFnOnce`
-    /// is called on a coroutine-closure whose closure kind greater than `FnOnce`, or
-    /// similarly for `AsyncFnMut`.
-    ///
-    /// This will select the body that is produced by the `ByMoveBody` transform, and thus
-    /// take and use all of its upvars by-move rather than by-ref.
-    CoroutineKindShim { coroutine_def_id: DefId },
-
     /// Compiler-generated accessor for thread locals which returns a reference to the thread local
     /// the `DefId` defines. This is used to export thread locals from dylibs on platforms lacking
     /// native support.
@@ -248,7 +240,6 @@ impl<'tcx> InstanceKind<'tcx> {
                 coroutine_closure_def_id: def_id,
                 receiver_by_ref: _,
             }
-            | ty::InstanceKind::CoroutineKindShim { coroutine_def_id: def_id }
             | InstanceKind::DropGlue(def_id, _)
             | InstanceKind::CloneShim(def_id, _)
             | InstanceKind::FnPtrAddrShim(def_id, _)
@@ -270,7 +261,6 @@ impl<'tcx> InstanceKind<'tcx> {
             | InstanceKind::Intrinsic(..)
             | InstanceKind::ClosureOnceShim { .. }
             | ty::InstanceKind::ConstructCoroutineInClosureShim { .. }
-            | ty::InstanceKind::CoroutineKindShim { .. }
             | InstanceKind::DropGlue(..)
             | InstanceKind::AsyncDropGlueCtorShim(..)
             | InstanceKind::CloneShim(..)
@@ -377,7 +367,6 @@ impl<'tcx> InstanceKind<'tcx> {
             | InstanceKind::AsyncDropGlueCtorShim(_, Some(_)) => false,
             InstanceKind::ClosureOnceShim { .. }
             | InstanceKind::ConstructCoroutineInClosureShim { .. }
-            | InstanceKind::CoroutineKindShim { .. }
             | InstanceKind::DropGlue(..)
             | InstanceKind::AsyncDropGlueCtorShim(..)
             | InstanceKind::Item(_)
@@ -452,7 +441,6 @@ pub fn fmt_instance(
         InstanceKind::FnPtrShim(_, ty) => write!(f, " - shim({ty})"),
         InstanceKind::ClosureOnceShim { .. } => write!(f, " - shim"),
         InstanceKind::ConstructCoroutineInClosureShim { .. } => write!(f, " - shim"),
-        InstanceKind::CoroutineKindShim { .. } => write!(f, " - shim"),
         InstanceKind::DropGlue(_, None) => write!(f, " - shim(None)"),
         InstanceKind::DropGlue(_, Some(ty)) => write!(f, " - shim(Some({ty}))"),
         InstanceKind::CloneShim(_, ty) => write!(f, " - shim({ty})"),
@@ -850,7 +838,9 @@ impl<'tcx> Instance<'tcx> {
                 Some(Instance { def: ty::InstanceKind::Item(coroutine_def_id), args })
             } else {
                 Some(Instance {
-                    def: ty::InstanceKind::CoroutineKindShim { coroutine_def_id },
+                    def: ty::InstanceKind::Item(
+                        tcx.coroutine_by_move_body_def_id(coroutine_def_id),
+                    ),
                     args,
                 })
             }
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 1e3b5800cbac6..e41ea7507efff 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1756,7 +1756,6 @@ impl<'tcx> TyCtxt<'tcx> {
             | ty::InstanceKind::Virtual(..)
             | ty::InstanceKind::ClosureOnceShim { .. }
             | ty::InstanceKind::ConstructCoroutineInClosureShim { .. }
-            | ty::InstanceKind::CoroutineKindShim { .. }
             | ty::InstanceKind::DropGlue(..)
             | ty::InstanceKind::CloneShim(..)
             | ty::InstanceKind::ThreadLocalShim(..)
@@ -1874,7 +1873,8 @@ impl<'tcx> TyCtxt<'tcx> {
                     identity_kind_ty.to_opt_closure_kind(),
                     Some(ClosureKind::Fn | ClosureKind::FnMut)
                 );
-                mir.coroutine_by_move_body().unwrap().coroutine_layout_raw()
+                self.optimized_mir(self.coroutine_by_move_body_def_id(def_id))
+                    .coroutine_layout_raw()
             }
         }
     }
diff --git a/compiler/rustc_mir_transform/src/coroutine.rs b/compiler/rustc_mir_transform/src/coroutine.rs
index 703339bf5bca8..d9d2abc554a65 100644
--- a/compiler/rustc_mir_transform/src/coroutine.rs
+++ b/compiler/rustc_mir_transform/src/coroutine.rs
@@ -53,7 +53,7 @@
 mod by_move_body;
 use std::{iter, ops};
 
-pub use by_move_body::ByMoveBody;
+pub use by_move_body::coroutine_by_move_body_def_id;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::pluralize;
 use rustc_hir as hir;
diff --git a/compiler/rustc_mir_transform/src/coroutine/by_move_body.rs b/compiler/rustc_mir_transform/src/coroutine/by_move_body.rs
index 7ea36f08232e2..ebe8d2eff4ff3 100644
--- a/compiler/rustc_mir_transform/src/coroutine/by_move_body.rs
+++ b/compiler/rustc_mir_transform/src/coroutine/by_move_body.rs
@@ -69,161 +69,167 @@
 //! in case precise captures (edition 2021 closure capture rules) caused the inner coroutine
 //! to split one field capture into two.
 
+use rustc_data_structures::steal::Steal;
 use rustc_data_structures::unord::UnordMap;
 use rustc_hir as hir;
+use rustc_hir::def::DefKind;
+use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_middle::bug;
 use rustc_middle::hir::place::{Projection, ProjectionKind};
 use rustc_middle::mir::visit::MutVisitor;
-use rustc_middle::mir::{self, dump_mir, MirPass};
+use rustc_middle::mir::{self, dump_mir};
 use rustc_middle::ty::{self, InstanceKind, Ty, TyCtxt, TypeVisitableExt};
+use rustc_span::symbol::kw;
 use rustc_target::abi::{FieldIdx, VariantIdx};
 
-use crate::pass_manager::validate_body;
-
-pub struct ByMoveBody;
+pub fn coroutine_by_move_body_def_id<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    coroutine_def_id: LocalDefId,
+) -> DefId {
+    let body = tcx.mir_built(coroutine_def_id).borrow();
 
-impl<'tcx> MirPass<'tcx> for ByMoveBody {
-    fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut mir::Body<'tcx>) {
-        // We only need to generate by-move coroutine bodies for coroutines that come
-        // from coroutine-closures.
-        let Some(coroutine_def_id) = body.source.def_id().as_local() else {
-            return;
-        };
-        let Some(hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure)) =
-            tcx.coroutine_kind(coroutine_def_id)
-        else {
-            return;
-        };
+    let Some(hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure)) =
+        tcx.coroutine_kind(coroutine_def_id)
+    else {
+        bug!("should only be invoked on coroutine-closures");
+    };
 
-        // Also, let's skip processing any bodies with errors, since there's no guarantee
-        // the MIR body will be constructed well.
-        let coroutine_ty = body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty;
-        if coroutine_ty.references_error() {
-            return;
-        }
+    // Also, let's skip processing any bodies with errors, since there's no guarantee
+    // the MIR body will be constructed well.
+    let coroutine_ty = body.local_decls[ty::CAPTURE_STRUCT_LOCAL].ty;
 
-        // We don't need to generate a by-move coroutine if the coroutine body was
-        // produced by the `CoroutineKindShim`, since it's already by-move.
-        if matches!(body.source.instance, ty::InstanceKind::CoroutineKindShim { .. }) {
-            return;
-        }
+    let ty::Coroutine(_, args) = *coroutine_ty.kind() else { bug!("{body:#?}") };
+    let args = args.as_coroutine();
 
-        let ty::Coroutine(_, args) = *coroutine_ty.kind() else { bug!("{body:#?}") };
-        let args = args.as_coroutine();
+    let coroutine_kind = args.kind_ty().to_opt_closure_kind().unwrap();
 
-        let coroutine_kind = args.kind_ty().to_opt_closure_kind().unwrap();
+    let parent_def_id = tcx.local_parent(coroutine_def_id);
+    let ty::CoroutineClosure(_, parent_args) =
+        *tcx.type_of(parent_def_id).instantiate_identity().kind()
+    else {
+        bug!();
+    };
+    if parent_args.references_error() {
+        return coroutine_def_id.to_def_id();
+    }
 
-        let parent_def_id = tcx.local_parent(coroutine_def_id);
-        let ty::CoroutineClosure(_, parent_args) =
-            *tcx.type_of(parent_def_id).instantiate_identity().kind()
-        else {
-            bug!();
-        };
-        let parent_closure_args = parent_args.as_coroutine_closure();
-        let num_args = parent_closure_args
-            .coroutine_closure_sig()
-            .skip_binder()
-            .tupled_inputs_ty
-            .tuple_fields()
-            .len();
+    let parent_closure_args = parent_args.as_coroutine_closure();
+    let num_args = parent_closure_args
+        .coroutine_closure_sig()
+        .skip_binder()
+        .tupled_inputs_ty
+        .tuple_fields()
+        .len();
 
-        let field_remapping: UnordMap<_, _> = ty::analyze_coroutine_closure_captures(
-            tcx.closure_captures(parent_def_id).iter().copied(),
-            tcx.closure_captures(coroutine_def_id).iter().skip(num_args).copied(),
-            |(parent_field_idx, parent_capture), (child_field_idx, child_capture)| {
-                // Store this set of additional projections (fields and derefs).
-                // We need to re-apply them later.
-                let mut child_precise_captures = child_capture.place.projections
-                    [parent_capture.place.projections.len()..]
-                    .to_vec();
+    let field_remapping: UnordMap<_, _> = ty::analyze_coroutine_closure_captures(
+        tcx.closure_captures(parent_def_id).iter().copied(),
+        tcx.closure_captures(coroutine_def_id).iter().skip(num_args).copied(),
+        |(parent_field_idx, parent_capture), (child_field_idx, child_capture)| {
+            // Store this set of additional projections (fields and derefs).
+            // We need to re-apply them later.
+            let mut child_precise_captures =
+                child_capture.place.projections[parent_capture.place.projections.len()..].to_vec();
 
-                // If the parent capture is by-ref, then we need to apply an additional
-                // deref before applying any further projections to this place.
-                if parent_capture.is_by_ref() {
-                    child_precise_captures.insert(
-                        0,
-                        Projection { ty: parent_capture.place.ty(), kind: ProjectionKind::Deref },
-                    );
-                }
-                // If the child capture is by-ref, then we need to apply a "ref"
-                // projection (i.e. `&`) at the end. But wait! We don't have that
-                // as a projection kind. So instead, we can apply its dual and
-                // *peel* a deref off of the place when it shows up in the MIR body.
-                // Luckily, by construction this is always possible.
-                let peel_deref = if child_capture.is_by_ref() {
-                    assert!(
-                        parent_capture.is_by_ref() || coroutine_kind != ty::ClosureKind::FnOnce,
-                        "`FnOnce` coroutine-closures return coroutines that capture from \
+            // If the parent capture is by-ref, then we need to apply an additional
+            // deref before applying any further projections to this place.
+            if parent_capture.is_by_ref() {
+                child_precise_captures.insert(
+                    0,
+                    Projection { ty: parent_capture.place.ty(), kind: ProjectionKind::Deref },
+                );
+            }
+            // If the child capture is by-ref, then we need to apply a "ref"
+            // projection (i.e. `&`) at the end. But wait! We don't have that
+            // as a projection kind. So instead, we can apply its dual and
+            // *peel* a deref off of the place when it shows up in the MIR body.
+            // Luckily, by construction this is always possible.
+            let peel_deref = if child_capture.is_by_ref() {
+                assert!(
+                    parent_capture.is_by_ref() || coroutine_kind != ty::ClosureKind::FnOnce,
+                    "`FnOnce` coroutine-closures return coroutines that capture from \
                         their body; it will always result in a borrowck error!"
-                    );
-                    true
-                } else {
-                    false
-                };
+                );
+                true
+            } else {
+                false
+            };
 
-                // Regarding the behavior above, you may think that it's redundant to both
-                // insert a deref and then peel a deref if the parent and child are both
-                // captured by-ref. This would be correct, except for the case where we have
-                // precise capturing projections, since the inserted deref is to the *beginning*
-                // and the peeled deref is at the *end*. I cannot seem to actually find a
-                // case where this happens, though, but let's keep this code flexible.
+            // Regarding the behavior above, you may think that it's redundant to both
+            // insert a deref and then peel a deref if the parent and child are both
+            // captured by-ref. This would be correct, except for the case where we have
+            // precise capturing projections, since the inserted deref is to the *beginning*
+            // and the peeled deref is at the *end*. I cannot seem to actually find a
+            // case where this happens, though, but let's keep this code flexible.
 
-                // Finally, store the type of the parent's captured place. We need
-                // this when building the field projection in the MIR body later on.
-                let mut parent_capture_ty = parent_capture.place.ty();
-                parent_capture_ty = match parent_capture.info.capture_kind {
-                    ty::UpvarCapture::ByValue => parent_capture_ty,
-                    ty::UpvarCapture::ByRef(kind) => Ty::new_ref(
-                        tcx,
-                        tcx.lifetimes.re_erased,
-                        parent_capture_ty,
-                        kind.to_mutbl_lossy(),
-                    ),
-                };
+            // Finally, store the type of the parent's captured place. We need
+            // this when building the field projection in the MIR body later on.
+            let mut parent_capture_ty = parent_capture.place.ty();
+            parent_capture_ty = match parent_capture.info.capture_kind {
+                ty::UpvarCapture::ByValue => parent_capture_ty,
+                ty::UpvarCapture::ByRef(kind) => Ty::new_ref(
+                    tcx,
+                    tcx.lifetimes.re_erased,
+                    parent_capture_ty,
+                    kind.to_mutbl_lossy(),
+                ),
+            };
 
+            (
+                FieldIdx::from_usize(child_field_idx + num_args),
                 (
-                    FieldIdx::from_usize(child_field_idx + num_args),
-                    (
-                        FieldIdx::from_usize(parent_field_idx + num_args),
-                        parent_capture_ty,
-                        peel_deref,
-                        child_precise_captures,
-                    ),
-                )
-            },
-        )
-        .collect();
+                    FieldIdx::from_usize(parent_field_idx + num_args),
+                    parent_capture_ty,
+                    peel_deref,
+                    child_precise_captures,
+                ),
+            )
+        },
+    )
+    .collect();
 
-        if coroutine_kind == ty::ClosureKind::FnOnce {
-            assert_eq!(field_remapping.len(), tcx.closure_captures(parent_def_id).len());
-            return;
-        }
+    if coroutine_kind == ty::ClosureKind::FnOnce {
+        assert_eq!(field_remapping.len(), tcx.closure_captures(parent_def_id).len());
+        // The by-move body is just the body :)
+        return coroutine_def_id.to_def_id();
+    }
 
-        let by_move_coroutine_ty = tcx
-            .instantiate_bound_regions_with_erased(parent_closure_args.coroutine_closure_sig())
-            .to_coroutine_given_kind_and_upvars(
-                tcx,
-                parent_closure_args.parent_args(),
-                coroutine_def_id.to_def_id(),
-                ty::ClosureKind::FnOnce,
-                tcx.lifetimes.re_erased,
-                parent_closure_args.tupled_upvars_ty(),
-                parent_closure_args.coroutine_captures_by_ref_ty(),
-            );
+    let by_move_coroutine_ty = tcx
+        .instantiate_bound_regions_with_erased(parent_closure_args.coroutine_closure_sig())
+        .to_coroutine_given_kind_and_upvars(
+            tcx,
+            parent_closure_args.parent_args(),
+            coroutine_def_id.to_def_id(),
+            ty::ClosureKind::FnOnce,
+            tcx.lifetimes.re_erased,
+            parent_closure_args.tupled_upvars_ty(),
+            parent_closure_args.coroutine_captures_by_ref_ty(),
+        );
 
-        let mut by_move_body = body.clone();
-        MakeByMoveBody { tcx, field_remapping, by_move_coroutine_ty }.visit_body(&mut by_move_body);
-        dump_mir(tcx, false, "coroutine_by_move", &0, &by_move_body, |_, _| Ok(()));
+    let mut by_move_body = body.clone();
+    MakeByMoveBody { tcx, field_remapping, by_move_coroutine_ty }.visit_body(&mut by_move_body);
+    dump_mir(tcx, false, "coroutine_by_move", &0, &by_move_body, |_, _| Ok(()));
 
-        // Let's just always validate this body.
-        validate_body(tcx, &mut by_move_body, "Initial coroutine_by_move body".to_string());
+    let body_def = tcx.create_def(coroutine_def_id, kw::Empty, DefKind::SyntheticCoroutineBody);
+    by_move_body.source =
+        mir::MirSource::from_instance(InstanceKind::Item(body_def.def_id().to_def_id()));
 
-        // FIXME: use query feeding to generate the body right here and then only store the `DefId` of the new body.
-        by_move_body.source = mir::MirSource::from_instance(InstanceKind::CoroutineKindShim {
-            coroutine_def_id: coroutine_def_id.to_def_id(),
-        });
-        body.coroutine.as_mut().unwrap().by_move_body = Some(by_move_body);
-    }
+    // Inherited from the by-ref coroutine.
+    body_def.codegen_fn_attrs(tcx.codegen_fn_attrs(coroutine_def_id).clone());
+    body_def.constness(tcx.constness(coroutine_def_id).clone());
+    body_def.coroutine_kind(tcx.coroutine_kind(coroutine_def_id).clone());
+    body_def.def_ident_span(tcx.def_ident_span(coroutine_def_id));
+    body_def.def_span(tcx.def_span(coroutine_def_id));
+    body_def.explicit_predicates_of(tcx.explicit_predicates_of(coroutine_def_id).clone());
+    body_def.generics_of(tcx.generics_of(coroutine_def_id).clone());
+    body_def.param_env(tcx.param_env(coroutine_def_id).clone());
+    body_def.predicates_of(tcx.predicates_of(coroutine_def_id).clone());
+
+    // The type of the coroutine is the `by_move_coroutine_ty`.
+    body_def.type_of(ty::EarlyBinder::bind(by_move_coroutine_ty));
+
+    body_def.mir_built(tcx.arena.alloc(Steal::new(by_move_body)));
+
+    body_def.def_id().to_def_id()
 }
 
 struct MakeByMoveBody<'tcx> {
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 61fc5fc881606..2d6950be55d85 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -341,7 +341,6 @@ impl<'tcx> Inliner<'tcx> {
             | InstanceKind::FnPtrShim(..)
             | InstanceKind::ClosureOnceShim { .. }
             | InstanceKind::ConstructCoroutineInClosureShim { .. }
-            | InstanceKind::CoroutineKindShim { .. }
             | InstanceKind::DropGlue(..)
             | InstanceKind::CloneShim(..)
             | InstanceKind::ThreadLocalShim(..)
diff --git a/compiler/rustc_mir_transform/src/inline/cycle.rs b/compiler/rustc_mir_transform/src/inline/cycle.rs
index f5274c664cfa7..56e8905bead3c 100644
--- a/compiler/rustc_mir_transform/src/inline/cycle.rs
+++ b/compiler/rustc_mir_transform/src/inline/cycle.rs
@@ -88,7 +88,6 @@ pub(crate) fn mir_callgraph_reachable<'tcx>(
                 | InstanceKind::FnPtrShim(..)
                 | InstanceKind::ClosureOnceShim { .. }
                 | InstanceKind::ConstructCoroutineInClosureShim { .. }
-                | InstanceKind::CoroutineKindShim { .. }
                 | InstanceKind::ThreadLocalShim { .. }
                 | InstanceKind::CloneShim(..) => {}
 
diff --git a/compiler/rustc_mir_transform/src/lib.rs b/compiler/rustc_mir_transform/src/lib.rs
index 1f214bc42cbe6..88094b44edf21 100644
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -135,6 +135,7 @@ pub fn provide(providers: &mut Providers) {
         mir_inliner_callees: inline::cycle::mir_inliner_callees,
         promoted_mir,
         deduced_param_attrs: deduce_param_attrs::deduced_param_attrs,
+        coroutine_by_move_body_def_id: coroutine::coroutine_by_move_body_def_id,
         ..providers.queries
     };
 }
@@ -293,10 +294,6 @@ fn mir_built(tcx: TyCtxt<'_>, def: LocalDefId) -> &Steal<Body<'_>> {
             &Lint(check_packed_ref::CheckPackedRef),
             &Lint(check_const_item_mutation::CheckConstItemMutation),
             &Lint(function_item_references::FunctionItemReferences),
-            // If this is an async closure's output coroutine, generate
-            // by-move and by-mut bodies if needed. We do this first so
-            // they can be optimized in lockstep with their parent bodies.
-            &coroutine::ByMoveBody,
             // What we need to do constant evaluation.
             &simplify::SimplifyCfg::Initial,
             &rustc_peek::SanityCheck, // Just a lint
@@ -329,8 +326,15 @@ fn mir_promoted(
         | DefKind::AnonConst => tcx.mir_const_qualif(def),
         _ => ConstQualifs::default(),
     };
-    // has_ffi_unwind_calls query uses the raw mir, so make sure it is run.
+
+    // the `has_ffi_unwind_calls` query uses the raw mir, so make sure it is run.
     tcx.ensure_with_value().has_ffi_unwind_calls(def);
+
+    // the `by_move_body` query uses the raw mir, so make sure it is run.
+    if tcx.needs_coroutine_by_move_body_def_id(def) {
+        tcx.ensure_with_value().coroutine_by_move_body_def_id(def);
+    }
+
     let mut body = tcx.mir_built(def).steal();
     if let Some(error_reported) = const_qualifs.tainted_by_errors {
         body.tainted_by_errors = Some(error_reported);
@@ -339,14 +343,6 @@ fn mir_promoted(
     // Collect `required_consts` *before* promotion, so if there are any consts being promoted
     // we still add them to the list in the outer MIR body.
     RequiredConstsVisitor::compute_required_consts(&mut body);
-    // If this has an associated by-move async closure body, that doesn't get run through these
-    // passes itself, it gets "tagged along" by the pass manager. `RequiredConstsVisitor` is not
-    // a regular pass so we have to also apply it manually to the other body.
-    if let Some(coroutine) = body.coroutine.as_mut() {
-        if let Some(by_move_body) = coroutine.by_move_body.as_mut() {
-            RequiredConstsVisitor::compute_required_consts(by_move_body);
-        }
-    }
 
     // What we need to run borrowck etc.
     let promote_pass = promote_consts::PromoteTemps::default();
@@ -398,7 +394,10 @@ fn mir_drops_elaborated_and_const_checked(tcx: TyCtxt<'_>, def: LocalDefId) -> &
     if tcx.is_coroutine(def.to_def_id()) {
         tcx.ensure_with_value().mir_coroutine_witnesses(def);
     }
-    let mir_borrowck = tcx.mir_borrowck(def);
+
+    // We only need to borrowck non-synthetic MIR.
+    let tainted_by_errors =
+        if !tcx.is_synthetic_mir(def) { tcx.mir_borrowck(def).tainted_by_errors } else { None };
 
     let is_fn_like = tcx.def_kind(def).is_fn_like();
     if is_fn_like {
@@ -410,7 +409,8 @@ fn mir_drops_elaborated_and_const_checked(tcx: TyCtxt<'_>, def: LocalDefId) -> &
 
     let (body, _) = tcx.mir_promoted(def);
     let mut body = body.steal();
-    if let Some(error_reported) = mir_borrowck.tainted_by_errors {
+
+    if let Some(error_reported) = tainted_by_errors {
         body.tainted_by_errors = Some(error_reported);
     }
 
@@ -660,14 +660,6 @@ fn inner_optimized_mir(tcx: TyCtxt<'_>, did: LocalDefId) -> Body<'_> {
     // visited does not depend on the optimization level.
     // We do not use `run_passes` for this as that might skip the pass if `injection_phase` is set.
     mentioned_items::MentionedItems.run_pass(tcx, &mut body);
-    // If this has an associated by-move async closure body, that doesn't get run through these
-    // passes itself, it gets "tagged along" by the pass manager. Since we're not using the pass
-    // manager we have to do this by hand.
-    if let Some(coroutine) = body.coroutine.as_mut() {
-        if let Some(by_move_body) = coroutine.by_move_body.as_mut() {
-            mentioned_items::MentionedItems.run_pass(tcx, by_move_body);
-        }
-    }
 
     // If `mir_drops_elaborated_and_const_checked` found that the current body has unsatisfiable
     // predicates, it will shrink the MIR to a single `unreachable` terminator.
@@ -690,7 +682,9 @@ fn promoted_mir(tcx: TyCtxt<'_>, def: LocalDefId) -> &IndexVec<Promoted, Body<'_
         return tcx.arena.alloc(IndexVec::new());
     }
 
-    tcx.ensure_with_value().mir_borrowck(def);
+    if !tcx.is_synthetic_mir(def) {
+        tcx.ensure_with_value().mir_borrowck(def);
+    }
     let mut promoted = tcx.mir_promoted(def).1.steal();
 
     for body in &mut promoted {
diff --git a/compiler/rustc_mir_transform/src/pass_manager.rs b/compiler/rustc_mir_transform/src/pass_manager.rs
index 824a4b2f2df5b..d092477e340a4 100644
--- a/compiler/rustc_mir_transform/src/pass_manager.rs
+++ b/compiler/rustc_mir_transform/src/pass_manager.rs
@@ -182,12 +182,6 @@ fn run_passes_inner<'tcx>(
 
         body.pass_count = 1;
     }
-
-    if let Some(coroutine) = body.coroutine.as_mut() {
-        if let Some(by_move_body) = coroutine.by_move_body.as_mut() {
-            run_passes_inner(tcx, by_move_body, passes, phase_change, validate_each);
-        }
-    }
 }
 
 pub fn validate_body<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>, when: String) {
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
index 09b4e5e07113b..86eada0183f87 100644
--- a/compiler/rustc_mir_transform/src/shim.rs
+++ b/compiler/rustc_mir_transform/src/shim.rs
@@ -78,15 +78,11 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceKind<'tcx>) -> Body<
             receiver_by_ref,
         } => build_construct_coroutine_by_move_shim(tcx, coroutine_closure_def_id, receiver_by_ref),
 
-        ty::InstanceKind::CoroutineKindShim { coroutine_def_id } => {
-            return tcx.optimized_mir(coroutine_def_id).coroutine_by_move_body().unwrap().clone();
-        }
-
         ty::InstanceKind::DropGlue(def_id, ty) => {
             // FIXME(#91576): Drop shims for coroutines aren't subject to the MIR passes at the end
             // of this function. Is this intentional?
-            if let Some(ty::Coroutine(coroutine_def_id, args)) = ty.map(Ty::kind) {
-                let coroutine_body = tcx.optimized_mir(*coroutine_def_id);
+            if let Some(&ty::Coroutine(coroutine_def_id, args)) = ty.map(Ty::kind) {
+                let coroutine_body = tcx.optimized_mir(coroutine_def_id);
 
                 let ty::Coroutine(_, id_args) = *tcx.type_of(coroutine_def_id).skip_binder().kind()
                 else {
@@ -105,7 +101,9 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceKind<'tcx>) -> Body<
                         args.as_coroutine().kind_ty().to_opt_closure_kind().unwrap(),
                         ty::ClosureKind::FnOnce
                     );
-                    coroutine_body.coroutine_by_move_body().unwrap().coroutine_drop().unwrap()
+                    tcx.optimized_mir(tcx.coroutine_by_move_body_def_id(coroutine_def_id))
+                        .coroutine_drop()
+                        .unwrap()
                 };
 
                 let mut body = EarlyBinder::bind(body.clone()).instantiate(tcx, args);
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index 36908036796c1..99e06f59dd04d 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -102,25 +102,6 @@ impl<'tcx> MirPass<'tcx> for Validator {
                 }
             }
         }
-
-        // Enforce that coroutine-closure layouts are identical.
-        if let Some(layout) = body.coroutine_layout_raw()
-            && let Some(by_move_body) = body.coroutine_by_move_body()
-            && let Some(by_move_layout) = by_move_body.coroutine_layout_raw()
-        {
-            // FIXME(async_closures): We could do other validation here?
-            if layout.variant_fields.len() != by_move_layout.variant_fields.len() {
-                cfg_checker.fail(
-                    Location::START,
-                    format!(
-                        "Coroutine layout has different number of variant fields from \
-                        by-move coroutine layout:\n\
-                        layout: {layout:#?}\n\
-                        by_move_layout: {by_move_layout:#?}",
-                    ),
-                );
-            }
-        }
     }
 }
 
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index ff4207fbefda8..36fb2e89af141 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -920,7 +920,6 @@ fn visit_instance_use<'tcx>(
         | ty::InstanceKind::ReifyShim(..)
         | ty::InstanceKind::ClosureOnceShim { .. }
         | ty::InstanceKind::ConstructCoroutineInClosureShim { .. }
-        | ty::InstanceKind::CoroutineKindShim { .. }
         | ty::InstanceKind::Item(..)
         | ty::InstanceKind::FnPtrShim(..)
         | ty::InstanceKind::CloneShim(..)
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
index 610ad41ce5210..2f0088fb34ffd 100644
--- a/compiler/rustc_monomorphize/src/partitioning.rs
+++ b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -626,7 +626,6 @@ fn characteristic_def_id_of_mono_item<'tcx>(
                 | ty::InstanceKind::FnPtrShim(..)
                 | ty::InstanceKind::ClosureOnceShim { .. }
                 | ty::InstanceKind::ConstructCoroutineInClosureShim { .. }
-                | ty::InstanceKind::CoroutineKindShim { .. }
                 | ty::InstanceKind::Intrinsic(..)
                 | ty::InstanceKind::DropGlue(..)
                 | ty::InstanceKind::Virtual(..)
@@ -796,7 +795,6 @@ fn mono_item_visibility<'tcx>(
         | InstanceKind::Intrinsic(..)
         | InstanceKind::ClosureOnceShim { .. }
         | InstanceKind::ConstructCoroutineInClosureShim { .. }
-        | InstanceKind::CoroutineKindShim { .. }
         | InstanceKind::DropGlue(..)
         | InstanceKind::AsyncDropGlueCtorShim(..)
         | InstanceKind::CloneShim(..)
diff --git a/compiler/rustc_monomorphize/src/polymorphize.rs b/compiler/rustc_monomorphize/src/polymorphize.rs
index 5a24202db65ec..b59c7bcffa9c7 100644
--- a/compiler/rustc_monomorphize/src/polymorphize.rs
+++ b/compiler/rustc_monomorphize/src/polymorphize.rs
@@ -127,7 +127,7 @@ fn mark_used_by_default_parameters<'tcx>(
     unused_parameters: &mut UnusedGenericParams,
 ) {
     match tcx.def_kind(def_id) {
-        DefKind::Closure => {
+        DefKind::Closure | DefKind::SyntheticCoroutineBody => {
             for param in &generics.own_params {
                 debug!(?param, "(closure/gen)");
                 unused_parameters.mark_used(param.index);
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index d1d1e5e901f29..9f78215bfd1f9 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -626,7 +626,8 @@ impl<'tcx> EmbargoVisitor<'tcx> {
             | DefKind::Field
             | DefKind::GlobalAsm
             | DefKind::Impl { .. }
-            | DefKind::Closure => (),
+            | DefKind::Closure
+            | DefKind::SyntheticCoroutineBody => (),
         }
     }
 }
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
index 2ac7b200452f4..3ea782b62f179 100644
--- a/compiler/rustc_resolve/src/build_reduced_graph.rs
+++ b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -260,6 +260,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                 | DefKind::LifetimeParam
                 | DefKind::GlobalAsm
                 | DefKind::Closure
+                | DefKind::SyntheticCoroutineBody
                 | DefKind::Impl { .. },
                 _,
             )
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
index 332fe22d86955..9afd732486c28 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -851,7 +851,6 @@ impl<'tcx> Stable<'tcx> for ty::Instance<'tcx> {
             | ty::InstanceKind::FnPtrAddrShim(..)
             | ty::InstanceKind::ClosureOnceShim { .. }
             | ty::InstanceKind::ConstructCoroutineInClosureShim { .. }
-            | ty::InstanceKind::CoroutineKindShim { .. }
             | ty::InstanceKind::ThreadLocalShim(..)
             | ty::InstanceKind::DropGlue(..)
             | ty::InstanceKind::CloneShim(..)
diff --git a/compiler/rustc_smir/src/rustc_smir/mod.rs b/compiler/rustc_smir/src/rustc_smir/mod.rs
index 41e9698242bbd..9b27b94fb5a56 100644
--- a/compiler/rustc_smir/src/rustc_smir/mod.rs
+++ b/compiler/rustc_smir/src/rustc_smir/mod.rs
@@ -114,7 +114,9 @@ pub(crate) fn new_item_kind(kind: DefKind) -> ItemKind {
         | DefKind::GlobalAsm => {
             unreachable!("Not a valid item kind: {kind:?}");
         }
-        DefKind::Closure | DefKind::AssocFn | DefKind::Fn => ItemKind::Fn,
+        DefKind::Closure | DefKind::AssocFn | DefKind::Fn | DefKind::SyntheticCoroutineBody => {
+            ItemKind::Fn
+        }
         DefKind::Const | DefKind::InlineConst | DefKind::AssocConst | DefKind::AnonConst => {
             ItemKind::Const
         }
diff --git a/compiler/rustc_symbol_mangling/src/legacy.rs b/compiler/rustc_symbol_mangling/src/legacy.rs
index 0f91684a3a48b..59ccd6dff8588 100644
--- a/compiler/rustc_symbol_mangling/src/legacy.rs
+++ b/compiler/rustc_symbol_mangling/src/legacy.rs
@@ -92,9 +92,6 @@ pub(super) fn mangle<'tcx>(
                 .write_str(if receiver_by_ref { "{{by-move-shim}}" } else { "{{by-ref-shim}}" })
                 .unwrap();
         }
-        ty::InstanceKind::CoroutineKindShim { .. } => {
-            printer.write_str("{{by-move-body-shim}}").unwrap();
-        }
         _ => {}
     }
 
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
index 3a606f244e37a..75f4499352b99 100644
--- a/compiler/rustc_symbol_mangling/src/v0.rs
+++ b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -56,7 +56,6 @@ pub(super) fn mangle<'tcx>(
         ty::InstanceKind::ConstructCoroutineInClosureShim { receiver_by_ref: false, .. } => {
             Some("by_ref")
         }
-        ty::InstanceKind::CoroutineKindShim { .. } => Some("by_move_body"),
 
         _ => None,
     };
diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index 7e3c30f238388..16cd147b7d432 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -169,39 +169,6 @@ fn fn_sig_for_fn_abi<'tcx>(
                 kind: ty::BoundRegionKind::BrEnv,
             };
 
-            let mut ty = ty;
-            // When this `Closure` comes from a `CoroutineKindShim`,
-            // make sure we respect the `target_kind` in that shim.
-            // FIXME(async_closures): This shouldn't be needed, and we should be populating
-            // a separate def-id for these bodies.
-            if let InstanceKind::CoroutineKindShim { .. } = instance.def {
-                // Grab the parent coroutine-closure. It has the same args for the purposes
-                // of instantiation, so this will be okay to do.
-                let ty::CoroutineClosure(_, coroutine_closure_args) = *tcx
-                    .instantiate_and_normalize_erasing_regions(
-                        args,
-                        param_env,
-                        tcx.type_of(tcx.parent(did)),
-                    )
-                    .kind()
-                else {
-                    bug!("CoroutineKindShim comes from calling a coroutine-closure");
-                };
-                let coroutine_closure_args = coroutine_closure_args.as_coroutine_closure();
-                ty = tcx.instantiate_bound_regions_with_erased(
-                    coroutine_closure_args.coroutine_closure_sig().map_bound(|sig| {
-                        sig.to_coroutine_given_kind_and_upvars(
-                            tcx,
-                            coroutine_closure_args.parent_args(),
-                            did,
-                            ty::ClosureKind::FnOnce,
-                            tcx.lifetimes.re_erased,
-                            coroutine_closure_args.tupled_upvars_ty(),
-                            coroutine_closure_args.coroutine_captures_by_ref_ty(),
-                        )
-                    }),
-                );
-            }
             let env_ty = Ty::new_mut_ref(tcx, ty::Region::new_bound(tcx, ty::INNERMOST, br), ty);
 
             let pin_did = tcx.require_lang_item(LangItem::Pin, None);
diff --git a/compiler/rustc_ty_utils/src/implied_bounds.rs b/compiler/rustc_ty_utils/src/implied_bounds.rs
index 8812260b3af31..70321a071a208 100644
--- a/compiler/rustc_ty_utils/src/implied_bounds.rs
+++ b/compiler/rustc_ty_utils/src/implied_bounds.rs
@@ -144,7 +144,8 @@ fn assumed_wf_types<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &'tcx [(Ty<'
         | DefKind::Field
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
-        | DefKind::Closure => ty::List::empty(),
+        | DefKind::Closure
+        | DefKind::SyntheticCoroutineBody => ty::List::empty(),
     }
 }
 
diff --git a/compiler/rustc_ty_utils/src/opaque_types.rs b/compiler/rustc_ty_utils/src/opaque_types.rs
index 6680b451b7cc7..e899284674c8c 100644
--- a/compiler/rustc_ty_utils/src/opaque_types.rs
+++ b/compiler/rustc_ty_utils/src/opaque_types.rs
@@ -348,7 +348,8 @@ fn opaque_types_defined_by<'tcx>(
         | DefKind::Field
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
-        | DefKind::Impl { .. } => {}
+        | DefKind::Impl { .. }
+        | DefKind::SyntheticCoroutineBody => {}
         // Closures and coroutines are type checked with their parent, so we need to allow all
         // opaques from the closure signature *and* from the parent body.
         DefKind::Closure | DefKind::InlineConst => {
diff --git a/compiler/rustc_ty_utils/src/sig_types.rs b/compiler/rustc_ty_utils/src/sig_types.rs
index 568b9383ffbc4..6f1cbb0fee700 100644
--- a/compiler/rustc_ty_utils/src/sig_types.rs
+++ b/compiler/rustc_ty_utils/src/sig_types.rs
@@ -87,7 +87,7 @@ pub fn walk_types<'tcx, V: SpannedTypeVisitor<'tcx>>(
         // These are not part of a public API, they can only appear as hidden types, and there
         // the interesting parts are solely in the signature of the containing item's opaque type
         // or dyn type.
-        DefKind::InlineConst | DefKind::Closure => {}
+        DefKind::InlineConst | DefKind::Closure | DefKind::SyntheticCoroutineBody => {}
         DefKind::Impl { of_trait } => {
             if of_trait {
                 let span = tcx.hir_node_by_def_id(item).expect_item().expect_impl().of_trait.unwrap().path.span;
diff --git a/src/librustdoc/formats/item_type.rs b/src/librustdoc/formats/item_type.rs
index 3dcef15b552b2..9754e1e6f74d4 100644
--- a/src/librustdoc/formats/item_type.rs
+++ b/src/librustdoc/formats/item_type.rs
@@ -162,7 +162,8 @@ impl ItemType {
             | DefKind::LifetimeParam
             | DefKind::GlobalAsm
             | DefKind::Impl { .. }
-            | DefKind::Closure => Self::ForeignType,
+            | DefKind::Closure
+            | DefKind::SyntheticCoroutineBody => Self::ForeignType,
         }
     }
 
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index ab03f620230bd..eae12b848396c 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -1950,7 +1950,9 @@ fn resolution_failure(
                             | TraitAlias
                             | TyParam
                             | Static { .. } => "associated item",
-                            Impl { .. } | GlobalAsm => unreachable!("not a path"),
+                            Impl { .. } | GlobalAsm | SyntheticCoroutineBody => {
+                                unreachable!("not a path")
+                            }
                         }
                     } else {
                         "associated item"
diff --git a/tests/ui/lint/unused/lint-unused-variables.stderr b/tests/ui/lint/unused/lint-unused-variables.stderr
index 09729eeba7923..ef590d85aef78 100644
--- a/tests/ui/lint/unused/lint-unused-variables.stderr
+++ b/tests/ui/lint/unused/lint-unused-variables.stderr
@@ -16,6 +16,12 @@ error: unused variable: `a`
 LL |         a: i32,
    |         ^ help: if this is intentional, prefix it with an underscore: `_a`
 
+error: unused variable: `a`
+  --> $DIR/lint-unused-variables.rs:68:9
+   |
+LL |         a: i32,
+   |         ^ help: if this is intentional, prefix it with an underscore: `_a`
+
 error: unused variable: `b`
   --> $DIR/lint-unused-variables.rs:14:5
    |
@@ -58,12 +64,6 @@ error: unused variable: `b`
 LL |         b: i32,
    |         ^ help: if this is intentional, prefix it with an underscore: `_b`
 
-error: unused variable: `a`
-  --> $DIR/lint-unused-variables.rs:68:9
-   |
-LL |         a: i32,
-   |         ^ help: if this is intentional, prefix it with an underscore: `_a`
-
 error: unused variable: `b`
   --> $DIR/lint-unused-variables.rs:74:9
    |
diff --git a/tests/ui/rfcs/rfc-2565-param-attrs/param-attrs-cfg.stderr b/tests/ui/rfcs/rfc-2565-param-attrs/param-attrs-cfg.stderr
index 16e1af46059a4..9b92166bcb766 100644
--- a/tests/ui/rfcs/rfc-2565-param-attrs/param-attrs-cfg.stderr
+++ b/tests/ui/rfcs/rfc-2565-param-attrs/param-attrs-cfg.stderr
@@ -16,6 +16,12 @@ error: unused variable: `a`
 LL |         #[cfg(something)] a: i32,
    |                           ^ help: if this is intentional, prefix it with an underscore: `_a`
 
+error: unused variable: `a`
+  --> $DIR/param-attrs-cfg.rs:107:27
+   |
+LL |         #[cfg(something)] a: i32,
+   |                           ^ help: if this is intentional, prefix it with an underscore: `_a`
+
 error: unused variable: `b`
   --> $DIR/param-attrs-cfg.rs:30:23
    |
@@ -100,12 +106,6 @@ error: unused variable: `c`
 LL |         #[cfg_attr(nothing, cfg(nothing))] c: i32,
    |                                            ^ help: if this is intentional, prefix it with an underscore: `_c`
 
-error: unused variable: `a`
-  --> $DIR/param-attrs-cfg.rs:107:27
-   |
-LL |         #[cfg(something)] a: i32,
-   |                           ^ help: if this is intentional, prefix it with an underscore: `_a`
-
 error: unused variable: `b`
   --> $DIR/param-attrs-cfg.rs:113:27
    |

From 93295ff6dc48782ea3114e98313836b266f3e54a Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 7 Aug 2024 13:24:46 -0400
Subject: [PATCH 626/685] Remove some unnecessary TODOs

---
 compiler/rustc_interface/src/passes.rs       | 2 --
 compiler/rustc_metadata/src/rmeta/encoder.rs | 5 -----
 2 files changed, 7 deletions(-)

diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index 2a4367965eef3..779b98d073dab 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -796,8 +796,6 @@ fn run_required_analyses(tcx: TyCtxt<'_>) {
     // Freeze definitions as we don't add new ones at this point.
     // We need to wait until now since we synthesize a by-move body
     // This improves performance by allowing lock-free access to them.
-    // FIXME(async_closures): We could force `coroutine_by_move_body_def_id`
-    // immediately after typeck, then freeze after that.
     tcx.untracked().definitions.freeze();
 
     sess.time("MIR_borrow_checking", || {
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index 3125fb245e7e3..9c93726ca37f5 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1066,7 +1066,6 @@ fn should_encode_mir(
         }
         // Coroutines require optimized MIR to compute layout.
         DefKind::Closure if tcx.is_coroutine(def_id.to_def_id()) => (false, true),
-        // FIXME: lol
         DefKind::SyntheticCoroutineBody => (false, true),
         // Full-fledged functions + closures
         DefKind::AssocFn | DefKind::Fn | DefKind::Closure => {
@@ -1379,10 +1378,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 let def_span = tcx.def_span(local_id);
                 record!(self.tables.def_span[def_id] <- def_span);
             }
-            // FIXME(async_closures): We should just use `tcx.attrs` rather than going
-            // through the HIR. Historically, though, this has been inefficient apparently.
-            // For now, it's kind of pointless to fix, because coroutine-closures' coroutine
-            // bodies have no attrs anyways.
             if should_encode_attrs(def_kind) {
                 self.encode_attrs(local_id);
             }

From 56d861134dcdd5b4f363835b9ab22895c6e70228 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 22 Jul 2024 14:53:26 -0400
Subject: [PATCH 627/685] Fix tidy

---
 src/tools/tidy/src/edition.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/tools/tidy/src/edition.rs b/src/tools/tidy/src/edition.rs
index 6a58d58dbde14..08f6a3909f806 100644
--- a/src/tools/tidy/src/edition.rs
+++ b/src/tools/tidy/src/edition.rs
@@ -1,4 +1,4 @@
-//! Tidy check to ensure that crate `edition` is '2018' or '2021'.
+//! Tidy check to ensure that crate `edition` is '2021' or '2024'.
 
 use std::path::Path;
 
@@ -12,7 +12,9 @@ pub fn check(path: &Path, bad: &mut bool) {
             return;
         }
 
-        let is_2021 = contents.lines().any(|line| line.trim() == "edition = \"2021\"");
+        let is_current_edition = contents
+            .lines()
+            .any(|line| line.trim() == "edition = \"2021\"" || line.trim() == "edition = \"2024\"");
 
         let is_workspace = contents.lines().any(|line| line.trim() == "[workspace]");
         let is_package = contents.lines().any(|line| line.trim() == "[package]");
@@ -20,10 +22,10 @@ pub fn check(path: &Path, bad: &mut bool) {
 
         // Check that all packages use the 2021 edition. Virtual workspaces don't allow setting an
         // edition, so these shouldn't be checked.
-        if is_package && !is_2021 {
+        if is_package && !is_current_edition {
             tidy_error!(
                 bad,
-                "{} doesn't have `edition = \"2021\"` on a separate line",
+                "{} doesn't have `edition = \"2021\"` or `edition = \"2024\"` on a separate line",
                 file.display()
             );
         }

From 38e62b98418c22d3a00f5af689ae538e4216fb5f Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 26 Aug 2024 19:40:43 -0400
Subject: [PATCH 628/685] Use unsafe extern blocks throughout the compiler

---
 compiler/rustc_codegen_llvm/src/lib.rs        |  1 +
 compiler/rustc_codegen_llvm/src/llvm/ffi.rs   | 42 +++++++++----------
 compiler/rustc_driver_impl/src/lib.rs         |  1 +
 .../rustc_driver_impl/src/signal_handler.rs   |  2 +-
 compiler/rustc_llvm/src/lib.rs                |  5 ++-
 compiler/rustc_middle/src/lib.rs              |  2 +-
 compiler/rustc_middle/src/ty/list.rs          |  2 +-
 7 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 43164390a1c6c..f7b0ce25b4ab3 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -6,6 +6,7 @@
 
 // tidy-alphabetical-start
 #![allow(internal_features)]
+#![cfg_attr(bootstrap, feature(unsafe_extern_blocks))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(assert_matches)]
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index faabbcb020d5f..a774ea3339706 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -564,12 +564,12 @@ pub enum ArchiveKind {
 }
 
 // LLVMRustThinLTOData
-extern "C" {
+unsafe extern "C" {
     pub type ThinLTOData;
 }
 
 // LLVMRustThinLTOBuffer
-extern "C" {
+unsafe extern "C" {
     pub type ThinLTOBuffer;
 }
 
@@ -621,7 +621,7 @@ pub enum MemoryEffects {
     InaccessibleMemOnly,
 }
 
-extern "C" {
+unsafe extern "C" {
     type Opaque;
 }
 #[repr(C)]
@@ -631,54 +631,54 @@ struct InvariantOpaque<'a> {
 }
 
 // Opaque pointer types
-extern "C" {
+unsafe extern "C" {
     pub type Module;
 }
-extern "C" {
+unsafe extern "C" {
     pub type Context;
 }
-extern "C" {
+unsafe extern "C" {
     pub type Type;
 }
-extern "C" {
+unsafe extern "C" {
     pub type Value;
 }
-extern "C" {
+unsafe extern "C" {
     pub type ConstantInt;
 }
-extern "C" {
+unsafe extern "C" {
     pub type Attribute;
 }
-extern "C" {
+unsafe extern "C" {
     pub type Metadata;
 }
-extern "C" {
+unsafe extern "C" {
     pub type BasicBlock;
 }
 #[repr(C)]
 pub struct Builder<'a>(InvariantOpaque<'a>);
 #[repr(C)]
 pub struct PassManager<'a>(InvariantOpaque<'a>);
-extern "C" {
+unsafe extern "C" {
     pub type Pass;
 }
-extern "C" {
+unsafe extern "C" {
     pub type TargetMachine;
 }
-extern "C" {
+unsafe extern "C" {
     pub type Archive;
 }
 #[repr(C)]
 pub struct ArchiveIterator<'a>(InvariantOpaque<'a>);
 #[repr(C)]
 pub struct ArchiveChild<'a>(InvariantOpaque<'a>);
-extern "C" {
+unsafe extern "C" {
     pub type Twine;
 }
-extern "C" {
+unsafe extern "C" {
     pub type DiagnosticInfo;
 }
-extern "C" {
+unsafe extern "C" {
     pub type SMDiagnostic;
 }
 #[repr(C)]
@@ -688,7 +688,7 @@ pub struct OperandBundleDef<'a>(InvariantOpaque<'a>);
 #[repr(C)]
 pub struct Linker<'a>(InvariantOpaque<'a>);
 
-extern "C" {
+unsafe extern "C" {
     pub type DiagnosticHandler;
 }
 
@@ -823,7 +823,7 @@ bitflags! {
     }
 }
 
-extern "C" {
+unsafe extern "C" {
     pub type ModuleBuffer;
 }
 
@@ -834,7 +834,7 @@ pub type SelfProfileAfterPassCallback = unsafe extern "C" fn(*mut c_void);
 pub type GetSymbolsCallback = unsafe extern "C" fn(*mut c_void, *const c_char) -> *mut c_void;
 pub type GetSymbolsErrorCallback = unsafe extern "C" fn(*const c_char) -> *mut c_void;
 
-extern "C" {
+unsafe extern "C" {
     // Create and destroy contexts.
     pub fn LLVMContextDispose(C: &'static mut Context);
     pub fn LLVMGetMDKindIDInContext(C: &Context, Name: *const c_char, SLen: c_uint) -> c_uint;
@@ -1518,7 +1518,7 @@ extern "C" {
 }
 
 #[link(name = "llvm-wrapper", kind = "static")]
-extern "C" {
+unsafe extern "C" {
     pub fn LLVMRustInstallErrorHandlers();
     pub fn LLVMRustDisableSystemDialogsOnCrash();
 
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 2b7dc040f6411..ed072cd10b7a0 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -7,6 +7,7 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
+#![cfg_attr(bootstrap, feature(unsafe_extern_blocks))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(decl_macro)]
diff --git a/compiler/rustc_driver_impl/src/signal_handler.rs b/compiler/rustc_driver_impl/src/signal_handler.rs
index 51f2a508cf90c..e1f868c2522d9 100644
--- a/compiler/rustc_driver_impl/src/signal_handler.rs
+++ b/compiler/rustc_driver_impl/src/signal_handler.rs
@@ -6,7 +6,7 @@ use std::{fmt, mem, ptr};
 
 use rustc_interface::util::{DEFAULT_STACK_SIZE, STACK_SIZE};
 
-extern "C" {
+unsafe extern "C" {
     fn backtrace_symbols_fd(buffer: *const *mut libc::c_void, size: libc::c_int, fd: libc::c_int);
 }
 
diff --git a/compiler/rustc_llvm/src/lib.rs b/compiler/rustc_llvm/src/lib.rs
index 939e5e4dbd4ff..96e370c5b2648 100644
--- a/compiler/rustc_llvm/src/lib.rs
+++ b/compiler/rustc_llvm/src/lib.rs
@@ -1,5 +1,6 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
+#![cfg_attr(bootstrap, feature(unsafe_attributes, unsafe_extern_blocks))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
@@ -28,7 +29,7 @@ impl RustString {
 }
 
 /// Appending to a Rust string -- used by RawRustStringOstream.
-#[no_mangle]
+#[unsafe(no_mangle)]
 pub unsafe extern "C" fn LLVMRustStringWriteImpl(
     sr: &RustString,
     ptr: *const c_char,
@@ -46,7 +47,7 @@ pub fn initialize_available_targets() {
         ($cfg:meta, $($method:ident),*) => { {
             #[cfg($cfg)]
             fn init() {
-                extern "C" {
+                unsafe extern "C" {
                     $(fn $method();)*
                 }
                 unsafe {
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index 6886562d9b76d..ce330b4744bf6 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -28,7 +28,7 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::potential_query_instability)]
 #![allow(rustc::untranslatable_diagnostic)]
-#![cfg_attr(bootstrap, feature(min_exhaustive_patterns))]
+#![cfg_attr(bootstrap, feature(min_exhaustive_patterns, unsafe_extern_blocks))]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(allocator_api)]
diff --git a/compiler/rustc_middle/src/ty/list.rs b/compiler/rustc_middle/src/ty/list.rs
index 1a1acf36d77a4..af76d5b7d9267 100644
--- a/compiler/rustc_middle/src/ty/list.rs
+++ b/compiler/rustc_middle/src/ty/list.rs
@@ -58,7 +58,7 @@ impl<T> Default for &List<T> {
     }
 }
 
-extern "C" {
+unsafe extern "C" {
     /// A dummy type used to force `List` to be unsized while not requiring
     /// references to it be wide pointers.
     type OpaqueListContents;

From e81fad2b4d0c907445c6df76adea65602134fda8 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 11:47:25 +1000
Subject: [PATCH 629/685] Add `warn(unreachable_pub)` to `rustc_driver_impl`.

---
 compiler/rustc_driver_impl/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 2b7dc040f6411..970ac5627491b 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -15,6 +15,7 @@
 #![feature(panic_update_hook)]
 #![feature(result_flattening)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 use std::cmp::max;

From d607cfb33602750ba9b8adc090abfde2087e0fd6 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 11:49:59 +1000
Subject: [PATCH 630/685] Add `warn(unreachable_pub)` to `rustc_error_codes`.

---
 compiler/rustc_error_codes/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_error_codes/src/lib.rs b/compiler/rustc_error_codes/src/lib.rs
index 2a7bc2501c081..150f99a3ee743 100644
--- a/compiler/rustc_error_codes/src/lib.rs
+++ b/compiler/rustc_error_codes/src/lib.rs
@@ -6,6 +6,7 @@
 #![deny(rustdoc::invalid_codeblock_attributes)]
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 // This higher-order macro defines the error codes that are in use. It is used

From 2b5621280c118ca72eb84470129c72b069e22907 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 11:52:08 +1000
Subject: [PATCH 631/685] Add `warn(unreachable_pub)` to
 `rustc_error_messages`.

---
 compiler/rustc_error_messages/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs
index 87dee2898daf0..e84d7be45d7a0 100644
--- a/compiler/rustc_error_messages/src/lib.rs
+++ b/compiler/rustc_error_messages/src/lib.rs
@@ -4,6 +4,7 @@
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
 #![feature(type_alias_impl_trait)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 use std::borrow::Cow;

From 5fd503ab445b2a70897026e495dd4df4343333eb Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 12:03:37 +1000
Subject: [PATCH 632/685] Add `warn(unreachable_pub)` to `rustc_errors`.

---
 compiler/rustc_errors/src/diagnostic.rs     |  2 +-
 compiler/rustc_errors/src/emitter.rs        |  2 +-
 compiler/rustc_errors/src/lib.rs            |  5 ++--
 compiler/rustc_errors/src/lock.rs           |  4 +--
 compiler/rustc_errors/src/markdown/parse.rs |  2 +-
 compiler/rustc_errors/src/markdown/term.rs  |  4 +--
 compiler/rustc_errors/src/snippet.rs        | 32 ++++++++++-----------
 compiler/rustc_errors/src/styled_buffer.rs  | 20 ++++++-------
 8 files changed, 36 insertions(+), 35 deletions(-)

diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index fae8b5647fc9a..3303e4ee752c2 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -204,7 +204,7 @@ pub trait LintDiagnostic<'a, G: EmissionGuarantee> {
 }
 
 #[derive(Clone, Debug, Encodable, Decodable)]
-pub struct DiagLocation {
+pub(crate) struct DiagLocation {
     file: Cow<'static, str>,
     line: u32,
     col: u32,
diff --git a/compiler/rustc_errors/src/emitter.rs b/compiler/rustc_errors/src/emitter.rs
index 9ce5d77ef6c07..2bc29dabd18a1 100644
--- a/compiler/rustc_errors/src/emitter.rs
+++ b/compiler/rustc_errors/src/emitter.rs
@@ -2387,7 +2387,7 @@ enum DisplaySuggestion {
 impl FileWithAnnotatedLines {
     /// Preprocess all the annotations so that they are grouped by file and by line number
     /// This helps us quickly iterate over the whole message (including secondary file spans)
-    pub fn collect_annotations(
+    pub(crate) fn collect_annotations(
         emitter: &dyn Emitter,
         args: &FluentArgs<'_>,
         msp: &MultiSpan,
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index fd203c3831897..99ee8fb17d7dc 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -25,6 +25,7 @@
 #![feature(trait_alias)]
 #![feature(try_blocks)]
 #![feature(yeet_expr)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 extern crate self as rustc_errors;
@@ -1701,7 +1702,7 @@ impl DiagCtxtInner {
     }
 
     /// Translate `message` eagerly with `args` to `SubdiagMessage::Eager`.
-    pub fn eagerly_translate<'a>(
+    fn eagerly_translate<'a>(
         &self,
         message: DiagMessage,
         args: impl Iterator<Item = DiagArg<'a>>,
@@ -1710,7 +1711,7 @@ impl DiagCtxtInner {
     }
 
     /// Translate `message` eagerly with `args` to `String`.
-    pub fn eagerly_translate_to_string<'a>(
+    fn eagerly_translate_to_string<'a>(
         &self,
         message: DiagMessage,
         args: impl Iterator<Item = DiagArg<'a>>,
diff --git a/compiler/rustc_errors/src/lock.rs b/compiler/rustc_errors/src/lock.rs
index 915542c909240..7557969f374ac 100644
--- a/compiler/rustc_errors/src/lock.rs
+++ b/compiler/rustc_errors/src/lock.rs
@@ -12,7 +12,7 @@
 use std::any::Any;
 
 #[cfg(windows)]
-pub fn acquire_global_lock(name: &str) -> Box<dyn Any> {
+pub(crate) fn acquire_global_lock(name: &str) -> Box<dyn Any> {
     use std::ffi::CString;
     use std::io;
 
@@ -80,6 +80,6 @@ pub fn acquire_global_lock(name: &str) -> Box<dyn Any> {
 }
 
 #[cfg(not(windows))]
-pub fn acquire_global_lock(_name: &str) -> Box<dyn Any> {
+pub(crate) fn acquire_global_lock(_name: &str) -> Box<dyn Any> {
     Box::new(())
 }
diff --git a/compiler/rustc_errors/src/markdown/parse.rs b/compiler/rustc_errors/src/markdown/parse.rs
index 46f8959b6f246..b1db44dd215b8 100644
--- a/compiler/rustc_errors/src/markdown/parse.rs
+++ b/compiler/rustc_errors/src/markdown/parse.rs
@@ -74,7 +74,7 @@ enum ParseOpt {
 }
 
 /// Parse a buffer
-pub fn entrypoint(txt: &str) -> MdStream<'_> {
+pub(crate) fn entrypoint(txt: &str) -> MdStream<'_> {
     let ctx = Context { top_block: true, prev: Prev::Newline };
     normalize(parse_recursive(txt.trim().as_bytes(), ctx), &mut Vec::new())
 }
diff --git a/compiler/rustc_errors/src/markdown/term.rs b/compiler/rustc_errors/src/markdown/term.rs
index 06c1333d93dd0..579e00b8b85bd 100644
--- a/compiler/rustc_errors/src/markdown/term.rs
+++ b/compiler/rustc_errors/src/markdown/term.rs
@@ -15,7 +15,7 @@ thread_local! {
 }
 
 /// Print to terminal output to a buffer
-pub fn entrypoint(stream: &MdStream<'_>, buf: &mut Buffer) -> io::Result<()> {
+pub(crate) fn entrypoint(stream: &MdStream<'_>, buf: &mut Buffer) -> io::Result<()> {
     #[cfg(not(test))]
     if let Some((w, _)) = termize::dimensions() {
         WIDTH.with(|c| c.set(std::cmp::min(w, DEFAULT_COLUMN_WIDTH)));
@@ -47,7 +47,7 @@ fn write_stream(
     Ok(())
 }
 
-pub fn write_tt(tt: &MdTree<'_>, buf: &mut Buffer, indent: usize) -> io::Result<()> {
+fn write_tt(tt: &MdTree<'_>, buf: &mut Buffer, indent: usize) -> io::Result<()> {
     match tt {
         MdTree::CodeBlock { txt, lang: _ } => {
             buf.set_color(ColorSpec::new().set_dimmed(true))?;
diff --git a/compiler/rustc_errors/src/snippet.rs b/compiler/rustc_errors/src/snippet.rs
index 50abf8a49c268..8485d7087cfc5 100644
--- a/compiler/rustc_errors/src/snippet.rs
+++ b/compiler/rustc_errors/src/snippet.rs
@@ -5,13 +5,13 @@ use rustc_macros::{Decodable, Encodable};
 use crate::{Level, Loc};
 
 #[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
-pub struct Line {
+pub(crate) struct Line {
     pub line_index: usize,
     pub annotations: Vec<Annotation>,
 }
 
 #[derive(Clone, Copy, Debug, PartialOrd, Ord, PartialEq, Eq, Default)]
-pub struct AnnotationColumn {
+pub(crate) struct AnnotationColumn {
     /// the (0-indexed) column for *display* purposes, counted in characters, not utf-8 bytes
     pub display: usize,
     /// the (0-indexed) column in the file, counted in characters, not utf-8 bytes.
@@ -31,13 +31,13 @@ pub struct AnnotationColumn {
 }
 
 impl AnnotationColumn {
-    pub fn from_loc(loc: &Loc) -> AnnotationColumn {
+    pub(crate) fn from_loc(loc: &Loc) -> AnnotationColumn {
         AnnotationColumn { display: loc.col_display, file: loc.col.0 }
     }
 }
 
 #[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
-pub struct MultilineAnnotation {
+pub(crate) struct MultilineAnnotation {
     pub depth: usize,
     pub line_start: usize,
     pub line_end: usize,
@@ -49,19 +49,19 @@ pub struct MultilineAnnotation {
 }
 
 impl MultilineAnnotation {
-    pub fn increase_depth(&mut self) {
+    pub(crate) fn increase_depth(&mut self) {
         self.depth += 1;
     }
 
     /// Compare two `MultilineAnnotation`s considering only the `Span` they cover.
-    pub fn same_span(&self, other: &MultilineAnnotation) -> bool {
+    pub(crate) fn same_span(&self, other: &MultilineAnnotation) -> bool {
         self.line_start == other.line_start
             && self.line_end == other.line_end
             && self.start_col == other.start_col
             && self.end_col == other.end_col
     }
 
-    pub fn as_start(&self) -> Annotation {
+    pub(crate) fn as_start(&self) -> Annotation {
         Annotation {
             start_col: self.start_col,
             end_col: AnnotationColumn {
@@ -76,7 +76,7 @@ impl MultilineAnnotation {
         }
     }
 
-    pub fn as_end(&self) -> Annotation {
+    pub(crate) fn as_end(&self) -> Annotation {
         Annotation {
             start_col: AnnotationColumn {
                 // these might not correspond to the same place anymore,
@@ -91,7 +91,7 @@ impl MultilineAnnotation {
         }
     }
 
-    pub fn as_line(&self) -> Annotation {
+    pub(crate) fn as_line(&self) -> Annotation {
         Annotation {
             start_col: Default::default(),
             end_col: Default::default(),
@@ -103,7 +103,7 @@ impl MultilineAnnotation {
 }
 
 #[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
-pub enum AnnotationType {
+pub(crate) enum AnnotationType {
     /// Annotation under a single line of code
     Singleline,
 
@@ -129,7 +129,7 @@ pub enum AnnotationType {
 }
 
 #[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
-pub struct Annotation {
+pub(crate) struct Annotation {
     /// Start column.
     /// Note that it is important that this field goes
     /// first, so that when we sort, we sort orderings by start
@@ -152,12 +152,12 @@ pub struct Annotation {
 
 impl Annotation {
     /// Whether this annotation is a vertical line placeholder.
-    pub fn is_line(&self) -> bool {
+    pub(crate) fn is_line(&self) -> bool {
         matches!(self.annotation_type, AnnotationType::MultilineLine(_))
     }
 
     /// Length of this annotation as displayed in the stderr output
-    pub fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
         // Account for usize underflows
         if self.end_col.display > self.start_col.display {
             self.end_col.display - self.start_col.display
@@ -166,7 +166,7 @@ impl Annotation {
         }
     }
 
-    pub fn has_label(&self) -> bool {
+    pub(crate) fn has_label(&self) -> bool {
         if let Some(ref label) = self.label {
             // Consider labels with no text as effectively not being there
             // to avoid weird output with unnecessary vertical lines, like:
@@ -184,7 +184,7 @@ impl Annotation {
         }
     }
 
-    pub fn takes_space(&self) -> bool {
+    pub(crate) fn takes_space(&self) -> bool {
         // Multiline annotations always have to keep vertical space.
         matches!(
             self.annotation_type,
@@ -194,7 +194,7 @@ impl Annotation {
 }
 
 #[derive(Debug)]
-pub struct StyledString {
+pub(crate) struct StyledString {
     pub text: String,
     pub style: Style,
 }
diff --git a/compiler/rustc_errors/src/styled_buffer.rs b/compiler/rustc_errors/src/styled_buffer.rs
index 9aa14e1f21485..5ca9e9b18f341 100644
--- a/compiler/rustc_errors/src/styled_buffer.rs
+++ b/compiler/rustc_errors/src/styled_buffer.rs
@@ -3,7 +3,7 @@
 use crate::snippet::{Style, StyledString};
 
 #[derive(Debug)]
-pub struct StyledBuffer {
+pub(crate) struct StyledBuffer {
     lines: Vec<Vec<StyledChar>>,
 }
 
@@ -22,12 +22,12 @@ impl StyledChar {
 }
 
 impl StyledBuffer {
-    pub fn new() -> StyledBuffer {
+    pub(crate) fn new() -> StyledBuffer {
         StyledBuffer { lines: vec![] }
     }
 
     /// Returns content of `StyledBuffer` split by lines and line styles
-    pub fn render(&self) -> Vec<Vec<StyledString>> {
+    pub(crate) fn render(&self) -> Vec<Vec<StyledString>> {
         // Tabs are assumed to have been replaced by spaces in calling code.
         debug_assert!(self.lines.iter().all(|r| !r.iter().any(|sc| sc.chr == '\t')));
 
@@ -70,7 +70,7 @@ impl StyledBuffer {
     /// Sets `chr` with `style` for given `line`, `col`.
     /// If `line` does not exist in our buffer, adds empty lines up to the given
     /// and fills the last line with unstyled whitespace.
-    pub fn putc(&mut self, line: usize, col: usize, chr: char, style: Style) {
+    pub(crate) fn putc(&mut self, line: usize, col: usize, chr: char, style: Style) {
         self.ensure_lines(line);
         if col >= self.lines[line].len() {
             self.lines[line].resize(col + 1, StyledChar::SPACE);
@@ -81,7 +81,7 @@ impl StyledBuffer {
     /// Sets `string` with `style` for given `line`, starting from `col`.
     /// If `line` does not exist in our buffer, adds empty lines up to the given
     /// and fills the last line with unstyled whitespace.
-    pub fn puts(&mut self, line: usize, col: usize, string: &str, style: Style) {
+    pub(crate) fn puts(&mut self, line: usize, col: usize, string: &str, style: Style) {
         let mut n = col;
         for c in string.chars() {
             self.putc(line, n, c, style);
@@ -91,7 +91,7 @@ impl StyledBuffer {
 
     /// For given `line` inserts `string` with `style` before old content of that line,
     /// adding lines if needed
-    pub fn prepend(&mut self, line: usize, string: &str, style: Style) {
+    pub(crate) fn prepend(&mut self, line: usize, string: &str, style: Style) {
         self.ensure_lines(line);
         let string_len = string.chars().count();
 
@@ -107,7 +107,7 @@ impl StyledBuffer {
 
     /// For given `line` inserts `string` with `style` after old content of that line,
     /// adding lines if needed
-    pub fn append(&mut self, line: usize, string: &str, style: Style) {
+    pub(crate) fn append(&mut self, line: usize, string: &str, style: Style) {
         if line >= self.lines.len() {
             self.puts(line, 0, string, style);
         } else {
@@ -116,14 +116,14 @@ impl StyledBuffer {
         }
     }
 
-    pub fn num_lines(&self) -> usize {
+    pub(crate) fn num_lines(&self) -> usize {
         self.lines.len()
     }
 
     /// Set `style` for `line`, `col_start..col_end` range if:
     /// 1. That line and column range exist in `StyledBuffer`
     /// 2. `overwrite` is `true` or existing style is `Style::NoStyle` or `Style::Quotation`
-    pub fn set_style_range(
+    pub(crate) fn set_style_range(
         &mut self,
         line: usize,
         col_start: usize,
@@ -139,7 +139,7 @@ impl StyledBuffer {
     /// Set `style` for `line`, `col` if:
     /// 1. That line and column exist in `StyledBuffer`
     /// 2. `overwrite` is `true` or existing style is `Style::NoStyle` or `Style::Quotation`
-    pub fn set_style(&mut self, line: usize, col: usize, style: Style, overwrite: bool) {
+    fn set_style(&mut self, line: usize, col: usize, style: Style, overwrite: bool) {
         if let Some(ref mut line) = self.lines.get_mut(line) {
             if let Some(StyledChar { style: s, .. }) = line.get_mut(col) {
                 if overwrite || matches!(s, Style::NoStyle | Style::Quotation) {

From df5fbf05a15a391192c40680af968733524d99d0 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 12:40:38 +1000
Subject: [PATCH 633/685] Add `warn(unreachable_pub)` to `rustc_expand`.

Plus a tiny bit of reformatting.
---
 compiler/rustc_expand/src/errors.rs            | 14 +++++++-------
 compiler/rustc_expand/src/lib.rs               |  1 +
 compiler/rustc_expand/src/mbe/diagnostics.rs   |  7 ++++---
 compiler/rustc_expand/src/mbe/macro_parser.rs  |  2 +-
 compiler/rustc_expand/src/mbe/quoted.rs        | 11 +++++------
 compiler/rustc_expand/src/placeholders.rs      |  4 ++--
 compiler/rustc_expand/src/proc_macro_server.rs |  4 ++--
 7 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/compiler/rustc_expand/src/errors.rs b/compiler/rustc_expand/src/errors.rs
index f6b5cd394b620..0fdccb0891899 100644
--- a/compiler/rustc_expand/src/errors.rs
+++ b/compiler/rustc_expand/src/errors.rs
@@ -350,7 +350,7 @@ pub(crate) struct ModuleMultipleCandidates {
 
 #[derive(Diagnostic)]
 #[diag(expand_trace_macro)]
-pub struct TraceMacro {
+pub(crate) struct TraceMacro {
     #[primary_span]
     pub span: Span,
 }
@@ -402,14 +402,14 @@ pub(crate) struct CustomAttributePanickedHelp {
 
 #[derive(Diagnostic)]
 #[diag(expand_proc_macro_derive_tokens)]
-pub struct ProcMacroDeriveTokens {
+pub(crate) struct ProcMacroDeriveTokens {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(expand_duplicate_matcher_binding)]
-pub struct DuplicateMatcherBinding {
+pub(crate) struct DuplicateMatcherBinding {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -421,7 +421,7 @@ pub struct DuplicateMatcherBinding {
 #[diag(expand_missing_fragment_specifier)]
 #[note]
 #[help(expand_valid)]
-pub struct MissingFragmentSpecifier {
+pub(crate) struct MissingFragmentSpecifier {
     #[primary_span]
     pub span: Span,
     #[suggestion(
@@ -437,7 +437,7 @@ pub struct MissingFragmentSpecifier {
 #[derive(Diagnostic)]
 #[diag(expand_invalid_fragment_specifier)]
 #[help]
-pub struct InvalidFragmentSpecifier {
+pub(crate) struct InvalidFragmentSpecifier {
     #[primary_span]
     pub span: Span,
     pub fragment: Ident,
@@ -446,7 +446,7 @@ pub struct InvalidFragmentSpecifier {
 
 #[derive(Diagnostic)]
 #[diag(expand_expected_paren_or_brace)]
-pub struct ExpectedParenOrBrace<'a> {
+pub(crate) struct ExpectedParenOrBrace<'a> {
     #[primary_span]
     pub span: Span,
     pub token: Cow<'a, str>,
@@ -479,7 +479,7 @@ pub(crate) struct GlobDelegationTraitlessQpath {
 #[derive(Diagnostic)]
 #[diag(expand_proc_macro_back_compat)]
 #[note]
-pub struct ProcMacroBackCompat {
+pub(crate) struct ProcMacroBackCompat {
     pub crate_name: String,
     pub fixed_version: String,
 }
diff --git a/compiler/rustc_expand/src/lib.rs b/compiler/rustc_expand/src/lib.rs
index 4222c9fe90616..777044e3f33bf 100644
--- a/compiler/rustc_expand/src/lib.rs
+++ b/compiler/rustc_expand/src/lib.rs
@@ -13,6 +13,7 @@
 #![feature(rustdoc_internals)]
 #![feature(try_blocks)]
 #![feature(yeet_expr)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 extern crate proc_macro as pm;
diff --git a/compiler/rustc_expand/src/mbe/diagnostics.rs b/compiler/rustc_expand/src/mbe/diagnostics.rs
index 628c6bfeb7932..5778f6616227a 100644
--- a/compiler/rustc_expand/src/mbe/diagnostics.rs
+++ b/compiler/rustc_expand/src/mbe/diagnostics.rs
@@ -196,13 +196,14 @@ impl<'dcx> CollectTrackerAndEmitter<'dcx, '_> {
     }
 }
 
-/// Currently used by macro_rules! compilation to extract a little information from the `Failure` case.
-pub struct FailureForwarder<'matcher> {
+/// Currently used by macro_rules! compilation to extract a little information from the `Failure`
+/// case.
+pub(crate) struct FailureForwarder<'matcher> {
     expected_token: Option<&'matcher Token>,
 }
 
 impl<'matcher> FailureForwarder<'matcher> {
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self { expected_token: None }
     }
 }
diff --git a/compiler/rustc_expand/src/mbe/macro_parser.rs b/compiler/rustc_expand/src/mbe/macro_parser.rs
index e5b9c62742967..9011d02da3358 100644
--- a/compiler/rustc_expand/src/mbe/macro_parser.rs
+++ b/compiler/rustc_expand/src/mbe/macro_parser.rs
@@ -407,7 +407,7 @@ fn token_name_eq(t1: &Token, t2: &Token) -> bool {
 
 // Note: the vectors could be created and dropped within `parse_tt`, but to avoid excess
 // allocations we have a single vector for each kind that is cleared and reused repeatedly.
-pub struct TtParser {
+pub(crate) struct TtParser {
     macro_name: Ident,
 
     /// The set of current mps to be processed. This should be empty by the end of a successful
diff --git a/compiler/rustc_expand/src/mbe/quoted.rs b/compiler/rustc_expand/src/mbe/quoted.rs
index b2f7c8f5183a2..5df0aebfe57bd 100644
--- a/compiler/rustc_expand/src/mbe/quoted.rs
+++ b/compiler/rustc_expand/src/mbe/quoted.rs
@@ -14,12 +14,11 @@ use crate::mbe::macro_parser::count_metavar_decls;
 use crate::mbe::{Delimited, KleeneOp, KleeneToken, MetaVarExpr, SequenceRepetition, TokenTree};
 
 const VALID_FRAGMENT_NAMES_MSG: &str = "valid fragment specifiers are \
-                                        `ident`, `block`, `stmt`, `expr`, `pat`, `ty`, `lifetime`, \
-                                        `literal`, `path`, `meta`, `tt`, `item` and `vis`";
-pub const VALID_FRAGMENT_NAMES_MSG_2021: &str = "valid fragment specifiers are \
-                                             `ident`, `block`, `stmt`, `expr`, `expr_2021`, `pat`, \
-                                             `ty`, `lifetime`, `literal`, `path`, `meta`, `tt`, \
-                                             `item` and `vis`";
+    `ident`, `block`, `stmt`, `expr`, `pat`, `ty`, `lifetime`, `literal`, `path`, `meta`, `tt`, \
+    `item` and `vis`";
+pub(crate) const VALID_FRAGMENT_NAMES_MSG_2021: &str = "valid fragment specifiers are \
+    `ident`, `block`, `stmt`, `expr`, `expr_2021`, `pat`, `ty`, `lifetime`, `literal`, `path`, \
+    `meta`, `tt`, `item` and `vis`";
 
 /// Takes a `tokenstream::TokenStream` and returns a `Vec<self::TokenTree>`. Specifically, this
 /// takes a generic `TokenStream`, such as is used in the rest of the compiler, and returns a
diff --git a/compiler/rustc_expand/src/placeholders.rs b/compiler/rustc_expand/src/placeholders.rs
index 1e455d465e4d1..469bed3cd5926 100644
--- a/compiler/rustc_expand/src/placeholders.rs
+++ b/compiler/rustc_expand/src/placeholders.rs
@@ -191,12 +191,12 @@ pub(crate) fn placeholder(
 }
 
 #[derive(Default)]
-pub struct PlaceholderExpander {
+pub(crate) struct PlaceholderExpander {
     expanded_fragments: FxHashMap<ast::NodeId, AstFragment>,
 }
 
 impl PlaceholderExpander {
-    pub fn add(&mut self, id: ast::NodeId, mut fragment: AstFragment) {
+    pub(crate) fn add(&mut self, id: ast::NodeId, mut fragment: AstFragment) {
         fragment.mut_visit_with(self);
         self.expanded_fragments.insert(id, fragment);
     }
diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index 1438d1ad11f57..4ff5da1a4bdfa 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -414,7 +414,7 @@ impl ToInternal<rustc_errors::Level> for Level {
     }
 }
 
-pub struct FreeFunctions;
+pub(crate) struct FreeFunctions;
 
 pub(crate) struct Rustc<'a, 'b> {
     ecx: &'a mut ExtCtxt<'b>,
@@ -426,7 +426,7 @@ pub(crate) struct Rustc<'a, 'b> {
 }
 
 impl<'a, 'b> Rustc<'a, 'b> {
-    pub fn new(ecx: &'a mut ExtCtxt<'b>) -> Self {
+    pub(crate) fn new(ecx: &'a mut ExtCtxt<'b>) -> Self {
         let expn_data = ecx.current_expansion.id.expn_data();
         Rustc {
             def_site: ecx.with_def_site_ctxt(expn_data.def_site),

From 0d8d05c07f8be4c90adf27141c0f64f76c318f64 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 12:55:54 +1000
Subject: [PATCH 634/685] Add `warn(unreachable_pub)` to `rustc_feature`.

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

diff --git a/compiler/rustc_feature/src/lib.rs b/compiler/rustc_feature/src/lib.rs
index dcc1c3202ea28..adaaba3cd235e 100644
--- a/compiler/rustc_feature/src/lib.rs
+++ b/compiler/rustc_feature/src/lib.rs
@@ -15,6 +15,7 @@
 #![allow(internal_features)]
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 mod accepted;

From a510813e03966582ca9f1a06cb62e1d009ed0278 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 12:56:54 +1000
Subject: [PATCH 635/685] Add `warn(unreachable_pub)` to `rustc_fluent_macro`.

---
 compiler/rustc_fluent_macro/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_fluent_macro/src/lib.rs b/compiler/rustc_fluent_macro/src/lib.rs
index 0a04e6743a8b8..6e5add24bcc4f 100644
--- a/compiler/rustc_fluent_macro/src/lib.rs
+++ b/compiler/rustc_fluent_macro/src/lib.rs
@@ -6,6 +6,7 @@
 #![feature(proc_macro_diagnostic)]
 #![feature(proc_macro_span)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 use proc_macro::TokenStream;

From fa1814099426482e08a5a9900017858a525e9304 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 12:58:29 +1000
Subject: [PATCH 636/685] Add `warn(unreachable_pub)` to `rustc_graphviz`.

---
 compiler/rustc_graphviz/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_graphviz/src/lib.rs b/compiler/rustc_graphviz/src/lib.rs
index c8f8fd5be0237..b5774f64b66b2 100644
--- a/compiler/rustc_graphviz/src/lib.rs
+++ b/compiler/rustc_graphviz/src/lib.rs
@@ -277,6 +277,7 @@
 )]
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 use std::borrow::Cow;

From bffa2244edd9cc210c7cd267fbacb77935cceaa6 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 12:59:20 +1000
Subject: [PATCH 637/685] Add `warn(unreachable_pub)` to `rustc_hir`.

---
 compiler/rustc_hir/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_hir/src/lib.rs b/compiler/rustc_hir/src/lib.rs
index e517c3fd07a1d..c1a4a4497c7a9 100644
--- a/compiler/rustc_hir/src/lib.rs
+++ b/compiler/rustc_hir/src/lib.rs
@@ -10,6 +10,7 @@
 #![feature(never_type)]
 #![feature(rustc_attrs)]
 #![feature(variant_count)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 extern crate self as rustc_hir;

From 5acf4e7b4b257993aee8a71f958dac2ba4ce38c7 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 13:14:50 +1000
Subject: [PATCH 638/685] Add `warn(unreachable_pub)` to `rustc_hir_analysis`.

---
 compiler/rustc_hir_analysis/src/bounds.rs     |  14 +-
 .../rustc_hir_analysis/src/check/check.rs     |   2 +-
 compiler/rustc_hir_analysis/src/check/errs.rs |   4 +-
 .../rustc_hir_analysis/src/check/region.rs    |   4 +-
 .../rustc_hir_analysis/src/check_unused.rs    |   2 +-
 .../src/coherence/builtin.rs                  |   2 +-
 .../src/coherence/inherent_impls.rs           |   9 +-
 .../src/coherence/inherent_impls_overlap.rs   |   5 +-
 .../rustc_hir_analysis/src/coherence/mod.rs   |   2 +-
 .../src/collect/resolve_bound_vars.rs         |   2 +-
 .../rustc_hir_analysis/src/collect/type_of.rs |   2 +-
 .../src/constrained_generic_params.rs         |  10 +-
 compiler/rustc_hir_analysis/src/errors.rs     | 180 +++++++++---------
 .../src/errors/pattern_types.rs               |   2 +-
 .../src/errors/precise_captures.rs            |  14 +-
 .../errors/wrong_number_of_generic_args.rs    |   6 +-
 .../src/hir_ty_lowering/cmse.rs               |   2 +-
 .../rustc_hir_analysis/src/hir_wf_check.rs    |   2 +-
 .../rustc_hir_analysis/src/impl_wf_check.rs   |   5 +-
 compiler/rustc_hir_analysis/src/lib.rs        |   1 +
 .../src/outlives/explicit.rs                  |   4 +-
 .../rustc_hir_analysis/src/outlives/mod.rs    |   2 +-
 .../src/variance/constraints.rs               |   8 +-
 .../rustc_hir_analysis/src/variance/mod.rs    |   2 +-
 .../rustc_hir_analysis/src/variance/solve.rs  |   2 +-
 .../rustc_hir_analysis/src/variance/terms.rs  |  10 +-
 .../rustc_hir_analysis/src/variance/xform.rs  |   2 +-
 27 files changed, 155 insertions(+), 145 deletions(-)

diff --git a/compiler/rustc_hir_analysis/src/bounds.rs b/compiler/rustc_hir_analysis/src/bounds.rs
index c30a6f1eeb910..d0b0c08aa798b 100644
--- a/compiler/rustc_hir_analysis/src/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/bounds.rs
@@ -26,13 +26,13 @@ use rustc_span::Span;
 /// Our representation is a bit mixed here -- in some cases, we
 /// include the self type (e.g., `trait_bounds`) but in others we do not
 #[derive(Default, PartialEq, Eq, Clone, Debug)]
-pub struct Bounds<'tcx> {
+pub(crate) struct Bounds<'tcx> {
     clauses: Vec<(ty::Clause<'tcx>, Span)>,
     effects_min_tys: FxIndexMap<Ty<'tcx>, Span>,
 }
 
 impl<'tcx> Bounds<'tcx> {
-    pub fn push_region_bound(
+    pub(crate) fn push_region_bound(
         &mut self,
         tcx: TyCtxt<'tcx>,
         region: ty::PolyTypeOutlivesPredicate<'tcx>,
@@ -42,7 +42,7 @@ impl<'tcx> Bounds<'tcx> {
             .push((region.map_bound(|p| ty::ClauseKind::TypeOutlives(p)).upcast(tcx), span));
     }
 
-    pub fn push_trait_bound(
+    pub(crate) fn push_trait_bound(
         &mut self,
         tcx: TyCtxt<'tcx>,
         defining_def_id: DefId,
@@ -154,7 +154,7 @@ impl<'tcx> Bounds<'tcx> {
         self.clauses.push((bound_trait_ref.rebind(new_trait_ref).upcast(tcx), span));
     }
 
-    pub fn push_projection_bound(
+    pub(crate) fn push_projection_bound(
         &mut self,
         tcx: TyCtxt<'tcx>,
         projection: ty::PolyProjectionPredicate<'tcx>,
@@ -166,14 +166,14 @@ impl<'tcx> Bounds<'tcx> {
         ));
     }
 
-    pub fn push_sized(&mut self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) {
+    pub(crate) fn push_sized(&mut self, tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) {
         let sized_def_id = tcx.require_lang_item(LangItem::Sized, Some(span));
         let trait_ref = ty::TraitRef::new(tcx, sized_def_id, [ty]);
         // Preferable to put this obligation first, since we report better errors for sized ambiguity.
         self.clauses.insert(0, (trait_ref.upcast(tcx), span));
     }
 
-    pub fn clauses(
+    pub(crate) fn clauses(
         &self,
         // FIXME(effects): remove tcx
         _tcx: TyCtxt<'tcx>,
@@ -181,7 +181,7 @@ impl<'tcx> Bounds<'tcx> {
         self.clauses.iter().cloned()
     }
 
-    pub fn effects_min_tys(&self) -> impl Iterator<Item = Ty<'tcx>> + '_ {
+    pub(crate) fn effects_min_tys(&self) -> impl Iterator<Item = Ty<'tcx>> + '_ {
         self.effects_min_tys.keys().copied()
     }
 }
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 728c3790098e7..d414bcdb95b34 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -1053,7 +1053,7 @@ fn check_impl_items_against_trait<'tcx>(
     }
 }
 
-pub fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
+fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
     let t = tcx.type_of(def_id).instantiate_identity();
     if let ty::Adt(def, args) = t.kind()
         && def.is_struct()
diff --git a/compiler/rustc_hir_analysis/src/check/errs.rs b/compiler/rustc_hir_analysis/src/check/errs.rs
index 19a0476e63016..22d7d1fea9cb4 100644
--- a/compiler/rustc_hir_analysis/src/check/errs.rs
+++ b/compiler/rustc_hir_analysis/src/check/errs.rs
@@ -6,7 +6,7 @@ use rustc_span::Span;
 use crate::errors;
 
 /// Check for shared or mutable references of `static mut` inside expression
-pub fn maybe_expr_static_mut(tcx: TyCtxt<'_>, expr: hir::Expr<'_>) {
+pub(crate) fn maybe_expr_static_mut(tcx: TyCtxt<'_>, expr: hir::Expr<'_>) {
     let span = expr.span;
     let hir_id = expr.hir_id;
     if let hir::ExprKind::AddrOf(borrow_kind, m, expr) = expr.kind
@@ -26,7 +26,7 @@ pub fn maybe_expr_static_mut(tcx: TyCtxt<'_>, expr: hir::Expr<'_>) {
 }
 
 /// Check for shared or mutable references of `static mut` inside statement
-pub fn maybe_stmt_static_mut(tcx: TyCtxt<'_>, stmt: hir::Stmt<'_>) {
+pub(crate) fn maybe_stmt_static_mut(tcx: TyCtxt<'_>, stmt: hir::Stmt<'_>) {
     if let hir::StmtKind::Let(loc) = stmt.kind
         && let hir::PatKind::Binding(ba, _, _, _) = loc.pat.kind
         && let hir::ByRef::Yes(rmutbl) = ba.0
diff --git a/compiler/rustc_hir_analysis/src/check/region.rs b/compiler/rustc_hir_analysis/src/check/region.rs
index bc6641c688ccf..483351739792b 100644
--- a/compiler/rustc_hir_analysis/src/check/region.rs
+++ b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -22,7 +22,7 @@ use rustc_span::source_map;
 use super::errs::{maybe_expr_static_mut, maybe_stmt_static_mut};
 
 #[derive(Debug, Copy, Clone)]
-pub struct Context {
+struct Context {
     /// The scope that contains any new variables declared, plus its depth in
     /// the scope tree.
     var_parent: Option<(Scope, ScopeDepth)>,
@@ -893,7 +893,7 @@ impl<'tcx> Visitor<'tcx> for RegionResolutionVisitor<'tcx> {
 /// re-use in incremental scenarios. We may sometimes need to rerun the
 /// type checker even when the HIR hasn't changed, and in those cases
 /// we can avoid reconstructing the region scope tree.
-pub fn region_scope_tree(tcx: TyCtxt<'_>, def_id: DefId) -> &ScopeTree {
+pub(crate) fn region_scope_tree(tcx: TyCtxt<'_>, def_id: DefId) -> &ScopeTree {
     let typeck_root_def_id = tcx.typeck_root_def_id(def_id);
     if typeck_root_def_id != def_id {
         return tcx.region_scope_tree(typeck_root_def_id);
diff --git a/compiler/rustc_hir_analysis/src/check_unused.rs b/compiler/rustc_hir_analysis/src/check_unused.rs
index ed23dc2a827b4..ca9e2e8a3cc6a 100644
--- a/compiler/rustc_hir_analysis/src/check_unused.rs
+++ b/compiler/rustc_hir_analysis/src/check_unused.rs
@@ -5,7 +5,7 @@ use rustc_middle::query::Providers;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::lint;
 
-pub fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers { check_unused_traits, ..*providers };
 }
 
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index fecd78bc38f47..23f1adfe302e3 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -332,7 +332,7 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
     }
 }
 
-pub fn coerce_unsized_info<'tcx>(
+pub(crate) fn coerce_unsized_info<'tcx>(
     tcx: TyCtxt<'tcx>,
     impl_did: LocalDefId,
 ) -> Result<CoerceUnsizedInfo, ErrorGuaranteed> {
diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
index 89acb778d6c29..bd8b43e28e540 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
@@ -19,7 +19,7 @@ use rustc_span::ErrorGuaranteed;
 use crate::errors;
 
 /// On-demand query: yields a map containing all types mapped to their inherent impls.
-pub fn crate_inherent_impls(
+pub(crate) fn crate_inherent_impls(
     tcx: TyCtxt<'_>,
     (): (),
 ) -> Result<&'_ CrateInherentImpls, ErrorGuaranteed> {
@@ -32,7 +32,7 @@ pub fn crate_inherent_impls(
     Ok(tcx.arena.alloc(collect.impls_map))
 }
 
-pub fn crate_incoherent_impls(
+pub(crate) fn crate_incoherent_impls(
     tcx: TyCtxt<'_>,
     simp: SimplifiedType,
 ) -> Result<&[DefId], ErrorGuaranteed> {
@@ -43,7 +43,10 @@ pub fn crate_incoherent_impls(
 }
 
 /// On-demand query: yields a vector of the inherent impls for a specific type.
-pub fn inherent_impls(tcx: TyCtxt<'_>, ty_def_id: LocalDefId) -> Result<&[DefId], ErrorGuaranteed> {
+pub(crate) fn inherent_impls(
+    tcx: TyCtxt<'_>,
+    ty_def_id: LocalDefId,
+) -> Result<&[DefId], ErrorGuaranteed> {
     let crate_map = tcx.crate_inherent_impls(())?;
     Ok(match crate_map.inherent_impls.get(&ty_def_id) {
         Some(v) => &v[..],
diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs
index cd5cc33d65abc..00bbbf7130f83 100644
--- a/compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs
@@ -11,7 +11,10 @@ use rustc_span::{ErrorGuaranteed, Symbol};
 use rustc_trait_selection::traits::{self, SkipLeakCheck};
 use smallvec::SmallVec;
 
-pub fn crate_inherent_impls_overlap_check(tcx: TyCtxt<'_>, (): ()) -> Result<(), ErrorGuaranteed> {
+pub(crate) fn crate_inherent_impls_overlap_check(
+    tcx: TyCtxt<'_>,
+    (): (),
+) -> Result<(), ErrorGuaranteed> {
     let mut inherent_overlap_checker = InherentOverlapChecker { tcx };
     let mut res = Ok(());
     for id in tcx.hir().items() {
diff --git a/compiler/rustc_hir_analysis/src/coherence/mod.rs b/compiler/rustc_hir_analysis/src/coherence/mod.rs
index 8e4da90ca2646..3d800bb165cb4 100644
--- a/compiler/rustc_hir_analysis/src/coherence/mod.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/mod.rs
@@ -123,7 +123,7 @@ fn enforce_empty_impls_for_marker_traits(
     .emit())
 }
 
-pub fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers) {
     use self::builtin::coerce_unsized_info;
     use self::inherent_impls::{crate_incoherent_impls, crate_inherent_impls, inherent_impls};
     use self::inherent_impls_overlap::crate_inherent_impls_overlap_check;
diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
index 0cf9e128bceef..e38492d9e6497 100644
--- a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
+++ b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -2071,7 +2071,7 @@ fn is_late_bound_map(
     }
 }
 
-pub fn deny_non_region_late_bound(
+fn deny_non_region_late_bound(
     tcx: TyCtxt<'_>,
     bound_vars: &mut FxIndexMap<LocalDefId, ResolvedArg>,
     where_: &str,
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index 8cb4ba6c6691d..96256b91b9f9d 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -725,7 +725,7 @@ fn check_feature_inherent_assoc_ty(tcx: TyCtxt<'_>, span: Span) {
     }
 }
 
-pub fn type_alias_is_lazy<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> bool {
+pub(crate) fn type_alias_is_lazy<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> bool {
     use hir::intravisit::Visitor;
     if tcx.features().lazy_type_alias {
         return true;
diff --git a/compiler/rustc_hir_analysis/src/constrained_generic_params.rs b/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
index 620170164f535..edf6524566418 100644
--- a/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
+++ b/compiler/rustc_hir_analysis/src/constrained_generic_params.rs
@@ -6,7 +6,7 @@ use rustc_span::Span;
 use rustc_type_ir::fold::TypeFoldable;
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
-pub struct Parameter(pub u32);
+pub(crate) struct Parameter(pub u32);
 
 impl From<ty::ParamTy> for Parameter {
     fn from(param: ty::ParamTy) -> Self {
@@ -27,7 +27,7 @@ impl From<ty::ParamConst> for Parameter {
 }
 
 /// Returns the set of parameters constrained by the impl header.
-pub fn parameters_for_impl<'tcx>(
+pub(crate) fn parameters_for_impl<'tcx>(
     tcx: TyCtxt<'tcx>,
     impl_self_ty: Ty<'tcx>,
     impl_trait_ref: Option<ty::TraitRef<'tcx>>,
@@ -44,7 +44,7 @@ pub fn parameters_for_impl<'tcx>(
 /// uniquely determined by `value` (see RFC 447). If it is true, return the list
 /// of parameters whose values are needed in order to constrain `value` - these
 /// differ, with the latter being a superset, in the presence of projections.
-pub fn parameters_for<'tcx>(
+pub(crate) fn parameters_for<'tcx>(
     tcx: TyCtxt<'tcx>,
     value: impl TypeFoldable<TyCtxt<'tcx>>,
     include_nonconstraining: bool,
@@ -102,7 +102,7 @@ impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ParameterCollector {
     }
 }
 
-pub fn identify_constrained_generic_params<'tcx>(
+pub(crate) fn identify_constrained_generic_params<'tcx>(
     tcx: TyCtxt<'tcx>,
     predicates: ty::GenericPredicates<'tcx>,
     impl_trait_ref: Option<ty::TraitRef<'tcx>>,
@@ -156,7 +156,7 @@ pub fn identify_constrained_generic_params<'tcx>(
 /// which is determined by 1, which requires `U`, that is determined
 /// by 0. I should probably pick a less tangled example, but I can't
 /// think of any.
-pub fn setup_constraining_predicates<'tcx>(
+pub(crate) fn setup_constraining_predicates<'tcx>(
     tcx: TyCtxt<'tcx>,
     predicates: &mut [(ty::Clause<'tcx>, Span)],
     impl_trait_ref: Option<ty::TraitRef<'tcx>>,
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index 821f79505f0b4..39df18ff658cd 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -11,15 +11,15 @@ use rustc_span::{Span, Symbol};
 
 use crate::fluent_generated as fluent;
 mod pattern_types;
-pub use pattern_types::*;
-pub mod wrong_number_of_generic_args;
+pub(crate) use pattern_types::*;
+pub(crate) mod wrong_number_of_generic_args;
 
 mod precise_captures;
 pub(crate) use precise_captures::*;
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_ambiguous_assoc_item)]
-pub struct AmbiguousAssocItem<'a> {
+pub(crate) struct AmbiguousAssocItem<'a> {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -30,7 +30,7 @@ pub struct AmbiguousAssocItem<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_assoc_kind_mismatch)]
-pub struct AssocKindMismatch {
+pub(crate) struct AssocKindMismatch {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -52,7 +52,7 @@ pub struct AssocKindMismatch {
     hir_analysis_assoc_kind_mismatch_wrap_in_braces_sugg,
     applicability = "maybe-incorrect"
 )]
-pub struct AssocKindMismatchWrapInBracesSugg {
+pub(crate) struct AssocKindMismatchWrapInBracesSugg {
     #[suggestion_part(code = "{{ ")]
     pub lo: Span,
     #[suggestion_part(code = " }}")]
@@ -61,7 +61,7 @@ pub struct AssocKindMismatchWrapInBracesSugg {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_assoc_item_is_private, code = E0624)]
-pub struct AssocItemIsPrivate {
+pub(crate) struct AssocItemIsPrivate {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -73,7 +73,7 @@ pub struct AssocItemIsPrivate {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_assoc_item_not_found, code = E0220)]
-pub struct AssocItemNotFound<'a> {
+pub(crate) struct AssocItemNotFound<'a> {
     #[primary_span]
     pub span: Span,
     pub assoc_name: Ident,
@@ -86,7 +86,7 @@ pub struct AssocItemNotFound<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum AssocItemNotFoundLabel<'a> {
+pub(crate) enum AssocItemNotFoundLabel<'a> {
     #[label(hir_analysis_assoc_item_not_found_label)]
     NotFound {
         #[primary_span]
@@ -105,7 +105,7 @@ pub enum AssocItemNotFoundLabel<'a> {
 
 #[derive(Subdiagnostic)]
 
-pub enum AssocItemNotFoundSugg<'a> {
+pub(crate) enum AssocItemNotFoundSugg<'a> {
     #[suggestion(
         hir_analysis_assoc_item_not_found_similar_sugg,
         code = "{suggested_name}",
@@ -162,7 +162,7 @@ pub enum AssocItemNotFoundSugg<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_unrecognized_atomic_operation, code = E0092)]
-pub struct UnrecognizedAtomicOperation<'a> {
+pub(crate) struct UnrecognizedAtomicOperation<'a> {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -171,7 +171,7 @@ pub struct UnrecognizedAtomicOperation<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_wrong_number_of_generic_arguments_to_intrinsic, code = E0094)]
-pub struct WrongNumberOfGenericArgumentsToIntrinsic<'a> {
+pub(crate) struct WrongNumberOfGenericArgumentsToIntrinsic<'a> {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -183,7 +183,7 @@ pub struct WrongNumberOfGenericArgumentsToIntrinsic<'a> {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_unrecognized_intrinsic_function, code = E0093)]
 #[help]
-pub struct UnrecognizedIntrinsicFunction {
+pub(crate) struct UnrecognizedIntrinsicFunction {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -192,7 +192,7 @@ pub struct UnrecognizedIntrinsicFunction {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_lifetimes_or_bounds_mismatch_on_trait, code = E0195)]
-pub struct LifetimesOrBoundsMismatchOnTrait {
+pub(crate) struct LifetimesOrBoundsMismatchOnTrait {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -208,14 +208,14 @@ pub struct LifetimesOrBoundsMismatchOnTrait {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_drop_impl_on_wrong_item, code = E0120)]
-pub struct DropImplOnWrongItem {
+pub(crate) struct DropImplOnWrongItem {
     #[primary_span]
     #[label]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
-pub enum FieldAlreadyDeclared {
+pub(crate) enum FieldAlreadyDeclared {
     #[diag(hir_analysis_field_already_declared, code = E0124)]
     NotNested {
         field_name: Symbol,
@@ -272,14 +272,14 @@ pub enum FieldAlreadyDeclared {
 
 #[derive(Subdiagnostic)]
 #[help(hir_analysis_field_already_declared_nested_help)]
-pub struct FieldAlreadyDeclaredNestedHelp {
+pub(crate) struct FieldAlreadyDeclaredNestedHelp {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_copy_impl_on_type_with_dtor, code = E0184)]
-pub struct CopyImplOnTypeWithDtor {
+pub(crate) struct CopyImplOnTypeWithDtor {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -287,14 +287,14 @@ pub struct CopyImplOnTypeWithDtor {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_multiple_relaxed_default_bounds, code = E0203)]
-pub struct MultipleRelaxedDefaultBounds {
+pub(crate) struct MultipleRelaxedDefaultBounds {
     #[primary_span]
     pub spans: Vec<Span>,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_copy_impl_on_non_adt, code = E0206)]
-pub struct CopyImplOnNonAdt {
+pub(crate) struct CopyImplOnNonAdt {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -302,7 +302,7 @@ pub struct CopyImplOnNonAdt {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_const_param_ty_impl_on_unsized)]
-pub struct ConstParamTyImplOnUnsized {
+pub(crate) struct ConstParamTyImplOnUnsized {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -310,7 +310,7 @@ pub struct ConstParamTyImplOnUnsized {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_const_param_ty_impl_on_non_adt)]
-pub struct ConstParamTyImplOnNonAdt {
+pub(crate) struct ConstParamTyImplOnNonAdt {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -318,7 +318,7 @@ pub struct ConstParamTyImplOnNonAdt {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_trait_object_declared_with_no_traits, code = E0224)]
-pub struct TraitObjectDeclaredWithNoTraits {
+pub(crate) struct TraitObjectDeclaredWithNoTraits {
     #[primary_span]
     pub span: Span,
     #[label(hir_analysis_alias_span)]
@@ -327,14 +327,14 @@ pub struct TraitObjectDeclaredWithNoTraits {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_ambiguous_lifetime_bound, code = E0227)]
-pub struct AmbiguousLifetimeBound {
+pub(crate) struct AmbiguousLifetimeBound {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_assoc_item_constraints_not_allowed_here, code = E0229)]
-pub struct AssocItemConstraintsNotAllowedHere {
+pub(crate) struct AssocItemConstraintsNotAllowedHere {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -383,7 +383,7 @@ pub(crate) struct EscapingBoundVarInTyOfAssocConstBinding<'tcx> {
 
 #[derive(Subdiagnostic)]
 #[help(hir_analysis_parenthesized_fn_trait_expansion)]
-pub struct ParenthesizedFnTraitExpansion {
+pub(crate) struct ParenthesizedFnTraitExpansion {
     #[primary_span]
     pub span: Span,
 
@@ -392,7 +392,7 @@ pub struct ParenthesizedFnTraitExpansion {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_typeof_reserved_keyword_used, code = E0516)]
-pub struct TypeofReservedKeywordUsed<'tcx> {
+pub(crate) struct TypeofReservedKeywordUsed<'tcx> {
     pub ty: Ty<'tcx>,
     #[primary_span]
     #[label]
@@ -403,7 +403,7 @@ pub struct TypeofReservedKeywordUsed<'tcx> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_value_of_associated_struct_already_specified, code = E0719)]
-pub struct ValueOfAssociatedStructAlreadySpecified {
+pub(crate) struct ValueOfAssociatedStructAlreadySpecified {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -416,7 +416,7 @@ pub struct ValueOfAssociatedStructAlreadySpecified {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_unconstrained_opaque_type)]
 #[note]
-pub struct UnconstrainedOpaqueType {
+pub(crate) struct UnconstrainedOpaqueType {
     #[primary_span]
     pub span: Span,
     pub name: Symbol,
@@ -426,7 +426,7 @@ pub struct UnconstrainedOpaqueType {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_tait_forward_compat)]
 #[note]
-pub struct TaitForwardCompat {
+pub(crate) struct TaitForwardCompat {
     #[primary_span]
     pub span: Span,
     #[note]
@@ -436,7 +436,7 @@ pub struct TaitForwardCompat {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_tait_forward_compat2)]
 #[note]
-pub struct TaitForwardCompat2 {
+pub(crate) struct TaitForwardCompat2 {
     #[primary_span]
     pub span: Span,
     #[note(hir_analysis_opaque)]
@@ -444,7 +444,7 @@ pub struct TaitForwardCompat2 {
     pub opaque_type: String,
 }
 
-pub struct MissingTypeParams {
+pub(crate) struct MissingTypeParams {
     pub span: Span,
     pub def_span: Span,
     pub span_snippet: Option<String>,
@@ -512,7 +512,7 @@ impl<'a, G: EmissionGuarantee> Diagnostic<'a, G> for MissingTypeParams {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_manual_implementation, code = E0183)]
 #[help]
-pub struct ManualImplementation {
+pub(crate) struct ManualImplementation {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -521,14 +521,14 @@ pub struct ManualImplementation {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_generic_args_on_overridden_impl)]
-pub struct GenericArgsOnOverriddenImpl {
+pub(crate) struct GenericArgsOnOverriddenImpl {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_const_impl_for_non_const_trait)]
-pub struct ConstImplForNonConstTrait {
+pub(crate) struct ConstImplForNonConstTrait {
     #[primary_span]
     pub trait_ref_span: Span,
     pub trait_name: String,
@@ -542,7 +542,7 @@ pub struct ConstImplForNonConstTrait {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_const_bound_for_non_const_trait)]
-pub struct ConstBoundForNonConstTrait {
+pub(crate) struct ConstBoundForNonConstTrait {
     #[primary_span]
     pub span: Span,
     pub modifier: &'static str,
@@ -550,7 +550,7 @@ pub struct ConstBoundForNonConstTrait {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_self_in_impl_self)]
-pub struct SelfInImplSelf {
+pub(crate) struct SelfInImplSelf {
     #[primary_span]
     pub span: MultiSpan,
     #[note]
@@ -567,7 +567,7 @@ pub(crate) struct LinkageType {
 #[derive(Diagnostic)]
 #[help]
 #[diag(hir_analysis_auto_deref_reached_recursion_limit, code = E0055)]
-pub struct AutoDerefReachedRecursionLimit<'a> {
+pub(crate) struct AutoDerefReachedRecursionLimit<'a> {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -736,7 +736,7 @@ pub(crate) struct InvalidUnionField {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_invalid_unnamed_field_ty)]
-pub struct InvalidUnnamedFieldTy {
+pub(crate) struct InvalidUnnamedFieldTy {
     #[primary_span]
     pub span: Span,
 }
@@ -894,7 +894,7 @@ pub(crate) struct SIMDFFIHighlyExperimental {
 }
 
 #[derive(Diagnostic)]
-pub enum ImplNotMarkedDefault {
+pub(crate) enum ImplNotMarkedDefault {
     #[diag(hir_analysis_impl_not_marked_default, code = E0520)]
     #[note]
     Ok {
@@ -1137,7 +1137,7 @@ pub(crate) enum LateBoundInApit {
 #[derive(LintDiagnostic)]
 #[diag(hir_analysis_unused_associated_type_bounds)]
 #[note]
-pub struct UnusedAssociatedTypeBounds {
+pub(crate) struct UnusedAssociatedTypeBounds {
     #[suggestion(code = "")]
     pub span: Span,
 }
@@ -1162,7 +1162,7 @@ pub(crate) struct ReturnPositionImplTraitInTraitRefined<'tcx> {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_inherent_ty_outside, code = E0390)]
 #[help]
-pub struct InherentTyOutside {
+pub(crate) struct InherentTyOutside {
     #[primary_span]
     #[help(hir_analysis_span_help)]
     pub span: Span,
@@ -1170,7 +1170,7 @@ pub struct InherentTyOutside {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_coerce_unsized_may, code = E0378)]
-pub struct DispatchFromDynCoercion<'a> {
+pub(crate) struct DispatchFromDynCoercion<'a> {
     #[primary_span]
     pub span: Span,
     pub trait_name: &'a str,
@@ -1182,7 +1182,7 @@ pub struct DispatchFromDynCoercion<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_dispatch_from_dyn_repr, code = E0378)]
-pub struct DispatchFromDynRepr {
+pub(crate) struct DispatchFromDynRepr {
     #[primary_span]
     pub span: Span,
 }
@@ -1190,7 +1190,7 @@ pub struct DispatchFromDynRepr {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_inherent_ty_outside_relevant, code = E0390)]
 #[help]
-pub struct InherentTyOutsideRelevant {
+pub(crate) struct InherentTyOutsideRelevant {
     #[primary_span]
     pub span: Span,
     #[help(hir_analysis_span_help)]
@@ -1200,7 +1200,7 @@ pub struct InherentTyOutsideRelevant {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_inherent_ty_outside_new, code = E0116)]
 #[note]
-pub struct InherentTyOutsideNew {
+pub(crate) struct InherentTyOutsideNew {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1209,7 +1209,7 @@ pub struct InherentTyOutsideNew {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_inherent_ty_outside_primitive, code = E0390)]
 #[help]
-pub struct InherentTyOutsidePrimitive {
+pub(crate) struct InherentTyOutsidePrimitive {
     #[primary_span]
     pub span: Span,
     #[help(hir_analysis_span_help)]
@@ -1219,7 +1219,7 @@ pub struct InherentTyOutsidePrimitive {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_inherent_primitive_ty, code = E0390)]
 #[help]
-pub struct InherentPrimitiveTy<'a> {
+pub(crate) struct InherentPrimitiveTy<'a> {
     #[primary_span]
     pub span: Span,
     #[subdiagnostic]
@@ -1228,14 +1228,14 @@ pub struct InherentPrimitiveTy<'a> {
 
 #[derive(Subdiagnostic)]
 #[note(hir_analysis_inherent_primitive_ty_note)]
-pub struct InherentPrimitiveTyNote<'a> {
+pub(crate) struct InherentPrimitiveTyNote<'a> {
     pub subty: Ty<'a>,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_inherent_dyn, code = E0785)]
 #[note]
-pub struct InherentDyn {
+pub(crate) struct InherentDyn {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1244,7 +1244,7 @@ pub struct InherentDyn {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_inherent_nominal, code = E0118)]
 #[note]
-pub struct InherentNominal {
+pub(crate) struct InherentNominal {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1253,7 +1253,7 @@ pub struct InherentNominal {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_dispatch_from_dyn_zst, code = E0378)]
 #[note]
-pub struct DispatchFromDynZST<'a> {
+pub(crate) struct DispatchFromDynZST<'a> {
     #[primary_span]
     pub span: Span,
     pub name: Symbol,
@@ -1262,7 +1262,7 @@ pub struct DispatchFromDynZST<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_coerce_unsized_may, code = E0378)]
-pub struct DispatchFromDynSingle<'a> {
+pub(crate) struct DispatchFromDynSingle<'a> {
     #[primary_span]
     pub span: Span,
     pub trait_name: &'a str,
@@ -1273,7 +1273,7 @@ pub struct DispatchFromDynSingle<'a> {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_dispatch_from_dyn_multi, code = E0378)]
 #[note]
-pub struct DispatchFromDynMulti {
+pub(crate) struct DispatchFromDynMulti {
     #[primary_span]
     pub span: Span,
     #[note(hir_analysis_coercions_note)]
@@ -1284,7 +1284,7 @@ pub struct DispatchFromDynMulti {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_coerce_unsized_may, code = E0376)]
-pub struct DispatchFromDynStruct<'a> {
+pub(crate) struct DispatchFromDynStruct<'a> {
     #[primary_span]
     pub span: Span,
     pub trait_name: &'a str,
@@ -1292,7 +1292,7 @@ pub struct DispatchFromDynStruct<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_coerce_unsized_may, code = E0377)]
-pub struct DispatchFromDynSame<'a> {
+pub(crate) struct DispatchFromDynSame<'a> {
     #[primary_span]
     pub span: Span,
     pub trait_name: &'a str,
@@ -1304,7 +1304,7 @@ pub struct DispatchFromDynSame<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_coerce_unsized_may, code = E0374)]
-pub struct CoerceUnsizedOneField<'a> {
+pub(crate) struct CoerceUnsizedOneField<'a> {
     #[primary_span]
     pub span: Span,
     pub trait_name: &'a str,
@@ -1315,7 +1315,7 @@ pub struct CoerceUnsizedOneField<'a> {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_coerce_unsized_multi, code = E0375)]
 #[note]
-pub struct CoerceUnsizedMulti {
+pub(crate) struct CoerceUnsizedMulti {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1327,7 +1327,7 @@ pub struct CoerceUnsizedMulti {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_coerce_unsized_may, code = E0378)]
-pub struct CoerceUnsizedMay<'a> {
+pub(crate) struct CoerceUnsizedMay<'a> {
     #[primary_span]
     pub span: Span,
     pub trait_name: &'a str,
@@ -1335,7 +1335,7 @@ pub struct CoerceUnsizedMay<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_trait_cannot_impl_for_ty, code = E0204)]
-pub struct TraitCannotImplForTy {
+pub(crate) struct TraitCannotImplForTy {
     #[primary_span]
     pub span: Span,
     pub trait_name: String,
@@ -1347,7 +1347,7 @@ pub struct TraitCannotImplForTy {
 
 #[derive(Subdiagnostic)]
 #[note(hir_analysis_requires_note)]
-pub struct ImplForTyRequires {
+pub(crate) struct ImplForTyRequires {
     #[primary_span]
     pub span: MultiSpan,
     pub error_predicate: String,
@@ -1358,7 +1358,7 @@ pub struct ImplForTyRequires {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_traits_with_defualt_impl, code = E0321)]
 #[note]
-pub struct TraitsWithDefaultImpl<'a> {
+pub(crate) struct TraitsWithDefaultImpl<'a> {
     #[primary_span]
     pub span: Span,
     pub traits: String,
@@ -1368,7 +1368,7 @@ pub struct TraitsWithDefaultImpl<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_cross_crate_traits, code = E0321)]
-pub struct CrossCrateTraits<'a> {
+pub(crate) struct CrossCrateTraits<'a> {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1378,7 +1378,7 @@ pub struct CrossCrateTraits<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_cross_crate_traits_defined, code = E0321)]
-pub struct CrossCrateTraitsDefined {
+pub(crate) struct CrossCrateTraitsDefined {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1390,7 +1390,7 @@ pub struct CrossCrateTraitsDefined {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_ty_param_first_local, code = E0210)]
 #[note]
-pub struct TyParamFirstLocal<'tcx> {
+pub(crate) struct TyParamFirstLocal<'tcx> {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1403,7 +1403,7 @@ pub struct TyParamFirstLocal<'tcx> {
 #[derive(LintDiagnostic)]
 #[diag(hir_analysis_ty_param_first_local, code = E0210)]
 #[note]
-pub struct TyParamFirstLocalLint<'tcx> {
+pub(crate) struct TyParamFirstLocalLint<'tcx> {
     #[label]
     pub span: Span,
     #[note(hir_analysis_case_note)]
@@ -1415,7 +1415,7 @@ pub struct TyParamFirstLocalLint<'tcx> {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_ty_param_some, code = E0210)]
 #[note]
-pub struct TyParamSome {
+pub(crate) struct TyParamSome {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1427,7 +1427,7 @@ pub struct TyParamSome {
 #[derive(LintDiagnostic)]
 #[diag(hir_analysis_ty_param_some, code = E0210)]
 #[note]
-pub struct TyParamSomeLint {
+pub(crate) struct TyParamSomeLint {
     #[label]
     pub span: Span,
     #[note(hir_analysis_only_note)]
@@ -1436,7 +1436,7 @@ pub struct TyParamSomeLint {
 }
 
 #[derive(Diagnostic)]
-pub enum OnlyCurrentTraits {
+pub(crate) enum OnlyCurrentTraits {
     #[diag(hir_analysis_only_current_traits_outside, code = E0117)]
     Outside {
         #[primary_span]
@@ -1465,20 +1465,20 @@ pub enum OnlyCurrentTraits {
 
 #[derive(Subdiagnostic)]
 #[label(hir_analysis_only_current_traits_opaque)]
-pub struct OnlyCurrentTraitsOpaque {
+pub(crate) struct OnlyCurrentTraitsOpaque {
     #[primary_span]
     pub span: Span,
 }
 #[derive(Subdiagnostic)]
 #[label(hir_analysis_only_current_traits_foreign)]
-pub struct OnlyCurrentTraitsForeign {
+pub(crate) struct OnlyCurrentTraitsForeign {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Subdiagnostic)]
 #[label(hir_analysis_only_current_traits_name)]
-pub struct OnlyCurrentTraitsName<'a> {
+pub(crate) struct OnlyCurrentTraitsName<'a> {
     #[primary_span]
     pub span: Span,
     pub name: &'a str,
@@ -1486,7 +1486,7 @@ pub struct OnlyCurrentTraitsName<'a> {
 
 #[derive(Subdiagnostic)]
 #[label(hir_analysis_only_current_traits_pointer)]
-pub struct OnlyCurrentTraitsPointer<'a> {
+pub(crate) struct OnlyCurrentTraitsPointer<'a> {
     #[primary_span]
     pub span: Span,
     pub pointer: Ty<'a>,
@@ -1494,7 +1494,7 @@ pub struct OnlyCurrentTraitsPointer<'a> {
 
 #[derive(Subdiagnostic)]
 #[label(hir_analysis_only_current_traits_ty)]
-pub struct OnlyCurrentTraitsTy<'a> {
+pub(crate) struct OnlyCurrentTraitsTy<'a> {
     #[primary_span]
     pub span: Span,
     pub ty: Ty<'a>,
@@ -1502,7 +1502,7 @@ pub struct OnlyCurrentTraitsTy<'a> {
 
 #[derive(Subdiagnostic)]
 #[label(hir_analysis_only_current_traits_adt)]
-pub struct OnlyCurrentTraitsAdt {
+pub(crate) struct OnlyCurrentTraitsAdt {
     #[primary_span]
     pub span: Span,
     pub name: String,
@@ -1513,11 +1513,11 @@ pub struct OnlyCurrentTraitsAdt {
     hir_analysis_only_current_traits_pointer_sugg,
     applicability = "maybe-incorrect"
 )]
-pub struct OnlyCurrentTraitsPointerSugg<'a> {
+pub(crate) struct OnlyCurrentTraitsPointerSugg<'a> {
     #[suggestion_part(code = "WrapperType")]
     pub wrapper_span: Span,
     #[suggestion_part(code = "struct WrapperType(*{mut_key}{ptr_ty});\n\n")]
-    pub struct_span: Span,
+    pub(crate) struct_span: Span,
     pub mut_key: &'a str,
     pub ptr_ty: Ty<'a>,
 }
@@ -1525,7 +1525,7 @@ pub struct OnlyCurrentTraitsPointerSugg<'a> {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_static_mut_ref, code = E0796)]
 #[note]
-pub struct StaticMutRef<'a> {
+pub(crate) struct StaticMutRef<'a> {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1535,7 +1535,7 @@ pub struct StaticMutRef<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum MutRefSugg {
+pub(crate) enum MutRefSugg {
     #[multipart_suggestion(
         hir_analysis_suggestion,
         style = "verbose",
@@ -1565,7 +1565,7 @@ pub enum MutRefSugg {
 #[diag(hir_analysis_static_mut_refs_lint)]
 #[note]
 #[note(hir_analysis_why_note)]
-pub struct RefOfMutStatic<'a> {
+pub(crate) struct RefOfMutStatic<'a> {
     #[label]
     pub span: Span,
     #[subdiagnostic]
@@ -1575,7 +1575,7 @@ pub struct RefOfMutStatic<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_not_supported_delegation)]
-pub struct UnsupportedDelegation<'a> {
+pub(crate) struct UnsupportedDelegation<'a> {
     #[primary_span]
     pub span: Span,
     pub descr: &'a str,
@@ -1585,7 +1585,7 @@ pub struct UnsupportedDelegation<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_method_should_return_future)]
-pub struct MethodShouldReturnFuture {
+pub(crate) struct MethodShouldReturnFuture {
     #[primary_span]
     pub span: Span,
     pub method_name: Symbol,
@@ -1649,7 +1649,7 @@ pub(crate) struct UnconstrainedGenericParameter {
 }
 
 #[derive(Diagnostic)]
-pub enum UnnamedFieldsRepr<'a> {
+pub(crate) enum UnnamedFieldsRepr<'a> {
     #[diag(hir_analysis_unnamed_fields_repr_missing_repr_c)]
     MissingReprC {
         #[primary_span]
@@ -1678,14 +1678,14 @@ pub enum UnnamedFieldsRepr<'a> {
 
 #[derive(Subdiagnostic)]
 #[note(hir_analysis_unnamed_fields_repr_field_defined)]
-pub struct UnnamedFieldsReprFieldDefined {
+pub(crate) struct UnnamedFieldsReprFieldDefined {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_opaque_captures_higher_ranked_lifetime, code = E0657)]
-pub struct OpaqueCapturesHigherRankedLifetime {
+pub(crate) struct OpaqueCapturesHigherRankedLifetime {
     #[primary_span]
     pub span: Span,
     #[label]
@@ -1697,7 +1697,7 @@ pub struct OpaqueCapturesHigherRankedLifetime {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_pattern_type_non_const_range)]
-pub struct NonConstRange {
+pub(crate) struct NonConstRange {
     #[primary_span]
     pub span: Span,
 }
@@ -1706,7 +1706,7 @@ pub struct NonConstRange {
 #[diag(hir_analysis_invalid_receiver_ty, code = E0307)]
 #[note]
 #[help(hir_analysis_invalid_receiver_ty_help)]
-pub struct InvalidReceiverTy<'tcx> {
+pub(crate) struct InvalidReceiverTy<'tcx> {
     #[primary_span]
     pub span: Span,
     pub receiver_ty: Ty<'tcx>,
@@ -1716,12 +1716,12 @@ pub struct InvalidReceiverTy<'tcx> {
 #[diag(hir_analysis_effects_without_next_solver)]
 #[note]
 #[help]
-pub struct EffectsWithoutNextSolver;
+pub(crate) struct EffectsWithoutNextSolver;
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_cmse_call_inputs_stack_spill, code = E0798)]
 #[note]
-pub struct CmseCallInputsStackSpill {
+pub(crate) struct CmseCallInputsStackSpill {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1732,7 +1732,7 @@ pub struct CmseCallInputsStackSpill {
 #[diag(hir_analysis_cmse_call_output_stack_spill, code = E0798)]
 #[note(hir_analysis_note1)]
 #[note(hir_analysis_note2)]
-pub struct CmseCallOutputStackSpill {
+pub(crate) struct CmseCallOutputStackSpill {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -1740,7 +1740,7 @@ pub struct CmseCallOutputStackSpill {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_cmse_call_generic, code = E0798)]
-pub struct CmseCallGeneric {
+pub(crate) struct CmseCallGeneric {
     #[primary_span]
     pub span: Span,
 }
diff --git a/compiler/rustc_hir_analysis/src/errors/pattern_types.rs b/compiler/rustc_hir_analysis/src/errors/pattern_types.rs
index 008d26989890d..bb771d6ea170e 100644
--- a/compiler/rustc_hir_analysis/src/errors/pattern_types.rs
+++ b/compiler/rustc_hir_analysis/src/errors/pattern_types.rs
@@ -3,7 +3,7 @@ use rustc_span::Span;
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_pattern_type_wild_pat)]
-pub struct WildPatTy {
+pub(crate) struct WildPatTy {
     #[primary_span]
     pub span: Span,
 }
diff --git a/compiler/rustc_hir_analysis/src/errors/precise_captures.rs b/compiler/rustc_hir_analysis/src/errors/precise_captures.rs
index 8a9b5fe636967..af2bb053c0ab4 100644
--- a/compiler/rustc_hir_analysis/src/errors/precise_captures.rs
+++ b/compiler/rustc_hir_analysis/src/errors/precise_captures.rs
@@ -4,7 +4,7 @@ use rustc_span::{Span, Symbol};
 #[derive(Diagnostic)]
 #[diag(hir_analysis_param_not_captured)]
 #[note]
-pub struct ParamNotCaptured {
+pub(crate) struct ParamNotCaptured {
     #[primary_span]
     pub opaque_span: Span,
     #[label]
@@ -15,7 +15,7 @@ pub struct ParamNotCaptured {
 #[derive(Diagnostic)]
 #[diag(hir_analysis_self_ty_not_captured)]
 #[note]
-pub struct SelfTyNotCaptured {
+pub(crate) struct SelfTyNotCaptured {
     #[primary_span]
     pub opaque_span: Span,
     #[label]
@@ -24,7 +24,7 @@ pub struct SelfTyNotCaptured {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_lifetime_not_captured)]
-pub struct LifetimeNotCaptured {
+pub(crate) struct LifetimeNotCaptured {
     #[primary_span]
     pub use_span: Span,
     #[label(hir_analysis_param_label)]
@@ -35,7 +35,7 @@ pub struct LifetimeNotCaptured {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_bad_precise_capture)]
-pub struct BadPreciseCapture {
+pub(crate) struct BadPreciseCapture {
     #[primary_span]
     pub span: Span,
     pub kind: &'static str,
@@ -44,7 +44,7 @@ pub struct BadPreciseCapture {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_precise_capture_self_alias)]
-pub struct PreciseCaptureSelfAlias {
+pub(crate) struct PreciseCaptureSelfAlias {
     #[primary_span]
     pub span: Span,
     #[label]
@@ -54,7 +54,7 @@ pub struct PreciseCaptureSelfAlias {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_duplicate_precise_capture)]
-pub struct DuplicatePreciseCapture {
+pub(crate) struct DuplicatePreciseCapture {
     #[primary_span]
     pub first_span: Span,
     pub name: Symbol,
@@ -64,7 +64,7 @@ pub struct DuplicatePreciseCapture {
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_lifetime_must_be_first)]
-pub struct LifetimesMustBeFirst {
+pub(crate) struct LifetimesMustBeFirst {
     #[primary_span]
     pub lifetime_span: Span,
     pub name: Symbol,
diff --git a/compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs b/compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs
index 8ecf53bfacb94..f8b2469dfea45 100644
--- a/compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs
+++ b/compiler/rustc_hir_analysis/src/errors/wrong_number_of_generic_args.rs
@@ -8,7 +8,7 @@ use rustc_span::def_id::DefId;
 use GenericArgsInfo::*;
 
 /// Handles the `wrong number of type / lifetime / ... arguments` family of error messages.
-pub struct WrongNumberOfGenericArgs<'a, 'tcx> {
+pub(crate) struct WrongNumberOfGenericArgs<'a, 'tcx> {
     pub(crate) tcx: TyCtxt<'tcx>,
 
     pub(crate) angle_brackets: AngleBrackets,
@@ -49,7 +49,7 @@ pub(crate) enum AngleBrackets {
 
 // Information about the kind of arguments that are either missing or are unexpected
 #[derive(Debug)]
-pub enum GenericArgsInfo {
+pub(crate) enum GenericArgsInfo {
     MissingLifetimes {
         num_missing_args: usize,
     },
@@ -87,7 +87,7 @@ pub enum GenericArgsInfo {
 }
 
 impl<'a, 'tcx> WrongNumberOfGenericArgs<'a, 'tcx> {
-    pub fn new(
+    pub(crate) fn new(
         tcx: TyCtxt<'tcx>,
         gen_args_info: GenericArgsInfo,
         path_segment: &'a hir::PathSegment<'_>,
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
index e99717ce00f8c..1b73cecd6664b 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@@ -11,7 +11,7 @@ use crate::errors;
 /// Check conditions on inputs and outputs that the cmse ABIs impose: arguments and results MUST be
 /// returned via registers (i.e. MUST NOT spill to the stack). LLVM will also validate these
 /// conditions, but by checking them here rustc can emit nicer error messages.
-pub fn validate_cmse_abi<'tcx>(
+pub(crate) fn validate_cmse_abi<'tcx>(
     tcx: TyCtxt<'tcx>,
     dcx: DiagCtxtHandle<'_>,
     hir_id: HirId,
diff --git a/compiler/rustc_hir_analysis/src/hir_wf_check.rs b/compiler/rustc_hir_analysis/src/hir_wf_check.rs
index 7d2cabd3f2c7e..3ecf61501f6d3 100644
--- a/compiler/rustc_hir_analysis/src/hir_wf_check.rs
+++ b/compiler/rustc_hir_analysis/src/hir_wf_check.rs
@@ -11,7 +11,7 @@ use rustc_trait_selection::traits::{self, ObligationCtxt};
 
 use crate::collect::ItemCtxt;
 
-pub fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers { diagnostic_hir_wf_check, ..*providers };
 }
 
diff --git a/compiler/rustc_hir_analysis/src/impl_wf_check.rs b/compiler/rustc_hir_analysis/src/impl_wf_check.rs
index 02520c472b9de..7f183324f0433 100644
--- a/compiler/rustc_hir_analysis/src/impl_wf_check.rs
+++ b/compiler/rustc_hir_analysis/src/impl_wf_check.rs
@@ -53,7 +53,10 @@ mod min_specialization;
 /// impl<'a> Trait<Foo> for Bar { type X = &'a i32; }
 /// //   ^ 'a is unused and appears in assoc type, error
 /// ```
-pub fn check_impl_wf(tcx: TyCtxt<'_>, impl_def_id: LocalDefId) -> Result<(), ErrorGuaranteed> {
+pub(crate) fn check_impl_wf(
+    tcx: TyCtxt<'_>,
+    impl_def_id: LocalDefId,
+) -> Result<(), ErrorGuaranteed> {
     let min_specialization = tcx.features().min_specialization;
     let mut res = Ok(());
     debug_assert_matches!(tcx.def_kind(impl_def_id), DefKind::Impl { .. });
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index 291d57f2a176f..f6d96003ce9e3 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -72,6 +72,7 @@ This API is completely unstable and subject to change.
 #![feature(slice_partition_dedup)]
 #![feature(try_blocks)]
 #![feature(unwrap_infallible)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 #[macro_use]
diff --git a/compiler/rustc_hir_analysis/src/outlives/explicit.rs b/compiler/rustc_hir_analysis/src/outlives/explicit.rs
index bbfadbb5c3087..f576499ecac38 100644
--- a/compiler/rustc_hir_analysis/src/outlives/explicit.rs
+++ b/compiler/rustc_hir_analysis/src/outlives/explicit.rs
@@ -5,12 +5,12 @@ use rustc_middle::ty::{self, OutlivesPredicate, TyCtxt};
 use super::utils::*;
 
 #[derive(Debug)]
-pub struct ExplicitPredicatesMap<'tcx> {
+pub(crate) struct ExplicitPredicatesMap<'tcx> {
     map: FxIndexMap<DefId, ty::EarlyBinder<'tcx, RequiredPredicates<'tcx>>>,
 }
 
 impl<'tcx> ExplicitPredicatesMap<'tcx> {
-    pub fn new() -> ExplicitPredicatesMap<'tcx> {
+    pub(crate) fn new() -> ExplicitPredicatesMap<'tcx> {
         ExplicitPredicatesMap { map: FxIndexMap::default() }
     }
 
diff --git a/compiler/rustc_hir_analysis/src/outlives/mod.rs b/compiler/rustc_hir_analysis/src/outlives/mod.rs
index cb61ef7c64da0..e3cdb1bf5f7d6 100644
--- a/compiler/rustc_hir_analysis/src/outlives/mod.rs
+++ b/compiler/rustc_hir_analysis/src/outlives/mod.rs
@@ -9,7 +9,7 @@ mod explicit;
 mod implicit_infer;
 mod utils;
 
-pub fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers { inferred_outlives_of, inferred_outlives_crate, ..*providers };
 }
 
diff --git a/compiler/rustc_hir_analysis/src/variance/constraints.rs b/compiler/rustc_hir_analysis/src/variance/constraints.rs
index ce9e73bf24503..4fb7a02f8c937 100644
--- a/compiler/rustc_hir_analysis/src/variance/constraints.rs
+++ b/compiler/rustc_hir_analysis/src/variance/constraints.rs
@@ -12,7 +12,7 @@ use rustc_middle::{bug, span_bug};
 use super::terms::VarianceTerm::*;
 use super::terms::*;
 
-pub struct ConstraintContext<'a, 'tcx> {
+pub(crate) struct ConstraintContext<'a, 'tcx> {
     pub terms_cx: TermsContext<'a, 'tcx>,
 
     // These are pointers to common `ConstantTerm` instances
@@ -27,7 +27,7 @@ pub struct ConstraintContext<'a, 'tcx> {
 /// Declares that the variable `decl_id` appears in a location with
 /// variance `variance`.
 #[derive(Copy, Clone)]
-pub struct Constraint<'a> {
+pub(crate) struct Constraint<'a> {
     pub inferred: InferredIndex,
     pub variance: &'a VarianceTerm<'a>,
 }
@@ -41,11 +41,11 @@ pub struct Constraint<'a> {
 /// ```
 /// then while we are visiting `Bar<T>`, the `CurrentItem` would have
 /// the `DefId` and the start of `Foo`'s inferreds.
-pub struct CurrentItem {
+struct CurrentItem {
     inferred_start: InferredIndex,
 }
 
-pub fn add_constraints_from_crate<'a, 'tcx>(
+pub(crate) fn add_constraints_from_crate<'a, 'tcx>(
     terms_cx: TermsContext<'a, 'tcx>,
 ) -> ConstraintContext<'a, 'tcx> {
     let tcx = terms_cx.tcx;
diff --git a/compiler/rustc_hir_analysis/src/variance/mod.rs b/compiler/rustc_hir_analysis/src/variance/mod.rs
index 8a4114c3e4bca..e8e2caf7e62a5 100644
--- a/compiler/rustc_hir_analysis/src/variance/mod.rs
+++ b/compiler/rustc_hir_analysis/src/variance/mod.rs
@@ -28,7 +28,7 @@ pub(crate) mod dump;
 /// Code for transforming variances.
 mod xform;
 
-pub fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers { variances_of, crate_variances, ..*providers };
 }
 
diff --git a/compiler/rustc_hir_analysis/src/variance/solve.rs b/compiler/rustc_hir_analysis/src/variance/solve.rs
index e64c6721fe018..4f1bac17e71be 100644
--- a/compiler/rustc_hir_analysis/src/variance/solve.rs
+++ b/compiler/rustc_hir_analysis/src/variance/solve.rs
@@ -21,7 +21,7 @@ struct SolveContext<'a, 'tcx> {
     solutions: Vec<ty::Variance>,
 }
 
-pub fn solve_constraints<'tcx>(
+pub(crate) fn solve_constraints<'tcx>(
     constraints_cx: ConstraintContext<'_, 'tcx>,
 ) -> ty::CrateVariancesMap<'tcx> {
     let ConstraintContext { terms_cx, constraints, .. } = constraints_cx;
diff --git a/compiler/rustc_hir_analysis/src/variance/terms.rs b/compiler/rustc_hir_analysis/src/variance/terms.rs
index 36bff60e01978..597699b37b1c5 100644
--- a/compiler/rustc_hir_analysis/src/variance/terms.rs
+++ b/compiler/rustc_hir_analysis/src/variance/terms.rs
@@ -18,13 +18,13 @@ use rustc_middle::ty::{self, TyCtxt};
 
 use self::VarianceTerm::*;
 
-pub type VarianceTermPtr<'a> = &'a VarianceTerm<'a>;
+pub(crate) type VarianceTermPtr<'a> = &'a VarianceTerm<'a>;
 
 #[derive(Copy, Clone, Debug)]
-pub struct InferredIndex(pub usize);
+pub(crate) struct InferredIndex(pub usize);
 
 #[derive(Copy, Clone)]
-pub enum VarianceTerm<'a> {
+pub(crate) enum VarianceTerm<'a> {
     ConstantTerm(ty::Variance),
     TransformTerm(VarianceTermPtr<'a>, VarianceTermPtr<'a>),
     InferredTerm(InferredIndex),
@@ -45,7 +45,7 @@ impl<'a> fmt::Debug for VarianceTerm<'a> {
 
 /// The first pass over the crate simply builds up the set of inferreds.
 
-pub struct TermsContext<'a, 'tcx> {
+pub(crate) struct TermsContext<'a, 'tcx> {
     pub tcx: TyCtxt<'tcx>,
     pub arena: &'a DroplessArena,
 
@@ -62,7 +62,7 @@ pub struct TermsContext<'a, 'tcx> {
     pub inferred_terms: Vec<VarianceTermPtr<'a>>,
 }
 
-pub fn determine_parameters_to_be_inferred<'a, 'tcx>(
+pub(crate) fn determine_parameters_to_be_inferred<'a, 'tcx>(
     tcx: TyCtxt<'tcx>,
     arena: &'a DroplessArena,
 ) -> TermsContext<'a, 'tcx> {
diff --git a/compiler/rustc_hir_analysis/src/variance/xform.rs b/compiler/rustc_hir_analysis/src/variance/xform.rs
index 027f0859fcd54..2e9964788e6e5 100644
--- a/compiler/rustc_hir_analysis/src/variance/xform.rs
+++ b/compiler/rustc_hir_analysis/src/variance/xform.rs
@@ -1,6 +1,6 @@
 use rustc_middle::ty;
 
-pub fn glb(v1: ty::Variance, v2: ty::Variance) -> ty::Variance {
+pub(crate) fn glb(v1: ty::Variance, v2: ty::Variance) -> ty::Variance {
     // Greatest lower bound of the variance lattice as
     // defined in The Paper:
     //

From 3aae994ca2d2316b54d04b77064034d5edab878f Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 13:25:40 +1000
Subject: [PATCH 639/685] Add `warn(unreachable_pub)` to `rustc_hir_pretty`.

---
 compiler/rustc_hir_pretty/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index cff21173f7982..ac6707f931602 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -3,6 +3,7 @@
 
 // tidy-alphabetical-start
 #![recursion_limit = "256"]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 use std::cell::Cell;

From a1746b42024685ac0bb1f4735a26735257a4f336 Mon Sep 17 00:00:00 2001
From: Michael Howell <michael@notriddle.com>
Date: Mon, 26 Aug 2024 19:52:13 -0700
Subject: [PATCH 640/685] rustdoc: fix missing resource suffix on `crates.js`

Fixes a regression introduced in #128252.
---
 src/librustdoc/html/render/write_shared.rs     | 18 ++++++++++++------
 .../html/render/write_shared/tests.rs          |  6 +++---
 tests/run-make/emit-shared-files/rmake.rs      |  1 +
 3 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index a18b7a252a402..60dc142b9ff91 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -75,11 +75,11 @@ pub(crate) fn write_shared(
     let crate_name = krate.name(cx.tcx());
     let crate_name = crate_name.as_str(); // rand
     let crate_name_json = OrderedJson::serialize(crate_name).unwrap(); // "rand"
-    let external_crates = hack_get_external_crate_names(&cx.dst)?;
+    let external_crates = hack_get_external_crate_names(&cx.dst, &cx.shared.resource_suffix)?;
     let info = CrateInfo {
         src_files_js: SourcesPart::get(cx, &crate_name_json)?,
         search_index_js: SearchIndexPart::get(index, &cx.shared.resource_suffix)?,
-        all_crates: AllCratesPart::get(crate_name_json.clone())?,
+        all_crates: AllCratesPart::get(crate_name_json.clone(), &cx.shared.resource_suffix)?,
         crates_index: CratesIndexPart::get(&crate_name, &external_crates)?,
         trait_impl: TraitAliasPart::get(cx, &crate_name_json)?,
         type_impl: TypeAliasPart::get(cx, krate, &crate_name_json)?,
@@ -291,10 +291,13 @@ impl AllCratesPart {
         SortedTemplate::from_before_after("window.ALL_CRATES = [", "];")
     }
 
-    fn get(crate_name_json: OrderedJson) -> Result<PartsAndLocations<Self>, Error> {
+    fn get(
+        crate_name_json: OrderedJson,
+        resource_suffix: &str,
+    ) -> Result<PartsAndLocations<Self>, Error> {
         // external hack_get_external_crate_names not needed here, because
         // there's no way that we write the search index but not crates.js
-        let path = PathBuf::from("crates.js");
+        let path = suffix_path("crates.js", resource_suffix);
         Ok(PartsAndLocations::with(path, crate_name_json))
     }
 }
@@ -305,8 +308,11 @@ impl AllCratesPart {
 ///
 /// This is to match the current behavior of rustdoc, which allows you to get all crates
 /// on the index page, even if --enable-index-page is only passed to the last crate.
-fn hack_get_external_crate_names(doc_root: &Path) -> Result<Vec<String>, Error> {
-    let path = doc_root.join("crates.js");
+fn hack_get_external_crate_names(
+    doc_root: &Path,
+    resource_suffix: &str,
+) -> Result<Vec<String>, Error> {
+    let path = doc_root.join(suffix_path("crates.js", resource_suffix));
     let Ok(content) = fs::read_to_string(&path) else {
         // they didn't emit invocation specific, so we just say there were no crates
         return Ok(Vec::default());
diff --git a/src/librustdoc/html/render/write_shared/tests.rs b/src/librustdoc/html/render/write_shared/tests.rs
index 4d1874b7df5f9..e282cd99e43cc 100644
--- a/src/librustdoc/html/render/write_shared/tests.rs
+++ b/src/librustdoc/html/render/write_shared/tests.rs
@@ -6,10 +6,10 @@ use crate::html::render::write_shared::*;
 fn hack_external_crate_names() {
     let path = tempfile::TempDir::new().unwrap();
     let path = path.path();
-    let crates = hack_get_external_crate_names(&path).unwrap();
+    let crates = hack_get_external_crate_names(&path, "").unwrap();
     assert!(crates.is_empty());
     fs::write(path.join("crates.js"), r#"window.ALL_CRATES = ["a","b","c"];"#).unwrap();
-    let crates = hack_get_external_crate_names(&path).unwrap();
+    let crates = hack_get_external_crate_names(&path, "").unwrap();
     assert_eq!(crates, ["a".to_string(), "b".to_string(), "c".to_string()]);
 }
 
@@ -60,7 +60,7 @@ fn all_crates_template() {
 
 #[test]
 fn all_crates_parts() {
-    let parts = AllCratesPart::get(OrderedJson::serialize("crate").unwrap()).unwrap();
+    let parts = AllCratesPart::get(OrderedJson::serialize("crate").unwrap(), "").unwrap();
     assert_eq!(&parts.parts[0].0, Path::new("crates.js"));
     assert_eq!(&parts.parts[0].1.to_string(), r#""crate""#);
 }
diff --git a/tests/run-make/emit-shared-files/rmake.rs b/tests/run-make/emit-shared-files/rmake.rs
index e5482af10bb94..483f298776c09 100644
--- a/tests/run-make/emit-shared-files/rmake.rs
+++ b/tests/run-make/emit-shared-files/rmake.rs
@@ -20,6 +20,7 @@ fn main() {
         .input("x.rs")
         .run();
     assert!(Path::new("invocation-only/search-index-xxx.js").exists());
+    assert!(Path::new("invocation-only/crates-xxx.js").exists());
     assert!(Path::new("invocation-only/settings.html").exists());
     assert!(Path::new("invocation-only/x/all.html").exists());
     assert!(Path::new("invocation-only/x/index.html").exists());

From 7fc04443404914bb7c432c2269d94fd48d569244 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 14:22:07 +1000
Subject: [PATCH 641/685] Add `warn(unreachable_pub)` to `rustc_hir_typeck`.

---
 compiler/rustc_hir_typeck/src/_match.rs       |   4 +-
 compiler/rustc_hir_typeck/src/autoderef.rs    |   8 +-
 compiler/rustc_hir_typeck/src/callee.rs       |   8 +-
 compiler/rustc_hir_typeck/src/coercion.rs     |  28 ++---
 compiler/rustc_hir_typeck/src/demand.rs       |  24 ++--
 compiler/rustc_hir_typeck/src/diverges.rs     |   2 +-
 compiler/rustc_hir_typeck/src/errors.rs       | 104 +++++++++---------
 compiler/rustc_hir_typeck/src/expectation.rs  |   2 +-
 compiler/rustc_hir_typeck/src/expr.rs         |   8 +-
 compiler/rustc_hir_typeck/src/fallback.rs     |   2 +-
 .../rustc_hir_typeck/src/fn_ctxt/_impl.rs     |  40 +++----
 .../src/fn_ctxt/adjust_fulfillment_errors.rs  |   4 +-
 .../src/fn_ctxt/arg_matrix.rs                 |   2 +-
 .../rustc_hir_typeck/src/fn_ctxt/checks.rs    |  12 +-
 compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs  |  18 +--
 .../src/fn_ctxt/suggestions.rs                |  12 +-
 compiler/rustc_hir_typeck/src/intrinsicck.rs  |   2 +-
 compiler/rustc_hir_typeck/src/lib.rs          |   1 +
 .../rustc_hir_typeck/src/method/confirm.rs    |   6 +-
 compiler/rustc_hir_typeck/src/method/mod.rs   |  20 ++--
 compiler/rustc_hir_typeck/src/method/probe.rs |  22 ++--
 .../rustc_hir_typeck/src/method/suggest.rs    |   8 +-
 compiler/rustc_hir_typeck/src/op.rs           |   6 +-
 compiler/rustc_hir_typeck/src/pat.rs          |   2 +-
 compiler/rustc_hir_typeck/src/place_op.rs     |   2 +-
 .../rustc_hir_typeck/src/rvalue_scopes.rs     |   2 +-
 .../rustc_hir_typeck/src/typeck_root_ctxt.rs  |   4 +-
 compiler/rustc_hir_typeck/src/upvar.rs        |   2 +-
 compiler/rustc_hir_typeck/src/writeback.rs    |   2 +-
 29 files changed, 183 insertions(+), 174 deletions(-)

diff --git a/compiler/rustc_hir_typeck/src/_match.rs b/compiler/rustc_hir_typeck/src/_match.rs
index bc0ed4a7fa99d..7427fb147166f 100644
--- a/compiler/rustc_hir_typeck/src/_match.rs
+++ b/compiler/rustc_hir_typeck/src/_match.rs
@@ -374,7 +374,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn maybe_get_coercion_reason(
+    pub(crate) fn maybe_get_coercion_reason(
         &self,
         hir_id: hir::HirId,
         sp: Span,
@@ -584,7 +584,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     // (e.g. we're in the tail of a function body)
     //
     // Returns the `LocalDefId` of the RPIT, which is always identity-substituted.
-    pub fn return_position_impl_trait_from_match_expectation(
+    pub(crate) fn return_position_impl_trait_from_match_expectation(
         &self,
         expectation: Expectation<'tcx>,
     ) -> Option<LocalDefId> {
diff --git a/compiler/rustc_hir_typeck/src/autoderef.rs b/compiler/rustc_hir_typeck/src/autoderef.rs
index 69c4889d7a4b2..d2d6da8f32b30 100644
--- a/compiler/rustc_hir_typeck/src/autoderef.rs
+++ b/compiler/rustc_hir_typeck/src/autoderef.rs
@@ -13,11 +13,11 @@ use super::method::MethodCallee;
 use super::{FnCtxt, PlaceOp};
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    pub fn autoderef(&'a self, span: Span, base_ty: Ty<'tcx>) -> Autoderef<'a, 'tcx> {
+    pub(crate) fn autoderef(&'a self, span: Span, base_ty: Ty<'tcx>) -> Autoderef<'a, 'tcx> {
         Autoderef::new(self, self.param_env, self.body_id, span, base_ty)
     }
 
-    pub fn try_overloaded_deref(
+    pub(crate) fn try_overloaded_deref(
         &self,
         span: Span,
         base_ty: Ty<'tcx>,
@@ -26,11 +26,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     /// Returns the adjustment steps.
-    pub fn adjust_steps(&self, autoderef: &Autoderef<'a, 'tcx>) -> Vec<Adjustment<'tcx>> {
+    pub(crate) fn adjust_steps(&self, autoderef: &Autoderef<'a, 'tcx>) -> Vec<Adjustment<'tcx>> {
         self.register_infer_ok_obligations(self.adjust_steps_as_infer_ok(autoderef))
     }
 
-    pub fn adjust_steps_as_infer_ok(
+    pub(crate) fn adjust_steps_as_infer_ok(
         &self,
         autoderef: &Autoderef<'a, 'tcx>,
     ) -> InferOk<'tcx, Vec<Adjustment<'tcx>>> {
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index 44cb08e44eb81..fc08b872efc2e 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -29,7 +29,7 @@ use crate::errors;
 /// Checks that it is legal to call methods of the trait corresponding
 /// to `trait_id` (this only cares about the trait, not the specific
 /// method that is called).
-pub fn check_legal_trait_for_method_call(
+pub(crate) fn check_legal_trait_for_method_call(
     tcx: TyCtxt<'_>,
     span: Span,
     receiver: Option<Span>,
@@ -62,7 +62,7 @@ enum CallStep<'tcx> {
 }
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    pub fn check_call(
+    pub(crate) fn check_call(
         &self,
         call_expr: &'tcx hir::Expr<'tcx>,
         callee_expr: &'tcx hir::Expr<'tcx>,
@@ -940,7 +940,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 #[derive(Debug)]
-pub struct DeferredCallResolution<'tcx> {
+pub(crate) struct DeferredCallResolution<'tcx> {
     call_expr: &'tcx hir::Expr<'tcx>,
     callee_expr: &'tcx hir::Expr<'tcx>,
     closure_ty: Ty<'tcx>,
@@ -949,7 +949,7 @@ pub struct DeferredCallResolution<'tcx> {
 }
 
 impl<'a, 'tcx> DeferredCallResolution<'tcx> {
-    pub fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) {
+    pub(crate) fn resolve(self, fcx: &FnCtxt<'a, 'tcx>) {
         debug!("DeferredCallResolution::resolve() {:?}", self);
 
         // we should not be invoked until the closure kind has been
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index b47d8a97bceea..dabc5a8939783 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -976,7 +976,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// adjusted type of the expression, if successful.
     /// Adjustments are only recorded if the coercion succeeded.
     /// The expressions *must not* have any preexisting adjustments.
-    pub fn coerce(
+    pub(crate) fn coerce(
         &self,
         expr: &hir::Expr<'_>,
         expr_ty: Ty<'tcx>,
@@ -1011,7 +1011,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ///
     /// Returns false if the coercion creates any obligations that result in
     /// errors.
-    pub fn can_coerce(&self, expr_ty: Ty<'tcx>, target: Ty<'tcx>) -> bool {
+    pub(crate) fn can_coerce(&self, expr_ty: Ty<'tcx>, target: Ty<'tcx>) -> bool {
         // FIXME(-Znext-solver): We need to structurally resolve both types here.
         let source = self.resolve_vars_with_obligations(expr_ty);
         debug!("coercion::can_with_predicates({:?} -> {:?})", source, target);
@@ -1032,7 +1032,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// Given a type and a target type, this function will calculate and return
     /// how many dereference steps needed to achieve `expr_ty <: target`. If
     /// it's not possible, return `None`.
-    pub fn deref_steps(&self, expr_ty: Ty<'tcx>, target: Ty<'tcx>) -> Option<usize> {
+    pub(crate) fn deref_steps(&self, expr_ty: Ty<'tcx>, target: Ty<'tcx>) -> Option<usize> {
         let cause = self.cause(DUMMY_SP, ObligationCauseCode::ExprAssignable);
         // We don't ever need two-phase here since we throw out the result of the coercion
         let coerce = Coerce::new(self, cause, AllowTwoPhase::No);
@@ -1047,7 +1047,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// This function is for diagnostics only, since it does not register
     /// trait or region sub-obligations. (presumably we could, but it's not
     /// particularly important for diagnostics...)
-    pub fn deref_once_mutably_for_diagnostic(&self, expr_ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
+    pub(crate) fn deref_once_mutably_for_diagnostic(&self, expr_ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
         self.autoderef(DUMMY_SP, expr_ty).nth(1).and_then(|(deref_ty, _)| {
             self.infcx
                 .type_implements_trait(
@@ -1341,7 +1341,7 @@ pub fn can_coerce<'tcx>(
 /// }
 /// let final_ty = coerce.complete(fcx);
 /// ```
-pub struct CoerceMany<'tcx, 'exprs, E: AsCoercionSite> {
+pub(crate) struct CoerceMany<'tcx, 'exprs, E: AsCoercionSite> {
     expected_ty: Ty<'tcx>,
     final_ty: Option<Ty<'tcx>>,
     expressions: Expressions<'tcx, 'exprs, E>,
@@ -1350,7 +1350,7 @@ pub struct CoerceMany<'tcx, 'exprs, E: AsCoercionSite> {
 
 /// The type of a `CoerceMany` that is storing up the expressions into
 /// a buffer. We use this in `check/mod.rs` for things like `break`.
-pub type DynamicCoerceMany<'tcx> = CoerceMany<'tcx, 'tcx, &'tcx hir::Expr<'tcx>>;
+pub(crate) type DynamicCoerceMany<'tcx> = CoerceMany<'tcx, 'tcx, &'tcx hir::Expr<'tcx>>;
 
 enum Expressions<'tcx, 'exprs, E: AsCoercionSite> {
     Dynamic(Vec<&'tcx hir::Expr<'tcx>>),
@@ -1361,7 +1361,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
     /// The usual case; collect the set of expressions dynamically.
     /// If the full set of coercion sites is known before hand,
     /// consider `with_coercion_sites()` instead to avoid allocation.
-    pub fn new(expected_ty: Ty<'tcx>) -> Self {
+    pub(crate) fn new(expected_ty: Ty<'tcx>) -> Self {
         Self::make(expected_ty, Expressions::Dynamic(vec![]))
     }
 
@@ -1370,7 +1370,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
     /// expected to pass each element in the slice to `coerce(...)` in
     /// order. This is used with arrays in particular to avoid
     /// needlessly cloning the slice.
-    pub fn with_coercion_sites(expected_ty: Ty<'tcx>, coercion_sites: &'exprs [E]) -> Self {
+    pub(crate) fn with_coercion_sites(expected_ty: Ty<'tcx>, coercion_sites: &'exprs [E]) -> Self {
         Self::make(expected_ty, Expressions::UpFront(coercion_sites))
     }
 
@@ -1386,7 +1386,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
     /// Typically, this is used as the expected type when
     /// type-checking each of the alternative expressions whose types
     /// we are trying to merge.
-    pub fn expected_ty(&self) -> Ty<'tcx> {
+    pub(crate) fn expected_ty(&self) -> Ty<'tcx> {
         self.expected_ty
     }
 
@@ -1394,7 +1394,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
     /// at the LUB of the expressions we've seen so far (if any). This
     /// isn't *final* until you call `self.complete()`, which will return
     /// the merged type.
-    pub fn merged_ty(&self) -> Ty<'tcx> {
+    pub(crate) fn merged_ty(&self) -> Ty<'tcx> {
         self.final_ty.unwrap_or(self.expected_ty)
     }
 
@@ -1403,7 +1403,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
     /// could coerce from. This will record `expression`, and later
     /// calls to `coerce` may come back and add adjustments and things
     /// if necessary.
-    pub fn coerce<'a>(
+    pub(crate) fn coerce<'a>(
         &mut self,
         fcx: &FnCtxt<'a, 'tcx>,
         cause: &ObligationCause<'tcx>,
@@ -1425,7 +1425,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
     /// The `augment_error` gives you a chance to extend the error
     /// message, in case any results (e.g., we use this to suggest
     /// removing a `;`).
-    pub fn coerce_forced_unit<'a>(
+    pub(crate) fn coerce_forced_unit<'a>(
         &mut self,
         fcx: &FnCtxt<'a, 'tcx>,
         cause: &ObligationCause<'tcx>,
@@ -1920,7 +1920,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
         }
     }
 
-    pub fn complete<'a>(self, fcx: &FnCtxt<'a, 'tcx>) -> Ty<'tcx> {
+    pub(crate) fn complete<'a>(self, fcx: &FnCtxt<'a, 'tcx>) -> Ty<'tcx> {
         if let Some(final_ty) = self.final_ty {
             final_ty
         } else {
@@ -1934,7 +1934,7 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
 
 /// Something that can be converted into an expression to which we can
 /// apply a coercion.
-pub trait AsCoercionSite {
+pub(crate) trait AsCoercionSite {
     fn as_coercion_site(&self) -> &hir::Expr<'_>;
 }
 
diff --git a/compiler/rustc_hir_typeck/src/demand.rs b/compiler/rustc_hir_typeck/src/demand.rs
index 0a9fa5c64a54e..89f27e807749e 100644
--- a/compiler/rustc_hir_typeck/src/demand.rs
+++ b/compiler/rustc_hir_typeck/src/demand.rs
@@ -18,7 +18,7 @@ use super::method::probe;
 use crate::FnCtxt;
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    pub fn emit_type_mismatch_suggestions(
+    pub(crate) fn emit_type_mismatch_suggestions(
         &self,
         err: &mut Diag<'_>,
         expr: &hir::Expr<'tcx>,
@@ -70,7 +70,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn emit_coerce_suggestions(
+    pub(crate) fn emit_coerce_suggestions(
         &self,
         err: &mut Diag<'_>,
         expr: &hir::Expr<'tcx>,
@@ -165,13 +165,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     /// Requires that the two types unify, and prints an error message if
     /// they don't.
-    pub fn demand_suptype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) {
+    pub(crate) fn demand_suptype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) {
         if let Err(e) = self.demand_suptype_diag(sp, expected, actual) {
             e.emit();
         }
     }
 
-    pub fn demand_suptype_diag(
+    pub(crate) fn demand_suptype_diag(
         &'a self,
         sp: Span,
         expected: Ty<'tcx>,
@@ -193,13 +193,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .map_err(|e| self.err_ctxt().report_mismatched_types(cause, expected, actual, e))
     }
 
-    pub fn demand_eqtype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) {
+    pub(crate) fn demand_eqtype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) {
         if let Err(err) = self.demand_eqtype_diag(sp, expected, actual) {
             err.emit();
         }
     }
 
-    pub fn demand_eqtype_diag(
+    pub(crate) fn demand_eqtype_diag(
         &'a self,
         sp: Span,
         expected: Ty<'tcx>,
@@ -208,7 +208,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         self.demand_eqtype_with_origin(&self.misc(sp), expected, actual)
     }
 
-    pub fn demand_eqtype_with_origin(
+    pub(crate) fn demand_eqtype_with_origin(
         &'a self,
         cause: &ObligationCause<'tcx>,
         expected: Ty<'tcx>,
@@ -220,7 +220,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .map_err(|e| self.err_ctxt().report_mismatched_types(cause, expected, actual, e))
     }
 
-    pub fn demand_coerce(
+    pub(crate) fn demand_coerce(
         &self,
         expr: &'tcx hir::Expr<'tcx>,
         checked_ty: Ty<'tcx>,
@@ -279,7 +279,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     /// Notes the point at which a variable is constrained to some type incompatible
     /// with some expectation given by `source`.
-    pub fn note_source_of_type_mismatch_constraint(
+    pub(crate) fn note_source_of_type_mismatch_constraint(
         &self,
         err: &mut Diag<'_>,
         expr: &hir::Expr<'_>,
@@ -558,7 +558,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     // When encountering a type error on the value of a `break`, try to point at the reason for the
     // expected type.
-    pub fn annotate_loop_expected_due_to_inference(
+    pub(crate) fn annotate_loop_expected_due_to_inference(
         &self,
         err: &mut Diag<'_>,
         expr: &hir::Expr<'_>,
@@ -964,7 +964,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         );
     }
 
-    pub fn get_conversion_methods_for_diagnostic(
+    pub(crate) fn get_conversion_methods_for_diagnostic(
         &self,
         span: Span,
         expected: Ty<'tcx>,
@@ -1186,7 +1186,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 }
 
-pub enum TypeMismatchSource<'tcx> {
+pub(crate) enum TypeMismatchSource<'tcx> {
     /// Expected the binding to have the given type, but it was found to have
     /// a different type. Find out when that type first became incompatible.
     Ty(Ty<'tcx>),
diff --git a/compiler/rustc_hir_typeck/src/diverges.rs b/compiler/rustc_hir_typeck/src/diverges.rs
index aa30fb0f0af39..3066561a31d6d 100644
--- a/compiler/rustc_hir_typeck/src/diverges.rs
+++ b/compiler/rustc_hir_typeck/src/diverges.rs
@@ -8,7 +8,7 @@ use rustc_span::{Span, DUMMY_SP};
 /// as diverging), with some manual adjustments for control-flow
 /// primitives (approximating a CFG).
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub enum Diverges {
+pub(crate) enum Diverges {
     /// Potentially unknown, some cases converge,
     /// others require a CFG to determine them.
     Maybe,
diff --git a/compiler/rustc_hir_typeck/src/errors.rs b/compiler/rustc_hir_typeck/src/errors.rs
index c35f7a84c4fde..4d2770d2e50e2 100644
--- a/compiler/rustc_hir_typeck/src/errors.rs
+++ b/compiler/rustc_hir_typeck/src/errors.rs
@@ -17,7 +17,7 @@ use crate::fluent_generated as fluent;
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_field_multiply_specified_in_initializer, code = E0062)]
-pub struct FieldMultiplySpecifiedInInitializer {
+pub(crate) struct FieldMultiplySpecifiedInInitializer {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -28,7 +28,7 @@ pub struct FieldMultiplySpecifiedInInitializer {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_return_stmt_outside_of_fn_body, code = E0572)]
-pub struct ReturnStmtOutsideOfFnBody {
+pub(crate) struct ReturnStmtOutsideOfFnBody {
     #[primary_span]
     pub span: Span,
     #[label(hir_typeck_encl_body_label)]
@@ -38,7 +38,7 @@ pub struct ReturnStmtOutsideOfFnBody {
     pub statement_kind: ReturnLikeStatementKind,
 }
 
-pub enum ReturnLikeStatementKind {
+pub(crate) enum ReturnLikeStatementKind {
     Return,
     Become,
 }
@@ -57,21 +57,21 @@ impl IntoDiagArg for ReturnLikeStatementKind {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_rustcall_incorrect_args)]
-pub struct RustCallIncorrectArgs {
+pub(crate) struct RustCallIncorrectArgs {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_yield_expr_outside_of_coroutine, code = E0627)]
-pub struct YieldExprOutsideOfCoroutine {
+pub(crate) struct YieldExprOutsideOfCoroutine {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_struct_expr_non_exhaustive, code = E0639)]
-pub struct StructExprNonExhaustive {
+pub(crate) struct StructExprNonExhaustive {
     #[primary_span]
     pub span: Span,
     pub what: &'static str,
@@ -79,21 +79,21 @@ pub struct StructExprNonExhaustive {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_functional_record_update_on_non_struct, code = E0436)]
-pub struct FunctionalRecordUpdateOnNonStruct {
+pub(crate) struct FunctionalRecordUpdateOnNonStruct {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_address_of_temporary_taken, code = E0745)]
-pub struct AddressOfTemporaryTaken {
+pub(crate) struct AddressOfTemporaryTaken {
     #[primary_span]
     #[label]
     pub span: Span,
 }
 
 #[derive(Subdiagnostic)]
-pub enum AddReturnTypeSuggestion {
+pub(crate) enum AddReturnTypeSuggestion {
     #[suggestion(
         hir_typeck_add_return_type_add,
         code = " -> {found}",
@@ -116,7 +116,7 @@ pub enum AddReturnTypeSuggestion {
 }
 
 #[derive(Subdiagnostic)]
-pub enum ExpectedReturnTypeLabel<'tcx> {
+pub(crate) enum ExpectedReturnTypeLabel<'tcx> {
     #[label(hir_typeck_expected_default_return_type)]
     Unit {
         #[primary_span]
@@ -132,7 +132,7 @@ pub enum ExpectedReturnTypeLabel<'tcx> {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_explicit_destructor, code = E0040)]
-pub struct ExplicitDestructorCall {
+pub(crate) struct ExplicitDestructorCall {
     #[primary_span]
     #[label]
     pub span: Span,
@@ -141,7 +141,7 @@ pub struct ExplicitDestructorCall {
 }
 
 #[derive(Subdiagnostic)]
-pub enum ExplicitDestructorCallSugg {
+pub(crate) enum ExplicitDestructorCallSugg {
     #[suggestion(hir_typeck_suggestion, code = "drop", applicability = "maybe-incorrect")]
     Empty(#[primary_span] Span),
     #[multipart_suggestion(hir_typeck_suggestion, style = "short")]
@@ -155,7 +155,7 @@ pub enum ExplicitDestructorCallSugg {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_missing_parentheses_in_range, code = E0689)]
-pub struct MissingParenthesesInRange {
+pub(crate) struct MissingParenthesesInRange {
     #[primary_span]
     #[label(hir_typeck_missing_parentheses_in_range)]
     pub span: Span,
@@ -166,7 +166,7 @@ pub struct MissingParenthesesInRange {
 }
 
 #[derive(LintDiagnostic)]
-pub enum NeverTypeFallbackFlowingIntoUnsafe {
+pub(crate) enum NeverTypeFallbackFlowingIntoUnsafe {
     #[help]
     #[diag(hir_typeck_never_type_fallback_flowing_into_unsafe_call)]
     Call,
@@ -187,7 +187,7 @@ pub enum NeverTypeFallbackFlowingIntoUnsafe {
 #[derive(LintDiagnostic)]
 #[help]
 #[diag(hir_typeck_dependency_on_unit_never_type_fallback)]
-pub struct DependencyOnUnitNeverTypeFallback<'tcx> {
+pub(crate) struct DependencyOnUnitNeverTypeFallback<'tcx> {
     #[note]
     pub obligation_span: Span,
     pub obligation: ty::Predicate<'tcx>,
@@ -199,7 +199,7 @@ pub struct DependencyOnUnitNeverTypeFallback<'tcx> {
     style = "verbose",
     applicability = "maybe-incorrect"
 )]
-pub struct AddMissingParenthesesInRange {
+pub(crate) struct AddMissingParenthesesInRange {
     pub func_name: String,
     #[suggestion_part(code = "(")]
     pub left: Span,
@@ -207,7 +207,7 @@ pub struct AddMissingParenthesesInRange {
     pub right: Span,
 }
 
-pub struct TypeMismatchFruTypo {
+pub(crate) struct TypeMismatchFruTypo {
     /// Span of the LHS of the range
     pub expr_span: Span,
     /// Span of the `..RHS` part of the range
@@ -246,7 +246,7 @@ impl Subdiagnostic for TypeMismatchFruTypo {
 #[derive(LintDiagnostic)]
 #[diag(hir_typeck_lossy_provenance_int2ptr)]
 #[help]
-pub struct LossyProvenanceInt2Ptr<'tcx> {
+pub(crate) struct LossyProvenanceInt2Ptr<'tcx> {
     pub expr_ty: Ty<'tcx>,
     pub cast_ty: Ty<'tcx>,
     #[subdiagnostic]
@@ -255,14 +255,14 @@ pub struct LossyProvenanceInt2Ptr<'tcx> {
 
 #[derive(LintDiagnostic)]
 #[diag(hir_typeck_ptr_cast_add_auto_to_object)]
-pub struct PtrCastAddAutoToObject {
+pub(crate) struct PtrCastAddAutoToObject {
     pub traits_len: usize,
     pub traits: DiagSymbolList<String>,
 }
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(hir_typeck_suggestion, applicability = "has-placeholders")]
-pub struct LossyProvenanceInt2PtrSuggestion {
+pub(crate) struct LossyProvenanceInt2PtrSuggestion {
     #[suggestion_part(code = "(...).with_addr(")]
     pub lo: Span,
     #[suggestion_part(code = ")")]
@@ -272,7 +272,7 @@ pub struct LossyProvenanceInt2PtrSuggestion {
 #[derive(LintDiagnostic)]
 #[diag(hir_typeck_lossy_provenance_ptr2int)]
 #[help]
-pub struct LossyProvenancePtr2Int<'tcx> {
+pub(crate) struct LossyProvenancePtr2Int<'tcx> {
     pub expr_ty: Ty<'tcx>,
     pub cast_ty: Ty<'tcx>,
     #[subdiagnostic]
@@ -280,7 +280,7 @@ pub struct LossyProvenancePtr2Int<'tcx> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum LossyProvenancePtr2IntSuggestion<'tcx> {
+pub(crate) enum LossyProvenancePtr2IntSuggestion<'tcx> {
     #[multipart_suggestion(hir_typeck_suggestion, applicability = "maybe-incorrect")]
     NeedsParensCast {
         #[suggestion_part(code = "(")]
@@ -314,7 +314,7 @@ pub enum LossyProvenancePtr2IntSuggestion<'tcx> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum HelpUseLatestEdition {
+pub(crate) enum HelpUseLatestEdition {
     #[help(hir_typeck_help_set_edition_cargo)]
     #[note(hir_typeck_note_edition_guide)]
     Cargo { edition: Edition },
@@ -324,7 +324,7 @@ pub enum HelpUseLatestEdition {
 }
 
 impl HelpUseLatestEdition {
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         let edition = LATEST_STABLE_EDITION;
         if rustc_session::utils::was_invoked_from_cargo() {
             Self::Cargo { edition }
@@ -336,7 +336,7 @@ impl HelpUseLatestEdition {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_invalid_callee, code = E0618)]
-pub struct InvalidCallee {
+pub(crate) struct InvalidCallee {
     #[primary_span]
     pub span: Span,
     pub ty: String,
@@ -344,7 +344,7 @@ pub struct InvalidCallee {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_int_to_fat, code = E0606)]
-pub struct IntToWide<'tcx> {
+pub(crate) struct IntToWide<'tcx> {
     #[primary_span]
     #[label(hir_typeck_int_to_fat_label)]
     pub span: Span,
@@ -357,7 +357,7 @@ pub struct IntToWide<'tcx> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum OptionResultRefMismatch {
+pub(crate) enum OptionResultRefMismatch {
     #[suggestion(
         hir_typeck_option_result_copied,
         code = ".copied()",
@@ -396,7 +396,7 @@ pub enum OptionResultRefMismatch {
     // },
 }
 
-pub struct RemoveSemiForCoerce {
+pub(crate) struct RemoveSemiForCoerce {
     pub expr: Span,
     pub ret: Span,
     pub semi: Span,
@@ -426,7 +426,7 @@ impl Subdiagnostic for RemoveSemiForCoerce {
 #[derive(Diagnostic)]
 #[diag(hir_typeck_const_select_must_be_const)]
 #[help]
-pub struct ConstSelectMustBeConst {
+pub(crate) struct ConstSelectMustBeConst {
     #[primary_span]
     pub span: Span,
 }
@@ -435,7 +435,7 @@ pub struct ConstSelectMustBeConst {
 #[diag(hir_typeck_const_select_must_be_fn)]
 #[note]
 #[help]
-pub struct ConstSelectMustBeFn<'a> {
+pub(crate) struct ConstSelectMustBeFn<'a> {
     #[primary_span]
     pub span: Span,
     pub ty: Ty<'a>,
@@ -443,14 +443,14 @@ pub struct ConstSelectMustBeFn<'a> {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_union_pat_multiple_fields)]
-pub struct UnionPatMultipleFields {
+pub(crate) struct UnionPatMultipleFields {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_union_pat_dotdot)]
-pub struct UnionPatDotDot {
+pub(crate) struct UnionPatDotDot {
     #[primary_span]
     pub span: Span,
 }
@@ -461,7 +461,7 @@ pub struct UnionPatDotDot {
     applicability = "maybe-incorrect",
     style = "verbose"
 )]
-pub struct UseIsEmpty {
+pub(crate) struct UseIsEmpty {
     #[suggestion_part(code = "!")]
     pub lo: Span,
     #[suggestion_part(code = ".is_empty()")]
@@ -471,13 +471,13 @@ pub struct UseIsEmpty {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_arg_mismatch_indeterminate)]
-pub struct ArgMismatchIndeterminate {
+pub(crate) struct ArgMismatchIndeterminate {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Subdiagnostic)]
-pub enum SuggestBoxing {
+pub(crate) enum SuggestBoxing {
     #[note(hir_typeck_suggest_boxing_note)]
     #[multipart_suggestion(
         hir_typeck_suggest_boxing_when_appropriate,
@@ -511,7 +511,7 @@ pub enum SuggestBoxing {
     style = "verbose",
     code = "core::ptr::null_mut()"
 )]
-pub struct SuggestPtrNullMut {
+pub(crate) struct SuggestPtrNullMut {
     #[primary_span]
     pub span: Span,
 }
@@ -519,7 +519,7 @@ pub struct SuggestPtrNullMut {
 #[derive(LintDiagnostic)]
 #[diag(hir_typeck_trivial_cast)]
 #[help]
-pub struct TrivialCast<'tcx> {
+pub(crate) struct TrivialCast<'tcx> {
     pub numeric: bool,
     pub expr_ty: Ty<'tcx>,
     pub cast_ty: Ty<'tcx>,
@@ -527,7 +527,7 @@ pub struct TrivialCast<'tcx> {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_no_associated_item, code = E0599)]
-pub struct NoAssociatedItem {
+pub(crate) struct NoAssociatedItem {
     #[primary_span]
     pub span: Span,
     pub item_kind: &'static str,
@@ -539,7 +539,7 @@ pub struct NoAssociatedItem {
 
 #[derive(Subdiagnostic)]
 #[note(hir_typeck_candidate_trait_note)]
-pub struct CandidateTraitNote {
+pub(crate) struct CandidateTraitNote {
     #[primary_span]
     pub span: Span,
     pub trait_name: String,
@@ -549,7 +549,7 @@ pub struct CandidateTraitNote {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_cannot_cast_to_bool, code = E0054)]
-pub struct CannotCastToBool<'tcx> {
+pub(crate) struct CannotCastToBool<'tcx> {
     #[primary_span]
     pub span: Span,
     pub expr_ty: Ty<'tcx>,
@@ -559,14 +559,14 @@ pub struct CannotCastToBool<'tcx> {
 
 #[derive(LintDiagnostic)]
 #[diag(hir_typeck_cast_enum_drop)]
-pub struct CastEnumDrop<'tcx> {
+pub(crate) struct CastEnumDrop<'tcx> {
     pub expr_ty: Ty<'tcx>,
     pub cast_ty: Ty<'tcx>,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_cast_unknown_pointer, code = E0641)]
-pub struct CastUnknownPointer {
+pub(crate) struct CastUnknownPointer {
     #[primary_span]
     pub span: Span,
     pub to: bool,
@@ -574,7 +574,7 @@ pub struct CastUnknownPointer {
     pub sub: CastUnknownPointerSub,
 }
 
-pub enum CastUnknownPointerSub {
+pub(crate) enum CastUnknownPointerSub {
     To(Span),
     From(Span),
 }
@@ -601,7 +601,7 @@ impl rustc_errors::Subdiagnostic for CastUnknownPointerSub {
 }
 
 #[derive(Subdiagnostic)]
-pub enum CannotCastToBoolHelp {
+pub(crate) enum CannotCastToBoolHelp {
     #[suggestion(
         hir_typeck_suggestion,
         applicability = "machine-applicable",
@@ -615,7 +615,7 @@ pub enum CannotCastToBoolHelp {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_ctor_is_private, code = E0603)]
-pub struct CtorIsPrivate {
+pub(crate) struct CtorIsPrivate {
     #[primary_span]
     pub span: Span,
     pub def: String,
@@ -623,7 +623,7 @@ pub struct CtorIsPrivate {
 
 #[derive(Subdiagnostic)]
 #[note(hir_typeck_deref_is_empty)]
-pub struct DerefImplsIsEmpty {
+pub(crate) struct DerefImplsIsEmpty {
     #[primary_span]
     pub span: Span,
     pub deref_ty: String,
@@ -635,7 +635,7 @@ pub struct DerefImplsIsEmpty {
     applicability = "machine-applicable",
     style = "verbose"
 )]
-pub struct SuggestConvertViaMethod<'tcx> {
+pub(crate) struct SuggestConvertViaMethod<'tcx> {
     #[suggestion_part(code = "{sugg}")]
     pub span: Span,
     #[suggestion_part(code = "")]
@@ -647,13 +647,13 @@ pub struct SuggestConvertViaMethod<'tcx> {
 
 #[derive(Subdiagnostic)]
 #[note(hir_typeck_note_caller_chooses_ty_for_ty_param)]
-pub struct NoteCallerChoosesTyForTyParam<'tcx> {
+pub(crate) struct NoteCallerChoosesTyForTyParam<'tcx> {
     pub ty_param_name: Symbol,
     pub found_ty: Ty<'tcx>,
 }
 
 #[derive(Subdiagnostic)]
-pub enum SuggestBoxingForReturnImplTrait {
+pub(crate) enum SuggestBoxingForReturnImplTrait {
     #[multipart_suggestion(hir_typeck_rpit_change_return_type, applicability = "maybe-incorrect")]
     ChangeReturnType {
         #[suggestion_part(code = "Box<dyn")]
@@ -672,7 +672,7 @@ pub enum SuggestBoxingForReturnImplTrait {
 
 #[derive(Diagnostic)]
 #[diag(hir_typeck_self_ctor_from_outer_item, code = E0401)]
-pub struct SelfCtorFromOuterItem {
+pub(crate) struct SelfCtorFromOuterItem {
     #[primary_span]
     pub span: Span,
     #[label]
@@ -683,7 +683,7 @@ pub struct SelfCtorFromOuterItem {
 
 #[derive(LintDiagnostic)]
 #[diag(hir_typeck_self_ctor_from_outer_item)]
-pub struct SelfCtorFromOuterItemLint {
+pub(crate) struct SelfCtorFromOuterItemLint {
     #[label]
     pub impl_span: Span,
     #[subdiagnostic]
@@ -692,7 +692,7 @@ pub struct SelfCtorFromOuterItemLint {
 
 #[derive(Subdiagnostic)]
 #[suggestion(hir_typeck_suggestion, code = "{name}", applicability = "machine-applicable")]
-pub struct ReplaceWithName {
+pub(crate) struct ReplaceWithName {
     #[primary_span]
     pub span: Span,
     pub name: String,
diff --git a/compiler/rustc_hir_typeck/src/expectation.rs b/compiler/rustc_hir_typeck/src/expectation.rs
index 76ae41db5c51c..67f4dbee3cb4a 100644
--- a/compiler/rustc_hir_typeck/src/expectation.rs
+++ b/compiler/rustc_hir_typeck/src/expectation.rs
@@ -7,7 +7,7 @@ use super::FnCtxt;
 /// When type-checking an expression, we propagate downward
 /// whatever type hint we are able in the form of an `Expectation`.
 #[derive(Copy, Clone, Debug)]
-pub enum Expectation<'tcx> {
+pub(crate) enum Expectation<'tcx> {
     /// We know nothing about what type this expression should have.
     NoExpectation,
 
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 91778a366684b..dd33b947b0d06 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -51,7 +51,7 @@ use crate::{
 };
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    pub fn check_expr_has_type_or_error(
+    pub(crate) fn check_expr_has_type_or_error(
         &self,
         expr: &'tcx hir::Expr<'tcx>,
         expected_ty: Ty<'tcx>,
@@ -977,7 +977,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     /// Check if the expression that could not be assigned to was a typoed expression that
-    pub fn check_for_missing_semi(&self, expr: &'tcx hir::Expr<'tcx>, err: &mut Diag<'_>) -> bool {
+    pub(crate) fn check_for_missing_semi(
+        &self,
+        expr: &'tcx hir::Expr<'tcx>,
+        err: &mut Diag<'_>,
+    ) -> bool {
         if let hir::ExprKind::Binary(binop, lhs, rhs) = expr.kind
             && let hir::BinOpKind::Mul = binop.node
             && self.tcx.sess.source_map().is_multiline(lhs.span.between(rhs.span))
diff --git a/compiler/rustc_hir_typeck/src/fallback.rs b/compiler/rustc_hir_typeck/src/fallback.rs
index 6e1b7504626d3..b1dc19b377746 100644
--- a/compiler/rustc_hir_typeck/src/fallback.rs
+++ b/compiler/rustc_hir_typeck/src/fallback.rs
@@ -18,7 +18,7 @@ use rustc_trait_selection::traits::{ObligationCause, ObligationCtxt};
 use crate::{errors, FnCtxt, TypeckRootCtxt};
 
 #[derive(Copy, Clone)]
-pub enum DivergingFallbackBehavior {
+pub(crate) enum DivergingFallbackBehavior {
     /// Always fallback to `()` (aka "always spontaneous decay")
     ToUnit,
     /// Sometimes fallback to `!`, but mainly fallback to `()` so that most of the crates are not broken.
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 21e6ac9332cdf..2d205d1ede9cd 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -132,18 +132,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         deferred_call_resolutions.remove(&closure_def_id).unwrap_or_default()
     }
 
-    pub fn tag(&self) -> String {
+    fn tag(&self) -> String {
         format!("{self:p}")
     }
 
-    pub fn local_ty(&self, span: Span, nid: HirId) -> Ty<'tcx> {
+    pub(crate) fn local_ty(&self, span: Span, nid: HirId) -> Ty<'tcx> {
         self.locals.borrow().get(&nid).cloned().unwrap_or_else(|| {
             span_bug!(span, "no type for local variable {}", self.tcx.hir().node_to_string(nid))
         })
     }
 
     #[inline]
-    pub fn write_ty(&self, id: HirId, ty: Ty<'tcx>) {
+    pub(crate) fn write_ty(&self, id: HirId, ty: Ty<'tcx>) {
         debug!("write_ty({:?}, {:?}) in fcx {}", id, self.resolve_vars_if_possible(ty), self.tag());
         let mut typeck = self.typeck_results.borrow_mut();
         let mut node_ty = typeck.node_types_mut();
@@ -165,7 +165,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn write_field_index(
+    pub(crate) fn write_field_index(
         &self,
         hir_id: HirId,
         index: FieldIdx,
@@ -198,7 +198,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         self.write_args(hir_id, method.args);
     }
 
-    pub fn write_args(&self, node_id: HirId, args: GenericArgsRef<'tcx>) {
+    fn write_args(&self, node_id: HirId, args: GenericArgsRef<'tcx>) {
         if !args.is_empty() {
             debug!("write_args({:?}, {:?}) in fcx {}", node_id, args, self.tag());
 
@@ -364,7 +364,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         )
     }
 
-    pub fn require_type_meets(
+    pub(crate) fn require_type_meets(
         &self,
         ty: Ty<'tcx>,
         span: Span,
@@ -374,7 +374,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         self.register_bound(ty, def_id, traits::ObligationCause::new(span, self.body_id, code));
     }
 
-    pub fn require_type_is_sized(
+    pub(crate) fn require_type_is_sized(
         &self,
         ty: Ty<'tcx>,
         span: Span,
@@ -386,7 +386,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn require_type_is_sized_deferred(
+    pub(crate) fn require_type_is_sized_deferred(
         &self,
         ty: Ty<'tcx>,
         span: Span,
@@ -397,7 +397,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn require_type_has_static_alignment(
+    pub(crate) fn require_type_has_static_alignment(
         &self,
         ty: Ty<'tcx>,
         span: Span,
@@ -426,7 +426,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn register_bound(
+    pub(crate) fn register_bound(
         &self,
         ty: Ty<'tcx>,
         def_id: DefId,
@@ -443,7 +443,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> LoweredTy<'tcx> {
+    pub(crate) fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> LoweredTy<'tcx> {
         let ty = self.lowerer().lower_ty(hir_ty);
         self.register_wf_obligation(ty.into(), hir_ty.span, ObligationCauseCode::WellFormed(None));
         LoweredTy::from_raw(self, hir_ty.span, ty)
@@ -474,7 +474,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn lower_array_length(&self, length: &hir::ArrayLen<'tcx>) -> ty::Const<'tcx> {
+    pub(crate) fn lower_array_length(&self, length: &hir::ArrayLen<'tcx>) -> ty::Const<'tcx> {
         match length {
             hir::ArrayLen::Infer(inf) => self.ct_infer(None, inf.span),
             hir::ArrayLen::Body(const_arg) => {
@@ -486,7 +486,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn lower_const_arg(
+    pub(crate) fn lower_const_arg(
         &self,
         const_arg: &'tcx hir::ConstArg<'tcx>,
         param_def_id: DefId,
@@ -515,7 +515,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         t.has_free_regions() || t.has_aliases() || t.has_infer_types()
     }
 
-    pub fn node_ty(&self, id: HirId) -> Ty<'tcx> {
+    pub(crate) fn node_ty(&self, id: HirId) -> Ty<'tcx> {
         match self.typeck_results.borrow().node_types().get(id) {
             Some(&t) => t,
             None if let Some(e) = self.tainted_by_errors() => Ty::new_error(self.tcx, e),
@@ -529,7 +529,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn node_ty_opt(&self, id: HirId) -> Option<Ty<'tcx>> {
+    pub(crate) fn node_ty_opt(&self, id: HirId) -> Option<Ty<'tcx>> {
         match self.typeck_results.borrow().node_types().get(id) {
             Some(&t) => Some(t),
             None if let Some(e) = self.tainted_by_errors() => Some(Ty::new_error(self.tcx, e)),
@@ -538,7 +538,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     /// Registers an obligation for checking later, during regionck, that `arg` is well-formed.
-    pub fn register_wf_obligation(
+    pub(crate) fn register_wf_obligation(
         &self,
         arg: ty::GenericArg<'tcx>,
         span: Span,
@@ -555,7 +555,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     /// Registers obligations that all `args` are well-formed.
-    pub fn add_wf_bounds(&self, args: GenericArgsRef<'tcx>, expr: &hir::Expr<'_>) {
+    pub(crate) fn add_wf_bounds(&self, args: GenericArgsRef<'tcx>, expr: &hir::Expr<'_>) {
         for arg in args.iter().filter(|arg| {
             matches!(arg.unpack(), GenericArgKind::Type(..) | GenericArgKind::Const(..))
         }) {
@@ -566,7 +566,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     // FIXME(arielb1): use this instead of field.ty everywhere
     // Only for fields! Returns <none> for methods>
     // Indifferent to privacy flags
-    pub fn field_ty(
+    pub(crate) fn field_ty(
         &self,
         span: Span,
         field: &'tcx ty::FieldDef,
@@ -897,7 +897,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     /// Given a `HirId`, return the `HirId` of the enclosing function, its `FnDecl`, and whether a
     /// suggestion can be made, `None` otherwise.
-    pub fn get_fn_decl(
+    pub(crate) fn get_fn_decl(
         &self,
         blk_id: HirId,
     ) -> Option<(LocalDefId, &'tcx hir::FnDecl<'tcx>, bool)> {
@@ -1534,7 +1534,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ///
     /// If no resolution is possible, then an error is reported.
     /// Numeric inference variables may be left unresolved.
-    pub fn structurally_resolve_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
+    pub(crate) fn structurally_resolve_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
         let ty = self.try_structurally_resolve_type(sp, ty);
 
         if !ty.is_ty_var() {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
index 130fd130ec837..a8ba9f139cc7e 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs
@@ -12,7 +12,7 @@ use rustc_trait_selection::traits;
 use crate::FnCtxt;
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    pub fn adjust_fulfillment_error_for_expr_obligation(
+    pub(crate) fn adjust_fulfillment_error_for_expr_obligation(
         &self,
         error: &mut traits::FulfillmentError<'tcx>,
     ) -> bool {
@@ -483,7 +483,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
      *
      * This function only updates the error span.
      */
-    pub fn blame_specific_expr_if_possible(
+    pub(crate) fn blame_specific_expr_if_possible(
         &self,
         error: &mut traits::FulfillmentError<'tcx>,
         expr: &'tcx hir::Expr<'tcx>,
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
index 788956894333b..cb77d3f85d935 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
@@ -17,7 +17,7 @@ rustc_index::newtype_index! {
 }
 
 impl ExpectedIdx {
-    pub fn to_provided_idx(self) -> ProvidedIdx {
+    pub(crate) fn to_provided_idx(self) -> ProvidedIdx {
         ProvidedIdx::from_usize(self.as_usize())
     }
 }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index aca29d4758708..5333982c42029 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -45,7 +45,7 @@ use crate::{
 };
 
 #[derive(Clone, Copy, Default)]
-pub enum DivergingBlockBehavior {
+pub(crate) enum DivergingBlockBehavior {
     /// This is the current stable behavior:
     ///
     /// ```rust
@@ -1556,7 +1556,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn check_struct_path(
+    pub(crate) fn check_struct_path(
         &self,
         qpath: &QPath<'tcx>,
         hir_id: HirId,
@@ -1622,7 +1622,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn check_decl_initializer(
+    fn check_decl_initializer(
         &self,
         hir_id: HirId,
         pat: &'tcx hir::Pat<'tcx>,
@@ -1700,7 +1700,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     /// Type check a `let` statement.
-    pub fn check_decl_local(&self, local: &'tcx hir::LetStmt<'tcx>) {
+    fn check_decl_local(&self, local: &'tcx hir::LetStmt<'tcx>) {
         self.check_decl(local.into());
         if local.pat.is_never_pattern() {
             self.diverges.set(Diverges::Always {
@@ -1710,7 +1710,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
+    fn check_stmt(&self, stmt: &'tcx hir::Stmt<'tcx>) {
         // Don't do all the complex logic below for `DeclItem`.
         match stmt.kind {
             hir::StmtKind::Item(..) => return,
@@ -1745,7 +1745,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         self.diverges.set(self.diverges.get() | old_diverges);
     }
 
-    pub fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
+    pub(crate) fn check_block_no_value(&self, blk: &'tcx hir::Block<'tcx>) {
         let unit = self.tcx.types.unit;
         let ty = self.check_block_with_expected(blk, ExpectHasType(unit));
 
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
index 33f80dd3773fa..8e69a075030be 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
@@ -117,7 +117,7 @@ pub(crate) struct FnCtxt<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    pub fn new(
+    pub(crate) fn new(
         root_ctxt: &'a TypeckRootCtxt<'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         body_id: LocalDefId,
@@ -148,15 +148,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         self.root_ctxt.infcx.dcx()
     }
 
-    pub fn cause(&self, span: Span, code: ObligationCauseCode<'tcx>) -> ObligationCause<'tcx> {
+    pub(crate) fn cause(
+        &self,
+        span: Span,
+        code: ObligationCauseCode<'tcx>,
+    ) -> ObligationCause<'tcx> {
         ObligationCause::new(span, self.body_id, code)
     }
 
-    pub fn misc(&self, span: Span) -> ObligationCause<'tcx> {
+    pub(crate) fn misc(&self, span: Span) -> ObligationCause<'tcx> {
         self.cause(span, ObligationCauseCode::Misc)
     }
 
-    pub fn sess(&self) -> &Session {
+    pub(crate) fn sess(&self) -> &Session {
         self.tcx.sess
     }
 
@@ -165,7 +169,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// Use [`InferCtxtErrorExt::err_ctxt`] to start one without a `TypeckResults`.
     ///
     /// [`InferCtxtErrorExt::err_ctxt`]: rustc_trait_selection::error_reporting::InferCtxtErrorExt::err_ctxt
-    pub fn err_ctxt(&'a self) -> TypeErrCtxt<'a, 'tcx> {
+    pub(crate) fn err_ctxt(&'a self) -> TypeErrCtxt<'a, 'tcx> {
         let mut sub_relations = SubRelations::default();
         sub_relations.add_constraints(
             self,
@@ -365,7 +369,7 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
 /// This is a bridge between the interface of HIR ty lowering, which outputs a raw
 /// `Ty`, and the API in this module, which expect `Ty` to be fully normalized.
 #[derive(Clone, Copy, Debug)]
-pub struct LoweredTy<'tcx> {
+pub(crate) struct LoweredTy<'tcx> {
     /// The unnormalized type provided by the user.
     pub raw: Ty<'tcx>,
 
@@ -374,7 +378,7 @@ pub struct LoweredTy<'tcx> {
 }
 
 impl<'tcx> LoweredTy<'tcx> {
-    pub fn from_raw(fcx: &FnCtxt<'_, 'tcx>, span: Span, raw: Ty<'tcx>) -> LoweredTy<'tcx> {
+    fn from_raw(fcx: &FnCtxt<'_, 'tcx>, span: Span, raw: Ty<'tcx>) -> LoweredTy<'tcx> {
         // FIXME(-Znext-solver): We're still figuring out how to best handle
         // normalization and this doesn't feel too great. We should look at this
         // code again before stabilizing it.
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index 11c6e65a21101..031aa6159d2bc 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -64,7 +64,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// - Points out the method's return type as the reason for the expected type.
     /// - Possible missing semicolon.
     /// - Possible missing return type if the return type is the default, and not `fn main()`.
-    pub fn suggest_mismatched_types_on_tail(
+    pub(crate) fn suggest_mismatched_types_on_tail(
         &self,
         err: &mut Diag<'_>,
         expr: &'tcx hir::Expr<'tcx>,
@@ -177,7 +177,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         self.err_ctxt().extract_callable_info(self.body_id, self.param_env, ty)
     }
 
-    pub fn suggest_two_fn_call(
+    pub(crate) fn suggest_two_fn_call(
         &self,
         err: &mut Diag<'_>,
         lhs_expr: &'tcx hir::Expr<'tcx>,
@@ -251,7 +251,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn suggest_remove_last_method_call(
+    pub(crate) fn suggest_remove_last_method_call(
         &self,
         err: &mut Diag<'_>,
         expr: &hir::Expr<'tcx>,
@@ -280,7 +280,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         false
     }
 
-    pub fn suggest_deref_ref_or_into(
+    pub(crate) fn suggest_deref_ref_or_into(
         &self,
         err: &mut Diag<'_>,
         expr: &hir::Expr<'tcx>,
@@ -747,7 +747,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ///
     /// If the expression is the expression of a closure without block (`|| expr`), a
     /// block is needed to be added too (`|| { expr; }`). This is denoted by `needs_block`.
-    pub fn suggest_missing_semicolon(
+    pub(crate) fn suggest_missing_semicolon(
         &self,
         err: &mut Diag<'_>,
         expression: &'tcx hir::Expr<'tcx>,
@@ -2077,7 +2077,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     // If the expr is a while or for loop and is the tail expr of its
     // enclosing body suggest returning a value right after it
-    pub fn suggest_returning_value_after_loop(
+    pub(crate) fn suggest_returning_value_after_loop(
         &self,
         err: &mut Diag<'_>,
         expr: &hir::Expr<'tcx>,
diff --git a/compiler/rustc_hir_typeck/src/intrinsicck.rs b/compiler/rustc_hir_typeck/src/intrinsicck.rs
index a9c929e76d5bf..62aa29e673def 100644
--- a/compiler/rustc_hir_typeck/src/intrinsicck.rs
+++ b/compiler/rustc_hir_typeck/src/intrinsicck.rs
@@ -38,7 +38,7 @@ fn unpack_option_like<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
 }
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    pub fn check_transmute(&self, from: Ty<'tcx>, to: Ty<'tcx>, hir_id: HirId) {
+    pub(crate) fn check_transmute(&self, from: Ty<'tcx>, to: Ty<'tcx>, hir_id: HirId) {
         let tcx = self.tcx;
         let dl = &tcx.data_layout;
         let span = tcx.hir().span(hir_id);
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 8ff4c11f24a83..8e6484f1e2934 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -8,6 +8,7 @@
 #![feature(let_chains)]
 #![feature(never_type)]
 #![feature(try_blocks)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 #[macro_use]
diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs
index e0c0adac0767c..2c3cfcf3cbd63 100644
--- a/compiler/rustc_hir_typeck/src/method/confirm.rs
+++ b/compiler/rustc_hir_typeck/src/method/confirm.rs
@@ -42,13 +42,13 @@ impl<'a, 'tcx> Deref for ConfirmContext<'a, 'tcx> {
 }
 
 #[derive(Debug)]
-pub struct ConfirmResult<'tcx> {
+pub(crate) struct ConfirmResult<'tcx> {
     pub callee: MethodCallee<'tcx>,
     pub illegal_sized_bound: Option<Span>,
 }
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    pub fn confirm_method(
+    pub(crate) fn confirm_method(
         &self,
         span: Span,
         self_expr: &'tcx hir::Expr<'tcx>,
@@ -66,7 +66,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         confirm_cx.confirm(unadjusted_self_ty, pick, segment)
     }
 
-    pub fn confirm_method_for_diagnostic(
+    pub(crate) fn confirm_method_for_diagnostic(
         &self,
         span: Span,
         self_expr: &'tcx hir::Expr<'tcx>,
diff --git a/compiler/rustc_hir_typeck/src/method/mod.rs b/compiler/rustc_hir_typeck/src/method/mod.rs
index d6110ab94c15a..39307a29dad1f 100644
--- a/compiler/rustc_hir_typeck/src/method/mod.rs
+++ b/compiler/rustc_hir_typeck/src/method/mod.rs
@@ -4,7 +4,7 @@
 
 mod confirm;
 mod prelude_edition_lints;
-pub mod probe;
+pub(crate) mod probe;
 mod suggest;
 
 use rustc_errors::{Applicability, Diag, SubdiagMessage};
@@ -24,15 +24,15 @@ use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
 use rustc_trait_selection::traits::{self, NormalizeExt};
 
 use self::probe::{IsSuggestion, ProbeScope};
-pub use self::MethodError::*;
+pub(crate) use self::MethodError::*;
 use crate::FnCtxt;
 
-pub fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers) {
     probe::provide(providers);
 }
 
 #[derive(Clone, Copy, Debug)]
-pub struct MethodCallee<'tcx> {
+pub(crate) struct MethodCallee<'tcx> {
     /// Impl method ID, for inherent methods, or trait method ID, otherwise.
     pub def_id: DefId,
     pub args: GenericArgsRef<'tcx>,
@@ -44,7 +44,7 @@ pub struct MethodCallee<'tcx> {
 }
 
 #[derive(Debug)]
-pub enum MethodError<'tcx> {
+pub(crate) enum MethodError<'tcx> {
     // Did not find an applicable method, but we did find various near-misses that may work.
     NoMatch(NoMatchData<'tcx>),
 
@@ -70,7 +70,7 @@ pub enum MethodError<'tcx> {
 // Contains a list of static methods that may apply, a list of unsatisfied trait predicates which
 // could lead to matches if satisfied, and a list of not-in-scope traits which may work.
 #[derive(Debug)]
-pub struct NoMatchData<'tcx> {
+pub(crate) struct NoMatchData<'tcx> {
     pub static_candidates: Vec<CandidateSource>,
     pub unsatisfied_predicates:
         Vec<(ty::Predicate<'tcx>, Option<ty::Predicate<'tcx>>, Option<ObligationCause<'tcx>>)>,
@@ -82,7 +82,7 @@ pub struct NoMatchData<'tcx> {
 // A pared down enum describing just the places from which a method
 // candidate can arise. Used for error reporting only.
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum CandidateSource {
+pub(crate) enum CandidateSource {
     Impl(DefId),
     Trait(DefId /* trait id */),
 }
@@ -254,7 +254,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         Ok(result.callee)
     }
 
-    pub fn lookup_method_for_diagnostic(
+    pub(crate) fn lookup_method_for_diagnostic(
         &self,
         self_ty: Ty<'tcx>,
         segment: &hir::PathSegment<'tcx>,
@@ -296,7 +296,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         Ok(pick)
     }
 
-    pub fn lookup_probe_for_diagnostic(
+    pub(crate) fn lookup_probe_for_diagnostic(
         &self,
         method_name: Ident,
         self_ty: Ty<'tcx>,
@@ -569,7 +569,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     /// Finds item with name `item_name` defined in impl/trait `def_id`
     /// and return it, or `None`, if no such item was defined there.
-    pub fn associated_value(&self, def_id: DefId, item_name: Ident) -> Option<ty::AssocItem> {
+    fn associated_value(&self, def_id: DefId, item_name: Ident) -> Option<ty::AssocItem> {
         self.tcx
             .associated_items(def_id)
             .find_by_name_and_namespace(self.tcx, item_name, Namespace::ValueNS, def_id)
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
index 28f537c87c4ee..48e33c81b852b 100644
--- a/compiler/rustc_hir_typeck/src/method/probe.rs
+++ b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -38,14 +38,14 @@ use rustc_trait_selection::traits::{self, ObligationCause, ObligationCtxt};
 use smallvec::{smallvec, SmallVec};
 
 use self::CandidateKind::*;
-pub use self::PickKind::*;
+pub(crate) use self::PickKind::*;
 use super::{suggest, CandidateSource, MethodError, NoMatchData};
 use crate::FnCtxt;
 
 /// Boolean flag used to indicate if this search is for a suggestion
 /// or not. If true, we can allow ambiguity and so forth.
 #[derive(Clone, Copy, Debug)]
-pub struct IsSuggestion(pub bool);
+pub(crate) struct IsSuggestion(pub bool);
 
 pub(crate) struct ProbeContext<'a, 'tcx> {
     fcx: &'a FnCtxt<'a, 'tcx>,
@@ -134,7 +134,7 @@ enum ProbeResult {
 /// (at most) one of these. Either the receiver has type `T` and we convert it to `&T` (or with
 /// `mut`), or it has type `*mut T` and we convert it to `*const T`.
 #[derive(Debug, PartialEq, Copy, Clone)]
-pub enum AutorefOrPtrAdjustment {
+pub(crate) enum AutorefOrPtrAdjustment {
     /// Receiver has type `T`, add `&` or `&mut` (it `T` is `mut`), and maybe also "unsize" it.
     /// Unsizing is used to convert a `[T; N]` to `[T]`, which only makes sense when autorefing.
     Autoref {
@@ -158,7 +158,7 @@ impl AutorefOrPtrAdjustment {
 }
 
 #[derive(Debug, Clone)]
-pub struct Pick<'tcx> {
+pub(crate) struct Pick<'tcx> {
     pub item: ty::AssocItem,
     pub kind: PickKind<'tcx>,
     pub import_ids: SmallVec<[LocalDefId; 1]>,
@@ -179,7 +179,7 @@ pub struct Pick<'tcx> {
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
-pub enum PickKind<'tcx> {
+pub(crate) enum PickKind<'tcx> {
     InherentImplPick,
     ObjectPick,
     TraitPick,
@@ -189,10 +189,10 @@ pub enum PickKind<'tcx> {
     ),
 }
 
-pub type PickResult<'tcx> = Result<Pick<'tcx>, MethodError<'tcx>>;
+pub(crate) type PickResult<'tcx> = Result<Pick<'tcx>, MethodError<'tcx>>;
 
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
-pub enum Mode {
+pub(crate) enum Mode {
     // An expression of the form `receiver.method_name(...)`.
     // Autoderefs are performed on `receiver`, lookup is done based on the
     // `self` argument of the method, and static methods aren't considered.
@@ -204,7 +204,7 @@ pub enum Mode {
 }
 
 #[derive(PartialEq, Eq, Copy, Clone, Debug)]
-pub enum ProbeScope {
+pub(crate) enum ProbeScope {
     // Single candidate coming from pre-resolved delegation method.
     Single(DefId),
 
@@ -507,7 +507,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 }
 
-pub fn provide(providers: &mut Providers) {
+pub(crate) fn provide(providers: &mut Providers) {
     providers.method_autoderef_steps = method_autoderef_steps;
 }
 
@@ -1288,7 +1288,7 @@ impl<'tcx> Pick<'tcx> {
     /// Checks whether two picks do not refer to the same trait item for the same `Self` type.
     /// Only useful for comparisons of picks in order to improve diagnostics.
     /// Do not use for type checking.
-    pub fn differs_from(&self, other: &Self) -> bool {
+    pub(crate) fn differs_from(&self, other: &Self) -> bool {
         let Self {
             item:
                 AssocItem {
@@ -1312,7 +1312,7 @@ impl<'tcx> Pick<'tcx> {
     }
 
     /// In case there were unstable name collisions, emit them as a lint.
-    pub fn maybe_emit_unstable_name_collision_hint(
+    pub(crate) fn maybe_emit_unstable_name_collision_hint(
         &self,
         tcx: TyCtxt<'tcx>,
         span: Span,
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 8b8bb29dacdbd..b78bb8cb98db7 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -415,7 +415,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         err
     }
 
-    pub fn suggest_use_shadowed_binding_with_method(
+    fn suggest_use_shadowed_binding_with_method(
         &self,
         self_source: SelfSource<'tcx>,
         method_name: Ident,
@@ -4223,19 +4223,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 #[derive(Copy, Clone, Debug)]
-pub enum SelfSource<'a> {
+enum SelfSource<'a> {
     QPath(&'a hir::Ty<'a>),
     MethodCall(&'a hir::Expr<'a> /* rcvr */),
 }
 
 #[derive(Copy, Clone, PartialEq, Eq)]
-pub struct TraitInfo {
+pub(crate) struct TraitInfo {
     pub def_id: DefId,
 }
 
 /// Retrieves all traits in this crate and any dependent crates,
 /// and wraps them into `TraitInfo` for custom sorting.
-pub fn all_traits(tcx: TyCtxt<'_>) -> Vec<TraitInfo> {
+pub(crate) fn all_traits(tcx: TyCtxt<'_>) -> Vec<TraitInfo> {
     tcx.all_traits().map(|def_id| TraitInfo { def_id }).collect()
 }
 
diff --git a/compiler/rustc_hir_typeck/src/op.rs b/compiler/rustc_hir_typeck/src/op.rs
index c54f6cfd0999a..fb0d30d5b0ef2 100644
--- a/compiler/rustc_hir_typeck/src/op.rs
+++ b/compiler/rustc_hir_typeck/src/op.rs
@@ -25,7 +25,7 @@ use crate::Expectation;
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// Checks a `a <op>= b`
-    pub fn check_binop_assign(
+    pub(crate) fn check_binop_assign(
         &self,
         expr: &'tcx hir::Expr<'tcx>,
         op: hir::BinOp,
@@ -84,7 +84,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     /// Checks a potentially overloaded binary operator.
-    pub fn check_binop(
+    pub(crate) fn check_binop(
         &self,
         expr: &'tcx hir::Expr<'tcx>,
         op: hir::BinOp,
@@ -770,7 +770,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn check_user_unop(
+    pub(crate) fn check_user_unop(
         &self,
         ex: &'tcx hir::Expr<'tcx>,
         operand_ty: Ty<'tcx>,
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index a8e5e09c8bbeb..206de455cd575 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -944,7 +944,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    pub fn check_dereferenceable(
+    fn check_dereferenceable(
         &self,
         span: Span,
         expected: Ty<'tcx>,
diff --git a/compiler/rustc_hir_typeck/src/place_op.rs b/compiler/rustc_hir_typeck/src/place_op.rs
index ad04b6b8b1df5..bb22727258423 100644
--- a/compiler/rustc_hir_typeck/src/place_op.rs
+++ b/compiler/rustc_hir_typeck/src/place_op.rs
@@ -246,7 +246,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     /// always know whether a place needs to be mutable or not in the first pass.
     /// This happens whether there is an implicit mutable reborrow, e.g. when the type
     /// is used as the receiver of a method call.
-    pub fn convert_place_derefs_to_mutable(&self, expr: &hir::Expr<'_>) {
+    pub(crate) fn convert_place_derefs_to_mutable(&self, expr: &hir::Expr<'_>) {
         // Gather up expressions we want to munge.
         let mut exprs = vec![expr];
 
diff --git a/compiler/rustc_hir_typeck/src/rvalue_scopes.rs b/compiler/rustc_hir_typeck/src/rvalue_scopes.rs
index f22a13d292e0f..fb0fe23be65fc 100644
--- a/compiler/rustc_hir_typeck/src/rvalue_scopes.rs
+++ b/compiler/rustc_hir_typeck/src/rvalue_scopes.rs
@@ -65,7 +65,7 @@ fn record_rvalue_scope(
     }
 }
 
-pub fn resolve_rvalue_scopes<'a, 'tcx>(
+pub(crate) fn resolve_rvalue_scopes<'a, 'tcx>(
     fcx: &'a FnCtxt<'a, 'tcx>,
     scope_tree: &'a ScopeTree,
     def_id: DefId,
diff --git a/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs b/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
index a43164589b5f3..e6b8da3e5d6ba 100644
--- a/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
+++ b/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
@@ -77,7 +77,7 @@ impl<'tcx> Deref for TypeckRootCtxt<'tcx> {
 }
 
 impl<'tcx> TypeckRootCtxt<'tcx> {
-    pub fn new(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Self {
+    pub(crate) fn new(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Self {
         let hir_owner = tcx.local_def_id_to_hir_id(def_id).owner;
 
         let infcx = tcx.infer_ctxt().ignoring_regions().with_opaque_type_inference(def_id).build();
@@ -124,7 +124,7 @@ impl<'tcx> TypeckRootCtxt<'tcx> {
         infer_ok.value
     }
 
-    pub fn update_infer_var_info(&self, obligation: &PredicateObligation<'tcx>) {
+    fn update_infer_var_info(&self, obligation: &PredicateObligation<'tcx>) {
         let infer_var_info = &mut self.infer_var_info.borrow_mut();
 
         // (*) binder skipped
diff --git a/compiler/rustc_hir_typeck/src/upvar.rs b/compiler/rustc_hir_typeck/src/upvar.rs
index 55f002291f071..5350affb3bc48 100644
--- a/compiler/rustc_hir_typeck/src/upvar.rs
+++ b/compiler/rustc_hir_typeck/src/upvar.rs
@@ -74,7 +74,7 @@ enum PlaceAncestryRelation {
 type InferredCaptureInformation<'tcx> = Vec<(Place<'tcx>, ty::CaptureInfo)>;
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    pub fn closure_analyze(&self, body: &'tcx hir::Body<'tcx>) {
+    pub(crate) fn closure_analyze(&self, body: &'tcx hir::Body<'tcx>) {
         InferBorrowKindVisitor { fcx: self }.visit_body(body);
 
         // it's our job to process these.
diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
index 0327a3097eca2..0853ed9b05bfb 100644
--- a/compiler/rustc_hir_typeck/src/writeback.rs
+++ b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -35,7 +35,7 @@ use crate::FnCtxt;
 // resolve_type_vars_in_body, which creates a new TypeTables which
 // doesn't contain any inference types.
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
-    pub fn resolve_type_vars_in_body(
+    pub(crate) fn resolve_type_vars_in_body(
         &self,
         body: &'tcx hir::Body<'tcx>,
     ) -> &'tcx ty::TypeckResults<'tcx> {

From 969f9702dad51b288bc7b3b399ae96a6d0711cdb Mon Sep 17 00:00:00 2001
From: beetrees <b@beetr.ee>
Date: Tue, 27 Aug 2024 05:25:34 +0100
Subject: [PATCH 642/685] Fix typos in floating-point primitive type docs

---
 library/core/src/primitive_docs.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/library/core/src/primitive_docs.rs b/library/core/src/primitive_docs.rs
index 09ebef89fb0c2..70cfae3f7d991 100644
--- a/library/core/src/primitive_docs.rs
+++ b/library/core/src/primitive_docs.rs
@@ -1130,7 +1130,7 @@ impl<T> (T,) {}
 /// A 16-bit floating point type (specifically, the "binary16" type defined in IEEE 754-2008).
 ///
 /// This type is very similar to [`prim@f32`] but has decreased precision because it uses half as many
-/// bits. Please see [the documentation for [`prim@f32`] or [Wikipedia on
+/// bits. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on
 /// half-precision values][wikipedia] for more information.
 ///
 /// Note that most common platforms will not support `f16` in hardware without enabling extra target
@@ -1235,12 +1235,12 @@ mod prim_f64 {}
 /// A 128-bit floating point type (specifically, the "binary128" type defined in IEEE 754-2008).
 ///
 /// This type is very similar to [`prim@f32`] and [`prim@f64`], but has increased precision by using twice
-/// as many bits as `f64`. Please see [the documentation for [`prim@f32`] or [Wikipedia on
+/// as many bits as `f64`. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on
 /// quad-precision values][wikipedia] for more information.
 ///
 /// Note that no platforms have hardware support for `f128` without enabling target specific features,
 /// as for all instruction set architectures `f128` is considered an optional feature.
-/// Only Power ISA ("PowerPC") and RISCV specify it, and only certain microarchitectures
+/// Only Power ISA ("PowerPC") and RISC-V specify it, and only certain microarchitectures
 /// actually implement it. For x86-64 and AArch64, ISA support is not even specified,
 /// so it will always be a software implementation significantly slower than `f64`.
 ///

From d0548359b5810c5c509e01de58fd47a1c3c6a385 Mon Sep 17 00:00:00 2001
From: beetrees <b@beetr.ee>
Date: Tue, 27 Aug 2024 05:26:28 +0100
Subject: [PATCH 643/685] Reflow a couple of paragraphs in floating-point
 primitive docs

---
 library/core/src/primitive_docs.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/library/core/src/primitive_docs.rs b/library/core/src/primitive_docs.rs
index 70cfae3f7d991..a08b0ff60175f 100644
--- a/library/core/src/primitive_docs.rs
+++ b/library/core/src/primitive_docs.rs
@@ -1130,8 +1130,8 @@ impl<T> (T,) {}
 /// A 16-bit floating point type (specifically, the "binary16" type defined in IEEE 754-2008).
 ///
 /// This type is very similar to [`prim@f32`] but has decreased precision because it uses half as many
-/// bits. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on
-/// half-precision values][wikipedia] for more information.
+/// bits. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on half-precision
+/// values][wikipedia] for more information.
 ///
 /// Note that most common platforms will not support `f16` in hardware without enabling extra target
 /// features, with the notable exception of Apple Silicon (also known as M1, M2, etc.) processors.
@@ -1218,14 +1218,12 @@ mod prim_f32 {}
 #[doc(alias = "double")]
 /// A 64-bit floating point type (specifically, the "binary64" type defined in IEEE 754-2008).
 ///
-/// This type is very similar to [`f32`], but has increased
-/// precision by using twice as many bits. Please see [the documentation for
-/// `f32`][`f32`] or [Wikipedia on double precision
+/// This type is very similar to [`prim@f32`], but has increased precision by using twice as many
+/// bits. Please see [the documentation for `f32`](prim@f32) or [Wikipedia on double-precision
 /// values][wikipedia] for more information.
 ///
 /// *[See also the `std::f64::consts` module](crate::f64::consts).*
 ///
-/// [`f32`]: prim@f32
 /// [wikipedia]: https://en.wikipedia.org/wiki/Double-precision_floating-point_format
 #[stable(feature = "rust1", since = "1.0.0")]
 mod prim_f64 {}

From 37becf7bdcff5037cbb214277eb74ef17d8527f0 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 14:30:20 +1000
Subject: [PATCH 644/685] Add `warn(unreachable_pub)` to `rustc_incremental`.

---
 .../rustc_incremental/src/assert_dep_graph.rs |  4 +-
 compiler/rustc_incremental/src/errors.rs      | 82 +++++++++----------
 compiler/rustc_incremental/src/lib.rs         |  1 +
 .../rustc_incremental/src/persist/data.rs     |  2 +-
 .../src/persist/dirty_clean.rs                |  6 +-
 .../src/persist/file_format.rs                |  2 +-
 compiler/rustc_incremental/src/persist/fs.rs  |  2 +-
 7 files changed, 50 insertions(+), 49 deletions(-)

diff --git a/compiler/rustc_incremental/src/assert_dep_graph.rs b/compiler/rustc_incremental/src/assert_dep_graph.rs
index b29ba59c9f351..46f30526d2a83 100644
--- a/compiler/rustc_incremental/src/assert_dep_graph.rs
+++ b/compiler/rustc_incremental/src/assert_dep_graph.rs
@@ -55,7 +55,7 @@ use {rustc_ast as ast, rustc_graphviz as dot, rustc_hir as hir};
 use crate::errors;
 
 #[allow(missing_docs)]
-pub fn assert_dep_graph(tcx: TyCtxt<'_>) {
+pub(crate) fn assert_dep_graph(tcx: TyCtxt<'_>) {
     tcx.dep_graph.with_ignore(|| {
         if tcx.sess.opts.unstable_opts.dump_dep_graph {
             tcx.dep_graph.with_query(dump_graph);
@@ -261,7 +261,7 @@ fn dump_graph(query: &DepGraphQuery) {
 }
 
 #[allow(missing_docs)]
-pub struct GraphvizDepGraph(FxIndexSet<DepKind>, Vec<(DepKind, DepKind)>);
+struct GraphvizDepGraph(FxIndexSet<DepKind>, Vec<(DepKind, DepKind)>);
 
 impl<'a> dot::GraphWalk<'a> for GraphvizDepGraph {
     type Node = DepKind;
diff --git a/compiler/rustc_incremental/src/errors.rs b/compiler/rustc_incremental/src/errors.rs
index c6f8b99bcd67b..cb21f9758789c 100644
--- a/compiler/rustc_incremental/src/errors.rs
+++ b/compiler/rustc_incremental/src/errors.rs
@@ -6,7 +6,7 @@ use rustc_span::{Span, Symbol};
 
 #[derive(Diagnostic)]
 #[diag(incremental_unrecognized_depnode)]
-pub struct UnrecognizedDepNode {
+pub(crate) struct UnrecognizedDepNode {
     #[primary_span]
     pub span: Span,
     pub name: Symbol,
@@ -14,28 +14,28 @@ pub struct UnrecognizedDepNode {
 
 #[derive(Diagnostic)]
 #[diag(incremental_missing_depnode)]
-pub struct MissingDepNode {
+pub(crate) struct MissingDepNode {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_missing_if_this_changed)]
-pub struct MissingIfThisChanged {
+pub(crate) struct MissingIfThisChanged {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_ok)]
-pub struct Ok {
+pub(crate) struct Ok {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_no_path)]
-pub struct NoPath {
+pub(crate) struct NoPath {
     #[primary_span]
     pub span: Span,
     pub target: Symbol,
@@ -44,7 +44,7 @@ pub struct NoPath {
 
 #[derive(Diagnostic)]
 #[diag(incremental_assertion_auto)]
-pub struct AssertionAuto<'a> {
+pub(crate) struct AssertionAuto<'a> {
     #[primary_span]
     pub span: Span,
     pub name: &'a str,
@@ -53,7 +53,7 @@ pub struct AssertionAuto<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_undefined_clean_dirty_assertions_item)]
-pub struct UndefinedCleanDirtyItem {
+pub(crate) struct UndefinedCleanDirtyItem {
     #[primary_span]
     pub span: Span,
     pub kind: String,
@@ -61,7 +61,7 @@ pub struct UndefinedCleanDirtyItem {
 
 #[derive(Diagnostic)]
 #[diag(incremental_undefined_clean_dirty_assertions)]
-pub struct UndefinedCleanDirty {
+pub(crate) struct UndefinedCleanDirty {
     #[primary_span]
     pub span: Span,
     pub kind: String,
@@ -69,7 +69,7 @@ pub struct UndefinedCleanDirty {
 
 #[derive(Diagnostic)]
 #[diag(incremental_repeated_depnode_label)]
-pub struct RepeatedDepNodeLabel<'a> {
+pub(crate) struct RepeatedDepNodeLabel<'a> {
     #[primary_span]
     pub span: Span,
     pub label: &'a str,
@@ -77,7 +77,7 @@ pub struct RepeatedDepNodeLabel<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_unrecognized_depnode_label)]
-pub struct UnrecognizedDepNodeLabel<'a> {
+pub(crate) struct UnrecognizedDepNodeLabel<'a> {
     #[primary_span]
     pub span: Span,
     pub label: &'a str,
@@ -85,7 +85,7 @@ pub struct UnrecognizedDepNodeLabel<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_not_dirty)]
-pub struct NotDirty<'a> {
+pub(crate) struct NotDirty<'a> {
     #[primary_span]
     pub span: Span,
     pub dep_node_str: &'a str,
@@ -93,7 +93,7 @@ pub struct NotDirty<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_not_clean)]
-pub struct NotClean<'a> {
+pub(crate) struct NotClean<'a> {
     #[primary_span]
     pub span: Span,
     pub dep_node_str: &'a str,
@@ -101,7 +101,7 @@ pub struct NotClean<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_not_loaded)]
-pub struct NotLoaded<'a> {
+pub(crate) struct NotLoaded<'a> {
     #[primary_span]
     pub span: Span,
     pub dep_node_str: &'a str,
@@ -109,7 +109,7 @@ pub struct NotLoaded<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_unknown_item)]
-pub struct UnknownItem {
+pub(crate) struct UnknownItem {
     #[primary_span]
     pub span: Span,
     pub name: Symbol,
@@ -117,14 +117,14 @@ pub struct UnknownItem {
 
 #[derive(Diagnostic)]
 #[diag(incremental_no_cfg)]
-pub struct NoCfg {
+pub(crate) struct NoCfg {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_associated_value_expected_for)]
-pub struct AssociatedValueExpectedFor {
+pub(crate) struct AssociatedValueExpectedFor {
     #[primary_span]
     pub span: Span,
     pub ident: Ident,
@@ -132,21 +132,21 @@ pub struct AssociatedValueExpectedFor {
 
 #[derive(Diagnostic)]
 #[diag(incremental_associated_value_expected)]
-pub struct AssociatedValueExpected {
+pub(crate) struct AssociatedValueExpected {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_unchecked_clean)]
-pub struct UncheckedClean {
+pub(crate) struct UncheckedClean {
     #[primary_span]
     pub span: Span,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_delete_old)]
-pub struct DeleteOld<'a> {
+pub(crate) struct DeleteOld<'a> {
     pub name: &'a str,
     pub path: PathBuf,
     pub err: std::io::Error,
@@ -154,7 +154,7 @@ pub struct DeleteOld<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_create_new)]
-pub struct CreateNew<'a> {
+pub(crate) struct CreateNew<'a> {
     pub name: &'a str,
     pub path: PathBuf,
     pub err: std::io::Error,
@@ -162,7 +162,7 @@ pub struct CreateNew<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_write_new)]
-pub struct WriteNew<'a> {
+pub(crate) struct WriteNew<'a> {
     pub name: &'a str,
     pub path: PathBuf,
     pub err: std::io::Error,
@@ -170,14 +170,14 @@ pub struct WriteNew<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_canonicalize_path)]
-pub struct CanonicalizePath {
+pub(crate) struct CanonicalizePath {
     pub path: PathBuf,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_create_incr_comp_dir)]
-pub struct CreateIncrCompDir<'a> {
+pub(crate) struct CreateIncrCompDir<'a> {
     pub tag: &'a str,
     pub path: &'a Path,
     pub err: std::io::Error,
@@ -185,7 +185,7 @@ pub struct CreateIncrCompDir<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_create_lock)]
-pub struct CreateLock<'a> {
+pub(crate) struct CreateLock<'a> {
     pub lock_err: std::io::Error,
     pub session_dir: &'a Path,
     #[note(incremental_lock_unsupported)]
@@ -197,84 +197,84 @@ pub struct CreateLock<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_delete_lock)]
-pub struct DeleteLock<'a> {
+pub(crate) struct DeleteLock<'a> {
     pub path: &'a Path,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_hard_link_failed)]
-pub struct HardLinkFailed<'a> {
+pub(crate) struct HardLinkFailed<'a> {
     pub path: &'a Path,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_delete_partial)]
-pub struct DeletePartial<'a> {
+pub(crate) struct DeletePartial<'a> {
     pub path: &'a Path,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_delete_full)]
-pub struct DeleteFull<'a> {
+pub(crate) struct DeleteFull<'a> {
     pub path: &'a Path,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_finalize)]
-pub struct Finalize<'a> {
+pub(crate) struct Finalize<'a> {
     pub path: &'a Path,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_invalid_gc_failed)]
-pub struct InvalidGcFailed<'a> {
+pub(crate) struct InvalidGcFailed<'a> {
     pub path: &'a Path,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_finalized_gc_failed)]
-pub struct FinalizedGcFailed<'a> {
+pub(crate) struct FinalizedGcFailed<'a> {
     pub path: &'a Path,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_session_gc_failed)]
-pub struct SessionGcFailed<'a> {
+pub(crate) struct SessionGcFailed<'a> {
     pub path: &'a Path,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_assert_not_loaded)]
-pub struct AssertNotLoaded;
+pub(crate) struct AssertNotLoaded;
 
 #[derive(Diagnostic)]
 #[diag(incremental_assert_loaded)]
-pub struct AssertLoaded;
+pub(crate) struct AssertLoaded;
 
 #[derive(Diagnostic)]
 #[diag(incremental_delete_incompatible)]
-pub struct DeleteIncompatible {
+pub(crate) struct DeleteIncompatible {
     pub path: PathBuf,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_load_dep_graph)]
-pub struct LoadDepGraph {
+pub(crate) struct LoadDepGraph {
     pub path: PathBuf,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_move_dep_graph)]
-pub struct MoveDepGraph<'a> {
+pub(crate) struct MoveDepGraph<'a> {
     pub from: &'a Path,
     pub to: &'a Path,
     pub err: std::io::Error,
@@ -282,14 +282,14 @@ pub struct MoveDepGraph<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_create_dep_graph)]
-pub struct CreateDepGraph<'a> {
+pub(crate) struct CreateDepGraph<'a> {
     pub path: &'a Path,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_copy_workproduct_to_cache)]
-pub struct CopyWorkProductToCache<'a> {
+pub(crate) struct CopyWorkProductToCache<'a> {
     pub from: &'a Path,
     pub to: &'a Path,
     pub err: std::io::Error,
@@ -297,13 +297,13 @@ pub struct CopyWorkProductToCache<'a> {
 
 #[derive(Diagnostic)]
 #[diag(incremental_delete_workproduct)]
-pub struct DeleteWorkProduct<'a> {
+pub(crate) struct DeleteWorkProduct<'a> {
     pub path: &'a Path,
     pub err: std::io::Error,
 }
 
 #[derive(Diagnostic)]
 #[diag(incremental_corrupt_file)]
-pub struct CorruptFile<'a> {
+pub(crate) struct CorruptFile<'a> {
     pub path: &'a Path,
 }
diff --git a/compiler/rustc_incremental/src/lib.rs b/compiler/rustc_incremental/src/lib.rs
index fcdcb08eed655..c79d108183c53 100644
--- a/compiler/rustc_incremental/src/lib.rs
+++ b/compiler/rustc_incremental/src/lib.rs
@@ -6,6 +6,7 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 mod assert_dep_graph;
diff --git a/compiler/rustc_incremental/src/persist/data.rs b/compiler/rustc_incremental/src/persist/data.rs
index 81e5410978d5d..d962dc866f43b 100644
--- a/compiler/rustc_incremental/src/persist/data.rs
+++ b/compiler/rustc_incremental/src/persist/data.rs
@@ -4,7 +4,7 @@ use rustc_macros::{Decodable, Encodable};
 use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
 
 #[derive(Debug, Encodable, Decodable)]
-pub struct SerializedWorkProduct {
+pub(crate) struct SerializedWorkProduct {
     /// node that produced the work-product
     pub id: WorkProductId,
 
diff --git a/compiler/rustc_incremental/src/persist/dirty_clean.rs b/compiler/rustc_incremental/src/persist/dirty_clean.rs
index 1e02324f4048a..88cb82f0f37a8 100644
--- a/compiler/rustc_incremental/src/persist/dirty_clean.rs
+++ b/compiler/rustc_incremental/src/persist/dirty_clean.rs
@@ -133,7 +133,7 @@ struct Assertion {
     loaded_from_disk: Labels,
 }
 
-pub fn check_dirty_clean_annotations(tcx: TyCtxt<'_>) {
+pub(crate) fn check_dirty_clean_annotations(tcx: TyCtxt<'_>) {
     if !tcx.sess.opts.unstable_opts.query_dep_graph {
         return;
     }
@@ -174,7 +174,7 @@ pub fn check_dirty_clean_annotations(tcx: TyCtxt<'_>) {
     })
 }
 
-pub struct DirtyCleanVisitor<'tcx> {
+struct DirtyCleanVisitor<'tcx> {
     tcx: TyCtxt<'tcx>,
     checked_attrs: FxHashSet<ast::AttrId>,
 }
@@ -429,7 +429,7 @@ fn expect_associated_value(tcx: TyCtxt<'_>, item: &NestedMetaItem) -> Symbol {
 /// A visitor that collects all `#[rustc_clean]` attributes from
 /// the HIR. It is used to verify that we really ran checks for all annotated
 /// nodes.
-pub struct FindAllAttrs<'tcx> {
+struct FindAllAttrs<'tcx> {
     tcx: TyCtxt<'tcx>,
     found_attrs: Vec<&'tcx Attribute>,
 }
diff --git a/compiler/rustc_incremental/src/persist/file_format.rs b/compiler/rustc_incremental/src/persist/file_format.rs
index 174414d0c85ef..f834c48cbf8fc 100644
--- a/compiler/rustc_incremental/src/persist/file_format.rs
+++ b/compiler/rustc_incremental/src/persist/file_format.rs
@@ -89,7 +89,7 @@ where
 ///   incompatible version of the compiler.
 /// - Returns `Err(..)` if some kind of IO error occurred while reading the
 ///   file.
-pub fn read_file(
+pub(crate) fn read_file(
     path: &Path,
     report_incremental_info: bool,
     is_nightly_build: bool,
diff --git a/compiler/rustc_incremental/src/persist/fs.rs b/compiler/rustc_incremental/src/persist/fs.rs
index 0e87bc1e69211..feb25a9a89d0d 100644
--- a/compiler/rustc_incremental/src/persist/fs.rs
+++ b/compiler/rustc_incremental/src/persist/fs.rs
@@ -157,7 +157,7 @@ pub(crate) fn work_products_path(sess: &Session) -> PathBuf {
 }
 
 /// Returns the path to a session's query cache.
-pub fn query_cache_path(sess: &Session) -> PathBuf {
+pub(crate) fn query_cache_path(sess: &Session) -> PathBuf {
     in_incr_comp_dir_sess(sess, QUERY_CACHE_FILENAME)
 }
 

From 46fe09f3f3dd724a9a9f1af50f3408a4f8dea25a Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 14:33:24 +1000
Subject: [PATCH 645/685] Add `warn(unreachable_pub)` to `rustc_index`.

---
 compiler/rustc_index/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_index/src/lib.rs b/compiler/rustc_index/src/lib.rs
index b9d2a43206b1e..eb47ac3c68e90 100644
--- a/compiler/rustc_index/src/lib.rs
+++ b/compiler/rustc_index/src/lib.rs
@@ -3,6 +3,7 @@
 #![cfg_attr(feature = "nightly", allow(internal_features))]
 #![cfg_attr(feature = "nightly", feature(extend_one, new_uninit, step_trait, test))]
 #![cfg_attr(feature = "nightly", feature(new_zeroed_alloc))]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 pub mod bit_set;

From 688792715bb1e3c420e896b62ee3e825dce4c174 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 14:47:56 +1000
Subject: [PATCH 646/685] Add `warn(unreachable_pub)` to `rustc_infer`.

---
 compiler/rustc_infer/src/errors/mod.rs                      | 2 +-
 compiler/rustc_infer/src/infer/free_regions.rs              | 6 +++---
 .../rustc_infer/src/infer/lexical_region_resolve/mod.rs     | 2 +-
 compiler/rustc_infer/src/infer/relate/generalize.rs         | 2 +-
 compiler/rustc_infer/src/infer/relate/lattice.rs            | 2 +-
 compiler/rustc_infer/src/infer/snapshot/fudge.rs            | 2 +-
 compiler/rustc_infer/src/infer/snapshot/undo_log.rs         | 2 +-
 compiler/rustc_infer/src/lib.rs                             | 1 +
 compiler/rustc_infer/src/traits/mod.rs                      | 2 +-
 compiler/rustc_infer/src/traits/project.rs                  | 2 +-
 10 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/compiler/rustc_infer/src/errors/mod.rs b/compiler/rustc_infer/src/errors/mod.rs
index 1a5c013721971..76ea9c3433d39 100644
--- a/compiler/rustc_infer/src/errors/mod.rs
+++ b/compiler/rustc_infer/src/errors/mod.rs
@@ -3,7 +3,7 @@ use rustc_span::Span;
 
 #[derive(Diagnostic)]
 #[diag(infer_opaque_hidden_type)]
-pub struct OpaqueHiddenTypeDiag {
+pub(crate) struct OpaqueHiddenTypeDiag {
     #[primary_span]
     #[label]
     pub span: Span,
diff --git a/compiler/rustc_infer/src/infer/free_regions.rs b/compiler/rustc_infer/src/infer/free_regions.rs
index 0dde3082d48dc..9a5674369daba 100644
--- a/compiler/rustc_infer/src/infer/free_regions.rs
+++ b/compiler/rustc_infer/src/infer/free_regions.rs
@@ -18,11 +18,11 @@ pub(crate) struct RegionRelations<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> RegionRelations<'a, 'tcx> {
-    pub fn new(tcx: TyCtxt<'tcx>, free_regions: &'a FreeRegionMap<'tcx>) -> Self {
+    pub(crate) fn new(tcx: TyCtxt<'tcx>, free_regions: &'a FreeRegionMap<'tcx>) -> Self {
         Self { tcx, free_regions }
     }
 
-    pub fn lub_param_regions(&self, r_a: Region<'tcx>, r_b: Region<'tcx>) -> Region<'tcx> {
+    pub(crate) fn lub_param_regions(&self, r_a: Region<'tcx>, r_b: Region<'tcx>) -> Region<'tcx> {
         self.free_regions.lub_param_regions(self.tcx, r_a, r_b)
     }
 }
@@ -80,7 +80,7 @@ impl<'tcx> FreeRegionMap<'tcx> {
     /// cases, this is more conservative than necessary, in order to
     /// avoid making arbitrary choices. See
     /// `TransitiveRelation::postdom_upper_bound` for more details.
-    pub fn lub_param_regions(
+    pub(crate) fn lub_param_regions(
         &self,
         tcx: TyCtxt<'tcx>,
         r_a: Region<'tcx>,
diff --git a/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs b/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs
index c2c0c7a41feac..e5533213400c6 100644
--- a/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs
+++ b/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs
@@ -43,7 +43,7 @@ pub(crate) fn resolve<'tcx>(
 /// Contains the result of lexical region resolution. Offers methods
 /// to lookup up the final value of a region variable.
 #[derive(Clone)]
-pub struct LexicalRegionResolutions<'tcx> {
+pub(crate) struct LexicalRegionResolutions<'tcx> {
     pub(crate) values: IndexVec<RegionVid, VarValue<'tcx>>,
 }
 
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
index 542104fa10ba0..6fa10a95313c9 100644
--- a/compiler/rustc_infer/src/infer/relate/generalize.rs
+++ b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -705,7 +705,7 @@ impl<'tcx> TypeRelation<TyCtxt<'tcx>> for Generalizer<'_, 'tcx> {
 /// not only the generalized type, but also a bool flag
 /// indicating whether further WF checks are needed.
 #[derive(Debug)]
-pub struct Generalization<T> {
+struct Generalization<T> {
     /// When generalizing `<?0 as Trait>::Assoc` or
     /// `<T as Bar<<?0 as Foo>::Assoc>>::Assoc`
     /// for `?0` generalization returns an inference
diff --git a/compiler/rustc_infer/src/infer/relate/lattice.rs b/compiler/rustc_infer/src/infer/relate/lattice.rs
index f555fedbb5bcd..1eafbb9acb330 100644
--- a/compiler/rustc_infer/src/infer/relate/lattice.rs
+++ b/compiler/rustc_infer/src/infer/relate/lattice.rs
@@ -29,7 +29,7 @@ use crate::traits::ObligationCause;
 ///
 /// GLB moves "down" the lattice (to smaller values); LUB moves
 /// "up" the lattice (to bigger values).
-pub trait LatticeDir<'f, 'tcx>: PredicateEmittingRelation<InferCtxt<'tcx>> {
+pub(crate) trait LatticeDir<'f, 'tcx>: PredicateEmittingRelation<InferCtxt<'tcx>> {
     fn infcx(&self) -> &'f InferCtxt<'tcx>;
 
     fn cause(&self) -> &ObligationCause<'tcx>;
diff --git a/compiler/rustc_infer/src/infer/snapshot/fudge.rs b/compiler/rustc_infer/src/infer/snapshot/fudge.rs
index bc954054ea281..fdf55447f7983 100644
--- a/compiler/rustc_infer/src/infer/snapshot/fudge.rs
+++ b/compiler/rustc_infer/src/infer/snapshot/fudge.rs
@@ -170,7 +170,7 @@ impl<'tcx> InferCtxt<'tcx> {
     }
 }
 
-pub struct InferenceFudger<'a, 'tcx> {
+struct InferenceFudger<'a, 'tcx> {
     infcx: &'a InferCtxt<'tcx>,
     type_vars: (Range<TyVid>, Vec<TypeVariableOrigin>),
     int_vars: Range<IntVid>,
diff --git a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
index 50a0d3bf21407..366af913ddc1c 100644
--- a/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
+++ b/compiler/rustc_infer/src/infer/snapshot/undo_log.rs
@@ -158,7 +158,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
 }
 
 impl<'tcx> InferCtxtUndoLogs<'tcx> {
-    pub fn start_snapshot(&mut self) -> Snapshot<'tcx> {
+    pub(crate) fn start_snapshot(&mut self) -> Snapshot<'tcx> {
         self.num_open_snapshots += 1;
         Snapshot { undo_len: self.logs.len(), _marker: PhantomData }
     }
diff --git a/compiler/rustc_infer/src/lib.rs b/compiler/rustc_infer/src/lib.rs
index 30dc666128cb1..94aa2ddd92fcc 100644
--- a/compiler/rustc_infer/src/lib.rs
+++ b/compiler/rustc_infer/src/lib.rs
@@ -28,6 +28,7 @@
 #![feature(let_chains)]
 #![feature(rustdoc_internals)]
 #![recursion_limit = "512"] // For rustdoc
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 #[macro_use]
diff --git a/compiler/rustc_infer/src/traits/mod.rs b/compiler/rustc_infer/src/traits/mod.rs
index 4f34c1395451b..3a05b576a9744 100644
--- a/compiler/rustc_infer/src/traits/mod.rs
+++ b/compiler/rustc_infer/src/traits/mod.rs
@@ -22,7 +22,7 @@ pub use self::engine::{FromSolverError, ScrubbedTraitError, TraitEngine};
 pub(crate) use self::project::UndoLog;
 pub use self::project::{
     MismatchedProjectionTypes, Normalized, NormalizedTerm, ProjectionCache, ProjectionCacheEntry,
-    ProjectionCacheKey, ProjectionCacheStorage, Reveal,
+    ProjectionCacheKey, ProjectionCacheStorage,
 };
 pub use self::ImplSource::*;
 pub use self::SelectionError::*;
diff --git a/compiler/rustc_infer/src/traits/project.rs b/compiler/rustc_infer/src/traits/project.rs
index 9ed557ec40bc3..3d4ec9e51db23 100644
--- a/compiler/rustc_infer/src/traits/project.rs
+++ b/compiler/rustc_infer/src/traits/project.rs
@@ -2,7 +2,7 @@
 
 use rustc_data_structures::snapshot_map::{self, SnapshotMapRef, SnapshotMapStorage};
 use rustc_data_structures::undo_log::Rollback;
-pub use rustc_middle::traits::{EvaluationResult, Reveal};
+use rustc_middle::traits::EvaluationResult;
 use rustc_middle::ty;
 
 use super::PredicateObligation;

From a941a4be77dbf2953d23bf89947d58abfca0a824 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 15:11:54 +1000
Subject: [PATCH 647/685] Add `warn(unreachable_pub)` to `rustc_interface`.

---
 compiler/rustc_interface/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_interface/src/lib.rs b/compiler/rustc_interface/src/lib.rs
index 3492df69b8d32..3b6c2acaf3083 100644
--- a/compiler/rustc_interface/src/lib.rs
+++ b/compiler/rustc_interface/src/lib.rs
@@ -2,6 +2,7 @@
 #![feature(decl_macro)]
 #![feature(let_chains)]
 #![feature(try_blocks)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 mod callbacks;

From 6c84c55c9f279b9ea1f77c7cac3a63f0c89ab90a Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 15:12:46 +1000
Subject: [PATCH 648/685] Add `warn(unreachable_pub)` to `rustc_lexer`.

---
 compiler/rustc_lexer/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_lexer/src/lib.rs b/compiler/rustc_lexer/src/lib.rs
index 2116ba6c079ac..31fdd2d7cec70 100644
--- a/compiler/rustc_lexer/src/lib.rs
+++ b/compiler/rustc_lexer/src/lib.rs
@@ -23,6 +23,7 @@
 // We want to be able to build this crate with a stable compiler,
 // so no `#![feature]` attributes should be added.
 #![deny(unstable_features)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 mod cursor;

From f10284162ff1cebaab7b2d7b2d5f952f4e52a5bc Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 15:24:11 +1000
Subject: [PATCH 649/685] Add `warn(unreachable_pub)` to `rustc_lint`.

---
 compiler/rustc_lint/src/early.rs              |   2 +-
 compiler/rustc_lint/src/errors.rs             |  18 +-
 compiler/rustc_lint/src/late.rs               |   2 +-
 compiler/rustc_lint/src/levels.rs             |   2 +-
 compiler/rustc_lint/src/lib.rs                |   1 +
 compiler/rustc_lint/src/lints.rs              | 494 +++++++++---------
 compiler/rustc_lint/src/non_local_def.rs      |   2 +-
 compiler/rustc_lint/src/nonstandard_style.rs  |   4 +-
 compiler/rustc_lint/src/shadowed_into_iter.rs |   2 +-
 compiler/rustc_lint/src/types.rs              |   6 +-
 compiler/rustc_lint/src/unused.rs             |   4 +-
 11 files changed, 269 insertions(+), 268 deletions(-)

diff --git a/compiler/rustc_lint/src/early.rs b/compiler/rustc_lint/src/early.rs
index 6fb0a6246442e..0ee9dda1fefa2 100644
--- a/compiler/rustc_lint/src/early.rs
+++ b/compiler/rustc_lint/src/early.rs
@@ -413,7 +413,7 @@ pub fn check_ast_node<'a>(
     }
 }
 
-pub fn check_ast_node_inner<'a, T: EarlyLintPass>(
+fn check_ast_node_inner<'a, T: EarlyLintPass>(
     sess: &Session,
     check_node: impl EarlyCheckNode<'a>,
     context: EarlyContext<'_>,
diff --git a/compiler/rustc_lint/src/errors.rs b/compiler/rustc_lint/src/errors.rs
index 85ee18aba8f47..d109a5c90305e 100644
--- a/compiler/rustc_lint/src/errors.rs
+++ b/compiler/rustc_lint/src/errors.rs
@@ -8,7 +8,7 @@ use crate::fluent_generated as fluent;
 
 #[derive(Diagnostic)]
 #[diag(lint_overruled_attribute, code = E0453)]
-pub struct OverruledAttribute<'a> {
+pub(crate) struct OverruledAttribute<'a> {
     #[primary_span]
     pub span: Span,
     #[label]
@@ -19,7 +19,7 @@ pub struct OverruledAttribute<'a> {
     pub sub: OverruledAttributeSub,
 }
 
-pub enum OverruledAttributeSub {
+pub(crate) enum OverruledAttributeSub {
     DefaultSource { id: String },
     NodeSource { span: Span, reason: Option<Symbol> },
     CommandLineSource,
@@ -52,7 +52,7 @@ impl Subdiagnostic for OverruledAttributeSub {
 
 #[derive(Diagnostic)]
 #[diag(lint_malformed_attribute, code = E0452)]
-pub struct MalformedAttribute {
+pub(crate) struct MalformedAttribute {
     #[primary_span]
     pub span: Span,
     #[subdiagnostic]
@@ -60,7 +60,7 @@ pub struct MalformedAttribute {
 }
 
 #[derive(Subdiagnostic)]
-pub enum MalformedAttributeSub {
+pub(crate) enum MalformedAttributeSub {
     #[label(lint_bad_attribute_argument)]
     BadAttributeArgument(#[primary_span] Span),
     #[label(lint_reason_must_be_string_literal)]
@@ -71,7 +71,7 @@ pub enum MalformedAttributeSub {
 
 #[derive(Diagnostic)]
 #[diag(lint_unknown_tool_in_scoped_lint, code = E0710)]
-pub struct UnknownToolInScopedLint {
+pub(crate) struct UnknownToolInScopedLint {
     #[primary_span]
     pub span: Option<Span>,
     pub tool_name: Symbol,
@@ -82,7 +82,7 @@ pub struct UnknownToolInScopedLint {
 
 #[derive(Diagnostic)]
 #[diag(lint_builtin_ellipsis_inclusive_range_patterns, code = E0783)]
-pub struct BuiltinEllipsisInclusiveRangePatterns {
+pub(crate) struct BuiltinEllipsisInclusiveRangePatterns {
     #[primary_span]
     pub span: Span,
     #[suggestion(style = "short", code = "{replace}", applicability = "machine-applicable")]
@@ -92,20 +92,20 @@ pub struct BuiltinEllipsisInclusiveRangePatterns {
 
 #[derive(Subdiagnostic)]
 #[note(lint_requested_level)]
-pub struct RequestedLevel<'a> {
+pub(crate) struct RequestedLevel<'a> {
     pub level: Level,
     pub lint_name: &'a str,
 }
 
 #[derive(Diagnostic)]
 #[diag(lint_unsupported_group, code = E0602)]
-pub struct UnsupportedGroup {
+pub(crate) struct UnsupportedGroup {
     pub lint_group: String,
 }
 
 #[derive(Diagnostic)]
 #[diag(lint_check_name_unknown_tool, code = E0602)]
-pub struct CheckNameUnknownTool<'a> {
+pub(crate) struct CheckNameUnknownTool<'a> {
     pub tool_name: Symbol,
     #[subdiagnostic]
     pub sub: RequestedLevel<'a>,
diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs
index 638b623510e74..cb369d99a8450 100644
--- a/compiler/rustc_lint/src/late.rs
+++ b/compiler/rustc_lint/src/late.rs
@@ -47,7 +47,7 @@ macro_rules! lint_callback { ($cx:expr, $f:ident, $($args:expr),*) => ({
 
 /// Implements the AST traversal for late lint passes. `T` provides the
 /// `check_*` methods.
-pub struct LateContextAndPass<'tcx, T: LateLintPass<'tcx>> {
+struct LateContextAndPass<'tcx, T: LateLintPass<'tcx>> {
     context: LateContext<'tcx>,
     pass: T,
 }
diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs
index 91d4f95df8054..07ac63ec96cf1 100644
--- a/compiler/rustc_lint/src/levels.rs
+++ b/compiler/rustc_lint/src/levels.rs
@@ -1103,7 +1103,7 @@ pub(crate) fn provide(providers: &mut Providers) {
     *providers = Providers { shallow_lint_levels_on, lint_expectations, ..*providers };
 }
 
-pub fn parse_lint_and_tool_name(lint_name: &str) -> (Option<Symbol>, &str) {
+pub(crate) fn parse_lint_and_tool_name(lint_name: &str) -> (Option<Symbol>, &str) {
     match lint_name.split_once("::") {
         Some((tool_name, lint_name)) => {
             let tool_name = Symbol::intern(tool_name);
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index a6e7d288f0827..c5a5c5b30afef 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -39,6 +39,7 @@
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
 #![feature(trait_upcasting)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 mod async_closures;
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index c12c5427997f9..c6bcb1f3e8334 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -26,7 +26,7 @@ use crate::{fluent_generated as fluent, LateContext};
 // array_into_iter.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_shadowed_into_iter)]
-pub struct ShadowedIntoIterDiag {
+pub(crate) struct ShadowedIntoIterDiag {
     pub target: &'static str,
     pub edition: &'static str,
     #[suggestion(lint_use_iter_suggestion, code = "iter", applicability = "machine-applicable")]
@@ -36,7 +36,7 @@ pub struct ShadowedIntoIterDiag {
 }
 
 #[derive(Subdiagnostic)]
-pub enum ShadowedIntoIterDiagSub {
+pub(crate) enum ShadowedIntoIterDiagSub {
     #[suggestion(lint_remove_into_iter_suggestion, code = "", applicability = "maybe-incorrect")]
     RemoveIntoIter {
         #[primary_span]
@@ -57,7 +57,7 @@ pub enum ShadowedIntoIterDiagSub {
 // builtin.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_while_true)]
-pub struct BuiltinWhileTrue {
+pub(crate) struct BuiltinWhileTrue {
     #[suggestion(style = "short", code = "{replace}", applicability = "machine-applicable")]
     pub suggestion: Span,
     pub replace: String,
@@ -65,7 +65,7 @@ pub struct BuiltinWhileTrue {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_non_shorthand_field_patterns)]
-pub struct BuiltinNonShorthandFieldPatterns {
+pub(crate) struct BuiltinNonShorthandFieldPatterns {
     pub ident: Ident,
     #[suggestion(code = "{prefix}{ident}", applicability = "machine-applicable")]
     pub suggestion: Span,
@@ -73,7 +73,7 @@ pub struct BuiltinNonShorthandFieldPatterns {
 }
 
 #[derive(LintDiagnostic)]
-pub enum BuiltinUnsafe {
+pub(crate) enum BuiltinUnsafe {
     #[diag(lint_builtin_allow_internal_unsafe)]
     AllowInternalUnsafe,
     #[diag(lint_builtin_unsafe_block)]
@@ -121,16 +121,16 @@ pub enum BuiltinUnsafe {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_missing_doc)]
-pub struct BuiltinMissingDoc<'a> {
+pub(crate) struct BuiltinMissingDoc<'a> {
     pub article: &'a str,
     pub desc: &'a str,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_missing_copy_impl)]
-pub struct BuiltinMissingCopyImpl;
+pub(crate) struct BuiltinMissingCopyImpl;
 
-pub struct BuiltinMissingDebugImpl<'a> {
+pub(crate) struct BuiltinMissingDebugImpl<'a> {
     pub tcx: TyCtxt<'a>,
     pub def_id: DefId,
 }
@@ -145,7 +145,7 @@ impl<'a> LintDiagnostic<'a, ()> for BuiltinMissingDebugImpl<'_> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_anonymous_params)]
-pub struct BuiltinAnonymousParams<'a> {
+pub(crate) struct BuiltinAnonymousParams<'a> {
     #[suggestion(code = "_: {ty_snip}")]
     pub suggestion: (Span, Applicability),
     pub ty_snip: &'a str,
@@ -154,7 +154,7 @@ pub struct BuiltinAnonymousParams<'a> {
 // FIXME(davidtwco) translatable deprecated attr
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_deprecated_attr_link)]
-pub struct BuiltinDeprecatedAttrLink<'a> {
+pub(crate) struct BuiltinDeprecatedAttrLink<'a> {
     pub name: Symbol,
     pub reason: &'a str,
     pub link: &'a str,
@@ -163,7 +163,7 @@ pub struct BuiltinDeprecatedAttrLink<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum BuiltinDeprecatedAttrLinkSuggestion<'a> {
+pub(crate) enum BuiltinDeprecatedAttrLinkSuggestion<'a> {
     #[suggestion(lint_msg_suggestion, code = "", applicability = "machine-applicable")]
     Msg {
         #[primary_span]
@@ -179,7 +179,7 @@ pub enum BuiltinDeprecatedAttrLinkSuggestion<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_deprecated_attr_used)]
-pub struct BuiltinDeprecatedAttrUsed {
+pub(crate) struct BuiltinDeprecatedAttrUsed {
     pub name: String,
     #[suggestion(
         lint_builtin_deprecated_attr_default_suggestion,
@@ -192,7 +192,7 @@ pub struct BuiltinDeprecatedAttrUsed {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_unused_doc_comment)]
-pub struct BuiltinUnusedDocComment<'a> {
+pub(crate) struct BuiltinUnusedDocComment<'a> {
     pub kind: &'a str,
     #[label]
     pub label: Span,
@@ -201,7 +201,7 @@ pub struct BuiltinUnusedDocComment<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum BuiltinUnusedDocCommentSub {
+pub(crate) enum BuiltinUnusedDocCommentSub {
     #[help(lint_plain_help)]
     PlainHelp,
     #[help(lint_block_help)]
@@ -210,7 +210,7 @@ pub enum BuiltinUnusedDocCommentSub {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_no_mangle_generic)]
-pub struct BuiltinNoMangleGeneric {
+pub(crate) struct BuiltinNoMangleGeneric {
     // Use of `#[no_mangle]` suggests FFI intent; correct
     // fix may be to monomorphize source by hand
     #[suggestion(style = "short", code = "", applicability = "maybe-incorrect")]
@@ -219,21 +219,21 @@ pub struct BuiltinNoMangleGeneric {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_const_no_mangle)]
-pub struct BuiltinConstNoMangle {
+pub(crate) struct BuiltinConstNoMangle {
     #[suggestion(code = "pub static", applicability = "machine-applicable")]
     pub suggestion: Span,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_mutable_transmutes)]
-pub struct BuiltinMutablesTransmutes;
+pub(crate) struct BuiltinMutablesTransmutes;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_unstable_features)]
-pub struct BuiltinUnstableFeatures;
+pub(crate) struct BuiltinUnstableFeatures;
 
 // lint_ungated_async_fn_track_caller
-pub struct BuiltinUngatedAsyncFnTrackCaller<'a> {
+pub(crate) struct BuiltinUngatedAsyncFnTrackCaller<'a> {
     pub label: Span,
     pub session: &'a Session,
 }
@@ -252,7 +252,7 @@ impl<'a> LintDiagnostic<'a, ()> for BuiltinUngatedAsyncFnTrackCaller<'_> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_unreachable_pub)]
-pub struct BuiltinUnreachablePub<'a> {
+pub(crate) struct BuiltinUnreachablePub<'a> {
     pub what: &'a str,
     #[suggestion(code = "pub(crate)")]
     pub suggestion: (Span, Applicability),
@@ -262,12 +262,12 @@ pub struct BuiltinUnreachablePub<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_macro_expr_fragment_specifier_2024_migration)]
-pub struct MacroExprFragment2024 {
+pub(crate) struct MacroExprFragment2024 {
     #[suggestion(code = "expr_2021", applicability = "machine-applicable")]
     pub suggestion: Span,
 }
 
-pub struct BuiltinTypeAliasBounds<'a, 'hir> {
+pub(crate) struct BuiltinTypeAliasBounds<'a, 'hir> {
     pub in_where_clause: bool,
     pub label: Span,
     pub enable_feat_help: bool,
@@ -338,13 +338,13 @@ impl<'a> LintDiagnostic<'a, ()> for BuiltinTypeAliasBounds<'_, '_> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_trivial_bounds)]
-pub struct BuiltinTrivialBounds<'a> {
+pub(crate) struct BuiltinTrivialBounds<'a> {
     pub predicate_kind_name: &'a str,
     pub predicate: Clause<'a>,
 }
 
 #[derive(LintDiagnostic)]
-pub enum BuiltinEllipsisInclusiveRangePatternsLint {
+pub(crate) enum BuiltinEllipsisInclusiveRangePatternsLint {
     #[diag(lint_builtin_ellipsis_inclusive_range_patterns)]
     Parenthesise {
         #[suggestion(code = "{replace}", applicability = "machine-applicable")]
@@ -360,7 +360,7 @@ pub enum BuiltinEllipsisInclusiveRangePatternsLint {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_keyword_idents)]
-pub struct BuiltinKeywordIdents {
+pub(crate) struct BuiltinKeywordIdents {
     pub kw: Ident,
     pub next: Edition,
     #[suggestion(code = "r#{kw}", applicability = "machine-applicable")]
@@ -369,7 +369,7 @@ pub struct BuiltinKeywordIdents {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_explicit_outlives)]
-pub struct BuiltinExplicitOutlives {
+pub(crate) struct BuiltinExplicitOutlives {
     pub count: usize,
     #[subdiagnostic]
     pub suggestion: BuiltinExplicitOutlivesSuggestion,
@@ -377,7 +377,7 @@ pub struct BuiltinExplicitOutlives {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(lint_suggestion)]
-pub struct BuiltinExplicitOutlivesSuggestion {
+pub(crate) struct BuiltinExplicitOutlivesSuggestion {
     #[suggestion_part(code = "")]
     pub spans: Vec<Span>,
     #[applicability]
@@ -386,7 +386,7 @@ pub struct BuiltinExplicitOutlivesSuggestion {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_incomplete_features)]
-pub struct BuiltinIncompleteFeatures {
+pub(crate) struct BuiltinIncompleteFeatures {
     pub name: Symbol,
     #[subdiagnostic]
     pub note: Option<BuiltinFeatureIssueNote>,
@@ -397,21 +397,21 @@ pub struct BuiltinIncompleteFeatures {
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_internal_features)]
 #[note]
-pub struct BuiltinInternalFeatures {
+pub(crate) struct BuiltinInternalFeatures {
     pub name: Symbol,
 }
 
 #[derive(Subdiagnostic)]
 #[help(lint_help)]
-pub struct BuiltinIncompleteFeaturesHelp;
+pub(crate) struct BuiltinIncompleteFeaturesHelp;
 
 #[derive(Subdiagnostic)]
 #[note(lint_note)]
-pub struct BuiltinFeatureIssueNote {
+pub(crate) struct BuiltinFeatureIssueNote {
     pub n: NonZero<u32>,
 }
 
-pub struct BuiltinUnpermittedTypeInit<'a> {
+pub(crate) struct BuiltinUnpermittedTypeInit<'a> {
     pub msg: DiagMessage,
     pub ty: Ty<'a>,
     pub label: Span,
@@ -436,7 +436,7 @@ impl<'a> LintDiagnostic<'a, ()> for BuiltinUnpermittedTypeInit<'_> {
 }
 
 // FIXME(davidtwco): make translatable
-pub struct BuiltinUnpermittedTypeInitSub {
+pub(crate) struct BuiltinUnpermittedTypeInitSub {
     pub err: InitError,
 }
 
@@ -463,7 +463,7 @@ impl Subdiagnostic for BuiltinUnpermittedTypeInitSub {
 }
 
 #[derive(LintDiagnostic)]
-pub enum BuiltinClashingExtern<'a> {
+pub(crate) enum BuiltinClashingExtern<'a> {
     #[diag(lint_builtin_clashing_extern_same_name)]
     SameName {
         this: Symbol,
@@ -489,7 +489,7 @@ pub enum BuiltinClashingExtern<'a> {
 }
 
 // FIXME(davidtwco): translatable expected/found
-pub struct BuiltinClashingExternSub<'a> {
+pub(crate) struct BuiltinClashingExternSub<'a> {
     pub tcx: TyCtxt<'a>,
     pub expected: Ty<'a>,
     pub found: Ty<'a>,
@@ -511,7 +511,7 @@ impl Subdiagnostic for BuiltinClashingExternSub<'_> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_builtin_deref_nullptr)]
-pub struct BuiltinDerefNullptr {
+pub(crate) struct BuiltinDerefNullptr {
     #[label]
     pub label: Span,
 }
@@ -519,7 +519,7 @@ pub struct BuiltinDerefNullptr {
 // FIXME: migrate fluent::lint::builtin_asm_labels
 
 #[derive(LintDiagnostic)]
-pub enum BuiltinSpecialModuleNameUsed {
+pub(crate) enum BuiltinSpecialModuleNameUsed {
     #[diag(lint_builtin_special_module_name_used_lib)]
     #[note]
     #[help]
@@ -532,7 +532,7 @@ pub enum BuiltinSpecialModuleNameUsed {
 // deref_into_dyn_supertrait.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_supertrait_as_deref_target)]
-pub struct SupertraitAsDerefTarget<'a> {
+pub(crate) struct SupertraitAsDerefTarget<'a> {
     pub self_ty: Ty<'a>,
     pub supertrait_principal: PolyExistentialTraitRef<'a>,
     pub target_principal: PolyExistentialTraitRef<'a>,
@@ -544,7 +544,7 @@ pub struct SupertraitAsDerefTarget<'a> {
 
 #[derive(Subdiagnostic)]
 #[label(lint_label2)]
-pub struct SupertraitAsDerefTargetLabel {
+pub(crate) struct SupertraitAsDerefTargetLabel {
     #[primary_span]
     pub label: Span,
 }
@@ -552,7 +552,7 @@ pub struct SupertraitAsDerefTargetLabel {
 // enum_intrinsics_non_enums.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_enum_intrinsics_mem_discriminant)]
-pub struct EnumIntrinsicsMemDiscriminate<'a> {
+pub(crate) struct EnumIntrinsicsMemDiscriminate<'a> {
     pub ty_param: Ty<'a>,
     #[note]
     pub note: Span,
@@ -561,14 +561,14 @@ pub struct EnumIntrinsicsMemDiscriminate<'a> {
 #[derive(LintDiagnostic)]
 #[diag(lint_enum_intrinsics_mem_variant)]
 #[note]
-pub struct EnumIntrinsicsMemVariant<'a> {
+pub(crate) struct EnumIntrinsicsMemVariant<'a> {
     pub ty_param: Ty<'a>,
 }
 
 // expect.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_expectation)]
-pub struct Expectation {
+pub(crate) struct Expectation {
     #[subdiagnostic]
     pub rationale: Option<ExpectationNote>,
     #[note]
@@ -577,13 +577,13 @@ pub struct Expectation {
 
 #[derive(Subdiagnostic)]
 #[note(lint_rationale)]
-pub struct ExpectationNote {
+pub(crate) struct ExpectationNote {
     pub rationale: Symbol,
 }
 
 // ptr_nulls.rs
 #[derive(LintDiagnostic)]
-pub enum PtrNullChecksDiag<'a> {
+pub(crate) enum PtrNullChecksDiag<'a> {
     #[diag(lint_ptr_null_checks_fn_ptr)]
     #[help(lint_help)]
     FnPtr {
@@ -604,7 +604,7 @@ pub enum PtrNullChecksDiag<'a> {
 // for_loops_over_fallibles.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_for_loops_over_fallibles)]
-pub struct ForLoopsOverFalliblesDiag<'a> {
+pub(crate) struct ForLoopsOverFalliblesDiag<'a> {
     pub article: &'static str,
     pub ref_prefix: &'static str,
     pub ty: &'static str,
@@ -617,7 +617,7 @@ pub struct ForLoopsOverFalliblesDiag<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum ForLoopsOverFalliblesLoopSub<'a> {
+pub(crate) enum ForLoopsOverFalliblesLoopSub<'a> {
     #[suggestion(lint_remove_next, code = ".by_ref()", applicability = "maybe-incorrect")]
     RemoveNext {
         #[primary_span]
@@ -636,14 +636,14 @@ pub enum ForLoopsOverFalliblesLoopSub<'a> {
 
 #[derive(Subdiagnostic)]
 #[suggestion(lint_use_question_mark, code = "?", applicability = "maybe-incorrect")]
-pub struct ForLoopsOverFalliblesQuestionMark {
+pub(crate) struct ForLoopsOverFalliblesQuestionMark {
     #[primary_span]
     pub suggestion: Span,
 }
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(lint_suggestion, applicability = "maybe-incorrect")]
-pub struct ForLoopsOverFalliblesSuggestion<'a> {
+pub(crate) struct ForLoopsOverFalliblesSuggestion<'a> {
     pub var: &'a str,
     #[suggestion_part(code = "if let {var}(")]
     pub start_span: Span,
@@ -652,7 +652,7 @@ pub struct ForLoopsOverFalliblesSuggestion<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum UseLetUnderscoreIgnoreSuggestion {
+pub(crate) enum UseLetUnderscoreIgnoreSuggestion {
     #[note(lint_use_let_underscore_ignore_suggestion)]
     Note,
     #[multipart_suggestion(
@@ -671,7 +671,7 @@ pub enum UseLetUnderscoreIgnoreSuggestion {
 // drop_forget_useless.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_dropping_references)]
-pub struct DropRefDiag<'a> {
+pub(crate) struct DropRefDiag<'a> {
     pub arg_ty: Ty<'a>,
     #[label]
     pub label: Span,
@@ -681,7 +681,7 @@ pub struct DropRefDiag<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_dropping_copy_types)]
-pub struct DropCopyDiag<'a> {
+pub(crate) struct DropCopyDiag<'a> {
     pub arg_ty: Ty<'a>,
     #[label]
     pub label: Span,
@@ -691,7 +691,7 @@ pub struct DropCopyDiag<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_forgetting_references)]
-pub struct ForgetRefDiag<'a> {
+pub(crate) struct ForgetRefDiag<'a> {
     pub arg_ty: Ty<'a>,
     #[label]
     pub label: Span,
@@ -701,7 +701,7 @@ pub struct ForgetRefDiag<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_forgetting_copy_types)]
-pub struct ForgetCopyDiag<'a> {
+pub(crate) struct ForgetCopyDiag<'a> {
     pub arg_ty: Ty<'a>,
     #[label]
     pub label: Span,
@@ -711,7 +711,7 @@ pub struct ForgetCopyDiag<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_undropped_manually_drops)]
-pub struct UndroppedManuallyDropsDiag<'a> {
+pub(crate) struct UndroppedManuallyDropsDiag<'a> {
     pub arg_ty: Ty<'a>,
     #[label]
     pub label: Span,
@@ -721,7 +721,7 @@ pub struct UndroppedManuallyDropsDiag<'a> {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(lint_suggestion, applicability = "machine-applicable")]
-pub struct UndroppedManuallyDropsSuggestion {
+pub(crate) struct UndroppedManuallyDropsSuggestion {
     #[suggestion_part(code = "std::mem::ManuallyDrop::into_inner(")]
     pub start_span: Span,
     #[suggestion_part(code = ")")]
@@ -730,7 +730,7 @@ pub struct UndroppedManuallyDropsSuggestion {
 
 // invalid_from_utf8.rs
 #[derive(LintDiagnostic)]
-pub enum InvalidFromUtf8Diag {
+pub(crate) enum InvalidFromUtf8Diag {
     #[diag(lint_invalid_from_utf8_unchecked)]
     Unchecked {
         method: String,
@@ -749,7 +749,7 @@ pub enum InvalidFromUtf8Diag {
 
 // reference_casting.rs
 #[derive(LintDiagnostic)]
-pub enum InvalidReferenceCastingDiag<'tcx> {
+pub(crate) enum InvalidReferenceCastingDiag<'tcx> {
     #[diag(lint_invalid_reference_casting_borrow_as_mut)]
     #[note(lint_invalid_reference_casting_note_book)]
     BorrowAsMut {
@@ -784,7 +784,7 @@ pub enum InvalidReferenceCastingDiag<'tcx> {
 #[derive(LintDiagnostic)]
 #[diag(lint_hidden_unicode_codepoints)]
 #[note]
-pub struct HiddenUnicodeCodepointsDiag<'a> {
+pub(crate) struct HiddenUnicodeCodepointsDiag<'a> {
     pub label: &'a str,
     pub count: usize,
     #[label]
@@ -795,7 +795,7 @@ pub struct HiddenUnicodeCodepointsDiag<'a> {
     pub sub: HiddenUnicodeCodepointsDiagSub,
 }
 
-pub struct HiddenUnicodeCodepointsDiagLabels {
+pub(crate) struct HiddenUnicodeCodepointsDiagLabels {
     pub spans: Vec<(char, Span)>,
 }
 
@@ -811,7 +811,7 @@ impl Subdiagnostic for HiddenUnicodeCodepointsDiagLabels {
     }
 }
 
-pub enum HiddenUnicodeCodepointsDiagSub {
+pub(crate) enum HiddenUnicodeCodepointsDiagSub {
     Escape { spans: Vec<(char, Span)> },
     NoEscape { spans: Vec<(char, Span)> },
 }
@@ -866,7 +866,7 @@ impl Subdiagnostic for HiddenUnicodeCodepointsDiagSub {
 #[derive(LintDiagnostic)]
 #[diag(lint_map_unit_fn)]
 #[note]
-pub struct MappingToUnit {
+pub(crate) struct MappingToUnit {
     #[label(lint_function_label)]
     pub function_label: Span,
     #[label(lint_argument_label)]
@@ -882,7 +882,7 @@ pub struct MappingToUnit {
 #[derive(LintDiagnostic)]
 #[diag(lint_default_hash_types)]
 #[note]
-pub struct DefaultHashTypesDiag<'a> {
+pub(crate) struct DefaultHashTypesDiag<'a> {
     pub preferred: &'a str,
     pub used: Symbol,
 }
@@ -890,17 +890,17 @@ pub struct DefaultHashTypesDiag<'a> {
 #[derive(LintDiagnostic)]
 #[diag(lint_query_instability)]
 #[note]
-pub struct QueryInstability {
+pub(crate) struct QueryInstability {
     pub query: Symbol,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_span_use_eq_ctxt)]
-pub struct SpanUseEqCtxtDiag;
+pub(crate) struct SpanUseEqCtxtDiag;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_tykind_kind)]
-pub struct TykindKind {
+pub(crate) struct TykindKind {
     #[suggestion(code = "ty", applicability = "maybe-incorrect")]
     pub suggestion: Span,
 }
@@ -908,11 +908,11 @@ pub struct TykindKind {
 #[derive(LintDiagnostic)]
 #[diag(lint_tykind)]
 #[help]
-pub struct TykindDiag;
+pub(crate) struct TykindDiag;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_ty_qualified)]
-pub struct TyQualified {
+pub(crate) struct TyQualified {
     pub ty: String,
     #[suggestion(code = "{ty}", applicability = "maybe-incorrect")]
     pub suggestion: Span,
@@ -920,7 +920,7 @@ pub struct TyQualified {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_non_glob_import_type_ir_inherent)]
-pub struct NonGlobImportTypeIrInherent {
+pub(crate) struct NonGlobImportTypeIrInherent {
     #[suggestion(code = "{snippet}", applicability = "maybe-incorrect")]
     pub suggestion: Option<Span>,
     pub snippet: &'static str,
@@ -929,32 +929,32 @@ pub struct NonGlobImportTypeIrInherent {
 #[derive(LintDiagnostic)]
 #[diag(lint_lintpass_by_hand)]
 #[help]
-pub struct LintPassByHand;
+pub(crate) struct LintPassByHand;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_non_existent_doc_keyword)]
 #[help]
-pub struct NonExistentDocKeyword {
+pub(crate) struct NonExistentDocKeyword {
     pub keyword: Symbol,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_diag_out_of_impl)]
-pub struct DiagOutOfImpl;
+pub(crate) struct DiagOutOfImpl;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_untranslatable_diag)]
-pub struct UntranslatableDiag;
+pub(crate) struct UntranslatableDiag;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_bad_opt_access)]
-pub struct BadOptAccessDiag<'a> {
+pub(crate) struct BadOptAccessDiag<'a> {
     pub msg: &'a str,
 }
 
 // let_underscore.rs
 #[derive(LintDiagnostic)]
-pub enum NonBindingLet {
+pub(crate) enum NonBindingLet {
     #[diag(lint_non_binding_let_on_sync_lock)]
     SyncLock {
         #[label]
@@ -969,7 +969,7 @@ pub enum NonBindingLet {
     },
 }
 
-pub struct NonBindingLetSub {
+pub(crate) struct NonBindingLetSub {
     pub suggestion: Span,
     pub drop_fn_start_end: Option<(Span, Span)>,
     pub is_assign_desugar: bool,
@@ -1012,7 +1012,7 @@ impl Subdiagnostic for NonBindingLetSub {
 // levels.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_overruled_attribute)]
-pub struct OverruledAttributeLint<'a> {
+pub(crate) struct OverruledAttributeLint<'a> {
     #[label]
     pub overruled: Span,
     pub lint_level: &'a str,
@@ -1023,7 +1023,7 @@ pub struct OverruledAttributeLint<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_deprecated_lint_name)]
-pub struct DeprecatedLintName<'a> {
+pub(crate) struct DeprecatedLintName<'a> {
     pub name: String,
     #[suggestion(code = "{replace}", applicability = "machine-applicable")]
     pub suggestion: Span,
@@ -1033,7 +1033,7 @@ pub struct DeprecatedLintName<'a> {
 #[derive(LintDiagnostic)]
 #[diag(lint_deprecated_lint_name)]
 #[help]
-pub struct DeprecatedLintNameFromCommandLine<'a> {
+pub(crate) struct DeprecatedLintNameFromCommandLine<'a> {
     pub name: String,
     pub replace: &'a str,
     #[subdiagnostic]
@@ -1042,14 +1042,14 @@ pub struct DeprecatedLintNameFromCommandLine<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_renamed_lint)]
-pub struct RenamedLint<'a> {
+pub(crate) struct RenamedLint<'a> {
     pub name: &'a str,
     #[subdiagnostic]
     pub suggestion: RenamedLintSuggestion<'a>,
 }
 
 #[derive(Subdiagnostic)]
-pub enum RenamedLintSuggestion<'a> {
+pub(crate) enum RenamedLintSuggestion<'a> {
     #[suggestion(lint_suggestion, code = "{replace}", applicability = "machine-applicable")]
     WithSpan {
         #[primary_span]
@@ -1062,7 +1062,7 @@ pub enum RenamedLintSuggestion<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_renamed_lint)]
-pub struct RenamedLintFromCommandLine<'a> {
+pub(crate) struct RenamedLintFromCommandLine<'a> {
     pub name: &'a str,
     #[subdiagnostic]
     pub suggestion: RenamedLintSuggestion<'a>,
@@ -1072,14 +1072,14 @@ pub struct RenamedLintFromCommandLine<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_removed_lint)]
-pub struct RemovedLint<'a> {
+pub(crate) struct RemovedLint<'a> {
     pub name: &'a str,
     pub reason: &'a str,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_removed_lint)]
-pub struct RemovedLintFromCommandLine<'a> {
+pub(crate) struct RemovedLintFromCommandLine<'a> {
     pub name: &'a str,
     pub reason: &'a str,
     #[subdiagnostic]
@@ -1088,14 +1088,14 @@ pub struct RemovedLintFromCommandLine<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unknown_lint)]
-pub struct UnknownLint {
+pub(crate) struct UnknownLint {
     pub name: String,
     #[subdiagnostic]
     pub suggestion: Option<UnknownLintSuggestion>,
 }
 
 #[derive(Subdiagnostic)]
-pub enum UnknownLintSuggestion {
+pub(crate) enum UnknownLintSuggestion {
     #[suggestion(lint_suggestion, code = "{replace}", applicability = "maybe-incorrect")]
     WithSpan {
         #[primary_span]
@@ -1109,7 +1109,7 @@ pub enum UnknownLintSuggestion {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unknown_lint, code = E0602)]
-pub struct UnknownLintFromCommandLine<'a> {
+pub(crate) struct UnknownLintFromCommandLine<'a> {
     pub name: String,
     #[subdiagnostic]
     pub suggestion: Option<UnknownLintSuggestion>,
@@ -1119,7 +1119,7 @@ pub struct UnknownLintFromCommandLine<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_ignored_unless_crate_specified)]
-pub struct IgnoredUnlessCrateSpecified<'a> {
+pub(crate) struct IgnoredUnlessCrateSpecified<'a> {
     pub level: &'a str,
     pub name: Symbol,
 }
@@ -1129,7 +1129,7 @@ pub struct IgnoredUnlessCrateSpecified<'a> {
 #[diag(lint_cstring_ptr)]
 #[note]
 #[help]
-pub struct CStringPtr {
+pub(crate) struct CStringPtr {
     #[label(lint_as_ptr_label)]
     pub as_ptr: Span,
     #[label(lint_unwrap_label)]
@@ -1139,19 +1139,19 @@ pub struct CStringPtr {
 // multiple_supertrait_upcastable.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_multiple_supertrait_upcastable)]
-pub struct MultipleSupertraitUpcastable {
+pub(crate) struct MultipleSupertraitUpcastable {
     pub ident: Ident,
 }
 
 // non_ascii_idents.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_identifier_non_ascii_char)]
-pub struct IdentifierNonAsciiChar;
+pub(crate) struct IdentifierNonAsciiChar;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_identifier_uncommon_codepoints)]
 #[note]
-pub struct IdentifierUncommonCodepoints {
+pub(crate) struct IdentifierUncommonCodepoints {
     pub codepoints: Vec<char>,
     pub codepoints_len: usize,
     pub identifier_type: &'static str,
@@ -1159,7 +1159,7 @@ pub struct IdentifierUncommonCodepoints {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_confusable_identifier_pair)]
-pub struct ConfusableIdentifierPair {
+pub(crate) struct ConfusableIdentifierPair {
     pub existing_sym: Symbol,
     pub sym: Symbol,
     #[label(lint_other_use)]
@@ -1172,13 +1172,13 @@ pub struct ConfusableIdentifierPair {
 #[diag(lint_mixed_script_confusables)]
 #[note(lint_includes_note)]
 #[note]
-pub struct MixedScriptConfusables {
+pub(crate) struct MixedScriptConfusables {
     pub set: String,
     pub includes: String,
 }
 
 // non_fmt_panic.rs
-pub struct NonFmtPanicUnused {
+pub(crate) struct NonFmtPanicUnused {
     pub count: usize,
     pub suggestion: Option<Span>,
 }
@@ -1209,7 +1209,7 @@ impl<'a> LintDiagnostic<'a, ()> for NonFmtPanicUnused {
 #[derive(LintDiagnostic)]
 #[diag(lint_non_fmt_panic_braces)]
 #[note]
-pub struct NonFmtPanicBraces {
+pub(crate) struct NonFmtPanicBraces {
     pub count: usize,
     #[suggestion(code = "\"{{}}\", ", applicability = "machine-applicable")]
     pub suggestion: Option<Span>,
@@ -1218,7 +1218,7 @@ pub struct NonFmtPanicBraces {
 // nonstandard_style.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_non_camel_case_type)]
-pub struct NonCamelCaseType<'a> {
+pub(crate) struct NonCamelCaseType<'a> {
     pub sort: &'a str,
     pub name: &'a str,
     #[subdiagnostic]
@@ -1226,7 +1226,7 @@ pub struct NonCamelCaseType<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum NonCamelCaseTypeSub {
+pub(crate) enum NonCamelCaseTypeSub {
     #[label(lint_label)]
     Label {
         #[primary_span]
@@ -1242,7 +1242,7 @@ pub enum NonCamelCaseTypeSub {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_non_snake_case)]
-pub struct NonSnakeCaseDiag<'a> {
+pub(crate) struct NonSnakeCaseDiag<'a> {
     pub sort: &'a str,
     pub name: &'a str,
     pub sc: String,
@@ -1250,7 +1250,7 @@ pub struct NonSnakeCaseDiag<'a> {
     pub sub: NonSnakeCaseDiagSub,
 }
 
-pub enum NonSnakeCaseDiagSub {
+pub(crate) enum NonSnakeCaseDiagSub {
     Label { span: Span },
     Help,
     RenameOrConvertSuggestion { span: Span, suggestion: Ident },
@@ -1302,7 +1302,7 @@ impl Subdiagnostic for NonSnakeCaseDiagSub {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_non_upper_case_global)]
-pub struct NonUpperCaseGlobal<'a> {
+pub(crate) struct NonUpperCaseGlobal<'a> {
     pub sort: &'a str,
     pub name: &'a str,
     #[subdiagnostic]
@@ -1310,7 +1310,7 @@ pub struct NonUpperCaseGlobal<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum NonUpperCaseGlobalSub {
+pub(crate) enum NonUpperCaseGlobalSub {
     #[label(lint_label)]
     Label {
         #[primary_span]
@@ -1328,7 +1328,7 @@ pub enum NonUpperCaseGlobalSub {
 #[derive(LintDiagnostic)]
 #[diag(lint_noop_method_call)]
 #[note]
-pub struct NoopMethodCallDiag<'a> {
+pub(crate) struct NoopMethodCallDiag<'a> {
     pub method: Symbol,
     pub orig_ty: Ty<'a>,
     pub trait_: Symbol,
@@ -1344,18 +1344,18 @@ pub struct NoopMethodCallDiag<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_suspicious_double_ref_deref)]
-pub struct SuspiciousDoubleRefDerefDiag<'a> {
+pub(crate) struct SuspiciousDoubleRefDerefDiag<'a> {
     pub ty: Ty<'a>,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_suspicious_double_ref_clone)]
-pub struct SuspiciousDoubleRefCloneDiag<'a> {
+pub(crate) struct SuspiciousDoubleRefCloneDiag<'a> {
     pub ty: Ty<'a>,
 }
 
 // non_local_defs.rs
-pub enum NonLocalDefinitionsDiag {
+pub(crate) enum NonLocalDefinitionsDiag {
     Impl {
         depth: u32,
         body_kind_descr: &'static str,
@@ -1487,7 +1487,7 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
 
 #[derive(Subdiagnostic)]
 #[note(lint_non_local_definitions_cargo_update)]
-pub struct NonLocalDefinitionsCargoUpdateNote {
+pub(crate) struct NonLocalDefinitionsCargoUpdateNote {
     pub macro_kind: &'static str,
     pub macro_name: Symbol,
     pub crate_name: Symbol,
@@ -1497,7 +1497,7 @@ pub struct NonLocalDefinitionsCargoUpdateNote {
 #[derive(LintDiagnostic)]
 #[diag(lint_ambiguous_negative_literals)]
 #[note(lint_example)]
-pub struct AmbiguousNegativeLiteralsDiag {
+pub(crate) struct AmbiguousNegativeLiteralsDiag {
     #[subdiagnostic]
     pub negative_literal: AmbiguousNegativeLiteralsNegativeLiteralSuggestion,
     #[subdiagnostic]
@@ -1506,7 +1506,7 @@ pub struct AmbiguousNegativeLiteralsDiag {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(lint_negative_literal, applicability = "maybe-incorrect")]
-pub struct AmbiguousNegativeLiteralsNegativeLiteralSuggestion {
+pub(crate) struct AmbiguousNegativeLiteralsNegativeLiteralSuggestion {
     #[suggestion_part(code = "(")]
     pub start_span: Span,
     #[suggestion_part(code = ")")]
@@ -1515,7 +1515,7 @@ pub struct AmbiguousNegativeLiteralsNegativeLiteralSuggestion {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(lint_current_behavior, applicability = "maybe-incorrect")]
-pub struct AmbiguousNegativeLiteralsCurrentBehaviorSuggestion {
+pub(crate) struct AmbiguousNegativeLiteralsCurrentBehaviorSuggestion {
     #[suggestion_part(code = "(")]
     pub start_span: Span,
     #[suggestion_part(code = ")")]
@@ -1525,7 +1525,7 @@ pub struct AmbiguousNegativeLiteralsCurrentBehaviorSuggestion {
 // pass_by_value.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_pass_by_value)]
-pub struct PassByValueDiag {
+pub(crate) struct PassByValueDiag {
     pub ty: String,
     #[suggestion(code = "{ty}", applicability = "maybe-incorrect")]
     pub suggestion: Span,
@@ -1534,14 +1534,14 @@ pub struct PassByValueDiag {
 // redundant_semicolon.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_redundant_semicolons)]
-pub struct RedundantSemicolonsDiag {
+pub(crate) struct RedundantSemicolonsDiag {
     pub multiple: bool,
     #[suggestion(code = "", applicability = "maybe-incorrect")]
     pub suggestion: Span,
 }
 
 // traits.rs
-pub struct DropTraitConstraintsDiag<'a> {
+pub(crate) struct DropTraitConstraintsDiag<'a> {
     pub predicate: Clause<'a>,
     pub tcx: TyCtxt<'a>,
     pub def_id: DefId,
@@ -1556,7 +1556,7 @@ impl<'a> LintDiagnostic<'a, ()> for DropTraitConstraintsDiag<'_> {
     }
 }
 
-pub struct DropGlue<'a> {
+pub(crate) struct DropGlue<'a> {
     pub tcx: TyCtxt<'a>,
     pub def_id: DefId,
 }
@@ -1572,14 +1572,14 @@ impl<'a> LintDiagnostic<'a, ()> for DropGlue<'_> {
 // types.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_range_endpoint_out_of_range)]
-pub struct RangeEndpointOutOfRange<'a> {
+pub(crate) struct RangeEndpointOutOfRange<'a> {
     pub ty: &'a str,
     #[subdiagnostic]
     pub sub: UseInclusiveRange<'a>,
 }
 
 #[derive(Subdiagnostic)]
-pub enum UseInclusiveRange<'a> {
+pub(crate) enum UseInclusiveRange<'a> {
     #[suggestion(
         lint_range_use_inclusive_range,
         code = "{start}..={literal}{suffix}",
@@ -1605,7 +1605,7 @@ pub enum UseInclusiveRange<'a> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_overflowing_bin_hex)]
-pub struct OverflowingBinHex<'a> {
+pub(crate) struct OverflowingBinHex<'a> {
     pub ty: &'a str,
     pub lit: String,
     pub dec: u128,
@@ -1618,7 +1618,7 @@ pub struct OverflowingBinHex<'a> {
     pub sign_bit_sub: Option<OverflowingBinHexSignBitSub<'a>>,
 }
 
-pub enum OverflowingBinHexSign {
+pub(crate) enum OverflowingBinHexSign {
     Positive,
     Negative,
 }
@@ -1642,7 +1642,7 @@ impl Subdiagnostic for OverflowingBinHexSign {
 }
 
 #[derive(Subdiagnostic)]
-pub enum OverflowingBinHexSub<'a> {
+pub(crate) enum OverflowingBinHexSub<'a> {
     #[suggestion(
         lint_suggestion,
         code = "{sans_suffix}{suggestion_ty}",
@@ -1664,7 +1664,7 @@ pub enum OverflowingBinHexSub<'a> {
     code = "{lit_no_suffix}{uint_ty} as {int_ty}",
     applicability = "maybe-incorrect"
 )]
-pub struct OverflowingBinHexSignBitSub<'a> {
+pub(crate) struct OverflowingBinHexSignBitSub<'a> {
     #[primary_span]
     pub span: Span,
     pub lit_no_suffix: &'a str,
@@ -1676,7 +1676,7 @@ pub struct OverflowingBinHexSignBitSub<'a> {
 #[derive(LintDiagnostic)]
 #[diag(lint_overflowing_int)]
 #[note]
-pub struct OverflowingInt<'a> {
+pub(crate) struct OverflowingInt<'a> {
     pub ty: &'a str,
     pub lit: String,
     pub min: i128,
@@ -1687,13 +1687,13 @@ pub struct OverflowingInt<'a> {
 
 #[derive(Subdiagnostic)]
 #[help(lint_help)]
-pub struct OverflowingIntHelp<'a> {
+pub(crate) struct OverflowingIntHelp<'a> {
     pub suggestion_ty: &'a str,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_only_cast_u8_to_char)]
-pub struct OnlyCastu8ToChar {
+pub(crate) struct OnlyCastu8ToChar {
     #[suggestion(code = "'\\u{{{literal:X}}}'", applicability = "machine-applicable")]
     pub span: Span,
     pub literal: u128,
@@ -1702,7 +1702,7 @@ pub struct OnlyCastu8ToChar {
 #[derive(LintDiagnostic)]
 #[diag(lint_overflowing_uint)]
 #[note]
-pub struct OverflowingUInt<'a> {
+pub(crate) struct OverflowingUInt<'a> {
     pub ty: &'a str,
     pub lit: String,
     pub min: u128,
@@ -1712,17 +1712,17 @@ pub struct OverflowingUInt<'a> {
 #[derive(LintDiagnostic)]
 #[diag(lint_overflowing_literal)]
 #[note]
-pub struct OverflowingLiteral<'a> {
+pub(crate) struct OverflowingLiteral<'a> {
     pub ty: &'a str,
     pub lit: String,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_comparisons)]
-pub struct UnusedComparisons;
+pub(crate) struct UnusedComparisons;
 
 #[derive(LintDiagnostic)]
-pub enum InvalidNanComparisons {
+pub(crate) enum InvalidNanComparisons {
     #[diag(lint_invalid_nan_comparisons_eq_ne)]
     EqNe {
         #[subdiagnostic]
@@ -1733,7 +1733,7 @@ pub enum InvalidNanComparisons {
 }
 
 #[derive(Subdiagnostic)]
-pub enum InvalidNanComparisonsSuggestion {
+pub(crate) enum InvalidNanComparisonsSuggestion {
     #[multipart_suggestion(
         lint_suggestion,
         style = "verbose",
@@ -1752,7 +1752,7 @@ pub enum InvalidNanComparisonsSuggestion {
 }
 
 #[derive(LintDiagnostic)]
-pub enum AmbiguousWidePointerComparisons<'a> {
+pub(crate) enum AmbiguousWidePointerComparisons<'a> {
     #[diag(lint_ambiguous_wide_pointer_comparisons)]
     Spanful {
         #[subdiagnostic]
@@ -1773,7 +1773,7 @@ pub enum AmbiguousWidePointerComparisons<'a> {
     // FIXME(#53934): make machine-applicable again
     applicability = "maybe-incorrect"
 )]
-pub struct AmbiguousWidePointerComparisonsAddrMetadataSuggestion<'a> {
+pub(crate) struct AmbiguousWidePointerComparisonsAddrMetadataSuggestion<'a> {
     pub ne: &'a str,
     pub deref_left: &'a str,
     pub deref_right: &'a str,
@@ -1788,7 +1788,7 @@ pub struct AmbiguousWidePointerComparisonsAddrMetadataSuggestion<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum AmbiguousWidePointerComparisonsAddrSuggestion<'a> {
+pub(crate) enum AmbiguousWidePointerComparisonsAddrSuggestion<'a> {
     #[multipart_suggestion(
         lint_addr_suggestion,
         style = "verbose",
@@ -1832,7 +1832,7 @@ pub enum AmbiguousWidePointerComparisonsAddrSuggestion<'a> {
     },
 }
 
-pub struct ImproperCTypes<'a> {
+pub(crate) struct ImproperCTypes<'a> {
     pub ty: Ty<'a>,
     pub desc: &'a str,
     pub label: Span,
@@ -1860,29 +1860,29 @@ impl<'a> LintDiagnostic<'a, ()> for ImproperCTypes<'_> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_variant_size_differences)]
-pub struct VariantSizeDifferencesDiag {
+pub(crate) struct VariantSizeDifferencesDiag {
     pub largest: u64,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_atomic_ordering_load)]
 #[help]
-pub struct AtomicOrderingLoad;
+pub(crate) struct AtomicOrderingLoad;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_atomic_ordering_store)]
 #[help]
-pub struct AtomicOrderingStore;
+pub(crate) struct AtomicOrderingStore;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_atomic_ordering_fence)]
 #[help]
-pub struct AtomicOrderingFence;
+pub(crate) struct AtomicOrderingFence;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_atomic_ordering_invalid)]
 #[help]
-pub struct InvalidAtomicOrderingDiag {
+pub(crate) struct InvalidAtomicOrderingDiag {
     pub method: Symbol,
     #[label]
     pub fail_order_arg_span: Span,
@@ -1891,7 +1891,7 @@ pub struct InvalidAtomicOrderingDiag {
 // unused.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_op)]
-pub struct UnusedOp<'a> {
+pub(crate) struct UnusedOp<'a> {
     pub op: &'a str,
     #[label]
     pub label: Span,
@@ -1900,7 +1900,7 @@ pub struct UnusedOp<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub enum UnusedOpSuggestion {
+pub(crate) enum UnusedOpSuggestion {
     #[suggestion(
         lint_suggestion,
         style = "verbose",
@@ -1922,7 +1922,7 @@ pub enum UnusedOpSuggestion {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_result)]
-pub struct UnusedResult<'a> {
+pub(crate) struct UnusedResult<'a> {
     pub ty: Ty<'a>,
 }
 
@@ -1931,7 +1931,7 @@ pub struct UnusedResult<'a> {
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_closure)]
 #[note]
-pub struct UnusedClosure<'a> {
+pub(crate) struct UnusedClosure<'a> {
     pub count: usize,
     pub pre: &'a str,
     pub post: &'a str,
@@ -1942,7 +1942,7 @@ pub struct UnusedClosure<'a> {
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_coroutine)]
 #[note]
-pub struct UnusedCoroutine<'a> {
+pub(crate) struct UnusedCoroutine<'a> {
     pub count: usize,
     pub pre: &'a str,
     pub post: &'a str,
@@ -1950,7 +1950,7 @@ pub struct UnusedCoroutine<'a> {
 
 // FIXME(davidtwco): this isn't properly translatable because of the pre/post
 // strings
-pub struct UnusedDef<'a, 'b> {
+pub(crate) struct UnusedDef<'a, 'b> {
     pub pre: &'a str,
     pub post: &'a str,
     pub cx: &'a LateContext<'b>,
@@ -1961,7 +1961,7 @@ pub struct UnusedDef<'a, 'b> {
 
 #[derive(Subdiagnostic)]
 
-pub enum UnusedDefSuggestion {
+pub(crate) enum UnusedDefSuggestion {
     #[suggestion(
         lint_suggestion,
         style = "verbose",
@@ -2000,13 +2000,13 @@ impl<'a> LintDiagnostic<'a, ()> for UnusedDef<'_, '_> {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_path_statement_drop)]
-pub struct PathStatementDrop {
+pub(crate) struct PathStatementDrop {
     #[subdiagnostic]
     pub sub: PathStatementDropSub,
 }
 
 #[derive(Subdiagnostic)]
-pub enum PathStatementDropSub {
+pub(crate) enum PathStatementDropSub {
     #[suggestion(lint_suggestion, code = "drop({snippet});", applicability = "machine-applicable")]
     Suggestion {
         #[primary_span]
@@ -2022,11 +2022,11 @@ pub enum PathStatementDropSub {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_path_statement_no_effect)]
-pub struct PathStatementNoEffect;
+pub(crate) struct PathStatementNoEffect;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_delim)]
-pub struct UnusedDelim<'a> {
+pub(crate) struct UnusedDelim<'a> {
     pub delim: &'static str,
     pub item: &'a str,
     #[subdiagnostic]
@@ -2035,7 +2035,7 @@ pub struct UnusedDelim<'a> {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(lint_suggestion, applicability = "machine-applicable")]
-pub struct UnusedDelimSuggestion {
+pub(crate) struct UnusedDelimSuggestion {
     #[suggestion_part(code = "{start_replace}")]
     pub start_span: Span,
     pub start_replace: &'static str,
@@ -2046,19 +2046,19 @@ pub struct UnusedDelimSuggestion {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_import_braces)]
-pub struct UnusedImportBracesDiag {
+pub(crate) struct UnusedImportBracesDiag {
     pub node: Symbol,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_allocation)]
-pub struct UnusedAllocationDiag;
+pub(crate) struct UnusedAllocationDiag;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_allocation_mut)]
-pub struct UnusedAllocationMutDiag;
+pub(crate) struct UnusedAllocationMutDiag;
 
-pub struct AsyncFnInTraitDiag {
+pub(crate) struct AsyncFnInTraitDiag {
     pub sugg: Option<Vec<(Span, String)>>,
 }
 
@@ -2074,13 +2074,13 @@ impl<'a> LintDiagnostic<'a, ()> for AsyncFnInTraitDiag {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unit_bindings)]
-pub struct UnitBindingsDiag {
+pub(crate) struct UnitBindingsDiag {
     #[label]
     pub label: Span,
 }
 
 #[derive(LintDiagnostic)]
-pub enum InvalidAsmLabel {
+pub(crate) enum InvalidAsmLabel {
     #[diag(lint_invalid_asm_label_named)]
     #[help]
     #[note]
@@ -2110,7 +2110,7 @@ pub enum InvalidAsmLabel {
 }
 
 #[derive(Subdiagnostic)]
-pub enum UnexpectedCfgCargoHelp {
+pub(crate) enum UnexpectedCfgCargoHelp {
     #[help(lint_unexpected_cfg_add_cargo_feature)]
     #[help(lint_unexpected_cfg_add_cargo_toml_lint_cfg)]
     LintCfg { cargo_toml_lint_cfg: String },
@@ -2127,13 +2127,13 @@ impl UnexpectedCfgCargoHelp {
         )
     }
 
-    pub fn lint_cfg(unescaped: &str) -> Self {
+    pub(crate) fn lint_cfg(unescaped: &str) -> Self {
         UnexpectedCfgCargoHelp::LintCfg {
             cargo_toml_lint_cfg: Self::cargo_toml_lint_cfg(unescaped),
         }
     }
 
-    pub fn lint_cfg_and_build_rs(unescaped: &str, escaped: &str) -> Self {
+    pub(crate) fn lint_cfg_and_build_rs(unescaped: &str, escaped: &str) -> Self {
         UnexpectedCfgCargoHelp::LintCfgAndBuildRs {
             cargo_toml_lint_cfg: Self::cargo_toml_lint_cfg(unescaped),
             build_rs_println: format!("println!(\"cargo::rustc-check-cfg={escaped}\");"),
@@ -2143,19 +2143,19 @@ impl UnexpectedCfgCargoHelp {
 
 #[derive(Subdiagnostic)]
 #[help(lint_unexpected_cfg_add_cmdline_arg)]
-pub struct UnexpectedCfgRustcHelp {
+pub(crate) struct UnexpectedCfgRustcHelp {
     pub cmdline_arg: String,
 }
 
 impl UnexpectedCfgRustcHelp {
-    pub fn new(unescaped: &str) -> Self {
+    pub(crate) fn new(unescaped: &str) -> Self {
         Self { cmdline_arg: format!("--check-cfg={unescaped}") }
     }
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unexpected_cfg_name)]
-pub struct UnexpectedCfgName {
+pub(crate) struct UnexpectedCfgName {
     #[subdiagnostic]
     pub code_sugg: unexpected_cfg_name::CodeSuggestion,
     #[subdiagnostic]
@@ -2164,13 +2164,13 @@ pub struct UnexpectedCfgName {
     pub name: Symbol,
 }
 
-pub mod unexpected_cfg_name {
+pub(crate) mod unexpected_cfg_name {
     use rustc_errors::DiagSymbolList;
     use rustc_macros::Subdiagnostic;
     use rustc_span::{Span, Symbol};
 
     #[derive(Subdiagnostic)]
-    pub enum CodeSuggestion {
+    pub(crate) enum CodeSuggestion {
         #[help(lint_unexpected_cfg_define_features)]
         DefineFeatures,
         #[suggestion(
@@ -2227,7 +2227,7 @@ pub mod unexpected_cfg_name {
 
     #[derive(Subdiagnostic)]
     #[help(lint_unexpected_cfg_name_expected_values)]
-    pub struct ExpectedValues {
+    pub(crate) struct ExpectedValues {
         pub best_match: Symbol,
         pub possibilities: DiagSymbolList,
     }
@@ -2238,7 +2238,7 @@ pub mod unexpected_cfg_name {
         applicability = "maybe-incorrect",
         code = "{code}"
     )]
-    pub struct FoundWithSimilarValue {
+    pub(crate) struct FoundWithSimilarValue {
         #[primary_span]
         pub span: Span,
         pub code: String,
@@ -2246,13 +2246,13 @@ pub mod unexpected_cfg_name {
 
     #[derive(Subdiagnostic)]
     #[help_once(lint_unexpected_cfg_name_expected_names)]
-    pub struct ExpectedNames {
+    pub(crate) struct ExpectedNames {
         pub possibilities: DiagSymbolList,
         pub and_more: usize,
     }
 
     #[derive(Subdiagnostic)]
-    pub enum InvocationHelp {
+    pub(crate) enum InvocationHelp {
         #[note(lint_unexpected_cfg_doc_cargo)]
         Cargo {
             #[subdiagnostic]
@@ -2265,7 +2265,7 @@ pub mod unexpected_cfg_name {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unexpected_cfg_value)]
-pub struct UnexpectedCfgValue {
+pub(crate) struct UnexpectedCfgValue {
     #[subdiagnostic]
     pub code_sugg: unexpected_cfg_value::CodeSuggestion,
     #[subdiagnostic]
@@ -2275,13 +2275,13 @@ pub struct UnexpectedCfgValue {
     pub value: String,
 }
 
-pub mod unexpected_cfg_value {
+pub(crate) mod unexpected_cfg_value {
     use rustc_errors::DiagSymbolList;
     use rustc_macros::Subdiagnostic;
     use rustc_span::{Span, Symbol};
 
     #[derive(Subdiagnostic)]
-    pub enum CodeSuggestion {
+    pub(crate) enum CodeSuggestion {
         ChangeValue {
             #[subdiagnostic]
             expected_values: ExpectedValues,
@@ -2305,7 +2305,7 @@ pub mod unexpected_cfg_value {
     }
 
     #[derive(Subdiagnostic)]
-    pub enum ChangeValueSuggestion {
+    pub(crate) enum ChangeValueSuggestion {
         #[suggestion(
             lint_unexpected_cfg_value_similar_name,
             code = r#""{best_match}""#,
@@ -2334,7 +2334,7 @@ pub mod unexpected_cfg_value {
         code = "",
         applicability = "maybe-incorrect"
     )]
-    pub struct RemoveValueSuggestion {
+    pub(crate) struct RemoveValueSuggestion {
         #[primary_span]
         pub span: Span,
     }
@@ -2345,14 +2345,14 @@ pub mod unexpected_cfg_value {
         code = "",
         applicability = "maybe-incorrect"
     )]
-    pub struct RemoveConditionSuggestion {
+    pub(crate) struct RemoveConditionSuggestion {
         #[primary_span]
         pub span: Span,
     }
 
     #[derive(Subdiagnostic)]
     #[note(lint_unexpected_cfg_value_expected_values)]
-    pub struct ExpectedValues {
+    pub(crate) struct ExpectedValues {
         pub name: Symbol,
         pub have_none_possibility: bool,
         pub possibilities: DiagSymbolList,
@@ -2360,7 +2360,7 @@ pub mod unexpected_cfg_value {
     }
 
     #[derive(Subdiagnostic)]
-    pub enum InvocationHelp {
+    pub(crate) enum InvocationHelp {
         #[note(lint_unexpected_cfg_doc_cargo)]
         Cargo(#[subdiagnostic] Option<CargoHelp>),
         #[note(lint_unexpected_cfg_doc_rustc)]
@@ -2368,7 +2368,7 @@ pub mod unexpected_cfg_value {
     }
 
     #[derive(Subdiagnostic)]
-    pub enum CargoHelp {
+    pub(crate) enum CargoHelp {
         #[help(lint_unexpected_cfg_value_add_feature)]
         AddFeature {
             value: Symbol,
@@ -2383,7 +2383,7 @@ pub mod unexpected_cfg_value {
 #[diag(lint_unexpected_builtin_cfg)]
 #[note(lint_controlled_by)]
 #[note(lint_incoherent)]
-pub struct UnexpectedBuiltinCfg {
+pub(crate) struct UnexpectedBuiltinCfg {
     pub(crate) cfg: String,
     pub(crate) cfg_name: Symbol,
     pub(crate) controlled_by: &'static str,
@@ -2392,15 +2392,15 @@ pub struct UnexpectedBuiltinCfg {
 #[derive(LintDiagnostic)]
 #[diag(lint_macro_use_deprecated)]
 #[help]
-pub struct MacroUseDeprecated;
+pub(crate) struct MacroUseDeprecated;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_macro_use)]
-pub struct UnusedMacroUse;
+pub(crate) struct UnusedMacroUse;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_private_extern_crate_reexport, code = E0365)]
-pub struct PrivateExternCrateReexport {
+pub(crate) struct PrivateExternCrateReexport {
     pub ident: Ident,
     #[suggestion(code = "pub ", style = "verbose", applicability = "maybe-incorrect")]
     pub sugg: Span,
@@ -2408,28 +2408,28 @@ pub struct PrivateExternCrateReexport {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_label)]
-pub struct UnusedLabel;
+pub(crate) struct UnusedLabel;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_macro_is_private)]
-pub struct MacroIsPrivate {
+pub(crate) struct MacroIsPrivate {
     pub ident: Ident,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_macro_definition)]
-pub struct UnusedMacroDefinition {
+pub(crate) struct UnusedMacroDefinition {
     pub name: Symbol,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_macro_rule_never_used)]
-pub struct MacroRuleNeverUsed {
+pub(crate) struct MacroRuleNeverUsed {
     pub n: usize,
     pub name: Symbol,
 }
 
-pub struct UnstableFeature {
+pub(crate) struct UnstableFeature {
     pub msg: DiagMessage,
 }
 
@@ -2441,81 +2441,81 @@ impl<'a> LintDiagnostic<'a, ()> for UnstableFeature {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_avoid_intel_syntax)]
-pub struct AvoidIntelSyntax;
+pub(crate) struct AvoidIntelSyntax;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_avoid_att_syntax)]
-pub struct AvoidAttSyntax;
+pub(crate) struct AvoidAttSyntax;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_incomplete_include)]
-pub struct IncompleteInclude;
+pub(crate) struct IncompleteInclude;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unnameable_test_items)]
-pub struct UnnameableTestItems;
+pub(crate) struct UnnameableTestItems;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_duplicate_macro_attribute)]
-pub struct DuplicateMacroAttribute;
+pub(crate) struct DuplicateMacroAttribute;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_cfg_attr_no_attributes)]
-pub struct CfgAttrNoAttributes;
+pub(crate) struct CfgAttrNoAttributes;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_crate_type_in_cfg_attr_deprecated)]
-pub struct CrateTypeInCfgAttr;
+pub(crate) struct CrateTypeInCfgAttr;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_crate_name_in_cfg_attr_deprecated)]
-pub struct CrateNameInCfgAttr;
+pub(crate) struct CrateNameInCfgAttr;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_missing_fragment_specifier)]
-pub struct MissingFragmentSpecifier;
+pub(crate) struct MissingFragmentSpecifier;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_metavariable_still_repeating)]
-pub struct MetaVariableStillRepeating {
+pub(crate) struct MetaVariableStillRepeating {
     pub name: MacroRulesNormalizedIdent,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_metavariable_wrong_operator)]
-pub struct MetaVariableWrongOperator;
+pub(crate) struct MetaVariableWrongOperator;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_duplicate_matcher_binding)]
-pub struct DuplicateMatcherBinding;
+pub(crate) struct DuplicateMatcherBinding;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unknown_macro_variable)]
-pub struct UnknownMacroVariable {
+pub(crate) struct UnknownMacroVariable {
     pub name: MacroRulesNormalizedIdent,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_crate_dependency)]
 #[help]
-pub struct UnusedCrateDependency {
+pub(crate) struct UnusedCrateDependency {
     pub extern_crate: Symbol,
     pub local_crate: Symbol,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_wasm_c_abi)]
-pub struct WasmCAbi;
+pub(crate) struct WasmCAbi;
 
 #[derive(LintDiagnostic)]
 #[diag(lint_ill_formed_attribute_input)]
-pub struct IllFormedAttributeInput {
+pub(crate) struct IllFormedAttributeInput {
     pub num_suggestions: usize,
     pub suggestions: DiagArgValue,
 }
 
 #[derive(LintDiagnostic)]
-pub enum InnerAttributeUnstable {
+pub(crate) enum InnerAttributeUnstable {
     #[diag(lint_inner_macro_attribute_unstable)]
     InnerMacroAttribute,
     #[diag(lint_custom_inner_attribute_unstable)]
@@ -2524,7 +2524,7 @@ pub enum InnerAttributeUnstable {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unknown_diagnostic_attribute)]
-pub struct UnknownDiagnosticAttribute {
+pub(crate) struct UnknownDiagnosticAttribute {
     #[subdiagnostic]
     pub typo: Option<UnknownDiagnosticAttributeTypoSugg>,
 }
@@ -2536,7 +2536,7 @@ pub struct UnknownDiagnosticAttribute {
     code = "{typo_name}",
     applicability = "machine-applicable"
 )]
-pub struct UnknownDiagnosticAttributeTypoSugg {
+pub(crate) struct UnknownDiagnosticAttributeTypoSugg {
     #[primary_span]
     pub span: Span,
     pub typo_name: Symbol,
@@ -2545,7 +2545,7 @@ pub struct UnknownDiagnosticAttributeTypoSugg {
 #[derive(LintDiagnostic)]
 #[diag(lint_unicode_text_flow)]
 #[note]
-pub struct UnicodeTextFlow {
+pub(crate) struct UnicodeTextFlow {
     #[label]
     pub comment_span: Span,
     #[subdiagnostic]
@@ -2558,7 +2558,7 @@ pub struct UnicodeTextFlow {
 
 #[derive(Subdiagnostic)]
 #[label(lint_label_comment_char)]
-pub struct UnicodeCharNoteSub {
+pub(crate) struct UnicodeCharNoteSub {
     #[primary_span]
     pub span: Span,
     pub c_debug: String,
@@ -2566,21 +2566,21 @@ pub struct UnicodeCharNoteSub {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(lint_suggestion, applicability = "machine-applicable", style = "hidden")]
-pub struct UnicodeTextFlowSuggestion {
+pub(crate) struct UnicodeTextFlowSuggestion {
     #[suggestion_part(code = "")]
     pub spans: Vec<Span>,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_abs_path_with_module)]
-pub struct AbsPathWithModule {
+pub(crate) struct AbsPathWithModule {
     #[subdiagnostic]
     pub sugg: AbsPathWithModuleSugg,
 }
 
 #[derive(Subdiagnostic)]
 #[suggestion(lint_suggestion, code = "{replacement}")]
-pub struct AbsPathWithModuleSugg {
+pub(crate) struct AbsPathWithModuleSugg {
     #[primary_span]
     pub span: Span,
     #[applicability]
@@ -2590,7 +2590,7 @@ pub struct AbsPathWithModuleSugg {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_proc_macro_derive_resolution_fallback)]
-pub struct ProcMacroDeriveResolutionFallback {
+pub(crate) struct ProcMacroDeriveResolutionFallback {
     #[label]
     pub span: Span,
     pub ns: Namespace,
@@ -2599,28 +2599,28 @@ pub struct ProcMacroDeriveResolutionFallback {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_macro_expanded_macro_exports_accessed_by_absolute_paths)]
-pub struct MacroExpandedMacroExportsAccessedByAbsolutePaths {
+pub(crate) struct MacroExpandedMacroExportsAccessedByAbsolutePaths {
     #[note]
     pub definition: Span,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_hidden_lifetime_parameters)]
-pub struct ElidedLifetimesInPaths {
+pub(crate) struct ElidedLifetimesInPaths {
     #[subdiagnostic]
     pub subdiag: ElidedLifetimeInPathSubdiag,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_invalid_crate_type_value)]
-pub struct UnknownCrateTypes {
+pub(crate) struct UnknownCrateTypes {
     #[subdiagnostic]
     pub sugg: Option<UnknownCrateTypesSub>,
 }
 
 #[derive(Subdiagnostic)]
 #[suggestion(lint_suggestion, code = r#""{candidate}""#, applicability = "maybe-incorrect")]
-pub struct UnknownCrateTypesSub {
+pub(crate) struct UnknownCrateTypesSub {
     #[primary_span]
     pub span: Span,
     pub candidate: Symbol,
@@ -2628,7 +2628,7 @@ pub struct UnknownCrateTypesSub {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_imports)]
-pub struct UnusedImports {
+pub(crate) struct UnusedImports {
     #[subdiagnostic]
     pub sugg: UnusedImportsSugg,
     #[help]
@@ -2639,7 +2639,7 @@ pub struct UnusedImports {
 }
 
 #[derive(Subdiagnostic)]
-pub enum UnusedImportsSugg {
+pub(crate) enum UnusedImportsSugg {
     #[suggestion(
         lint_suggestion_remove_whole_use,
         applicability = "machine-applicable",
@@ -2664,7 +2664,7 @@ pub enum UnusedImportsSugg {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_redundant_import)]
-pub struct RedundantImport {
+pub(crate) struct RedundantImport {
     #[subdiagnostic]
     pub subs: Vec<RedundantImportSub>,
 
@@ -2672,7 +2672,7 @@ pub struct RedundantImport {
 }
 
 #[derive(Subdiagnostic)]
-pub enum RedundantImportSub {
+pub(crate) enum RedundantImportSub {
     #[label(lint_label_imported_here)]
     ImportedHere(#[primary_span] Span),
     #[label(lint_label_defined_here)]
@@ -2686,13 +2686,13 @@ pub enum RedundantImportSub {
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_doc_comment)]
 #[help]
-pub struct UnusedDocComment {
+pub(crate) struct UnusedDocComment {
     #[label]
     pub span: Span,
 }
 
 #[derive(LintDiagnostic)]
-pub enum PatternsInFnsWithoutBody {
+pub(crate) enum PatternsInFnsWithoutBody {
     #[diag(lint_pattern_in_foreign)]
     Foreign {
         #[subdiagnostic]
@@ -2707,7 +2707,7 @@ pub enum PatternsInFnsWithoutBody {
 
 #[derive(Subdiagnostic)]
 #[suggestion(lint_remove_mut_from_pattern, code = "{ident}", applicability = "machine-applicable")]
-pub struct PatternsInFnsWithoutBodySub {
+pub(crate) struct PatternsInFnsWithoutBodySub {
     #[primary_span]
     pub span: Span,
 
@@ -2717,7 +2717,7 @@ pub struct PatternsInFnsWithoutBodySub {
 #[derive(LintDiagnostic)]
 #[diag(lint_extern_without_abi)]
 #[help]
-pub struct MissingAbi {
+pub(crate) struct MissingAbi {
     #[label]
     pub span: Span,
 
@@ -2726,14 +2726,14 @@ pub struct MissingAbi {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_legacy_derive_helpers)]
-pub struct LegacyDeriveHelpers {
+pub(crate) struct LegacyDeriveHelpers {
     #[label]
     pub span: Span,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_or_patterns_back_compat)]
-pub struct OrPatternsBackCompat {
+pub(crate) struct OrPatternsBackCompat {
     #[suggestion(code = "{suggestion}", applicability = "machine-applicable")]
     pub span: Span,
     pub suggestion: String,
@@ -2741,7 +2741,7 @@ pub struct OrPatternsBackCompat {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_reserved_prefix)]
-pub struct ReservedPrefix {
+pub(crate) struct ReservedPrefix {
     #[label]
     pub label: Span,
     #[suggestion(code = " ", applicability = "machine-applicable")]
@@ -2752,7 +2752,7 @@ pub struct ReservedPrefix {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_builtin_attribute)]
-pub struct UnusedBuiltinAttribute {
+pub(crate) struct UnusedBuiltinAttribute {
     #[note]
     pub invoc_span: Span,
 
@@ -2762,7 +2762,7 @@ pub struct UnusedBuiltinAttribute {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_trailing_semi_macro)]
-pub struct TrailingMacro {
+pub(crate) struct TrailingMacro {
     #[note(lint_note1)]
     #[note(lint_note2)]
     pub is_trailing: bool,
@@ -2772,14 +2772,14 @@ pub struct TrailingMacro {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_break_with_label_and_loop)]
-pub struct BreakWithLabelAndLoop {
+pub(crate) struct BreakWithLabelAndLoop {
     #[subdiagnostic]
     pub sub: BreakWithLabelAndLoopSub,
 }
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(lint_suggestion, applicability = "machine-applicable")]
-pub struct BreakWithLabelAndLoopSub {
+pub(crate) struct BreakWithLabelAndLoopSub {
     #[suggestion_part(code = "(")]
     pub left: Span,
     #[suggestion_part(code = ")")]
@@ -2789,13 +2789,13 @@ pub struct BreakWithLabelAndLoopSub {
 #[derive(LintDiagnostic)]
 #[diag(lint_deprecated_where_clause_location)]
 #[note]
-pub struct DeprecatedWhereClauseLocation {
+pub(crate) struct DeprecatedWhereClauseLocation {
     #[subdiagnostic]
     pub suggestion: DeprecatedWhereClauseLocationSugg,
 }
 
 #[derive(Subdiagnostic)]
-pub enum DeprecatedWhereClauseLocationSugg {
+pub(crate) enum DeprecatedWhereClauseLocationSugg {
     #[multipart_suggestion(lint_suggestion_move_to_end, applicability = "machine-applicable")]
     MoveToEnd {
         #[suggestion_part(code = "")]
@@ -2814,14 +2814,14 @@ pub enum DeprecatedWhereClauseLocationSugg {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_missing_unsafe_on_extern)]
-pub struct MissingUnsafeOnExtern {
+pub(crate) struct MissingUnsafeOnExtern {
     #[suggestion(code = "unsafe ", applicability = "machine-applicable")]
     pub suggestion: Span,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_single_use_lifetime)]
-pub struct SingleUseLifetime {
+pub(crate) struct SingleUseLifetime {
     #[label(lint_label_param)]
     pub param_span: Span,
     #[label(lint_label_use)]
@@ -2834,7 +2834,7 @@ pub struct SingleUseLifetime {
 
 #[derive(Subdiagnostic)]
 #[multipart_suggestion(lint_suggestion, applicability = "machine-applicable")]
-pub struct SingleUseLifetimeSugg {
+pub(crate) struct SingleUseLifetimeSugg {
     #[suggestion_part(code = "")]
     pub deletion_span: Option<Span>,
     #[suggestion_part(code = "{replace_lt}")]
@@ -2845,7 +2845,7 @@ pub struct SingleUseLifetimeSugg {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_lifetime)]
-pub struct UnusedLifetime {
+pub(crate) struct UnusedLifetime {
     #[suggestion(code = "", applicability = "machine-applicable")]
     pub deletion_span: Option<Span>,
 
@@ -2854,7 +2854,7 @@ pub struct UnusedLifetime {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_named_argument_used_positionally)]
-pub struct NamedArgumentUsedPositionally {
+pub(crate) struct NamedArgumentUsedPositionally {
     #[label(lint_label_named_arg)]
     pub named_arg_sp: Span,
     #[label(lint_label_position_arg)]
@@ -2869,21 +2869,21 @@ pub struct NamedArgumentUsedPositionally {
 #[derive(LintDiagnostic)]
 #[diag(lint_byte_slice_in_packed_struct_with_derive)]
 #[help]
-pub struct ByteSliceInPackedStructWithDerive {
+pub(crate) struct ByteSliceInPackedStructWithDerive {
     // FIXME: make this translatable
     pub ty: String,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unused_extern_crate)]
-pub struct UnusedExternCrate {
+pub(crate) struct UnusedExternCrate {
     #[suggestion(code = "", applicability = "machine-applicable")]
     pub removal_span: Span,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_extern_crate_not_idiomatic)]
-pub struct ExternCrateNotIdiomatic {
+pub(crate) struct ExternCrateNotIdiomatic {
     #[suggestion(style = "verbose", code = "{code}", applicability = "machine-applicable")]
     pub span: Span,
 
@@ -2891,7 +2891,7 @@ pub struct ExternCrateNotIdiomatic {
 }
 
 // FIXME: make this translatable
-pub struct AmbiguousGlobImports {
+pub(crate) struct AmbiguousGlobImports {
     pub ambiguity: AmbiguityErrorDiag,
 }
 
@@ -2904,7 +2904,7 @@ impl<'a, G: EmissionGuarantee> LintDiagnostic<'a, G> for AmbiguousGlobImports {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_ambiguous_glob_reexport)]
-pub struct AmbiguousGlobReexports {
+pub(crate) struct AmbiguousGlobReexports {
     #[label(lint_label_first_reexport)]
     pub first_reexport: Span,
     #[label(lint_label_duplicate_reexport)]
@@ -2917,7 +2917,7 @@ pub struct AmbiguousGlobReexports {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_hidden_glob_reexport)]
-pub struct HiddenGlobReexports {
+pub(crate) struct HiddenGlobReexports {
     #[note(lint_note_glob_reexport)]
     pub glob_reexport: Span,
     #[note(lint_note_private_item)]
@@ -2930,14 +2930,14 @@ pub struct HiddenGlobReexports {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unnecessary_qualification)]
-pub struct UnusedQualifications {
+pub(crate) struct UnusedQualifications {
     #[suggestion(style = "verbose", code = "", applicability = "machine-applicable")]
     pub removal_span: Span,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(lint_associated_const_elided_lifetime)]
-pub struct AssociatedConstElidedLifetime {
+pub(crate) struct AssociatedConstElidedLifetime {
     #[suggestion(style = "verbose", code = "{code}", applicability = "machine-applicable")]
     pub span: Span,
 
@@ -2949,7 +2949,7 @@ pub struct AssociatedConstElidedLifetime {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_redundant_import_visibility)]
-pub struct RedundantImportVisibility {
+pub(crate) struct RedundantImportVisibility {
     #[note]
     pub span: Span,
     #[help]
@@ -2961,7 +2961,7 @@ pub struct RedundantImportVisibility {
 
 #[derive(LintDiagnostic)]
 #[diag(lint_unsafe_attr_outside_unsafe)]
-pub struct UnsafeAttrOutsideUnsafe {
+pub(crate) struct UnsafeAttrOutsideUnsafe {
     #[label]
     pub span: Span,
     #[subdiagnostic]
@@ -2973,7 +2973,7 @@ pub struct UnsafeAttrOutsideUnsafe {
     lint_unsafe_attr_outside_unsafe_suggestion,
     applicability = "machine-applicable"
 )]
-pub struct UnsafeAttrOutsideUnsafeSuggestion {
+pub(crate) struct UnsafeAttrOutsideUnsafeSuggestion {
     #[suggestion_part(code = "unsafe(")]
     pub left: Span,
     #[suggestion_part(code = ")")]
@@ -2983,6 +2983,6 @@ pub struct UnsafeAttrOutsideUnsafeSuggestion {
 #[derive(LintDiagnostic)]
 #[diag(lint_out_of_scope_macro_calls)]
 #[help]
-pub struct OutOfScopeMacroCalls {
+pub(crate) struct OutOfScopeMacroCalls {
     pub path: String,
 }
diff --git a/compiler/rustc_lint/src/non_local_def.rs b/compiler/rustc_lint/src/non_local_def.rs
index 5ad677995da1c..13a3c741fe39b 100644
--- a/compiler/rustc_lint/src/non_local_def.rs
+++ b/compiler/rustc_lint/src/non_local_def.rs
@@ -55,7 +55,7 @@ declare_lint! {
 }
 
 #[derive(Default)]
-pub struct NonLocalDefinitions {
+pub(crate) struct NonLocalDefinitions {
     body_depth: u32,
 }
 
diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs
index d7fd41c0ad7a3..d81052b5e2466 100644
--- a/compiler/rustc_lint/src/nonstandard_style.rs
+++ b/compiler/rustc_lint/src/nonstandard_style.rs
@@ -17,13 +17,13 @@ use crate::lints::{
 use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 
 #[derive(PartialEq)]
-pub enum MethodLateContext {
+pub(crate) enum MethodLateContext {
     TraitAutoImpl,
     TraitImpl,
     PlainImpl,
 }
 
-pub fn method_context(cx: &LateContext<'_>, id: LocalDefId) -> MethodLateContext {
+pub(crate) fn method_context(cx: &LateContext<'_>, id: LocalDefId) -> MethodLateContext {
     let item = cx.tcx.associated_item(id);
     match item.container {
         ty::TraitContainer => MethodLateContext::TraitAutoImpl,
diff --git a/compiler/rustc_lint/src/shadowed_into_iter.rs b/compiler/rustc_lint/src/shadowed_into_iter.rs
index 4fe35a6a0a3bc..bb9c7d85c2efc 100644
--- a/compiler/rustc_lint/src/shadowed_into_iter.rs
+++ b/compiler/rustc_lint/src/shadowed_into_iter.rs
@@ -65,7 +65,7 @@ declare_lint! {
 }
 
 #[derive(Copy, Clone)]
-pub struct ShadowedIntoIter;
+pub(crate) struct ShadowedIntoIter;
 
 impl_lint_pass!(ShadowedIntoIter => [ARRAY_INTO_ITER, BOXED_SLICE_INTO_ITER]);
 
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index f1da14bb1f382..f2f7c0eaa4df8 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -165,7 +165,7 @@ declare_lint! {
 }
 
 #[derive(Copy, Clone)]
-pub struct TypeLimits {
+pub(crate) struct TypeLimits {
     /// Id of the last visited negated expression
     negated_expr_id: Option<hir::HirId>,
     /// Span of the last visited negated expression
@@ -180,7 +180,7 @@ impl_lint_pass!(TypeLimits => [
 ]);
 
 impl TypeLimits {
-    pub fn new() -> TypeLimits {
+    pub(crate) fn new() -> TypeLimits {
         TypeLimits { negated_expr_id: None, negated_expr_span: None }
     }
 }
@@ -1008,7 +1008,7 @@ pub(crate) fn nonnull_optimization_guaranteed<'tcx>(
 
 /// `repr(transparent)` structs can have a single non-1-ZST field, this function returns that
 /// field.
-pub fn transparent_newtype_field<'a, 'tcx>(
+pub(crate) fn transparent_newtype_field<'a, 'tcx>(
     tcx: TyCtxt<'tcx>,
     variant: &'a ty::VariantDef,
 ) -> Option<&'a ty::FieldDef> {
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index 553d9db12c572..c3b80e01c3624 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -1019,7 +1019,7 @@ declare_lint! {
     "`if`, `match`, `while` and `return` do not need parentheses"
 }
 
-pub struct UnusedParens {
+pub(crate) struct UnusedParens {
     with_self_ty_parens: bool,
     /// `1 as (i32) < 2` parses to ExprKind::Lt
     /// `1 as i32 < 2` parses to i32::<2[missing angle bracket]
@@ -1027,7 +1027,7 @@ pub struct UnusedParens {
 }
 
 impl UnusedParens {
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self { with_self_ty_parens: false, parens_in_cast_in_lt: Vec::new() }
     }
 }

From e7f1922abdca0a155effacb26d9d16dd283a2062 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 15:25:49 +1000
Subject: [PATCH 650/685] Add `warn(unreachable_pub)` to `rustc_lint_defs`.

---
 compiler/rustc_lint_defs/src/lib.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index 0f07de43e80ed..c17b85db3b044 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -1,3 +1,7 @@
+// tidy-alphabetical-start
+#![warn(unreachable_pub)]
+// tidy-alphabetical-end
+
 use rustc_ast::node_id::NodeId;
 use rustc_ast::{AttrId, Attribute};
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};

From 22cdd632f1a98830ead8f03cf7f227cc72d814a8 Mon Sep 17 00:00:00 2001
From: Nicholas Nethercote <n.nethercote@gmail.com>
Date: Tue, 27 Aug 2024 15:28:26 +1000
Subject: [PATCH 651/685] Add `warn(unreachable_pub)` to `rustc_llvm`.

---
 compiler/rustc_llvm/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/rustc_llvm/src/lib.rs b/compiler/rustc_llvm/src/lib.rs
index 939e5e4dbd4ff..29442655eb0ab 100644
--- a/compiler/rustc_llvm/src/lib.rs
+++ b/compiler/rustc_llvm/src/lib.rs
@@ -3,6 +3,7 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
+#![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
 // NOTE: This crate only exists to allow linking on mingw targets.

From ab7b03e3f4126c94864bd2548660143d6bbd3d3a Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 27 Aug 2024 09:04:59 +0200
Subject: [PATCH 652/685] ABI compat check: detect unadjusted ABI mismatches

---
 compiler/rustc_abi/src/lib.rs             |  4 +++-
 compiler/rustc_target/src/abi/call/mod.rs | 19 +++++++++++++++++--
 compiler/rustc_target/src/spec/abi/mod.rs |  2 ++
 tests/ui/abi/compatibility.rs             |  7 ++++---
 4 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index ea634d7485ef7..df29b3d54f0fb 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -1700,7 +1700,9 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutS<FieldIdx, VariantIdx> {
 
     /// Checks if these two `Layout` are equal enough to be considered "the same for all function
     /// call ABIs". Note however that real ABIs depend on more details that are not reflected in the
-    /// `Layout`; the `PassMode` need to be compared as well.
+    /// `Layout`; the `PassMode` need to be compared as well. Also note that we assume
+    /// aggregates are passed via `PassMode::Indirect` or `PassMode::Cast`; more strict
+    /// checks would otherwise be required.
     pub fn eq_abi(&self, other: &Self) -> bool {
         // The one thing that we are not capturing here is that for unsized types, the metadata must
         // also have the same ABI, and moreover that the same metadata leads to the same size. The
diff --git a/compiler/rustc_target/src/abi/call/mod.rs b/compiler/rustc_target/src/abi/call/mod.rs
index c1ddfcb2f9090..082c169b210f8 100644
--- a/compiler/rustc_target/src/abi/call/mod.rs
+++ b/compiler/rustc_target/src/abi/call/mod.rs
@@ -745,10 +745,25 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
 
     /// Checks if these two `ArgAbi` are equal enough to be considered "the same for all
     /// function call ABIs".
-    pub fn eq_abi(&self, other: &Self) -> bool {
+    pub fn eq_abi(&self, other: &Self) -> bool
+    where
+        Ty: PartialEq,
+    {
         // Ideally we'd just compare the `mode`, but that is not enough -- for some modes LLVM will look
         // at the type.
-        self.layout.eq_abi(&other.layout) && self.mode.eq_abi(&other.mode)
+        self.layout.eq_abi(&other.layout) && self.mode.eq_abi(&other.mode) && {
+            // `fn_arg_sanity_check` accepts `PassMode::Direct` for some aggregates.
+            // That elevates any type difference to an ABI difference since we just use the
+            // full Rust type as the LLVM argument/return type.
+            if matches!(self.mode, PassMode::Direct(..))
+                && matches!(self.layout.abi, Abi::Aggregate { .. })
+            {
+                // For aggregates in `Direct` mode to be compatible, the types need to be equal.
+                self.layout.ty == other.layout.ty
+            } else {
+                true
+            }
+        }
     }
 }
 
diff --git a/compiler/rustc_target/src/spec/abi/mod.rs b/compiler/rustc_target/src/spec/abi/mod.rs
index 0d61345a70e41..cc383f88fbc5b 100644
--- a/compiler/rustc_target/src/spec/abi/mod.rs
+++ b/compiler/rustc_target/src/spec/abi/mod.rs
@@ -53,6 +53,8 @@ pub enum Abi {
     },
     RustIntrinsic,
     RustCall,
+    /// *Not* a stable ABI, just directly use the Rust types to describe the ABI for LLVM. Even
+    /// normally ABI-compatible Rust types can become ABI-incompatible with this ABI!
     Unadjusted,
     /// For things unlikely to be called, where reducing register pressure in
     /// `extern "Rust"` callers is worth paying extra cost in the callee.
diff --git a/tests/ui/abi/compatibility.rs b/tests/ui/abi/compatibility.rs
index ca78604edd866..d37e793d9892d 100644
--- a/tests/ui/abi/compatibility.rs
+++ b/tests/ui/abi/compatibility.rs
@@ -40,9 +40,10 @@
 //@[loongarch64] compile-flags: --target loongarch64-unknown-linux-gnu
 //@[loongarch64] needs-llvm-components: loongarch
 //@[loongarch64] min-llvm-version: 18
-//@ revisions: wasm
-//@[wasm] compile-flags: --target wasm32-unknown-unknown
-//@[wasm] needs-llvm-components: webassembly
+//FIXME: wasm is disabled due to <https://github.com/rust-lang/rust/issues/115666>.
+//FIXME @ revisions: wasm
+//FIXME @[wasm] compile-flags: --target wasm32-unknown-unknown
+//FIXME @[wasm] needs-llvm-components: webassembly
 //@ revisions: wasip1
 //@[wasip1] compile-flags: --target wasm32-wasip1
 //@[wasip1] needs-llvm-components: webassembly

From d456814842e65a153a1de67960b892897a02ed14 Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Tue, 23 Jul 2024 16:10:08 +0200
Subject: [PATCH 653/685] std: move allocators to `sys`

---
 .../{pal/hermit/alloc.rs => alloc/hermit.rs}  |  1 -
 .../sys/{pal/common/alloc.rs => alloc/mod.rs} | 67 ++++++++++++++-----
 .../sys/{pal/sgx/alloc.rs => alloc/sgx.rs}    |  7 +-
 .../{pal/solid/alloc.rs => alloc/solid.rs}    |  2 +-
 .../sys/{pal/uefi/alloc.rs => alloc/uefi.rs}  |  2 +-
 .../sys/{pal/unix/alloc.rs => alloc/unix.rs}  | 20 +++---
 .../sys/{pal/wasm/alloc.rs => alloc/wasm.rs}  |  0
 .../windows/alloc.rs => alloc/windows.rs}     | 15 ++---
 .../windows/alloc => alloc/windows}/tests.rs  |  0
 .../sys/{pal/xous/alloc.rs => alloc/xous.rs}  |  0
 .../sys/{pal/zkvm/alloc.rs => alloc/zkvm.rs}  |  2 +-
 library/std/src/sys/mod.rs                    |  1 +
 library/std/src/sys/pal/common/mod.rs         |  1 -
 library/std/src/sys/pal/hermit/mod.rs         |  1 -
 library/std/src/sys/pal/sgx/mod.rs            |  1 -
 library/std/src/sys/pal/solid/mod.rs          |  1 -
 library/std/src/sys/pal/teeos/alloc.rs        | 57 ----------------
 library/std/src/sys/pal/teeos/mod.rs          |  1 -
 library/std/src/sys/pal/uefi/mod.rs           |  4 +-
 library/std/src/sys/pal/unix/mod.rs           |  1 -
 library/std/src/sys/pal/unsupported/alloc.rs  | 23 -------
 library/std/src/sys/pal/unsupported/mod.rs    |  1 -
 library/std/src/sys/pal/wasi/mod.rs           |  2 -
 library/std/src/sys/pal/wasip2/mod.rs         |  2 -
 library/std/src/sys/pal/wasm/mod.rs           |  1 -
 library/std/src/sys/pal/windows/mod.rs        |  1 -
 library/std/src/sys/pal/xous/mod.rs           |  1 -
 library/std/src/sys/pal/zkvm/mod.rs           |  9 +--
 28 files changed, 78 insertions(+), 146 deletions(-)
 rename library/std/src/sys/{pal/hermit/alloc.rs => alloc/hermit.rs} (97%)
 rename library/std/src/sys/{pal/common/alloc.rs => alloc/mod.rs} (55%)
 rename library/std/src/sys/{pal/sgx/alloc.rs => alloc/sgx.rs} (95%)
 rename library/std/src/sys/{pal/solid/alloc.rs => alloc/solid.rs} (94%)
 rename library/std/src/sys/{pal/uefi/alloc.rs => alloc/uefi.rs} (98%)
 rename library/std/src/sys/{pal/unix/alloc.rs => alloc/unix.rs} (83%)
 rename library/std/src/sys/{pal/wasm/alloc.rs => alloc/wasm.rs} (100%)
 rename library/std/src/sys/{pal/windows/alloc.rs => alloc/windows.rs} (97%)
 rename library/std/src/sys/{pal/windows/alloc => alloc/windows}/tests.rs (100%)
 rename library/std/src/sys/{pal/xous/alloc.rs => alloc/xous.rs} (100%)
 rename library/std/src/sys/{pal/zkvm/alloc.rs => alloc/zkvm.rs} (94%)
 delete mode 100644 library/std/src/sys/pal/teeos/alloc.rs
 delete mode 100644 library/std/src/sys/pal/unsupported/alloc.rs

diff --git a/library/std/src/sys/pal/hermit/alloc.rs b/library/std/src/sys/alloc/hermit.rs
similarity index 97%
rename from library/std/src/sys/pal/hermit/alloc.rs
rename to library/std/src/sys/alloc/hermit.rs
index f10d5f9227e63..77f8200a70a64 100644
--- a/library/std/src/sys/pal/hermit/alloc.rs
+++ b/library/std/src/sys/alloc/hermit.rs
@@ -1,4 +1,3 @@
-use super::hermit_abi;
 use crate::alloc::{GlobalAlloc, Layout, System};
 
 #[stable(feature = "alloc_system_type", since = "1.28.0")]
diff --git a/library/std/src/sys/pal/common/alloc.rs b/library/std/src/sys/alloc/mod.rs
similarity index 55%
rename from library/std/src/sys/pal/common/alloc.rs
rename to library/std/src/sys/alloc/mod.rs
index 1b465f95d1bc3..2c0b533a5703f 100644
--- a/library/std/src/sys/pal/common/alloc.rs
+++ b/library/std/src/sys/alloc/mod.rs
@@ -1,10 +1,18 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
+
 use crate::alloc::{GlobalAlloc, Layout, System};
-use crate::{cmp, ptr};
+use crate::ptr;
 
 // The minimum alignment guaranteed by the architecture. This value is used to
 // add fast paths for low alignment values.
-#[cfg(any(
+#[allow(dead_code)]
+const MIN_ALIGN: usize = if cfg!(any(
+    all(target_arch = "riscv32", any(target_os = "espidf", target_os = "zkvm")),
+    all(target_arch = "xtensa", target_os = "espidf"),
+)) {
+    // The allocator on the esp-idf and zkvm platforms guarantees 4 byte alignment.
+    4
+} else if cfg!(any(
     target_arch = "x86",
     target_arch = "arm",
     target_arch = "m68k",
@@ -16,11 +24,11 @@ use crate::{cmp, ptr};
     target_arch = "sparc",
     target_arch = "wasm32",
     target_arch = "hexagon",
-    all(target_arch = "riscv32", not(any(target_os = "espidf", target_os = "zkvm"))),
-    all(target_arch = "xtensa", not(target_os = "espidf")),
-))]
-pub const MIN_ALIGN: usize = 8;
-#[cfg(any(
+    target_arch = "riscv32",
+    target_arch = "xtensa",
+)) {
+    8
+} else if cfg!(any(
     target_arch = "x86_64",
     target_arch = "aarch64",
     target_arch = "arm64ec",
@@ -31,16 +39,14 @@ pub const MIN_ALIGN: usize = 8;
     target_arch = "sparc64",
     target_arch = "riscv64",
     target_arch = "wasm64",
-))]
-pub const MIN_ALIGN: usize = 16;
-// The allocator on the esp-idf and zkvm platforms guarantee 4 byte alignment.
-#[cfg(all(any(
-    all(target_arch = "riscv32", any(target_os = "espidf", target_os = "zkvm")),
-    all(target_arch = "xtensa", target_os = "espidf"),
-)))]
-pub const MIN_ALIGN: usize = 4;
+)) {
+    16
+} else {
+    panic!("add a value for MIN_ALIGN")
+};
 
-pub unsafe fn realloc_fallback(
+#[allow(dead_code)]
+unsafe fn realloc_fallback(
     alloc: &System,
     ptr: *mut u8,
     old_layout: Layout,
@@ -52,10 +58,37 @@ pub unsafe fn realloc_fallback(
 
         let new_ptr = GlobalAlloc::alloc(alloc, new_layout);
         if !new_ptr.is_null() {
-            let size = cmp::min(old_layout.size(), new_size);
+            let size = usize::min(old_layout.size(), new_size);
             ptr::copy_nonoverlapping(ptr, new_ptr, size);
             GlobalAlloc::dealloc(alloc, ptr, old_layout);
         }
+
         new_ptr
     }
 }
+
+cfg_if::cfg_if! {
+    if #[cfg(any(
+        target_family = "unix",
+        target_os = "wasi",
+        target_os = "teeos",
+    ))] {
+        mod unix;
+    } else if #[cfg(target_os = "windows")] {
+        mod windows;
+    } else if #[cfg(target_os = "hermit")] {
+        mod hermit;
+    } else if #[cfg(all(target_vendor = "fortanix", target_env = "sgx"))] {
+        mod sgx;
+    } else if #[cfg(target_os = "solid_asp3")] {
+        mod solid;
+    } else if #[cfg(target_os = "uefi")] {
+        mod uefi;
+    } else if #[cfg(target_family = "wasm")] {
+        mod wasm;
+    } else if #[cfg(target_os = "xous")] {
+        mod xous;
+    } else if #[cfg(target_os = "zkvm")] {
+        mod zkvm;
+    }
+}
diff --git a/library/std/src/sys/pal/sgx/alloc.rs b/library/std/src/sys/alloc/sgx.rs
similarity index 95%
rename from library/std/src/sys/pal/sgx/alloc.rs
rename to library/std/src/sys/alloc/sgx.rs
index f68ede9fcf012..fca9d087e5bfc 100644
--- a/library/std/src/sys/pal/sgx/alloc.rs
+++ b/library/std/src/sys/alloc/sgx.rs
@@ -1,9 +1,8 @@
-use core::sync::atomic::{AtomicBool, Ordering};
-
-use super::abi::mem as sgx_mem;
-use super::waitqueue::SpinMutex;
 use crate::alloc::{GlobalAlloc, Layout, System};
 use crate::ptr;
+use crate::sync::atomic::{AtomicBool, Ordering};
+use crate::sys::pal::abi::mem as sgx_mem;
+use crate::sys::pal::waitqueue::SpinMutex;
 
 // Using a SpinMutex because we never want to exit the enclave waiting for the
 // allocator.
diff --git a/library/std/src/sys/pal/solid/alloc.rs b/library/std/src/sys/alloc/solid.rs
similarity index 94%
rename from library/std/src/sys/pal/solid/alloc.rs
rename to library/std/src/sys/alloc/solid.rs
index 4cf60ac9b2e23..abb534a1c5cf4 100644
--- a/library/std/src/sys/pal/solid/alloc.rs
+++ b/library/std/src/sys/alloc/solid.rs
@@ -1,5 +1,5 @@
+use super::{realloc_fallback, MIN_ALIGN};
 use crate::alloc::{GlobalAlloc, Layout, System};
-use crate::sys::common::alloc::{realloc_fallback, MIN_ALIGN};
 
 #[stable(feature = "alloc_system_type", since = "1.28.0")]
 unsafe impl GlobalAlloc for System {
diff --git a/library/std/src/sys/pal/uefi/alloc.rs b/library/std/src/sys/alloc/uefi.rs
similarity index 98%
rename from library/std/src/sys/pal/uefi/alloc.rs
rename to library/std/src/sys/alloc/uefi.rs
index 15404ac3ea696..5221876e90866 100644
--- a/library/std/src/sys/pal/uefi/alloc.rs
+++ b/library/std/src/sys/alloc/uefi.rs
@@ -3,9 +3,9 @@
 
 use r_efi::protocols::loaded_image;
 
-use super::helpers;
 use crate::alloc::{GlobalAlloc, Layout, System};
 use crate::sync::OnceLock;
+use crate::sys::pal::helpers;
 
 #[stable(feature = "alloc_system_type", since = "1.28.0")]
 unsafe impl GlobalAlloc for System {
diff --git a/library/std/src/sys/pal/unix/alloc.rs b/library/std/src/sys/alloc/unix.rs
similarity index 83%
rename from library/std/src/sys/pal/unix/alloc.rs
rename to library/std/src/sys/alloc/unix.rs
index 625ba5247f111..46ed7de7162f8 100644
--- a/library/std/src/sys/pal/unix/alloc.rs
+++ b/library/std/src/sys/alloc/unix.rs
@@ -1,6 +1,6 @@
+use super::{realloc_fallback, MIN_ALIGN};
 use crate::alloc::{GlobalAlloc, Layout, System};
 use crate::ptr;
-use crate::sys::common::alloc::{realloc_fallback, MIN_ALIGN};
 
 #[stable(feature = "alloc_system_type", since = "1.28.0")]
 unsafe impl GlobalAlloc for System {
@@ -11,7 +11,7 @@ unsafe impl GlobalAlloc for System {
         // Also see <https://github.com/rust-lang/rust/issues/45955> and
         // <https://github.com/rust-lang/rust/issues/62251#issuecomment-507580914>.
         if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
-            libc::malloc(layout.size()) as *mut u8
+            unsafe { libc::malloc(layout.size()) as *mut u8 }
         } else {
             // `posix_memalign` returns a non-aligned value if supplied a very
             // large alignment on older versions of Apple's platforms (unknown
@@ -25,7 +25,7 @@ unsafe impl GlobalAlloc for System {
                     return ptr::null_mut();
                 }
             }
-            aligned_malloc(&layout)
+            unsafe { aligned_malloc(&layout) }
         }
     }
 
@@ -33,11 +33,11 @@ unsafe impl GlobalAlloc for System {
     unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
         // See the comment above in `alloc` for why this check looks the way it does.
         if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
-            libc::calloc(layout.size(), 1) as *mut u8
+            unsafe { libc::calloc(layout.size(), 1) as *mut u8 }
         } else {
-            let ptr = self.alloc(layout);
+            let ptr = unsafe { self.alloc(layout) };
             if !ptr.is_null() {
-                ptr::write_bytes(ptr, 0, layout.size());
+                unsafe { ptr::write_bytes(ptr, 0, layout.size()) };
             }
             ptr
         }
@@ -45,15 +45,15 @@ unsafe impl GlobalAlloc for System {
 
     #[inline]
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-        libc::free(ptr as *mut libc::c_void)
+        unsafe { libc::free(ptr as *mut libc::c_void) }
     }
 
     #[inline]
     unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
         if layout.align() <= MIN_ALIGN && layout.align() <= new_size {
-            libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8
+            unsafe { libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8 }
         } else {
-            realloc_fallback(self, ptr, layout, new_size)
+            unsafe { realloc_fallback(self, ptr, layout, new_size) }
         }
     }
 }
@@ -81,7 +81,7 @@ cfg_if::cfg_if! {
             // posix_memalign only has one, clear requirement: that the alignment be a multiple of
             // `sizeof(void*)`. Since these are all powers of 2, we can just use max.
             let align = layout.align().max(crate::mem::size_of::<usize>());
-            let ret = libc::posix_memalign(&mut out, align, layout.size());
+            let ret = unsafe { libc::posix_memalign(&mut out, align, layout.size()) };
             if ret != 0 { ptr::null_mut() } else { out as *mut u8 }
         }
     }
diff --git a/library/std/src/sys/pal/wasm/alloc.rs b/library/std/src/sys/alloc/wasm.rs
similarity index 100%
rename from library/std/src/sys/pal/wasm/alloc.rs
rename to library/std/src/sys/alloc/wasm.rs
diff --git a/library/std/src/sys/pal/windows/alloc.rs b/library/std/src/sys/alloc/windows.rs
similarity index 97%
rename from library/std/src/sys/pal/windows/alloc.rs
rename to library/std/src/sys/alloc/windows.rs
index 2205885687dea..e91956966aa73 100644
--- a/library/std/src/sys/pal/windows/alloc.rs
+++ b/library/std/src/sys/alloc/windows.rs
@@ -1,11 +1,10 @@
-use core::mem::MaybeUninit;
-
+use super::{realloc_fallback, MIN_ALIGN};
 use crate::alloc::{GlobalAlloc, Layout, System};
 use crate::ffi::c_void;
+use crate::mem::MaybeUninit;
 use crate::ptr;
 use crate::sync::atomic::{AtomicPtr, Ordering};
 use crate::sys::c;
-use crate::sys::common::alloc::{realloc_fallback, MIN_ALIGN};
 
 #[cfg(test)]
 mod tests;
@@ -113,28 +112,28 @@ fn init_or_get_process_heap() -> c::HANDLE {
 extern "C" fn process_heap_init_and_alloc(
     _heap: MaybeUninit<c::HANDLE>, // We pass this argument to match the ABI of `HeapAlloc`
     flags: u32,
-    dwBytes: usize,
+    bytes: usize,
 ) -> *mut c_void {
     let heap = init_or_get_process_heap();
     if core::intrinsics::unlikely(heap.is_null()) {
         return ptr::null_mut();
     }
     // SAFETY: `heap` is a non-null handle returned by `GetProcessHeap`.
-    unsafe { HeapAlloc(heap, flags, dwBytes) }
+    unsafe { HeapAlloc(heap, flags, bytes) }
 }
 
 #[inline(never)]
 fn process_heap_alloc(
     _heap: MaybeUninit<c::HANDLE>, // We pass this argument to match the ABI of `HeapAlloc`,
     flags: u32,
-    dwBytes: usize,
+    bytes: usize,
 ) -> *mut c_void {
     let heap = HEAP.load(Ordering::Relaxed);
     if core::intrinsics::likely(!heap.is_null()) {
         // SAFETY: `heap` is a non-null handle returned by `GetProcessHeap`.
-        unsafe { HeapAlloc(heap, flags, dwBytes) }
+        unsafe { HeapAlloc(heap, flags, bytes) }
     } else {
-        process_heap_init_and_alloc(MaybeUninit::uninit(), flags, dwBytes)
+        process_heap_init_and_alloc(MaybeUninit::uninit(), flags, bytes)
     }
 }
 
diff --git a/library/std/src/sys/pal/windows/alloc/tests.rs b/library/std/src/sys/alloc/windows/tests.rs
similarity index 100%
rename from library/std/src/sys/pal/windows/alloc/tests.rs
rename to library/std/src/sys/alloc/windows/tests.rs
diff --git a/library/std/src/sys/pal/xous/alloc.rs b/library/std/src/sys/alloc/xous.rs
similarity index 100%
rename from library/std/src/sys/pal/xous/alloc.rs
rename to library/std/src/sys/alloc/xous.rs
diff --git a/library/std/src/sys/pal/zkvm/alloc.rs b/library/std/src/sys/alloc/zkvm.rs
similarity index 94%
rename from library/std/src/sys/pal/zkvm/alloc.rs
rename to library/std/src/sys/alloc/zkvm.rs
index 2fdca22352470..a600cfa2220dd 100644
--- a/library/std/src/sys/pal/zkvm/alloc.rs
+++ b/library/std/src/sys/alloc/zkvm.rs
@@ -1,5 +1,5 @@
-use super::abi;
 use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::sys::pal::abi;
 
 #[stable(feature = "alloc_system_type", since = "1.28.0")]
 unsafe impl GlobalAlloc for System {
diff --git a/library/std/src/sys/mod.rs b/library/std/src/sys/mod.rs
index a86b3628f249a..1ef17dd530fd2 100644
--- a/library/std/src/sys/mod.rs
+++ b/library/std/src/sys/mod.rs
@@ -5,6 +5,7 @@
 /// descriptors.
 mod pal;
 
+mod alloc;
 mod personality;
 
 pub mod anonymous_pipe;
diff --git a/library/std/src/sys/pal/common/mod.rs b/library/std/src/sys/pal/common/mod.rs
index 29fc0835d7666..9af4dee401cf3 100644
--- a/library/std/src/sys/pal/common/mod.rs
+++ b/library/std/src/sys/pal/common/mod.rs
@@ -10,7 +10,6 @@
 
 #![allow(dead_code)]
 
-pub mod alloc;
 pub mod small_c_string;
 
 #[cfg(test)]
diff --git a/library/std/src/sys/pal/hermit/mod.rs b/library/std/src/sys/pal/hermit/mod.rs
index ef406b9ec7f0d..1f2e5d9469f5c 100644
--- a/library/std/src/sys/pal/hermit/mod.rs
+++ b/library/std/src/sys/pal/hermit/mod.rs
@@ -18,7 +18,6 @@
 
 use crate::os::raw::c_char;
 
-pub mod alloc;
 pub mod args;
 pub mod env;
 pub mod fd;
diff --git a/library/std/src/sys/pal/sgx/mod.rs b/library/std/src/sys/pal/sgx/mod.rs
index 851ab9b9f9767..8d29b2ec6193e 100644
--- a/library/std/src/sys/pal/sgx/mod.rs
+++ b/library/std/src/sys/pal/sgx/mod.rs
@@ -9,7 +9,6 @@ use crate::io::ErrorKind;
 use crate::sync::atomic::{AtomicBool, Ordering};
 
 pub mod abi;
-pub mod alloc;
 pub mod args;
 pub mod env;
 pub mod fd;
diff --git a/library/std/src/sys/pal/solid/mod.rs b/library/std/src/sys/pal/solid/mod.rs
index cbf34286878fe..6ebcf5b7c48c8 100644
--- a/library/std/src/sys/pal/solid/mod.rs
+++ b/library/std/src/sys/pal/solid/mod.rs
@@ -16,7 +16,6 @@ pub mod itron {
     use super::unsupported;
 }
 
-pub mod alloc;
 #[path = "../unsupported/args.rs"]
 pub mod args;
 pub mod env;
diff --git a/library/std/src/sys/pal/teeos/alloc.rs b/library/std/src/sys/pal/teeos/alloc.rs
deleted file mode 100644
index b280d1dd76f7a..0000000000000
--- a/library/std/src/sys/pal/teeos/alloc.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use crate::alloc::{GlobalAlloc, Layout, System};
-use crate::ptr;
-use crate::sys::common::alloc::{realloc_fallback, MIN_ALIGN};
-
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        // jemalloc provides alignment less than MIN_ALIGN for small allocations.
-        // So only rely on MIN_ALIGN if size >= align.
-        // Also see <https://github.com/rust-lang/rust/issues/45955> and
-        // <https://github.com/rust-lang/rust/issues/62251#issuecomment-507580914>.
-        if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
-            unsafe { libc::malloc(layout.size()) as *mut u8 }
-        } else {
-            unsafe { aligned_malloc(&layout) }
-        }
-    }
-
-    #[inline]
-    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
-        // See the comment above in `alloc` for why this check looks the way it does.
-        if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
-            unsafe { libc::calloc(layout.size(), 1) as *mut u8 }
-        } else {
-            let ptr = unsafe { self.alloc(layout) };
-            if !ptr.is_null() {
-                unsafe { ptr::write_bytes(ptr, 0, layout.size()) };
-            }
-            ptr
-        }
-    }
-
-    #[inline]
-    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-        unsafe { libc::free(ptr as *mut libc::c_void) }
-    }
-
-    #[inline]
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
-        if layout.align() <= MIN_ALIGN && layout.align() <= new_size {
-            unsafe { libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8 }
-        } else {
-            unsafe { realloc_fallback(self, ptr, layout, new_size) }
-        }
-    }
-}
-
-#[inline]
-unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {
-    let mut out = ptr::null_mut();
-    // posix_memalign requires that the alignment be a multiple of `sizeof(void*)`.
-    // Since these are all powers of 2, we can just use max.
-    let align = layout.align().max(crate::mem::size_of::<usize>());
-    let ret = unsafe { libc::posix_memalign(&mut out, align, layout.size()) };
-    if ret != 0 { ptr::null_mut() } else { out as *mut u8 }
-}
diff --git a/library/std/src/sys/pal/teeos/mod.rs b/library/std/src/sys/pal/teeos/mod.rs
index adefd1bb42c8d..00e3860424006 100644
--- a/library/std/src/sys/pal/teeos/mod.rs
+++ b/library/std/src/sys/pal/teeos/mod.rs
@@ -8,7 +8,6 @@
 
 pub use self::rand::hashmap_random_keys;
 
-pub mod alloc;
 #[path = "../unsupported/args.rs"]
 pub mod args;
 #[path = "../unsupported/env.rs"]
diff --git a/library/std/src/sys/pal/uefi/mod.rs b/library/std/src/sys/pal/uefi/mod.rs
index 851bcea4c1e43..ac22f4ded8855 100644
--- a/library/std/src/sys/pal/uefi/mod.rs
+++ b/library/std/src/sys/pal/uefi/mod.rs
@@ -13,11 +13,11 @@
 //! [`OsString`]: crate::ffi::OsString
 #![forbid(unsafe_op_in_unsafe_fn)]
 
-pub mod alloc;
 pub mod args;
 pub mod env;
 #[path = "../unsupported/fs.rs"]
 pub mod fs;
+pub mod helpers;
 #[path = "../unsupported/io.rs"]
 pub mod io;
 #[path = "../unsupported/net.rs"]
@@ -30,8 +30,6 @@ pub mod stdio;
 pub mod thread;
 pub mod time;
 
-mod helpers;
-
 #[cfg(test)]
 mod tests;
 
diff --git a/library/std/src/sys/pal/unix/mod.rs b/library/std/src/sys/pal/unix/mod.rs
index 10df3306f9251..ba2f58f9c10bd 100644
--- a/library/std/src/sys/pal/unix/mod.rs
+++ b/library/std/src/sys/pal/unix/mod.rs
@@ -7,7 +7,6 @@ use crate::io::ErrorKind;
 #[macro_use]
 pub mod weak;
 
-pub mod alloc;
 pub mod args;
 pub mod env;
 pub mod fd;
diff --git a/library/std/src/sys/pal/unsupported/alloc.rs b/library/std/src/sys/pal/unsupported/alloc.rs
deleted file mode 100644
index d715ae45401e6..0000000000000
--- a/library/std/src/sys/pal/unsupported/alloc.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use crate::alloc::{GlobalAlloc, Layout, System};
-use crate::ptr::null_mut;
-
-#[stable(feature = "alloc_system_type", since = "1.28.0")]
-unsafe impl GlobalAlloc for System {
-    #[inline]
-    unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
-        null_mut()
-    }
-
-    #[inline]
-    unsafe fn alloc_zeroed(&self, _layout: Layout) -> *mut u8 {
-        null_mut()
-    }
-
-    #[inline]
-    unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {}
-
-    #[inline]
-    unsafe fn realloc(&self, _ptr: *mut u8, _layout: Layout, _new_size: usize) -> *mut u8 {
-        null_mut()
-    }
-}
diff --git a/library/std/src/sys/pal/unsupported/mod.rs b/library/std/src/sys/pal/unsupported/mod.rs
index 442e6042ad561..01d516f7568bf 100644
--- a/library/std/src/sys/pal/unsupported/mod.rs
+++ b/library/std/src/sys/pal/unsupported/mod.rs
@@ -1,6 +1,5 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 
-pub mod alloc;
 pub mod args;
 pub mod env;
 pub mod fs;
diff --git a/library/std/src/sys/pal/wasi/mod.rs b/library/std/src/sys/pal/wasi/mod.rs
index f4dc3ebd4140b..8051021a58897 100644
--- a/library/std/src/sys/pal/wasi/mod.rs
+++ b/library/std/src/sys/pal/wasi/mod.rs
@@ -14,8 +14,6 @@
 //! compiling for wasm. That way it's a compile time error for something that's
 //! guaranteed to be a runtime error!
 
-#[path = "../unix/alloc.rs"]
-pub mod alloc;
 pub mod args;
 pub mod env;
 pub mod fd;
diff --git a/library/std/src/sys/pal/wasip2/mod.rs b/library/std/src/sys/pal/wasip2/mod.rs
index f20630e10cff9..546fadbe5011c 100644
--- a/library/std/src/sys/pal/wasip2/mod.rs
+++ b/library/std/src/sys/pal/wasip2/mod.rs
@@ -6,8 +6,6 @@
 //! To begin with, this target mirrors the wasi target 1 to 1, but over
 //! time this will change significantly.
 
-#[path = "../unix/alloc.rs"]
-pub mod alloc;
 #[path = "../wasi/args.rs"]
 pub mod args;
 #[path = "../wasi/env.rs"]
diff --git a/library/std/src/sys/pal/wasm/mod.rs b/library/std/src/sys/pal/wasm/mod.rs
index 4c34859e918bb..8141bfac49aad 100644
--- a/library/std/src/sys/pal/wasm/mod.rs
+++ b/library/std/src/sys/pal/wasm/mod.rs
@@ -16,7 +16,6 @@
 
 #![deny(unsafe_op_in_unsafe_fn)]
 
-pub mod alloc;
 #[path = "../unsupported/args.rs"]
 pub mod args;
 pub mod env;
diff --git a/library/std/src/sys/pal/windows/mod.rs b/library/std/src/sys/pal/windows/mod.rs
index 6ed77fbc3d445..272fadd915005 100644
--- a/library/std/src/sys/pal/windows/mod.rs
+++ b/library/std/src/sys/pal/windows/mod.rs
@@ -15,7 +15,6 @@ pub mod compat;
 
 mod api;
 
-pub mod alloc;
 pub mod args;
 pub mod c;
 pub mod env;
diff --git a/library/std/src/sys/pal/xous/mod.rs b/library/std/src/sys/pal/xous/mod.rs
index 961d45c5e834f..b211e94db65d6 100644
--- a/library/std/src/sys/pal/xous/mod.rs
+++ b/library/std/src/sys/pal/xous/mod.rs
@@ -1,6 +1,5 @@
 #![forbid(unsafe_op_in_unsafe_fn)]
 
-pub mod alloc;
 #[path = "../unsupported/args.rs"]
 pub mod args;
 #[path = "../unsupported/env.rs"]
diff --git a/library/std/src/sys/pal/zkvm/mod.rs b/library/std/src/sys/pal/zkvm/mod.rs
index 651f25d66236b..20fdb7468a40d 100644
--- a/library/std/src/sys/pal/zkvm/mod.rs
+++ b/library/std/src/sys/pal/zkvm/mod.rs
@@ -10,7 +10,7 @@
 
 const WORD_SIZE: usize = core::mem::size_of::<u32>();
 
-pub mod alloc;
+pub mod abi;
 #[path = "../zkvm/args.rs"]
 pub mod args;
 pub mod env;
@@ -26,13 +26,10 @@ pub mod pipe;
 #[path = "../unsupported/process.rs"]
 pub mod process;
 pub mod stdio;
-#[path = "../unsupported/time.rs"]
-pub mod time;
-
 #[path = "../unsupported/thread.rs"]
 pub mod thread;
-
-mod abi;
+#[path = "../unsupported/time.rs"]
+pub mod time;
 
 use crate::io as std_io;
 

From e9566ce9e92df5fbdf87260cef7f3aa8d096e1bd Mon Sep 17 00:00:00 2001
From: joboet <jonasboettiger@icloud.com>
Date: Wed, 24 Jul 2024 15:36:26 +0200
Subject: [PATCH 654/685] bless miri test

---
 src/tools/miri/tests/fail/alloc/global_system_mixup.rs     | 4 +++-
 src/tools/miri/tests/fail/alloc/global_system_mixup.stderr | 4 ++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/tools/miri/tests/fail/alloc/global_system_mixup.rs b/src/tools/miri/tests/fail/alloc/global_system_mixup.rs
index 804aa13660b99..bbf069b7a2def 100644
--- a/src/tools/miri/tests/fail/alloc/global_system_mixup.rs
+++ b/src/tools/miri/tests/fail/alloc/global_system_mixup.rs
@@ -4,7 +4,9 @@
 
 //@normalize-stderr-test: "using [A-Za-z]+ heap deallocation operation" -> "using PLATFORM heap deallocation operation"
 //@normalize-stderr-test: "\| +\^+" -> "| ^"
-//@normalize-stderr-test: "libc::free\([^()]*\)|unsafe \{ HeapFree\([^}]*\};" -> "FREE();"
+//@normalize-stderr-test: "unsafe \{ libc::free\([^()]*\) \}|unsafe \{ HeapFree\([^}]*\};" -> "FREE();"
+//@normalize-stderr-test: "alloc::[A-Za-z]+::" -> "alloc::PLATFORM::"
+//@normalize-stderr-test: "alloc/[A-Za-z]+.rs" -> "alloc/PLATFORM.rs"
 
 #![feature(allocator_api, slice_ptr_get)]
 
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 7790956414961..287a1f1a3e396 100644
--- a/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr
+++ b/src/tools/miri/tests/fail/alloc/global_system_mixup.stderr
@@ -1,5 +1,5 @@
 error: Undefined Behavior: deallocating ALLOC, which is Rust heap memory, using PLATFORM heap deallocation operation
-  --> RUSTLIB/std/src/sys/pal/PLATFORM/alloc.rs:LL:CC
+  --> RUSTLIB/std/src/sys/alloc/PLATFORM.rs:LL:CC
    |
 LL |         FREE();
    | ^ deallocating ALLOC, which is Rust heap memory, using PLATFORM heap deallocation operation
@@ -7,7 +7,7 @@ LL |         FREE();
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
    = note: BACKTRACE:
-   = note: inside `std::sys::pal::PLATFORM::alloc::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/pal/PLATFORM/alloc.rs:LL:CC
+   = note: inside `std::sys::alloc::PLATFORM::<impl std::alloc::GlobalAlloc for std::alloc::System>::dealloc` at RUSTLIB/std/src/sys/alloc/PLATFORM.rs:LL:CC
    = note: inside `<std::alloc::System as std::alloc::Allocator>::deallocate` at RUSTLIB/std/src/alloc.rs:LL:CC
 note: inside `main`
   --> $DIR/global_system_mixup.rs:LL:CC

From 4f847bd326e376de491b3e2a589392e66d61a2ed Mon Sep 17 00:00:00 2001
From: Kajetan Puchalski <kajetan.puchalski@arm.com>
Date: Fri, 14 Jun 2024 18:05:09 +0100
Subject: [PATCH 655/685] rustc_target: Add various aarch64 features

Add various aarch64 features already supported by LLVM and Linux.

The features are marked as unstable using a newly added symbol, i.e.
aarch64_unstable_target_feature.

Additionally include some comment fixes to ensure consistency of
feature names with the Arm ARM and support for architecture version
target features up to v9.5a.

This commit adds compiler support for the following features:

- FEAT_CSSC
- FEAT_ECV
- FEAT_FAMINMAX
- FEAT_FLAGM2
- FEAT_FP8
- FEAT_FP8DOT2
- FEAT_FP8DOT4
- FEAT_FP8FMA
- FEAT_FPMR
- FEAT_HBC
- FEAT_LSE128
- FEAT_LSE2
- FEAT_LUT
- FEAT_MOPS
- FEAT_LRCPC3
- FEAT_SVE_B16B16
- FEAT_SVE2p1
- FEAT_WFxT
---
 compiler/rustc_codegen_llvm/src/llvm_util.rs |  2 +
 compiler/rustc_feature/src/unstable.rs       |  1 +
 compiler/rustc_span/src/symbol.rs            |  1 +
 compiler/rustc_target/src/target_features.rs | 54 ++++++++++++++++++--
 library/std/tests/run-time-detect.rs         | 21 ++++++++
 tests/ui/target-feature/gate.rs              |  1 +
 6 files changed, 75 insertions(+), 5 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index 7af5eb9278f38..a0ef6483ed650 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -234,6 +234,8 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a
         ("aarch64", "pmuv3") => LLVMFeature::new("perfmon"),
         ("aarch64", "paca") => LLVMFeature::new("pauth"),
         ("aarch64", "pacg") => LLVMFeature::new("pauth"),
+        ("aarch64", "sve-b16b16") => LLVMFeature::new("b16b16"),
+        ("aarch64", "flagm2") => LLVMFeature::new("altnzcv"),
         // Rust ties fp and neon together.
         ("aarch64", "neon") => {
             LLVMFeature::with_dependency("neon", TargetFeatureFoldStrength::Both("fp-armv8"))
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 4524458023d7f..1ec1990d2c5c5 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -302,6 +302,7 @@ declare_features! (
     // FIXME: Document these and merge with the list below.
 
     // Unstable `#[target_feature]` directives.
+    (unstable, aarch64_unstable_target_feature, "CURRENT_RUSTC_VERSION", Some(44839)),
     (unstable, aarch64_ver_target_feature, "1.27.0", Some(44839)),
     (unstable, arm_target_feature, "1.27.0", Some(44839)),
     (unstable, avx512_target_feature, "1.27.0", Some(44839)),
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 2957105288bb3..e691d1cfcb54a 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -356,6 +356,7 @@ symbols! {
         _task_context,
         a32,
         aarch64_target_feature,
+        aarch64_unstable_target_feature,
         aarch64_ver_target_feature,
         abi,
         abi_amdgpu_kernel,
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index da66ba270b33c..d4b5a5ff675b3 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -99,6 +99,8 @@ const AARCH64_ALLOWED_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("bti", Stable, &[]),
     // FEAT_CRC
     ("crc", Stable, &[]),
+    // FEAT_CSSC
+    ("cssc", Unstable(sym::aarch64_unstable_target_feature), &[]),
     // FEAT_DIT
     ("dit", Stable, &[]),
     // FEAT_DotProd
@@ -107,21 +109,39 @@ const AARCH64_ALLOWED_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("dpb", Stable, &[]),
     // FEAT_DPB2
     ("dpb2", Stable, &["dpb"]),
+    // FEAT_ECV
+    ("ecv", Unstable(sym::aarch64_unstable_target_feature), &[]),
     // FEAT_F32MM
     ("f32mm", Stable, &["sve"]),
     // FEAT_F64MM
     ("f64mm", Stable, &["sve"]),
+    // FEAT_FAMINMAX
+    ("faminmax", Unstable(sym::aarch64_unstable_target_feature), &[]),
     // FEAT_FCMA
     ("fcma", Stable, &["neon"]),
     // FEAT_FHM
     ("fhm", Stable, &["fp16"]),
     // FEAT_FLAGM
     ("flagm", Stable, &[]),
+    // FEAT_FLAGM2
+    ("flagm2", Unstable(sym::aarch64_unstable_target_feature), &[]),
     // FEAT_FP16
     // Rust ties FP and Neon: https://github.com/rust-lang/rust/pull/91608
     ("fp16", Stable, &["neon"]),
+    // FEAT_FP8
+    ("fp8", Unstable(sym::aarch64_unstable_target_feature), &["faminmax", "lut", "bf16"]),
+    // FEAT_FP8DOT2
+    ("fp8dot2", Unstable(sym::aarch64_unstable_target_feature), &["fp8dot4"]),
+    // FEAT_FP8DOT4
+    ("fp8dot4", Unstable(sym::aarch64_unstable_target_feature), &["fp8fma"]),
+    // FEAT_FP8FMA
+    ("fp8fma", Unstable(sym::aarch64_unstable_target_feature), &["fp8"]),
+    // FEAT_FPMR
+    ("fpmr", Unstable(sym::aarch64_unstable_target_feature), &[]),
     // FEAT_FRINTTS
     ("frintts", Stable, &[]),
+    // FEAT_HBC
+    ("hbc", Unstable(sym::aarch64_unstable_target_feature), &[]),
     // FEAT_I8MM
     ("i8mm", Stable, &[]),
     // FEAT_JSCVT
@@ -131,6 +151,14 @@ const AARCH64_ALLOWED_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("lor", Stable, &[]),
     // FEAT_LSE
     ("lse", Stable, &[]),
+    // FEAT_LSE128
+    ("lse128", Unstable(sym::aarch64_unstable_target_feature), &["lse"]),
+    // FEAT_LSE2
+    ("lse2", Unstable(sym::aarch64_unstable_target_feature), &[]),
+    // FEAT_LUT
+    ("lut", Unstable(sym::aarch64_unstable_target_feature), &[]),
+    // FEAT_MOPS
+    ("mops", Unstable(sym::aarch64_unstable_target_feature), &[]),
     // FEAT_MTE & FEAT_MTE2
     ("mte", Stable, &[]),
     // FEAT_AdvSimd & FEAT_FP
@@ -143,14 +171,16 @@ const AARCH64_ALLOWED_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("pan", Stable, &[]),
     // FEAT_PMUv3
     ("pmuv3", Stable, &[]),
-    // FEAT_RAND
+    // FEAT_RNG
     ("rand", Stable, &[]),
     // FEAT_RAS & FEAT_RASv1p1
     ("ras", Stable, &[]),
-    // FEAT_RCPC
+    // FEAT_LRCPC
     ("rcpc", Stable, &[]),
-    // FEAT_RCPC2
+    // FEAT_LRCPC2
     ("rcpc2", Stable, &["rcpc"]),
+    // FEAT_LRCPC3
+    ("rcpc3", Unstable(sym::aarch64_unstable_target_feature), &["rcpc2"]),
     // FEAT_RDM
     ("rdm", Stable, &["neon"]),
     // FEAT_SB
@@ -173,9 +203,11 @@ const AARCH64_ALLOWED_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     //
     // "For backwards compatibility, Neon and VFP are required in the latest architectures."
     ("sve", Stable, &["neon"]),
+    // FEAT_SVE_B16B16 (SVE or SME Instructions)
+    ("sve-b16b16", Unstable(sym::aarch64_unstable_target_feature), &["bf16"]),
     // FEAT_SVE2
     ("sve2", Stable, &["sve"]),
-    // FEAT_SVE2_AES
+    // FEAT_SVE_AES & FEAT_SVE_PMULL128
     ("sve2-aes", Stable, &["sve2", "aes"]),
     // FEAT_SVE2_BitPerm
     ("sve2-bitperm", Stable, &["sve2"]),
@@ -183,6 +215,8 @@ const AARCH64_ALLOWED_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("sve2-sha3", Stable, &["sve2", "sha3"]),
     // FEAT_SVE2_SM4
     ("sve2-sm4", Stable, &["sve2", "sm4"]),
+    // FEAT_SVE2p1
+    ("sve2p1", Unstable(sym::aarch64_unstable_target_feature), &["sve2"]),
     // FEAT_TME
     ("tme", Stable, &[]),
     (
@@ -199,9 +233,19 @@ const AARCH64_ALLOWED_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("v8.4a", Unstable(sym::aarch64_ver_target_feature), &["v8.3a", "dotprod", "dit", "flagm"]),
     ("v8.5a", Unstable(sym::aarch64_ver_target_feature), &["v8.4a", "ssbs", "sb", "dpb2", "bti"]),
     ("v8.6a", Unstable(sym::aarch64_ver_target_feature), &["v8.5a", "bf16", "i8mm"]),
-    ("v8.7a", Unstable(sym::aarch64_ver_target_feature), &[]),
+    ("v8.7a", Unstable(sym::aarch64_ver_target_feature), &["v8.6a", "wfxt"]),
+    ("v8.8a", Unstable(sym::aarch64_ver_target_feature), &["v8.7a", "hbc", "mops"]),
+    ("v8.9a", Unstable(sym::aarch64_ver_target_feature), &["v8.8a", "cssc"]),
+    ("v9.1a", Unstable(sym::aarch64_ver_target_feature), &["v9a", "v8.6a"]),
+    ("v9.2a", Unstable(sym::aarch64_ver_target_feature), &["v9.1a", "v8.7a"]),
+    ("v9.3a", Unstable(sym::aarch64_ver_target_feature), &["v9.2a", "v8.8a"]),
+    ("v9.4a", Unstable(sym::aarch64_ver_target_feature), &["v9.3a", "v8.9a"]),
+    ("v9.5a", Unstable(sym::aarch64_ver_target_feature), &["v9.4a"]),
+    ("v9a", Unstable(sym::aarch64_ver_target_feature), &["v8.5a", "sve2"]),
     // FEAT_VHE
     ("vh", Stable, &[]),
+    // FEAT_WFxT
+    ("wfxt", Unstable(sym::aarch64_unstable_target_feature), &[]),
     // tidy-alphabetical-end
 ];
 
diff --git a/library/std/tests/run-time-detect.rs b/library/std/tests/run-time-detect.rs
index 6948670565662..779f0d1a9b892 100644
--- a/library/std/tests/run-time-detect.rs
+++ b/library/std/tests/run-time-detect.rs
@@ -4,6 +4,10 @@
     all(target_arch = "arm", any(target_os = "linux", target_os = "android")),
     feature(stdarch_arm_feature_detection)
 )]
+#![cfg_attr(
+    all(target_arch = "aarch64", any(target_os = "linux", target_os = "android")),
+    feature(stdarch_aarch64_feature_detection)
+)]
 #![cfg_attr(
     all(target_arch = "powerpc", target_os = "linux"),
     feature(stdarch_powerpc_feature_detection)
@@ -36,21 +40,34 @@ fn aarch64_linux() {
     println!("bf16: {}", is_aarch64_feature_detected!("bf16"));
     println!("bti: {}", is_aarch64_feature_detected!("bti"));
     println!("crc: {}", is_aarch64_feature_detected!("crc"));
+    println!("cssc: {}", is_aarch64_feature_detected!("cssc"));
     println!("dit: {}", is_aarch64_feature_detected!("dit"));
     println!("dotprod: {}", is_aarch64_feature_detected!("dotprod"));
     println!("dpb2: {}", is_aarch64_feature_detected!("dpb2"));
     println!("dpb: {}", is_aarch64_feature_detected!("dpb"));
+    println!("ecv: {}", is_aarch64_feature_detected!("ecv"));
     println!("f32mm: {}", is_aarch64_feature_detected!("f32mm"));
     println!("f64mm: {}", is_aarch64_feature_detected!("f64mm"));
+    println!("faminmax: {}", is_aarch64_feature_detected!("faminmax"));
     println!("fcma: {}", is_aarch64_feature_detected!("fcma"));
     println!("fhm: {}", is_aarch64_feature_detected!("fhm"));
+    println!("flagm2: {}", is_aarch64_feature_detected!("flagm2"));
     println!("flagm: {}", is_aarch64_feature_detected!("flagm"));
     println!("fp16: {}", is_aarch64_feature_detected!("fp16"));
+    println!("fp8: {}", is_aarch64_feature_detected!("fp8"));
+    println!("fp8dot2: {}", is_aarch64_feature_detected!("fp8dot2"));
+    println!("fp8dot4: {}", is_aarch64_feature_detected!("fp8dot4"));
+    println!("fp8fma: {}", is_aarch64_feature_detected!("fp8fma"));
+    println!("fpmr: {}", is_aarch64_feature_detected!("fpmr"));
     println!("frintts: {}", is_aarch64_feature_detected!("frintts"));
+    println!("hbc: {}", is_aarch64_feature_detected!("hbc"));
     println!("i8mm: {}", is_aarch64_feature_detected!("i8mm"));
     println!("jsconv: {}", is_aarch64_feature_detected!("jsconv"));
+    println!("lse128: {}", is_aarch64_feature_detected!("lse128"));
     println!("lse2: {}", is_aarch64_feature_detected!("lse2"));
     println!("lse: {}", is_aarch64_feature_detected!("lse"));
+    println!("lut: {}", is_aarch64_feature_detected!("lut"));
+    println!("mops: {}", is_aarch64_feature_detected!("mops"));
     println!("mte: {}", is_aarch64_feature_detected!("mte"));
     println!("neon: {}", is_aarch64_feature_detected!("neon"));
     println!("paca: {}", is_aarch64_feature_detected!("paca"));
@@ -58,6 +75,7 @@ fn aarch64_linux() {
     println!("pmull: {}", is_aarch64_feature_detected!("pmull"));
     println!("rand: {}", is_aarch64_feature_detected!("rand"));
     println!("rcpc2: {}", is_aarch64_feature_detected!("rcpc2"));
+    println!("rcpc3: {}", is_aarch64_feature_detected!("rcpc3"));
     println!("rcpc: {}", is_aarch64_feature_detected!("rcpc"));
     println!("rdm: {}", is_aarch64_feature_detected!("rdm"));
     println!("sb: {}", is_aarch64_feature_detected!("sb"));
@@ -65,13 +83,16 @@ fn aarch64_linux() {
     println!("sha3: {}", is_aarch64_feature_detected!("sha3"));
     println!("sm4: {}", is_aarch64_feature_detected!("sm4"));
     println!("ssbs: {}", is_aarch64_feature_detected!("ssbs"));
+    println!("sve-b16b16: {}", is_aarch64_feature_detected!("sve-b16b16"));
     println!("sve2-aes: {}", is_aarch64_feature_detected!("sve2-aes"));
     println!("sve2-bitperm: {}", is_aarch64_feature_detected!("sve2-bitperm"));
     println!("sve2-sha3: {}", is_aarch64_feature_detected!("sve2-sha3"));
     println!("sve2-sm4: {}", is_aarch64_feature_detected!("sve2-sm4"));
     println!("sve2: {}", is_aarch64_feature_detected!("sve2"));
+    println!("sve2p1: {}", is_aarch64_feature_detected!("sve2p1"));
     println!("sve: {}", is_aarch64_feature_detected!("sve"));
     println!("tme: {}", is_aarch64_feature_detected!("tme"));
+    println!("wfxt: {}", is_aarch64_feature_detected!("wfxt"));
     // tidy-alphabetical-end
 }
 
diff --git a/tests/ui/target-feature/gate.rs b/tests/ui/target-feature/gate.rs
index 94d79d56c5920..5c4fb8479324f 100644
--- a/tests/ui/target-feature/gate.rs
+++ b/tests/ui/target-feature/gate.rs
@@ -17,6 +17,7 @@
 // gate-test-ermsb_target_feature
 // gate-test-bpf_target_feature
 // gate-test-aarch64_ver_target_feature
+// gate-test-aarch64_unstable_target_feature
 // gate-test-csky_target_feature
 // gate-test-loongarch_target_feature
 // gate-test-lahfsahf_target_feature

From c3518067c74c2f875b3941beb601160175e1a698 Mon Sep 17 00:00:00 2001
From: Kajetan Puchalski <kajetan.puchalski@arm.com>
Date: Mon, 17 Jun 2024 15:37:46 +0100
Subject: [PATCH 656/685] rustc_target: Add SME aarch64 features

Add SME aarch64 features already supported by LLVM and Linux.

This commit adds compiler support for the following features:

- FEAT_SME
- FEAT_SME_F16F16
- FEAT_SME_F64F64
- FEAT_SME_F8F16
- FEAT_SME_F8F32
- FEAT_SME_FA64
- FEAT_SME_I16I64
- FEAT_SME_LUTv2
- FEAT_SME2
- FEAT_SME2p1
- FEAT_SSVE_FP8DOT2
- FEAT_SSVE_FP8DOT4
- FEAT_SSVE_FP8FMA
---
 compiler/rustc_target/src/target_features.rs | 26 ++++++++++++++++++++
 library/std/tests/run-time-detect.rs         | 13 ++++++++++
 2 files changed, 39 insertions(+)

diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index d4b5a5ff675b3..b48d1d1a49ceb 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -191,10 +191,36 @@ const AARCH64_ALLOWED_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("sha3", Stable, &["sha2"]),
     // FEAT_SM3 & FEAT_SM4
     ("sm4", Stable, &["neon"]),
+    // FEAT_SME
+    ("sme", Unstable(sym::aarch64_unstable_target_feature), &["bf16"]),
+    // FEAT_SME_F16F16
+    ("sme-f16f16", Unstable(sym::aarch64_unstable_target_feature), &["sme2"]),
+    // FEAT_SME_F64F64
+    ("sme-f64f64", Unstable(sym::aarch64_unstable_target_feature), &["sme"]),
+    // FEAT_SME_F8F16
+    ("sme-f8f16", Unstable(sym::aarch64_unstable_target_feature), &["sme-f8f32"]),
+    // FEAT_SME_F8F32
+    ("sme-f8f32", Unstable(sym::aarch64_unstable_target_feature), &["sme2", "fp8"]),
+    // FEAT_SME_FA64
+    ("sme-fa64", Unstable(sym::aarch64_unstable_target_feature), &["sme", "sve2"]),
+    // FEAT_SME_I16I64
+    ("sme-i16i64", Unstable(sym::aarch64_unstable_target_feature), &["sme"]),
+    // FEAT_SME_LUTv2
+    ("sme-lutv2", Unstable(sym::aarch64_unstable_target_feature), &[]),
+    // FEAT_SME2
+    ("sme2", Unstable(sym::aarch64_unstable_target_feature), &["sme"]),
+    // FEAT_SME2p1
+    ("sme2p1", Unstable(sym::aarch64_unstable_target_feature), &["sme2"]),
     // FEAT_SPE
     ("spe", Stable, &[]),
     // FEAT_SSBS & FEAT_SSBS2
     ("ssbs", Stable, &[]),
+    // FEAT_SSVE_FP8FDOT2
+    ("ssve-fp8dot2", Unstable(sym::aarch64_unstable_target_feature), &["ssve-fp8dot4"]),
+    // FEAT_SSVE_FP8FDOT4
+    ("ssve-fp8dot4", Unstable(sym::aarch64_unstable_target_feature), &["ssve-fp8fma"]),
+    // FEAT_SSVE_FP8FMA
+    ("ssve-fp8fma", Unstable(sym::aarch64_unstable_target_feature), &["sme2", "fp8"]),
     // FEAT_SVE
     // It was decided that SVE requires Neon: https://github.com/rust-lang/rust/pull/91608
     //
diff --git a/library/std/tests/run-time-detect.rs b/library/std/tests/run-time-detect.rs
index 779f0d1a9b892..dcd5cd7f6b9c7 100644
--- a/library/std/tests/run-time-detect.rs
+++ b/library/std/tests/run-time-detect.rs
@@ -82,7 +82,20 @@ fn aarch64_linux() {
     println!("sha2: {}", is_aarch64_feature_detected!("sha2"));
     println!("sha3: {}", is_aarch64_feature_detected!("sha3"));
     println!("sm4: {}", is_aarch64_feature_detected!("sm4"));
+    println!("sme-f16f16: {}", is_aarch64_feature_detected!("sme-f16f16"));
+    println!("sme-f64f64: {}", is_aarch64_feature_detected!("sme-f64f64"));
+    println!("sme-f8f16: {}", is_aarch64_feature_detected!("sme-f8f16"));
+    println!("sme-f8f32: {}", is_aarch64_feature_detected!("sme-f8f32"));
+    println!("sme-fa64: {}", is_aarch64_feature_detected!("sme-fa64"));
+    println!("sme-i16i64: {}", is_aarch64_feature_detected!("sme-i16i64"));
+    println!("sme-lutv2: {}", is_aarch64_feature_detected!("sme-lutv2"));
+    println!("sme2: {}", is_aarch64_feature_detected!("sme2"));
+    println!("sme2p1: {}", is_aarch64_feature_detected!("sme2p1"));
+    println!("sme: {}", is_aarch64_feature_detected!("sme"));
     println!("ssbs: {}", is_aarch64_feature_detected!("ssbs"));
+    println!("ssve-fp8dot2: {}", is_aarch64_feature_detected!("ssve-fp8dot2"));
+    println!("ssve-fp8dot4: {}", is_aarch64_feature_detected!("ssve-fp8dot4"));
+    println!("ssve-fp8fma: {}", is_aarch64_feature_detected!("ssve-fp8fma"));
     println!("sve-b16b16: {}", is_aarch64_feature_detected!("sve-b16b16"));
     println!("sve2-aes: {}", is_aarch64_feature_detected!("sve2-aes"));
     println!("sve2-bitperm: {}", is_aarch64_feature_detected!("sve2-bitperm"));

From 4fc4019cbc6f88350dd0faee1aa658f9508e293e Mon Sep 17 00:00:00 2001
From: Kajetan Puchalski <kajetan.puchalski@arm.com>
Date: Mon, 29 Jul 2024 13:08:31 +0100
Subject: [PATCH 657/685] rustc_target: Remove fpmr target feature

FEAT_FPMR has been removed from upstream LLVM as of LLVM 19.
Remove the feature from the target features list and temporarily hack
the LLVM codegen to always enable it until the minimum LLVM version is
bumped to 19.
---
 compiler/rustc_codegen_llvm/src/attributes.rs | 6 ++++++
 compiler/rustc_target/src/target_features.rs  | 2 --
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index 317e970d70485..33bdfd3825c82 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -528,6 +528,12 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
             InstructionSetAttr::ArmA32 => "-thumb-mode".to_string(),
             InstructionSetAttr::ArmT32 => "+thumb-mode".to_string(),
         }))
+        // HACK: LLVM versions 19+ do not have the FPMR feature and treat it as always enabled
+        // It only exists as a feature in LLVM 18, cannot be passed down for any other version
+        .chain(match &*cx.tcx.sess.target.arch {
+            "aarch64" if llvm_util::get_version().0 == 18 => vec!["+fpmr".to_string()],
+            _ => vec![],
+        })
         .collect::<Vec<String>>();
 
     if cx.tcx.sess.target.is_like_wasm {
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index b48d1d1a49ceb..8319cb880cc79 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -136,8 +136,6 @@ const AARCH64_ALLOWED_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("fp8dot4", Unstable(sym::aarch64_unstable_target_feature), &["fp8fma"]),
     // FEAT_FP8FMA
     ("fp8fma", Unstable(sym::aarch64_unstable_target_feature), &["fp8"]),
-    // FEAT_FPMR
-    ("fpmr", Unstable(sym::aarch64_unstable_target_feature), &[]),
     // FEAT_FRINTTS
     ("frintts", Stable, &[]),
     // FEAT_HBC

From 3a0fbb5d4ef32bc74ea388798c3c39db67e62d37 Mon Sep 17 00:00:00 2001
From: Kajetan Puchalski <kajetan.puchalski@arm.com>
Date: Fri, 9 Aug 2024 16:41:43 +0100
Subject: [PATCH 658/685] rustc_codegen_llvm: Filter out unavailable LLVM
 features

Convert to_llvm_features to return Option<LLVMFeature> so that it can
return None if the requested feature is not available for the current
LLVM version.

Add match rules to filter out aarch64 features not available in LLVM 17.
---
 compiler/rustc_codegen_llvm/src/attributes.rs |  7 +-
 compiler/rustc_codegen_llvm/src/llvm_util.rs  | 94 ++++++++++++-------
 2 files changed, 63 insertions(+), 38 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
index 33bdfd3825c82..92a857c2adcf4 100644
--- a/compiler/rustc_codegen_llvm/src/attributes.rs
+++ b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -521,9 +521,10 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
 
     let function_features = function_features
         .iter()
-        .flat_map(|feat| {
-            llvm_util::to_llvm_features(cx.tcx.sess, feat).into_iter().map(|f| format!("+{f}"))
-        })
+        // Convert to LLVMFeatures and filter out unavailable ones
+        .flat_map(|feat| llvm_util::to_llvm_features(cx.tcx.sess, feat))
+        // Convert LLVMFeatures & dependencies to +<feats>s
+        .flat_map(|feat| feat.into_iter().map(|f| format!("+{f}")))
         .chain(codegen_fn_attrs.instruction_set.iter().map(|x| match x {
             InstructionSetAttr::ArmA32 => "-thumb-mode".to_string(),
             InstructionSetAttr::ArmT32 => "+thumb-mode".to_string(),
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index a0ef6483ed650..618602ed70f44 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -209,7 +209,7 @@ impl<'a> IntoIterator for LLVMFeature<'a> {
 // Though note that Rust can also be build with an external precompiled version of LLVM
 // which might lead to failures if the oldest tested / supported LLVM version
 // doesn't yet support the relevant intrinsics
-pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a> {
+pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFeature<'a>> {
     let arch = if sess.target.arch == "x86_64" {
         "x86"
     } else if sess.target.arch == "arm64ec" {
@@ -218,42 +218,59 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> LLVMFeature<'a
         &*sess.target.arch
     };
     match (arch, s) {
-        ("x86", "sse4.2") => {
-            LLVMFeature::with_dependency("sse4.2", TargetFeatureFoldStrength::EnableOnly("crc32"))
-        }
-        ("x86", "pclmulqdq") => LLVMFeature::new("pclmul"),
-        ("x86", "rdrand") => LLVMFeature::new("rdrnd"),
-        ("x86", "bmi1") => LLVMFeature::new("bmi"),
-        ("x86", "cmpxchg16b") => LLVMFeature::new("cx16"),
-        ("x86", "lahfsahf") => LLVMFeature::new("sahf"),
-        ("aarch64", "rcpc2") => LLVMFeature::new("rcpc-immo"),
-        ("aarch64", "dpb") => LLVMFeature::new("ccpp"),
-        ("aarch64", "dpb2") => LLVMFeature::new("ccdp"),
-        ("aarch64", "frintts") => LLVMFeature::new("fptoint"),
-        ("aarch64", "fcma") => LLVMFeature::new("complxnum"),
-        ("aarch64", "pmuv3") => LLVMFeature::new("perfmon"),
-        ("aarch64", "paca") => LLVMFeature::new("pauth"),
-        ("aarch64", "pacg") => LLVMFeature::new("pauth"),
-        ("aarch64", "sve-b16b16") => LLVMFeature::new("b16b16"),
-        ("aarch64", "flagm2") => LLVMFeature::new("altnzcv"),
+        ("x86", "sse4.2") => Some(LLVMFeature::with_dependency(
+            "sse4.2",
+            TargetFeatureFoldStrength::EnableOnly("crc32"),
+        )),
+        ("x86", "pclmulqdq") => Some(LLVMFeature::new("pclmul")),
+        ("x86", "rdrand") => Some(LLVMFeature::new("rdrnd")),
+        ("x86", "bmi1") => Some(LLVMFeature::new("bmi")),
+        ("x86", "cmpxchg16b") => Some(LLVMFeature::new("cx16")),
+        ("x86", "lahfsahf") => Some(LLVMFeature::new("sahf")),
+        ("aarch64", "rcpc2") => Some(LLVMFeature::new("rcpc-immo")),
+        ("aarch64", "dpb") => Some(LLVMFeature::new("ccpp")),
+        ("aarch64", "dpb2") => Some(LLVMFeature::new("ccdp")),
+        ("aarch64", "frintts") => Some(LLVMFeature::new("fptoint")),
+        ("aarch64", "fcma") => Some(LLVMFeature::new("complxnum")),
+        ("aarch64", "pmuv3") => Some(LLVMFeature::new("perfmon")),
+        ("aarch64", "paca") => Some(LLVMFeature::new("pauth")),
+        ("aarch64", "pacg") => Some(LLVMFeature::new("pauth")),
+        ("aarch64", "sve-b16b16") => Some(LLVMFeature::new("b16b16")),
+        ("aarch64", "flagm2") => Some(LLVMFeature::new("altnzcv")),
         // Rust ties fp and neon together.
         ("aarch64", "neon") => {
-            LLVMFeature::with_dependency("neon", TargetFeatureFoldStrength::Both("fp-armv8"))
+            Some(LLVMFeature::with_dependency("neon", TargetFeatureFoldStrength::Both("fp-armv8")))
         }
         // In LLVM neon implicitly enables fp, but we manually enable
         // neon when a feature only implicitly enables fp
-        ("aarch64", "fhm") => LLVMFeature::new("fp16fml"),
-        ("aarch64", "fp16") => LLVMFeature::new("fullfp16"),
+        ("aarch64", "fhm") => Some(LLVMFeature::new("fp16fml")),
+        ("aarch64", "fp16") => Some(LLVMFeature::new("fullfp16")),
+        // Filter out features that are not supported by the current LLVM version
+        ("aarch64", "faminmax") if get_version().0 < 18 => None,
+        ("aarch64", "fp8") if get_version().0 < 18 => None,
+        ("aarch64", "fp8dot2") if get_version().0 < 18 => None,
+        ("aarch64", "fp8dot4") if get_version().0 < 18 => None,
+        ("aarch64", "fp8fma") if get_version().0 < 18 => None,
+        ("aarch64", "fpmr") if get_version().0 != 18 => None,
+        ("aarch64", "lut") if get_version().0 < 18 => None,
+        ("aarch64", "sme-f8f16") if get_version().0 < 18 => None,
+        ("aarch64", "sme-f8f32") if get_version().0 < 18 => None,
+        ("aarch64", "sme-fa64") if get_version().0 < 18 => None,
+        ("aarch64", "sme-lutv2") if get_version().0 < 18 => None,
+        ("aarch64", "ssve-fp8dot2") if get_version().0 < 18 => None,
+        ("aarch64", "ssve-fp8dot4") if get_version().0 < 18 => None,
+        ("aarch64", "ssve-fp8fma") if get_version().0 < 18 => None,
+        ("aarch64", "v9.5a") if get_version().0 < 18 => None,
         // In LLVM 18, `unaligned-scalar-mem` was merged with `unaligned-vector-mem` into a single feature called
         // `fast-unaligned-access`. In LLVM 19, it was split back out.
         ("riscv32" | "riscv64", "unaligned-scalar-mem") if get_version().0 == 18 => {
-            LLVMFeature::new("fast-unaligned-access")
+            Some(LLVMFeature::new("fast-unaligned-access"))
         }
         // For LLVM 18, enable the evex512 target feature if a avx512 target feature is enabled.
         ("x86", s) if get_version().0 >= 18 && s.starts_with("avx512") => {
-            LLVMFeature::with_dependency(s, TargetFeatureFoldStrength::EnableOnly("evex512"))
+            Some(LLVMFeature::with_dependency(s, TargetFeatureFoldStrength::EnableOnly("evex512")))
         }
-        (_, s) => LLVMFeature::new(s),
+        (_, s) => Some(LLVMFeature::new(s)),
     }
 }
 
@@ -293,13 +310,17 @@ pub fn target_features(sess: &Session, allow_unstable: bool) -> Vec<Symbol> {
                     return true;
                 }
                 // check that all features in a given smallvec are enabled
-                for llvm_feature in to_llvm_features(sess, feature) {
-                    let cstr = SmallCStr::new(llvm_feature);
-                    if !unsafe { llvm::LLVMRustHasFeature(&target_machine, cstr.as_ptr()) } {
-                        return false;
+                if let Some(feat) = to_llvm_features(sess, feature) {
+                    for llvm_feature in feat {
+                        let cstr = SmallCStr::new(llvm_feature);
+                        if !unsafe { llvm::LLVMRustHasFeature(&target_machine, cstr.as_ptr()) } {
+                            return false;
+                        }
                     }
+                    true
+                } else {
+                    false
                 }
-                true
             })
             .map(|(feature, _, _)| Symbol::intern(feature)),
     );
@@ -388,9 +409,9 @@ fn print_target_features(out: &mut String, sess: &Session, tm: &llvm::TargetMach
         .target
         .supported_target_features()
         .iter()
-        .map(|(feature, _gate, _implied)| {
+        .filter_map(|(feature, _gate, _implied)| {
             // LLVM asserts that these are sorted. LLVM and Rust both use byte comparison for these strings.
-            let llvm_feature = to_llvm_features(sess, *feature).llvm_feature_name;
+            let llvm_feature = to_llvm_features(sess, *feature)?.llvm_feature_name;
             let desc =
                 match llvm_target_features.binary_search_by_key(&llvm_feature, |(f, _d)| f).ok() {
                     Some(index) => {
@@ -400,7 +421,7 @@ fn print_target_features(out: &mut String, sess: &Session, tm: &llvm::TargetMach
                     None => "",
                 };
 
-            (*feature, desc)
+            Some((*feature, desc))
         })
         .collect::<Vec<_>>();
 
@@ -597,7 +618,7 @@ pub(crate) fn global_llvm_features(
                     if feature_state.is_none() {
                         let rust_feature =
                             supported_features.iter().find_map(|&(rust_feature, _, _)| {
-                                let llvm_features = to_llvm_features(sess, rust_feature);
+                                let llvm_features = to_llvm_features(sess, rust_feature)?;
                                 if llvm_features.contains(feature)
                                     && !llvm_features.contains(rust_feature)
                                 {
@@ -643,7 +664,7 @@ pub(crate) fn global_llvm_features(
                 // passing requests down to LLVM. This means that all in-language
                 // features also work on the command line instead of having two
                 // different names when the LLVM name and the Rust name differ.
-                let llvm_feature = to_llvm_features(sess, feature);
+                let llvm_feature = to_llvm_features(sess, feature)?;
 
                 Some(
                     std::iter::once(format!(
@@ -693,6 +714,9 @@ fn backend_feature_name<'a>(sess: &Session, s: &'a str) -> Option<&'a str> {
     let feature = s
         .strip_prefix(&['+', '-'][..])
         .unwrap_or_else(|| sess.dcx().emit_fatal(InvalidTargetFeaturePrefix { feature: s }));
+    if s.is_empty() {
+        return None;
+    }
     // Rustc-specific feature requests like `+crt-static` or `-crt-static`
     // are not passed down to LLVM.
     if RUSTC_SPECIFIC_FEATURES.contains(&feature) {

From ab4a743a38d4f466d16d97fde14604b242a37020 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 27 Aug 2024 11:08:09 +0200
Subject: [PATCH 659/685] fix Pointer to reference conversion docs

---
 library/core/src/ptr/mod.rs | 38 +++++++++++++++----------------------
 1 file changed, 15 insertions(+), 23 deletions(-)

diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index 859fad9e069ca..d7ed4edcc0041 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -57,50 +57,42 @@
 //! [`NonNull::dangling`] in such cases.
 //!
 //! ## Pointer to reference conversion
-//! When converting a pointer to a reference `&T` using `&*`,
+//!
+//! When converting a pointer to a reference (e.g. via `&*ptr` or `&mut *ptr`),
 //! there are several rules that must be followed:
 //!
 //! * The pointer must be properly aligned.
 //!
-// some microprocessors may use address 0 for an interrupt vector.
-// users of these microprocessors must always read/write address 0 through
-// a raw pointer, not a reference.
 //! * It must be non-null.
 //!
 //! * It must be "dereferenceable" in the sense defined above.
 //!
-//! * The pointer must point to a valid value of type `T`.
-//!   This means that the created reference can only refer to
-//!   uninitialized memory through careful use of `MaybeUninit`,
-//!   or if the uninitialized memory is entirely contained within
-//!   padding bytes, since
-//!   [padding has the same validity invariant as `MaybeUninit`][ucg-pad].
-//!
-//! * You must enforce Rust's aliasing rules, since the lifetime of the
-//!   created reference is arbitrarily chosen,
-//!   and does not necessarily reflect the actual lifetime of the data.
-//!   In particular, while this reference exists,
-//!   the memory the pointer points to must
-//!   not get accessed (read or written) through any raw pointer,
-//!   except for data inside an `UnsafeCell`.
-//!   Note that aliased writes are always UB for mutable references,
-//!   even if they only modify `UnsafeCell` data.
+//! * The pointer must point to a [valid value] of type `T`.
+//!
+//! * You must enforce Rust's aliasing rules. The exact aliasing rules are not decided yet, so we
+//!   only give a rough overview here. The rules also depend on whether a mutable or a shared
+//!   reference is being created.
+//!   * When creating a mutable reference, then while this reference exists, the memory it points to
+//!     must not get accessed (read or written) through any other pointer or reference not derived
+//!     from this reference.
+//!   * When creating a shared reference, then while this reference exists, the memory it points to
+//!     must not get mutated (except inside `UnsafeCell`).
 //!
 //! If a pointer follows all of these rules, it is said to be
-//! *convertible to a reference*.
+//! *convertible to a (mutable or shared) reference*.
 // ^ we use this term instead of saying that the produced reference must
 // be valid, as the validity of a reference is easily confused for the
 // validity of the thing it refers to, and while the two concepts are
 // closly related, they are not identical.
 //!
-//! These apply even if the result is unused!
+//! These rules apply even if the result is unused!
 //! (The part about being initialized is not yet fully decided, but until
 //! it is, the only safe approach is to ensure that they are indeed initialized.)
 //!
 //! An example of the implications of the above rules is that an expression such
 //! as `unsafe { &*(0 as *const u8) }` is Immediate Undefined Behavior.
 //!
-//! [ucgpad]: https://rust-lang.github.io/unsafe-code-guidelines/glossary.html#padding
+//! [valid value]: ../../reference/behavior-considered-undefined.html#invalid-values
 //!
 //! ## Allocated object
 //!

From 0f871b5baac8b8c77d67eca1f285801104518cfe Mon Sep 17 00:00:00 2001
From: Kajetan Puchalski <kajetan.puchalski@arm.com>
Date: Fri, 9 Aug 2024 18:24:55 +0000
Subject: [PATCH 660/685] tests: Update with new aarch64 target features

Additionally, remove optional matching for +v8a given that the minimum LLVM version is now past 14.
---
 tests/codegen/tied-features-strength.rs     | 14 +++++++-------
 tests/ui/check-cfg/mix.stderr               |  2 +-
 tests/ui/check-cfg/well-known-values.stderr |  2 +-
 tests/ui/target-feature/gate.stderr         |  2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/codegen/tied-features-strength.rs b/tests/codegen/tied-features-strength.rs
index 1b4596ae2cb57..1b2b63c3d1ac4 100644
--- a/tests/codegen/tied-features-strength.rs
+++ b/tests/codegen/tied-features-strength.rs
@@ -3,21 +3,21 @@
 //@ compile-flags: --crate-type=rlib --target=aarch64-unknown-linux-gnu
 //@ needs-llvm-components: aarch64
 
-// The "+v8a" feature is matched as optional as it isn't added when we
-// are targeting older LLVM versions. Once the min supported version
-// is LLVM-14 we can remove the optional regex matching for this feature.
+// The "+fpmr" feature is matched as optional as it is only an explicit
+// feature in LLVM 18. Once the min supported version is LLVM-19 the optional
+// regex matching for this feature can be removed.
 
 //@ [ENABLE_SVE] compile-flags: -C target-feature=+sve -Copt-level=0
-// ENABLE_SVE: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)?|(\+sve,?)|(\+neon,?)|(\+fp-armv8,?))*}}" }
+// ENABLE_SVE: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(\+sve,?)|(\+neon,?)|(\+fp-armv8,?))*}}" }
 
 //@ [DISABLE_SVE] compile-flags: -C target-feature=-sve -Copt-level=0
-// DISABLE_SVE: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)?|(-sve,?)|(\+neon,?))*}}" }
+// DISABLE_SVE: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(-sve,?)|(\+neon,?))*}}" }
 
 //@ [DISABLE_NEON] compile-flags: -C target-feature=-neon -Copt-level=0
-// DISABLE_NEON: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)?|(-fp-armv8,?)|(-neon,?))*}}" }
+// DISABLE_NEON: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(-fp-armv8,?)|(-neon,?))*}}" }
 
 //@ [ENABLE_NEON] compile-flags: -C target-feature=+neon -Copt-level=0
-// ENABLE_NEON: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)?|(\+fp-armv8,?)|(\+neon,?))*}}" }
+// ENABLE_NEON: attributes #0 = { {{.*}} "target-features"="{{((\+outline-atomics,?)|(\+v8a,?)|(\+fpmr,?)?|(\+fp-armv8,?)|(\+neon,?))*}}" }
 
 #![feature(no_core, lang_items)]
 #![no_core]
diff --git a/tests/ui/check-cfg/mix.stderr b/tests/ui/check-cfg/mix.stderr
index 520cffc4b0268..9b6448fe5a033 100644
--- a/tests/ui/check-cfg/mix.stderr
+++ b/tests/ui/check-cfg/mix.stderr
@@ -251,7 +251,7 @@ warning: unexpected `cfg` condition value: `zebra`
 LL |     cfg!(target_feature = "zebra");
    |          ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `amx-bf16`, `amx-complex`, `amx-fp16`, `amx-int8`, `amx-tile`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, and `avx512vpopcntdq` and 201 more
+   = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `amx-bf16`, `amx-complex`, `amx-fp16`, `amx-int8`, `amx-tile`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, and `avx512vpopcntdq` and 239 more
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: 27 warnings emitted
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index 103a7564a0f87..56423d8c30799 100644
--- a/tests/ui/check-cfg/well-known-values.stderr
+++ b/tests/ui/check-cfg/well-known-values.stderr
@@ -165,7 +165,7 @@ warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
 LL |     target_feature = "_UNEXPECTED_VALUE",
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `amx-bf16`, `amx-complex`, `amx-fp16`, `amx-int8`, `amx-tile`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, `avx512vpopcntdq`, `avxifma`, `avxneconvert`, `avxvnni`, `avxvnniint16`, `avxvnniint8`, `backchain`, `bf16`, `bmi1`, `bmi2`, `bti`, `bulk-memory`, `c`, `cache`, `cmpxchg16b`, `crc`, `crt-static`, `d`, `d32`, `dit`, `doloop`, `dotprod`, `dpb`, `dpb2`, `dsp`, `dsp1e2`, `dspe60`, `e`, `e1`, `e2`, `edsp`, `elrw`, `ermsb`, `exception-handling`, `extended-const`, `f`, `f16c`, `f32mm`, `f64mm`, `fcma`, `fdivdu`, `fhm`, `flagm`, `float1e2`, `float1e3`, `float3e4`, `float7e60`, `floate1`, `fma`, `fp-armv8`, `fp16`, `fp64`, `fpuv2_df`, `fpuv2_sf`, `fpuv3_df`, `fpuv3_hf`, `fpuv3_hi`, `fpuv3_sf`, `frecipe`, `frintts`, `fxsr`, `gfni`, `hard-float`, `hard-float-abi`, `hard-tp`, `high-registers`, `hvx`, `hvx-length128b`, `hwdiv`, `i8mm`, `jsconv`, `lahfsahf`, `lasx`, `lbt`, `lor`, `lse`, `lsx`, `lvz`, `lzcnt`, `m`, `mclass`, `movbe`, `mp`, `mp1e2`, `msa`, `mte`, `multivalue`, `mutable-globals`, `neon`, `nontrapping-fptoint`, `nvic`, `paca`, `pacg`, `pan`, `pclmulqdq`, `pmuv3`, `popcnt`, `power10-vector`, `power8-altivec`, `power8-vector`, `power9-altivec`, `power9-vector`, `prfchw`, `rand`, `ras`, `rclass`, `rcpc`, `rcpc2`, `rdm`, `rdrand`, `rdseed`, `reference-types`, `relax`, `relaxed-simd`, `rtm`, `sb`, `sha`, `sha2`, `sha3`, `sha512`, `sign-ext`, `simd128`, `sm3`, `sm4`, `spe`, `ssbs`, `sse`, `sse2`, `sse3`, `sse4.1`, `sse4.2`, `sse4a`, `ssse3`, `sve`, `sve2`, `sve2-aes`, `sve2-bitperm`, `sve2-sha3`, `sve2-sm4`, `tbm`, `thumb-mode`, `thumb2`, `tme`, `trust`, `trustzone`, `ual`, `unaligned-scalar-mem`, `v`, `v5te`, `v6`, `v6k`, `v6t2`, `v7`, `v8`, `v8.1a`, `v8.2a`, `v8.3a`, `v8.4a`, `v8.5a`, `v8.6a`, `v8.7a`, `vaes`, `vdsp2e60f`, `vdspv1`, `vdspv2`, `vector`, `vfp2`, `vfp3`, `vfp4`, `vh`, `virt`, `virtualization`, `vpclmulqdq`, `vsx`, `xop`, `xsave`, `xsavec`, `xsaveopt`, `xsaves`, `zba`, `zbb`, `zbc`, `zbkb`, `zbkc`, `zbkx`, `zbs`, `zdinx`, `zfh`, `zfhmin`, `zfinx`, `zhinx`, `zhinxmin`, `zk`, `zkn`, `zknd`, `zkne`, `zknh`, `zkr`, `zks`, `zksed`, `zksh`, and `zkt`
+   = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `amx-bf16`, `amx-complex`, `amx-fp16`, `amx-int8`, `amx-tile`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, `avx512vpopcntdq`, `avxifma`, `avxneconvert`, `avxvnni`, `avxvnniint16`, `avxvnniint8`, `backchain`, `bf16`, `bmi1`, `bmi2`, `bti`, `bulk-memory`, `c`, `cache`, `cmpxchg16b`, `crc`, `crt-static`, `cssc`, `d`, `d32`, `dit`, `doloop`, `dotprod`, `dpb`, `dpb2`, `dsp`, `dsp1e2`, `dspe60`, `e`, `e1`, `e2`, `ecv`, `edsp`, `elrw`, `ermsb`, `exception-handling`, `extended-const`, `f`, `f16c`, `f32mm`, `f64mm`, `faminmax`, `fcma`, `fdivdu`, `fhm`, `flagm`, `flagm2`, `float1e2`, `float1e3`, `float3e4`, `float7e60`, `floate1`, `fma`, `fp-armv8`, `fp16`, `fp64`, `fp8`, `fp8dot2`, `fp8dot4`, `fp8fma`, `fpuv2_df`, `fpuv2_sf`, `fpuv3_df`, `fpuv3_hf`, `fpuv3_hi`, `fpuv3_sf`, `frecipe`, `frintts`, `fxsr`, `gfni`, `hard-float`, `hard-float-abi`, `hard-tp`, `hbc`, `high-registers`, `hvx`, `hvx-length128b`, `hwdiv`, `i8mm`, `jsconv`, `lahfsahf`, `lasx`, `lbt`, `lor`, `lse`, `lse128`, `lse2`, `lsx`, `lut`, `lvz`, `lzcnt`, `m`, `mclass`, `mops`, `movbe`, `mp`, `mp1e2`, `msa`, `mte`, `multivalue`, `mutable-globals`, `neon`, `nontrapping-fptoint`, `nvic`, `paca`, `pacg`, `pan`, `pclmulqdq`, `pmuv3`, `popcnt`, `power10-vector`, `power8-altivec`, `power8-vector`, `power9-altivec`, `power9-vector`, `prfchw`, `rand`, `ras`, `rclass`, `rcpc`, `rcpc2`, `rcpc3`, `rdm`, `rdrand`, `rdseed`, `reference-types`, `relax`, `relaxed-simd`, `rtm`, `sb`, `sha`, `sha2`, `sha3`, `sha512`, `sign-ext`, `simd128`, `sm3`, `sm4`, `sme`, `sme-f16f16`, `sme-f64f64`, `sme-f8f16`, `sme-f8f32`, `sme-fa64`, `sme-i16i64`, `sme-lutv2`, `sme2`, `sme2p1`, `spe`, `ssbs`, `sse`, `sse2`, `sse3`, `sse4.1`, `sse4.2`, `sse4a`, `ssse3`, `ssve-fp8dot2`, `ssve-fp8dot4`, `ssve-fp8fma`, `sve`, `sve-b16b16`, `sve2`, `sve2-aes`, `sve2-bitperm`, `sve2-sha3`, `sve2-sm4`, `sve2p1`, `tbm`, `thumb-mode`, `thumb2`, `tme`, `trust`, `trustzone`, `ual`, `unaligned-scalar-mem`, `v`, `v5te`, `v6`, `v6k`, `v6t2`, `v7`, `v8`, `v8.1a`, `v8.2a`, `v8.3a`, `v8.4a`, `v8.5a`, `v8.6a`, `v8.7a`, `v8.8a`, `v8.9a`, `v9.1a`, `v9.2a`, `v9.3a`, `v9.4a`, `v9.5a`, `v9a`, `vaes`, `vdsp2e60f`, `vdspv1`, `vdspv2`, `vector`, `vfp2`, `vfp3`, `vfp4`, `vh`, `virt`, `virtualization`, `vpclmulqdq`, `vsx`, `wfxt`, `xop`, `xsave`, `xsavec`, `xsaveopt`, `xsaves`, `zba`, `zbb`, `zbc`, `zbkb`, `zbkc`, `zbkx`, `zbs`, `zdinx`, `zfh`, `zfhmin`, `zfinx`, `zhinx`, `zhinxmin`, `zk`, `zkn`, `zknd`, `zkne`, `zknh`, `zkr`, `zks`, `zksed`, `zksh`, and `zkt`
    = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
 
 warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
diff --git a/tests/ui/target-feature/gate.stderr b/tests/ui/target-feature/gate.stderr
index a69020e6864d2..37c5ed0168890 100644
--- a/tests/ui/target-feature/gate.stderr
+++ b/tests/ui/target-feature/gate.stderr
@@ -1,5 +1,5 @@
 error[E0658]: the target feature `avx512bw` is currently unstable
-  --> $DIR/gate.rs:26:18
+  --> $DIR/gate.rs:27:18
    |
 LL | #[target_feature(enable = "avx512bw")]
    |                  ^^^^^^^^^^^^^^^^^^^

From 1ad218f3af806c1f0c14e8b44656318b913a3906 Mon Sep 17 00:00:00 2001
From: Jack Wrenn <jack@wrenn.fyi>
Date: Tue, 27 Aug 2024 14:05:54 +0000
Subject: [PATCH 661/685] safe transmute: Rename `BikeshedIntrinsicFrom` to
 `TransmuteFrom`

As our implementation of MCP411 nears completion and we begin to
solicit testing, it's no longer reasonable to expect testers to
type or remember `BikeshedIntrinsicFrom`. The name degrades the
ease-of-reading of documentation, and the overall experience of
using compiler safe transmute.

Tentatively, we'll instead adopt `TransmuteFrom`.

This name seems to be the one most likely to be stabilized, after
discussion on Zulip [1]. We may want to revisit the ordering of
`Src` and `Dst` before stabilization, at which point we'd likely
consider `TransmuteInto` or `Transmute`.

[1] https://rust-lang.zulipchat.com/#narrow/stream/216762-project-safe-transmute/topic/What.20should.20.60BikeshedIntrinsicFrom.60.20be.20named.3F
---
 .../src/solve/normalizes_to/mod.rs            |   2 +-
 library/core/src/mem/mod.rs                   |   2 +-
 library/core/src/mem/transmutability.rs       | 109 ++++-----
 tests/crashes/123693.rs                       |   4 +-
 tests/crashes/124207.rs                       |   2 +-
 tests/crashes/125881.rs                       |   2 +-
 tests/crashes/126267.rs                       |   4 +-
 tests/crashes/126377.rs                       |   4 +-
 tests/crashes/126966.rs                       |   4 +-
 .../transmutable-ice-110969.rs                |   4 +-
 .../transmutable-ice-110969.stderr            |   4 +-
 .../abstraction/abstracted_assume.rs          |   4 +-
 .../abstraction/const_generic_fn.rs           |   6 +-
 .../transmutability/alignment/align-fail.rs   |   4 +-
 .../alignment/align-fail.stderr               |   2 +-
 .../transmutability/alignment/align-pass.rs   |   4 +-
 tests/ui/transmutability/arrays/huge-len.rs   |   4 +-
 .../ui/transmutability/arrays/huge-len.stderr |   8 +-
 .../arrays/issue-103783-array-length.rs       |   4 +-
 .../arrays/should_have_correct_length.rs      |   4 +-
 .../arrays/should_inherit_alignment.rs        |   4 +-
 .../should_require_well_defined_layout.rs     |   4 +-
 .../should_require_well_defined_layout.stderr |  12 +-
 .../enums/niche_optimization.rs               |   6 +-
 .../enums/repr/padding_differences.rs         |   6 +-
 ...mitive_reprs_should_have_correct_length.rs |   4 +-
 ...ve_reprs_should_have_correct_length.stderr |  40 +--
 .../enums/repr/should_handle_all.rs           |   4 +-
 .../enums/should_order_correctly.rs           |   4 +-
 .../enums/should_pad_variants.rs              |   4 +-
 .../enums/should_pad_variants.stderr          |   2 +-
 .../enums/should_respect_endianness.rs        |   4 +-
 .../enums/should_respect_endianness.stderr    |   2 +-
 .../enums/uninhabited_optimization.rs         |   2 +-
 tests/ui/transmutability/issue-101739-1.rs    |   4 +-
 .../ui/transmutability/issue-101739-1.stderr  |  14 +-
 tests/ui/transmutability/issue-101739-2.rs    |   4 +-
 .../ui/transmutability/issue-101739-2.stderr  |   4 +-
 tests/ui/transmutability/issue-110467.rs      |   4 +-
 tests/ui/transmutability/issue-110892.rs      |   4 +-
 .../feature-missing.rs                        |   2 +-
 .../feature-missing.stderr                    |   4 +-
 .../unknown_dst.rs                            |   4 +-
 .../unknown_dst_field.rs                      |   4 +-
 .../unknown_dst_field.stderr                  |   8 +-
 .../unknown_src.rs                            |   4 +-
 .../unknown_src_field.rs                      |   4 +-
 .../unknown_src_field.stderr                  |   8 +-
 .../wrong-type-assume.rs                      |   4 +-
 tests/ui/transmutability/maybeuninit.rs       |   4 +-
 tests/ui/transmutability/maybeuninit.stderr   |   4 +-
 .../ui/transmutability/primitives/bool-mut.rs |   4 +-
 .../primitives/bool-mut.stderr                |   4 +-
 .../primitives/bool.current.stderr            |   4 +-
 .../primitives/bool.next.stderr               |   4 +-
 tests/ui/transmutability/primitives/bool.rs   |   6 +-
 .../primitives/numbers.current.stderr         | 228 +++++++++---------
 .../primitives/numbers.next.stderr            | 228 +++++++++---------
 .../ui/transmutability/primitives/numbers.rs  |   4 +-
 .../primitives/unit.current.stderr            |   2 +-
 .../primitives/unit.next.stderr               |   2 +-
 tests/ui/transmutability/primitives/unit.rs   |   4 +-
 .../accept_assume_lifetime_extension.rs       |   6 +-
 .../accept_unexercised_lifetime_extension.rs  |   4 +-
 ...ursive-wrapper-types-bit-compatible-mut.rs |   4 +-
 ...ve-wrapper-types-bit-compatible-mut.stderr |   2 +-
 .../recursive-wrapper-types-bit-compatible.rs |   4 +-
 ...ecursive-wrapper-types-bit-incompatible.rs |   4 +-
 ...sive-wrapper-types-bit-incompatible.stderr |   2 +-
 .../references/recursive-wrapper-types.rs     |   4 +-
 .../references/reject_extension.rs            |   4 +-
 .../references/reject_extension.stderr        |   2 +-
 .../references/reject_lifetime_extension.rs   |   6 +-
 .../reject_lifetime_extension.stderr          |   4 +-
 .../transmutability/references/u8-to-unit.rs  |   4 +-
 .../references/unit-to-itself.rs              |   4 +-
 .../transmutability/references/unit-to-u8.rs  |   4 +-
 .../references/unit-to-u8.stderr              |   2 +-
 .../transmutability/references/unsafecell.rs  |   4 +-
 .../references/unsafecell.stderr              |   8 +-
 tests/ui/transmutability/region-infer.rs      |   4 +-
 tests/ui/transmutability/region-infer.stderr  |   2 +-
 ...ould_accept_if_dst_has_safety_invariant.rs |   4 +-
 ..._accept_if_ref_src_has_safety_invariant.rs |   4 +-
 ...ould_accept_if_src_has_safety_invariant.rs |   4 +-
 ...ould_accept_if_src_has_safety_invariant.rs |   4 +-
 ...ould_reject_if_dst_has_safety_invariant.rs |   4 +-
 ..._reject_if_dst_has_safety_invariant.stderr |   4 +-
 ..._reject_if_ref_src_has_safety_invariant.rs |   4 +-
 ...ect_if_ref_src_has_safety_invariant.stderr |   4 +-
 .../structs/repr/should_handle_align.rs       |   4 +-
 .../structs/repr/should_handle_all.rs         |   4 +-
 .../structs/repr/should_handle_packed.rs      |   4 +-
 .../transmute_infinitely_recursive_type.rs    |   4 +-
 ...transmute_infinitely_recursive_type.stderr |   2 +-
 .../structs/should_order_fields_correctly.rs  |   4 +-
 .../transmutability/transmute-padding-ice.rs  |   4 +-
 tests/ui/transmutability/uninhabited.rs       |   4 +-
 tests/ui/transmutability/uninhabited.stderr   |   8 +-
 tests/ui/transmutability/unions/boolish.rs    |   4 +-
 .../unions/repr/should_handle_align.rs        |   4 +-
 .../unions/repr/should_handle_all.rs          |   4 +-
 .../unions/repr/should_handle_packed.rs       |   4 +-
 .../unions/should_pad_variants.rs             |   4 +-
 .../unions/should_pad_variants.stderr         |   2 +-
 ...mit_intersecting_if_validity_is_assumed.rs |   4 +-
 .../unions/should_reject_contraction.rs       |   4 +-
 .../unions/should_reject_contraction.stderr   |   4 +-
 .../unions/should_reject_disjoint.rs          |   4 +-
 .../unions/should_reject_disjoint.stderr      |   8 +-
 .../unions/should_reject_intersecting.rs      |   4 +-
 .../unions/should_reject_intersecting.stderr  |   8 +-
 112 files changed, 528 insertions(+), 531 deletions(-)

diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
index 5738173c7a804..c7a9846cd97f0 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -862,7 +862,7 @@ where
         _ecx: &mut EvalCtxt<'_, D>,
         goal: Goal<I, Self>,
     ) -> Result<Candidate<I>, NoSolution> {
-        panic!("`BikeshedIntrinsicFrom` does not have an associated type: {:?}", goal)
+        panic!("`TransmuteFrom` does not have an associated type: {:?}", goal)
     }
 
     fn consider_builtin_effects_intersection_candidate(
diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index 7a9ca4011be84..e602b497d171a 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -19,7 +19,7 @@ pub use maybe_uninit::MaybeUninit;
 
 mod transmutability;
 #[unstable(feature = "transmutability", issue = "99571")]
-pub use transmutability::{Assume, BikeshedIntrinsicFrom};
+pub use transmutability::{Assume, TransmuteFrom};
 
 #[stable(feature = "rust1", since = "1.0.0")]
 #[doc(inline)]
diff --git a/library/core/src/mem/transmutability.rs b/library/core/src/mem/transmutability.rs
index 62d454a5289b1..049b32ede9c3d 100644
--- a/library/core/src/mem/transmutability.rs
+++ b/library/core/src/mem/transmutability.rs
@@ -11,10 +11,10 @@ use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
 ///
 /// # Safety
 ///
-/// If `Dst: BikeshedIntrinsicFrom<Src, ASSUMPTIONS>`, the compiler guarantees
-/// that `Src` is soundly *union-transmutable* into a value of type `Dst`,
-/// provided that the programmer has guaranteed that the given
-/// [`ASSUMPTIONS`](Assume) are satisfied.
+/// If `Dst: TransmuteFrom<Src, ASSUMPTIONS>`, the compiler guarantees that
+/// `Src` is soundly *union-transmutable* into a value of type `Dst`, provided
+/// that the programmer has guaranteed that the given [`ASSUMPTIONS`](Assume)
+/// are satisfied.
 ///
 /// A union-transmute is any bit-reinterpretation conversion in the form of:
 ///
@@ -47,7 +47,7 @@ use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
 #[cfg_attr(not(bootstrap), doc = "```rust")]
 /// #![feature(transmutability)]
 ///
-/// use core::mem::{Assume, BikeshedIntrinsicFrom};
+/// use core::mem::{Assume, TransmuteFrom};
 ///
 /// let src = 42u8; // size = 1
 ///
@@ -55,7 +55,7 @@ use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
 /// struct Dst(u8); // size = 2
 //
 /// let _ = unsafe {
-///     <Dst as BikeshedIntrinsicFrom<u8, { Assume::SAFETY }>>::transmute(src)
+///     <Dst as TransmuteFrom<u8, { Assume::SAFETY }>>::transmute(src)
 /// };
 /// ```
 ///
@@ -87,7 +87,7 @@ use crate::marker::{ConstParamTy_, UnsizedConstParamTy};
 #[lang = "transmute_trait"]
 #[rustc_deny_explicit_impl(implement_via_object = false)]
 #[rustc_coinductive]
-pub unsafe trait BikeshedIntrinsicFrom<Src, const ASSUME: Assume = { Assume::NOTHING }>
+pub unsafe trait TransmuteFrom<Src, const ASSUME: Assume = { Assume::NOTHING }>
 where
     Src: ?Sized,
 {
@@ -140,23 +140,21 @@ where
     }
 }
 
-/// Configurable proof assumptions of [`BikeshedIntrinsicFrom`].
+/// Configurable proof assumptions of [`TransmuteFrom`].
 ///
 /// When `false`, the respective proof obligation belongs to the compiler. When
 /// `true`, the onus of the safety proof belongs to the programmer.
-/// [`BikeshedIntrinsicFrom`].
 #[unstable(feature = "transmutability", issue = "99571")]
 #[lang = "transmute_opts"]
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
 pub struct Assume {
-    /// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for
-    /// transmutations that might violate the the alignment requirements of
-    /// references; e.g.:
+    /// When `false`, [`TransmuteFrom`] is not implemented for transmutations
+    /// that might violate the the alignment requirements of references; e.g.:
     ///
     #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
     #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
     /// #![feature(transmutability)]
-    /// use core::mem::{align_of, BikeshedIntrinsicFrom};
+    /// use core::mem::{align_of, TransmuteFrom};
     ///
     /// assert_eq!(align_of::<[u8; 2]>(), 1);
     /// assert_eq!(align_of::<u16>(), 2);
@@ -165,18 +163,18 @@ pub struct Assume {
     ///
     /// // SAFETY: No safety obligations.
     /// let dst: &u16 = unsafe {
-    ///     <_ as BikeshedIntrinsicFrom<_>>::transmute(src)
+    ///     <_ as TransmuteFrom<_>>::transmute(src)
     /// };
     /// ```
     ///
-    /// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured
+    /// When `true`, [`TransmuteFrom`] assumes that *you* have ensured
     /// that references in the transmuted value satisfy the alignment
     /// requirements of their referent types; e.g.:
     ///
     #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
     #[cfg_attr(not(bootstrap), doc = "```rust")]
     /// #![feature(pointer_is_aligned_to, transmutability)]
-    /// use core::mem::{align_of, Assume, BikeshedIntrinsicFrom};
+    /// use core::mem::{align_of, Assume, TransmuteFrom};
     ///
     /// let src: &[u8; 2] = &[0xFF, 0xFF];
     ///
@@ -184,7 +182,7 @@ pub struct Assume {
     ///     // SAFETY: We have checked above that the address of `src` satisfies the
     ///     // alignment requirements of `u16`.
     ///     Some(unsafe {
-    ///         <_ as BikeshedIntrinsicFrom<_, { Assume::ALIGNMENT }>>::transmute(src)
+    ///         <_ as TransmuteFrom<_, { Assume::ALIGNMENT }>>::transmute(src)
     ///     })
     /// } else {
     ///     None
@@ -194,21 +192,21 @@ pub struct Assume {
     /// ```
     pub alignment: bool,
 
-    /// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for
-    /// transmutations that extend the lifetimes of references.
+    /// When `false`, [`TransmuteFrom`] is not implemented for transmutations
+    /// that extend the lifetimes of references.
     ///
-    /// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured
-    /// that references in the transmuted value do not outlive their referents.
+    /// When `true`, [`TransmuteFrom`] assumes that *you* have ensured that
+    /// references in the transmuted value do not outlive their referents.
     pub lifetimes: bool,
 
-    /// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for
-    /// transmutations that might violate the library safety invariants of the
-    /// destination type; e.g.:
+    /// When `false`, [`TransmuteFrom`] is not implemented for transmutations
+    /// that might violate the library safety invariants of the destination
+    /// type; e.g.:
     ///
     #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
     #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
     /// #![feature(transmutability)]
-    /// use core::mem::BikeshedIntrinsicFrom;
+    /// use core::mem::TransmuteFrom;
     ///
     /// let src: u8 = 3;
     ///
@@ -219,18 +217,18 @@ pub struct Assume {
     ///
     /// // SAFETY: No safety obligations.
     /// let dst: EvenU8 = unsafe {
-    ///     <_ as BikeshedIntrinsicFrom<_>>::transmute(src)
+    ///     <_ as TransmuteFrom<_>>::transmute(src)
     /// };
     /// ```
     ///
-    /// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured
+    /// When `true`, [`TransmuteFrom`] assumes that *you* have ensured
     /// that undefined behavior does not arise from using the transmuted value;
     /// e.g.:
     ///
     #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
     #[cfg_attr(not(bootstrap), doc = "```rust")]
     /// #![feature(transmutability)]
-    /// use core::mem::{Assume, BikeshedIntrinsicFrom};
+    /// use core::mem::{Assume, TransmuteFrom};
     ///
     /// let src: u8 = 42;
     ///
@@ -242,7 +240,7 @@ pub struct Assume {
     /// let maybe_dst: Option<EvenU8> = if src % 2 == 0 {
     ///     // SAFETY: We have checked above that the value of `src` is even.
     ///     Some(unsafe {
-    ///         <_ as BikeshedIntrinsicFrom<_, { Assume::SAFETY }>>::transmute(src)
+    ///         <_ as TransmuteFrom<_, { Assume::SAFETY }>>::transmute(src)
     ///     })
     /// } else {
     ///     None
@@ -252,31 +250,31 @@ pub struct Assume {
     /// ```
     pub safety: bool,
 
-    /// When `false`, [`BikeshedIntrinsicFrom`] is not implemented for
-    /// transmutations that might violate the language-level bit-validity
-    /// invariant of the destination type; e.g.:
+    /// When `false`, [`TransmuteFrom`] is not implemented for transmutations
+    /// that might violate the language-level bit-validity invariant of the
+    /// destination type; e.g.:
     ///
     #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
     #[cfg_attr(not(bootstrap), doc = "```compile_fail,E0277")]
     /// #![feature(transmutability)]
-    /// use core::mem::BikeshedIntrinsicFrom;
+    /// use core::mem::TransmuteFrom;
     ///
     /// let src: u8 = 3;
     ///
     /// // SAFETY: No safety obligations.
     /// let dst: bool = unsafe {
-    ///     <_ as BikeshedIntrinsicFrom<_>>::transmute(src)
+    ///     <_ as TransmuteFrom<_>>::transmute(src)
     /// };
     /// ```
     ///
-    /// When `true`, [`BikeshedIntrinsicFrom`] assumes that *you* have ensured
+    /// When `true`, [`TransmuteFrom`] assumes that *you* have ensured
     /// that the value being transmuted is a bit-valid instance of the
     /// transmuted value; e.g.:
     ///
     #[cfg_attr(bootstrap, doc = "```rust,ignore not runnable on bootstrap")]
     #[cfg_attr(not(bootstrap), doc = "```rust")]
     /// #![feature(transmutability)]
-    /// use core::mem::{Assume, BikeshedIntrinsicFrom};
+    /// use core::mem::{Assume, TransmuteFrom};
     ///
     /// let src: u8 = 1;
     ///
@@ -284,7 +282,7 @@ pub struct Assume {
     ///     // SAFETY: We have checked above that the value of `src` is a bit-valid
     ///     // instance of `bool`.
     ///     Some(unsafe {
-    ///         <_ as BikeshedIntrinsicFrom<_, { Assume::VALIDITY }>>::transmute(src)
+    ///         <_ as TransmuteFrom<_, { Assume::VALIDITY }>>::transmute(src)
     ///     })
     /// } else {
     ///     None
@@ -301,35 +299,34 @@ impl ConstParamTy_ for Assume {}
 impl UnsizedConstParamTy for Assume {}
 
 impl Assume {
-    /// With this, [`BikeshedIntrinsicFrom`] does not assume you have ensured
-    /// any safety obligations are met, and relies only upon its own analysis to
-    /// (dis)prove transmutability.
+    /// With this, [`TransmuteFrom`] does not assume you have ensured any safety
+    /// obligations are met, and relies only upon its own analysis to (dis)prove
+    /// transmutability.
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const NOTHING: Self =
         Self { alignment: false, lifetimes: false, safety: false, validity: false };
 
-    /// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured
-    /// that references in the transmuted value satisfy the alignment
-    /// requirements of their referent types. See [`Assume::alignment`] for
-    /// examples.
+    /// With this, [`TransmuteFrom`] assumes only that you have ensured that
+    /// references in the transmuted value satisfy the alignment requirements of
+    /// their referent types. See [`Assume::alignment`] for examples.
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const ALIGNMENT: Self = Self { alignment: true, ..Self::NOTHING };
 
-    /// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured
-    /// that references in the transmuted value do not outlive their referents.
-    /// See [`Assume::lifetimes`] for examples.
+    /// With this, [`TransmuteFrom`] assumes only that you have ensured that
+    /// references in the transmuted value do not outlive their referents. See
+    /// [`Assume::lifetimes`] for examples.
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const LIFETIMES: Self = Self { lifetimes: true, ..Self::NOTHING };
 
-    /// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured
-    /// that undefined behavior does not arise from using the transmuted value.
-    /// See [`Assume::safety`] for examples.
+    /// With this, [`TransmuteFrom`] assumes only that you have ensured that
+    /// undefined behavior does not arise from using the transmuted value. See
+    /// [`Assume::safety`] for examples.
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const SAFETY: Self = Self { safety: true, ..Self::NOTHING };
 
-    /// With this, [`BikeshedIntrinsicFrom`] assumes only that you have ensured
-    /// that the value being transmuted is a bit-valid instance of the
-    /// transmuted value. See [`Assume::validity`] for examples.
+    /// With this, [`TransmuteFrom`] assumes only that you have ensured that the
+    /// value being transmuted is a bit-valid instance of the transmuted value.
+    /// See [`Assume::validity`] for examples.
     #[unstable(feature = "transmutability", issue = "99571")]
     pub const VALIDITY: Self = Self { validity: true, ..Self::NOTHING };
 
@@ -348,7 +345,7 @@ impl Assume {
     ///     transmutability,
     /// )]
     /// #![allow(incomplete_features)]
-    /// use core::mem::{align_of, Assume, BikeshedIntrinsicFrom};
+    /// use core::mem::{align_of, Assume, TransmuteFrom};
     ///
     /// /// Attempts to transmute `src` to `&Dst`.
     /// ///
@@ -360,7 +357,7 @@ impl Assume {
     /// /// alignment, are satisfied.
     /// unsafe fn try_transmute_ref<'a, Src, Dst, const ASSUME: Assume>(src: &'a Src) -> Option<&'a Dst>
     /// where
-    ///     &'a Dst: BikeshedIntrinsicFrom<&'a Src, { ASSUME.and(Assume::ALIGNMENT) }>,
+    ///     &'a Dst: TransmuteFrom<&'a Src, { ASSUME.and(Assume::ALIGNMENT) }>,
     /// {
     ///     if <*const _>::is_aligned_to(src, align_of::<Dst>()) {
     ///         // SAFETY: By the above dynamic check, we have ensured that the address
@@ -368,7 +365,7 @@ impl Assume {
     ///         // on the caller, the safety obligations required by `ASSUME` have also
     ///         // been satisfied.
     ///         Some(unsafe {
-    ///             <_ as BikeshedIntrinsicFrom<_, { ASSUME.and(Assume::ALIGNMENT) }>>::transmute(src)
+    ///             <_ as TransmuteFrom<_, { ASSUME.and(Assume::ALIGNMENT) }>>::transmute(src)
     ///         })
     ///     } else {
     ///         None
diff --git a/tests/crashes/123693.rs b/tests/crashes/123693.rs
index c2e192092be18..c3236322c6e2a 100644
--- a/tests/crashes/123693.rs
+++ b/tests/crashes/123693.rs
@@ -3,11 +3,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::NOTHING }>,
+        Dst: TransmuteFrom<Src, { Assume::NOTHING }>,
     {
     }
 }
diff --git a/tests/crashes/124207.rs b/tests/crashes/124207.rs
index a4e1c55189006..a11eedb140a68 100644
--- a/tests/crashes/124207.rs
+++ b/tests/crashes/124207.rs
@@ -4,6 +4,6 @@
 trait OpaqueTrait {}
 type OpaqueType = impl OpaqueTrait;
 trait AnotherTrait {}
-impl<T: std::mem::BikeshedIntrinsicFrom<(), ()>> AnotherTrait for T {}
+impl<T: std::mem::TransmuteFrom<(), ()>> AnotherTrait for T {}
 impl AnotherTrait for OpaqueType {}
 pub fn main() {}
diff --git a/tests/crashes/125881.rs b/tests/crashes/125881.rs
index 98331d3c97484..a38f1891b61d9 100644
--- a/tests/crashes/125881.rs
+++ b/tests/crashes/125881.rs
@@ -3,6 +3,6 @@
 #![feature(transmutability)]
 #![feature(unboxed_closures,effects)]
 
-const fn test() -> impl std::mem::BikeshedIntrinsicFrom() {
+const fn test() -> impl std::mem::TransmuteFrom() {
     || {}
 }
diff --git a/tests/crashes/126267.rs b/tests/crashes/126267.rs
index c0604b90a6701..728578179ed36 100644
--- a/tests/crashes/126267.rs
+++ b/tests/crashes/126267.rs
@@ -14,11 +14,11 @@ pub enum Error {
 }
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src>, // safety is NOT assumed
+        Dst: TransmuteFrom<Src>, // safety is NOT assumed
     {
     }
 }
diff --git a/tests/crashes/126377.rs b/tests/crashes/126377.rs
index f8b9b693b6550..f6727bcc0a494 100644
--- a/tests/crashes/126377.rs
+++ b/tests/crashes/126377.rs
@@ -4,7 +4,7 @@
 #![feature(generic_const_exprs)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<
         Src,
@@ -15,7 +15,7 @@ mod assert {
         const ASSUME_VALIDITY: bool,
     >()
     where
-        Dst: BikeshedIntrinsicFrom<
+        Dst: TransmuteFrom<
             Src,
             {  }
         >,
diff --git a/tests/crashes/126966.rs b/tests/crashes/126966.rs
index edeedc68c40d7..2c9f1a70f4fbf 100644
--- a/tests/crashes/126966.rs
+++ b/tests/crashes/126966.rs
@@ -1,10 +1,10 @@
 //@ known-bug: rust-lang/rust#126966
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src>,
+        Dst: TransmuteFrom<Src>,
     {
     }
 }
diff --git a/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.rs b/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.rs
index 569e57fa3262a..401267a0f16dc 100644
--- a/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.rs
+++ b/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.rs
@@ -4,11 +4,11 @@
 #![allow(incomplete_features, unstable_features)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, Dst, Context, const ASSUME: std::mem::Assume>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, Context, ASSUME>,
+        Dst: TransmuteFrom<Src, Context, ASSUME>,
         //~^ ERROR trait takes at most 2 generic arguments but 3 generic arguments were supplied
     {
     }
diff --git a/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr b/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr
index 5c04c4c9d5b52..9671668561477 100644
--- a/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr
+++ b/tests/ui/const-generics/adt_const_params/transmutable-ice-110969.stderr
@@ -1,8 +1,8 @@
 error[E0107]: trait takes at most 2 generic arguments but 3 generic arguments were supplied
   --> $DIR/transmutable-ice-110969.rs:11:14
    |
-LL |         Dst: BikeshedIntrinsicFrom<Src, Context, ASSUME>,
-   |              ^^^^^^^^^^^^^^^^^^^^^             -------- help: remove the unnecessary generic argument
+LL |         Dst: TransmuteFrom<Src, Context, ASSUME>,
+   |              ^^^^^^^^^^^^^             -------- help: remove the unnecessary generic argument
    |              |
    |              expected at most 2 generic arguments
 
diff --git a/tests/ui/transmutability/abstraction/abstracted_assume.rs b/tests/ui/transmutability/abstraction/abstracted_assume.rs
index 897e1b4b50af3..7fd91e31a047c 100644
--- a/tests/ui/transmutability/abstraction/abstracted_assume.rs
+++ b/tests/ui/transmutability/abstraction/abstracted_assume.rs
@@ -8,7 +8,7 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<
         Src,
@@ -16,7 +16,7 @@ mod assert {
         const ASSUME: std::mem::Assume,
     >()
     where
-        Dst: BikeshedIntrinsicFrom<
+        Dst: TransmuteFrom<
             Src,
             ASSUME,
         >,
diff --git a/tests/ui/transmutability/abstraction/const_generic_fn.rs b/tests/ui/transmutability/abstraction/const_generic_fn.rs
index 0a5f0de02148c..1ea978ce1bab9 100644
--- a/tests/ui/transmutability/abstraction/const_generic_fn.rs
+++ b/tests/ui/transmutability/abstraction/const_generic_fn.rs
@@ -6,12 +6,12 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn array_like<T, E, const N: usize>()
     where
-        T: BikeshedIntrinsicFrom<[E; N], { Assume::SAFETY }>,
-        [E; N]: BikeshedIntrinsicFrom<T, { Assume::SAFETY }>
+        T: TransmuteFrom<[E; N], { Assume::SAFETY }>,
+        [E; N]: TransmuteFrom<T, { Assume::SAFETY }>
     {}
 }
 
diff --git a/tests/ui/transmutability/alignment/align-fail.rs b/tests/ui/transmutability/alignment/align-fail.rs
index d88f1285c1183..4c1a69b012882 100644
--- a/tests/ui/transmutability/alignment/align-fail.rs
+++ b/tests/ui/transmutability/alignment/align-fail.rs
@@ -2,11 +2,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: false,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/alignment/align-fail.stderr b/tests/ui/transmutability/alignment/align-fail.stderr
index f05e55fb024d8..b9801e511b2ad 100644
--- a/tests/ui/transmutability/alignment/align-fail.stderr
+++ b/tests/ui/transmutability/alignment/align-fail.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: false,
diff --git a/tests/ui/transmutability/alignment/align-pass.rs b/tests/ui/transmutability/alignment/align-pass.rs
index aecf7b02d62ea..feecf5edaa1ac 100644
--- a/tests/ui/transmutability/alignment/align-pass.rs
+++ b/tests/ui/transmutability/alignment/align-pass.rs
@@ -2,11 +2,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: false,
                 lifetimes: false,
diff --git a/tests/ui/transmutability/arrays/huge-len.rs b/tests/ui/transmutability/arrays/huge-len.rs
index 3fe254ebef418..dec24a559d3d3 100644
--- a/tests/ui/transmutability/arrays/huge-len.rs
+++ b/tests/ui/transmutability/arrays/huge-len.rs
@@ -1,11 +1,11 @@
 #![crate_type = "lib"]
 #![feature(transmutability)]
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src>,
+        Dst: TransmuteFrom<Src>,
     {
     }
 }
diff --git a/tests/ui/transmutability/arrays/huge-len.stderr b/tests/ui/transmutability/arrays/huge-len.stderr
index 37160c5c9596b..1fa16c649d423 100644
--- a/tests/ui/transmutability/arrays/huge-len.stderr
+++ b/tests/ui/transmutability/arrays/huge-len.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_maybe_transmutable`
 LL |     pub fn is_maybe_transmutable<Src, Dst>()
    |            --------------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>,
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
+LL |         Dst: TransmuteFrom<Src>,
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
 
 error[E0277]: `ExplicitlyPadded` cannot be safely transmuted into `()`
   --> $DIR/huge-len.rs:24:55
@@ -25,8 +25,8 @@ note: required by a bound in `is_maybe_transmutable`
 LL |     pub fn is_maybe_transmutable<Src, Dst>()
    |            --------------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>,
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
+LL |         Dst: TransmuteFrom<Src>,
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/transmutability/arrays/issue-103783-array-length.rs b/tests/ui/transmutability/arrays/issue-103783-array-length.rs
index 7fcbcc0107563..3537a39259c30 100644
--- a/tests/ui/transmutability/arrays/issue-103783-array-length.rs
+++ b/tests/ui/transmutability/arrays/issue-103783-array-length.rs
@@ -3,11 +3,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<
+        Dst: TransmuteFrom<
             Src,
             { Assume { alignment: true, lifetimes: true, safety: true, validity: true } },
         >,
diff --git a/tests/ui/transmutability/arrays/should_have_correct_length.rs b/tests/ui/transmutability/arrays/should_have_correct_length.rs
index 747897d49d78d..00c0c1122ef6b 100644
--- a/tests/ui/transmutability/arrays/should_have_correct_length.rs
+++ b/tests/ui/transmutability/arrays/should_have_correct_length.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
     {}
 }
 
diff --git a/tests/ui/transmutability/arrays/should_inherit_alignment.rs b/tests/ui/transmutability/arrays/should_inherit_alignment.rs
index d95c51e3361be..70d2f07c449d3 100644
--- a/tests/ui/transmutability/arrays/should_inherit_alignment.rs
+++ b/tests/ui/transmutability/arrays/should_inherit_alignment.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume::ALIGNMENT
                 .and(Assume::LIFETIMES)
                 .and(Assume::SAFETY)
diff --git a/tests/ui/transmutability/arrays/should_require_well_defined_layout.rs b/tests/ui/transmutability/arrays/should_require_well_defined_layout.rs
index 5345b199f6ed7..29e8ad136ee82 100644
--- a/tests/ui/transmutability/arrays/should_require_well_defined_layout.rs
+++ b/tests/ui/transmutability/arrays/should_require_well_defined_layout.rs
@@ -5,11 +5,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume::ALIGNMENT
                 .and(Assume::LIFETIMES)
                 .and(Assume::SAFETY)
diff --git a/tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr b/tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr
index b4cd70142c499..e9420cd393e9a 100644
--- a/tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr
+++ b/tests/ui/transmutability/arrays/should_require_well_defined_layout.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
@@ -31,7 +31,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
@@ -52,7 +52,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
@@ -73,7 +73,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
@@ -94,7 +94,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
@@ -115,7 +115,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
diff --git a/tests/ui/transmutability/enums/niche_optimization.rs b/tests/ui/transmutability/enums/niche_optimization.rs
index 23f57ecad75f1..802d174756868 100644
--- a/tests/ui/transmutability/enums/niche_optimization.rs
+++ b/tests/ui/transmutability/enums/niche_optimization.rs
@@ -5,11 +5,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: false,
                 lifetimes: false,
@@ -21,7 +21,7 @@ mod assert {
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: false,
                 lifetimes: false,
diff --git a/tests/ui/transmutability/enums/repr/padding_differences.rs b/tests/ui/transmutability/enums/repr/padding_differences.rs
index d0e1502b5e296..9d2380c613e70 100644
--- a/tests/ui/transmutability/enums/repr/padding_differences.rs
+++ b/tests/ui/transmutability/enums/repr/padding_differences.rs
@@ -7,11 +7,11 @@
 use std::mem::MaybeUninit;
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: false,
                 lifetimes: false,
@@ -23,7 +23,7 @@ mod assert {
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: false,
                 lifetimes: false,
diff --git a/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.rs b/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.rs
index d3d463e792984..a8f4cccc73ed9 100644
--- a/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.rs
+++ b/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.rs
@@ -5,11 +5,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.stderr b/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.stderr
index 6c88bf4ff9686..c975ff276c8fd 100644
--- a/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.stderr
+++ b/tests/ui/transmutability/enums/repr/primitive_reprs_should_have_correct_length.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -32,7 +32,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -54,7 +54,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -76,7 +76,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -98,7 +98,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -120,7 +120,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -142,7 +142,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -164,7 +164,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -186,7 +186,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -208,7 +208,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -230,7 +230,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -252,7 +252,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -274,7 +274,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -296,7 +296,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -318,7 +318,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -340,7 +340,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -362,7 +362,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -384,7 +384,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -406,7 +406,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -428,7 +428,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
diff --git a/tests/ui/transmutability/enums/repr/should_handle_all.rs b/tests/ui/transmutability/enums/repr/should_handle_all.rs
index a8ec86fa40df6..dec0126f22d4c 100644
--- a/tests/ui/transmutability/enums/repr/should_handle_all.rs
+++ b/tests/ui/transmutability/enums/repr/should_handle_all.rs
@@ -5,11 +5,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/enums/should_order_correctly.rs b/tests/ui/transmutability/enums/should_order_correctly.rs
index d51a033f1a60e..cea2055e1484c 100644
--- a/tests/ui/transmutability/enums/should_order_correctly.rs
+++ b/tests/ui/transmutability/enums/should_order_correctly.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume::ALIGNMENT
                 .and(Assume::LIFETIMES)
                 .and(Assume::SAFETY)
diff --git a/tests/ui/transmutability/enums/should_pad_variants.rs b/tests/ui/transmutability/enums/should_pad_variants.rs
index 81ef9e8a567e7..82bafe8541579 100644
--- a/tests/ui/transmutability/enums/should_pad_variants.rs
+++ b/tests/ui/transmutability/enums/should_pad_variants.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume::ALIGNMENT
                 .and(Assume::LIFETIMES)
                 .and(Assume::SAFETY)
diff --git a/tests/ui/transmutability/enums/should_pad_variants.stderr b/tests/ui/transmutability/enums/should_pad_variants.stderr
index da4294bdbce8c..bb26281c2f0ba 100644
--- a/tests/ui/transmutability/enums/should_pad_variants.stderr
+++ b/tests/ui/transmutability/enums/should_pad_variants.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
diff --git a/tests/ui/transmutability/enums/should_respect_endianness.rs b/tests/ui/transmutability/enums/should_respect_endianness.rs
index 8e52274710a83..9cf4de06ad291 100644
--- a/tests/ui/transmutability/enums/should_respect_endianness.rs
+++ b/tests/ui/transmutability/enums/should_respect_endianness.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume::ALIGNMENT
                 .and(Assume::LIFETIMES)
                 .and(Assume::SAFETY)
diff --git a/tests/ui/transmutability/enums/should_respect_endianness.stderr b/tests/ui/transmutability/enums/should_respect_endianness.stderr
index 9f88bb0681345..1b9099b297bb2 100644
--- a/tests/ui/transmutability/enums/should_respect_endianness.stderr
+++ b/tests/ui/transmutability/enums/should_respect_endianness.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
diff --git a/tests/ui/transmutability/enums/uninhabited_optimization.rs b/tests/ui/transmutability/enums/uninhabited_optimization.rs
index c2d5b67ab2ce4..5b9de3a396329 100644
--- a/tests/ui/transmutability/enums/uninhabited_optimization.rs
+++ b/tests/ui/transmutability/enums/uninhabited_optimization.rs
@@ -4,7 +4,7 @@
 
 fn assert_transmutable<T>()
 where
-    (): std::mem::BikeshedIntrinsicFrom<T>
+    (): std::mem::TransmuteFrom<T>
 {}
 
 enum Uninhabited {}
diff --git a/tests/ui/transmutability/issue-101739-1.rs b/tests/ui/transmutability/issue-101739-1.rs
index 81a9038fdb536..fcc1db073ee0e 100644
--- a/tests/ui/transmutability/issue-101739-1.rs
+++ b/tests/ui/transmutability/issue-101739-1.rs
@@ -1,11 +1,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, const ASSUME_ALIGNMENT: bool>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>, //~ ERROR cannot find type `Dst` in this scope
+        Dst: TransmuteFrom<Src, ASSUME_ALIGNMENT>, //~ ERROR cannot find type `Dst` in this scope
                                                            //~| the constant `ASSUME_ALIGNMENT` is not of type `Assume`
                                                            //~| ERROR: mismatched types
     {
diff --git a/tests/ui/transmutability/issue-101739-1.stderr b/tests/ui/transmutability/issue-101739-1.stderr
index 6f79bf7b42468..3687631dc5119 100644
--- a/tests/ui/transmutability/issue-101739-1.stderr
+++ b/tests/ui/transmutability/issue-101739-1.stderr
@@ -1,23 +1,23 @@
 error[E0412]: cannot find type `Dst` in this scope
   --> $DIR/issue-101739-1.rs:8:9
    |
-LL |         Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
+LL |         Dst: TransmuteFrom<Src, ASSUME_ALIGNMENT>,
    |         ^^^ not found in this scope
 
 error: the constant `ASSUME_ALIGNMENT` is not of type `Assume`
   --> $DIR/issue-101739-1.rs:8:14
    |
-LL |         Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
+LL |         Dst: TransmuteFrom<Src, ASSUME_ALIGNMENT>,
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
    |
-note: required by a const generic parameter in `BikeshedIntrinsicFrom`
+note: required by a const generic parameter in `TransmuteFrom`
   --> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
 
 error[E0308]: mismatched types
-  --> $DIR/issue-101739-1.rs:8:41
+  --> $DIR/issue-101739-1.rs:8:33
    |
-LL |         Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
-   |                                         ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
+LL |         Dst: TransmuteFrom<Src, ASSUME_ALIGNMENT>,
+   |                                 ^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/transmutability/issue-101739-2.rs b/tests/ui/transmutability/issue-101739-2.rs
index 6dfde06d6b3c6..02aa4669e05ef 100644
--- a/tests/ui/transmutability/issue-101739-2.rs
+++ b/tests/ui/transmutability/issue-101739-2.rs
@@ -3,7 +3,7 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<
         Src,
@@ -14,7 +14,7 @@ mod assert {
         const ASSUME_VISIBILITY: bool,
     >()
     where
-        Dst: BikeshedIntrinsicFrom<
+        Dst: TransmuteFrom<
                 //~^ ERROR trait takes at most 2 generic arguments but 5 generic arguments were supplied
                 Src,
                 ASSUME_ALIGNMENT, //~ ERROR: mismatched types
diff --git a/tests/ui/transmutability/issue-101739-2.stderr b/tests/ui/transmutability/issue-101739-2.stderr
index 11e8fa1d8c5ae..526fcabe14e9f 100644
--- a/tests/ui/transmutability/issue-101739-2.stderr
+++ b/tests/ui/transmutability/issue-101739-2.stderr
@@ -1,8 +1,8 @@
 error[E0107]: trait takes at most 2 generic arguments but 5 generic arguments were supplied
   --> $DIR/issue-101739-2.rs:17:14
    |
-LL |           Dst: BikeshedIntrinsicFrom<
-   |                ^^^^^^^^^^^^^^^^^^^^^ expected at most 2 generic arguments
+LL |           Dst: TransmuteFrom<
+   |                ^^^^^^^^^^^^^ expected at most 2 generic arguments
 ...
 LL |                   ASSUME_ALIGNMENT,
    |  _________________________________-
diff --git a/tests/ui/transmutability/issue-110467.rs b/tests/ui/transmutability/issue-110467.rs
index 1f9e521c24b66..4acea5f766da2 100644
--- a/tests/ui/transmutability/issue-110467.rs
+++ b/tests/ui/transmutability/issue-110467.rs
@@ -1,11 +1,11 @@
 //@ check-pass
 #![crate_type = "lib"]
 #![feature(transmutability)]
-use std::mem::BikeshedIntrinsicFrom;
+use std::mem::TransmuteFrom;
 
 pub fn is_maybe_transmutable<Src, Dst>()
 where
-    Dst: BikeshedIntrinsicFrom<Src>,
+    Dst: TransmuteFrom<Src>,
 {
 }
 
diff --git a/tests/ui/transmutability/issue-110892.rs b/tests/ui/transmutability/issue-110892.rs
index 9713684c959a9..ad1b9e7af1081 100644
--- a/tests/ui/transmutability/issue-110892.rs
+++ b/tests/ui/transmutability/issue-110892.rs
@@ -3,7 +3,7 @@
 #![allow(incomplete_features)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<
         Src,
@@ -14,7 +14,7 @@ mod assert {
         const ASSUME_VALIDITY: bool,
     >()
     where
-        Dst: BikeshedIntrinsicFrom<
+        Dst: TransmuteFrom<
             Src,
             { from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) }
         >,
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/feature-missing.rs b/tests/ui/transmutability/malformed-program-gracefulness/feature-missing.rs
index 30c381745d0f9..07133aa56147d 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/feature-missing.rs
+++ b/tests/ui/transmutability/malformed-program-gracefulness/feature-missing.rs
@@ -2,7 +2,7 @@
 
 #![crate_type = "lib"]
 
-use std::mem::BikeshedIntrinsicFrom;
+use std::mem::TransmuteFrom;
 //~^ ERROR use of unstable library feature 'transmutability' [E0658]
 
 use std::mem::Assume;
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/feature-missing.stderr b/tests/ui/transmutability/malformed-program-gracefulness/feature-missing.stderr
index 9f22190717262..a2096cd53e5b3 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/feature-missing.stderr
+++ b/tests/ui/transmutability/malformed-program-gracefulness/feature-missing.stderr
@@ -1,8 +1,8 @@
 error[E0658]: use of unstable library feature 'transmutability'
   --> $DIR/feature-missing.rs:5:5
    |
-LL | use std::mem::BikeshedIntrinsicFrom;
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | use std::mem::TransmuteFrom;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #99571 <https://github.com/rust-lang/rust/issues/99571> for more information
    = help: add `#![feature(transmutability)]` to the crate attributes to enable
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst.rs b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst.rs
index bcfbc1430a8cc..b8828c59d355f 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst.rs
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst.rs
@@ -5,11 +5,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src>
+        Dst: TransmuteFrom<Src>
     {}
 }
 
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.rs b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.rs
index 8c18de111967f..2285d2f532eec 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.rs
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.rs
@@ -5,11 +5,11 @@
 #![allow(incomplete_features)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src>
+        Dst: TransmuteFrom<Src>
     {}
 }
 
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.stderr b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.stderr
index df10919f6d3f0..564aee687a5f9 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.stderr
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_dst_field.stderr
@@ -22,8 +22,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `should_gracefully_handle_unknown_dst_ref_field::Src` cannot be safely transmuted into `should_gracefully_handle_unknown_dst_ref_field::Dst`
   --> $DIR/unknown_dst_field.rs:25:36
@@ -37,8 +37,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src.rs b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src.rs
index bd7c3fc7fb505..10ba7a61b8723 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src.rs
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src.rs
@@ -5,11 +5,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src>
+        Dst: TransmuteFrom<Src>
     {}
 }
 
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.rs b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.rs
index 1da16e67223de..598e04971e28f 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.rs
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.rs
@@ -5,11 +5,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src>
+        Dst: TransmuteFrom<Src>
     {}
 }
 
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.stderr b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.stderr
index 6ec66e1706146..1156391c301c7 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.stderr
+++ b/tests/ui/transmutability/malformed-program-gracefulness/unknown_src_field.stderr
@@ -22,8 +22,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `should_gracefully_handle_unknown_src_ref_field::Src` cannot be safely transmuted into `should_gracefully_handle_unknown_src_ref_field::Dst`
   --> $DIR/unknown_src_field.rs:25:36
@@ -37,8 +37,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 4 previous errors
 
diff --git a/tests/ui/transmutability/malformed-program-gracefulness/wrong-type-assume.rs b/tests/ui/transmutability/malformed-program-gracefulness/wrong-type-assume.rs
index 608366fa08936..df925975bad0a 100644
--- a/tests/ui/transmutability/malformed-program-gracefulness/wrong-type-assume.rs
+++ b/tests/ui/transmutability/malformed-program-gracefulness/wrong-type-assume.rs
@@ -8,7 +8,7 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<
         Src,
@@ -19,7 +19,7 @@ mod assert {
         const ASSUME_VALIDITY: bool,
     >()
     where
-        Dst: BikeshedIntrinsicFrom<
+        Dst: TransmuteFrom<
             Src,
             { from_options(ASSUME_ALIGNMENT, ASSUME_LIFETIMES, ASSUME_SAFETY, ASSUME_VALIDITY) }
         >,
diff --git a/tests/ui/transmutability/maybeuninit.rs b/tests/ui/transmutability/maybeuninit.rs
index 77c3381c77497..7b60785b7e082 100644
--- a/tests/ui/transmutability/maybeuninit.rs
+++ b/tests/ui/transmutability/maybeuninit.rs
@@ -5,11 +5,11 @@
 use std::mem::MaybeUninit;
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY }>
     {}
 }
 
diff --git a/tests/ui/transmutability/maybeuninit.stderr b/tests/ui/transmutability/maybeuninit.stderr
index be7dcaf35eab9..897c2df10a8f5 100644
--- a/tests/ui/transmutability/maybeuninit.stderr
+++ b/tests/ui/transmutability/maybeuninit.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_maybe_transmutable`
 LL |     pub fn is_maybe_transmutable<Src, Dst>()
    |            --------------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/transmutability/primitives/bool-mut.rs b/tests/ui/transmutability/primitives/bool-mut.rs
index 09b6d582d871c..0a7dad37aaf0f 100644
--- a/tests/ui/transmutability/primitives/bool-mut.rs
+++ b/tests/ui/transmutability/primitives/bool-mut.rs
@@ -2,11 +2,11 @@
 
 #![feature(transmutability)]
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY }>
     {}
 }
 
diff --git a/tests/ui/transmutability/primitives/bool-mut.stderr b/tests/ui/transmutability/primitives/bool-mut.stderr
index a6cf146659e62..fcf60bc979c2d 100644
--- a/tests/ui/transmutability/primitives/bool-mut.stderr
+++ b/tests/ui/transmutability/primitives/bool-mut.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/transmutability/primitives/bool.current.stderr b/tests/ui/transmutability/primitives/bool.current.stderr
index da6a4a44e95e0..2945cdaad4062 100644
--- a/tests/ui/transmutability/primitives/bool.current.stderr
+++ b/tests/ui/transmutability/primitives/bool.current.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/transmutability/primitives/bool.next.stderr b/tests/ui/transmutability/primitives/bool.next.stderr
index da6a4a44e95e0..2945cdaad4062 100644
--- a/tests/ui/transmutability/primitives/bool.next.stderr
+++ b/tests/ui/transmutability/primitives/bool.next.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/transmutability/primitives/bool.rs b/tests/ui/transmutability/primitives/bool.rs
index 19236a1ae2e6a..6fac8ba1ad1e2 100644
--- a/tests/ui/transmutability/primitives/bool.rs
+++ b/tests/ui/transmutability/primitives/bool.rs
@@ -4,16 +4,16 @@
 
 #![feature(transmutability)]
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY }>
     {}
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
     {}
 }
 
diff --git a/tests/ui/transmutability/primitives/numbers.current.stderr b/tests/ui/transmutability/primitives/numbers.current.stderr
index 0a9b9d182f856..efb2ce8c77207 100644
--- a/tests/ui/transmutability/primitives/numbers.current.stderr
+++ b/tests/ui/transmutability/primitives/numbers.current.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `u16`
   --> $DIR/numbers.rs:65:40
@@ -25,8 +25,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `i32`
   --> $DIR/numbers.rs:66:40
@@ -40,8 +40,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `f32`
   --> $DIR/numbers.rs:67:40
@@ -55,8 +55,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `u32`
   --> $DIR/numbers.rs:68:40
@@ -70,8 +70,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:69:40
@@ -85,8 +85,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:70:40
@@ -100,8 +100,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:71:40
@@ -115,8 +115,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:72:39
@@ -130,8 +130,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:73:39
@@ -145,8 +145,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `i16`
   --> $DIR/numbers.rs:75:40
@@ -160,8 +160,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `u16`
   --> $DIR/numbers.rs:76:40
@@ -175,8 +175,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `i32`
   --> $DIR/numbers.rs:77:40
@@ -190,8 +190,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `f32`
   --> $DIR/numbers.rs:78:40
@@ -205,8 +205,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `u32`
   --> $DIR/numbers.rs:79:40
@@ -220,8 +220,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:80:40
@@ -235,8 +235,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:81:40
@@ -250,8 +250,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:82:40
@@ -265,8 +265,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:83:39
@@ -280,8 +280,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:84:39
@@ -295,8 +295,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `i32`
   --> $DIR/numbers.rs:86:40
@@ -310,8 +310,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `f32`
   --> $DIR/numbers.rs:87:40
@@ -325,8 +325,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `u32`
   --> $DIR/numbers.rs:88:40
@@ -340,8 +340,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:89:40
@@ -355,8 +355,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:90:40
@@ -370,8 +370,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:91:40
@@ -385,8 +385,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:92:39
@@ -400,8 +400,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:93:39
@@ -415,8 +415,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `i32`
   --> $DIR/numbers.rs:95:40
@@ -430,8 +430,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `f32`
   --> $DIR/numbers.rs:96:40
@@ -445,8 +445,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `u32`
   --> $DIR/numbers.rs:97:40
@@ -460,8 +460,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:98:40
@@ -475,8 +475,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:99:40
@@ -490,8 +490,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:100:40
@@ -505,8 +505,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:101:39
@@ -520,8 +520,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:102:39
@@ -535,8 +535,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i32` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:104:40
@@ -550,8 +550,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i32` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:105:40
@@ -565,8 +565,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i32` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:106:40
@@ -580,8 +580,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i32` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:107:39
@@ -595,8 +595,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i32` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:108:39
@@ -610,8 +610,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f32` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:110:40
@@ -625,8 +625,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f32` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:111:40
@@ -640,8 +640,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f32` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:112:40
@@ -655,8 +655,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f32` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:113:39
@@ -670,8 +670,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f32` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:114:39
@@ -685,8 +685,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u32` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:116:40
@@ -700,8 +700,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u32` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:117:40
@@ -715,8 +715,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u32` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:118:40
@@ -730,8 +730,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u32` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:119:39
@@ -745,8 +745,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u32` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:120:39
@@ -760,8 +760,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u64` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:122:39
@@ -775,8 +775,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u64` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:123:39
@@ -790,8 +790,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i64` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:125:39
@@ -805,8 +805,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i64` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:126:39
@@ -820,8 +820,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f64` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:128:39
@@ -835,8 +835,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f64` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:129:39
@@ -850,8 +850,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 57 previous errors
 
diff --git a/tests/ui/transmutability/primitives/numbers.next.stderr b/tests/ui/transmutability/primitives/numbers.next.stderr
index 0a9b9d182f856..efb2ce8c77207 100644
--- a/tests/ui/transmutability/primitives/numbers.next.stderr
+++ b/tests/ui/transmutability/primitives/numbers.next.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `u16`
   --> $DIR/numbers.rs:65:40
@@ -25,8 +25,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `i32`
   --> $DIR/numbers.rs:66:40
@@ -40,8 +40,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `f32`
   --> $DIR/numbers.rs:67:40
@@ -55,8 +55,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `u32`
   --> $DIR/numbers.rs:68:40
@@ -70,8 +70,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:69:40
@@ -85,8 +85,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:70:40
@@ -100,8 +100,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:71:40
@@ -115,8 +115,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:72:39
@@ -130,8 +130,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i8` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:73:39
@@ -145,8 +145,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `i16`
   --> $DIR/numbers.rs:75:40
@@ -160,8 +160,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `u16`
   --> $DIR/numbers.rs:76:40
@@ -175,8 +175,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `i32`
   --> $DIR/numbers.rs:77:40
@@ -190,8 +190,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `f32`
   --> $DIR/numbers.rs:78:40
@@ -205,8 +205,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `u32`
   --> $DIR/numbers.rs:79:40
@@ -220,8 +220,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:80:40
@@ -235,8 +235,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:81:40
@@ -250,8 +250,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:82:40
@@ -265,8 +265,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:83:39
@@ -280,8 +280,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u8` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:84:39
@@ -295,8 +295,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `i32`
   --> $DIR/numbers.rs:86:40
@@ -310,8 +310,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `f32`
   --> $DIR/numbers.rs:87:40
@@ -325,8 +325,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `u32`
   --> $DIR/numbers.rs:88:40
@@ -340,8 +340,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:89:40
@@ -355,8 +355,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:90:40
@@ -370,8 +370,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:91:40
@@ -385,8 +385,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:92:39
@@ -400,8 +400,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i16` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:93:39
@@ -415,8 +415,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `i32`
   --> $DIR/numbers.rs:95:40
@@ -430,8 +430,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `f32`
   --> $DIR/numbers.rs:96:40
@@ -445,8 +445,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `u32`
   --> $DIR/numbers.rs:97:40
@@ -460,8 +460,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:98:40
@@ -475,8 +475,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:99:40
@@ -490,8 +490,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:100:40
@@ -505,8 +505,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:101:39
@@ -520,8 +520,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u16` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:102:39
@@ -535,8 +535,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i32` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:104:40
@@ -550,8 +550,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i32` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:105:40
@@ -565,8 +565,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i32` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:106:40
@@ -580,8 +580,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i32` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:107:39
@@ -595,8 +595,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i32` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:108:39
@@ -610,8 +610,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f32` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:110:40
@@ -625,8 +625,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f32` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:111:40
@@ -640,8 +640,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f32` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:112:40
@@ -655,8 +655,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f32` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:113:39
@@ -670,8 +670,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f32` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:114:39
@@ -685,8 +685,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u32` cannot be safely transmuted into `u64`
   --> $DIR/numbers.rs:116:40
@@ -700,8 +700,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u32` cannot be safely transmuted into `i64`
   --> $DIR/numbers.rs:117:40
@@ -715,8 +715,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u32` cannot be safely transmuted into `f64`
   --> $DIR/numbers.rs:118:40
@@ -730,8 +730,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u32` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:119:39
@@ -745,8 +745,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u32` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:120:39
@@ -760,8 +760,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u64` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:122:39
@@ -775,8 +775,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `u64` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:123:39
@@ -790,8 +790,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i64` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:125:39
@@ -805,8 +805,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `i64` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:126:39
@@ -820,8 +820,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f64` cannot be safely transmuted into `u128`
   --> $DIR/numbers.rs:128:39
@@ -835,8 +835,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `f64` cannot be safely transmuted into `i128`
   --> $DIR/numbers.rs:129:39
@@ -850,8 +850,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src>
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 57 previous errors
 
diff --git a/tests/ui/transmutability/primitives/numbers.rs b/tests/ui/transmutability/primitives/numbers.rs
index 401502474cfb8..b5c21c992b671 100644
--- a/tests/ui/transmutability/primitives/numbers.rs
+++ b/tests/ui/transmutability/primitives/numbers.rs
@@ -7,11 +7,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src>
+        Dst: TransmuteFrom<Src>
     {}
 }
 
diff --git a/tests/ui/transmutability/primitives/unit.current.stderr b/tests/ui/transmutability/primitives/unit.current.stderr
index 52b708d680e83..4bfb229832b3f 100644
--- a/tests/ui/transmutability/primitives/unit.current.stderr
+++ b/tests/ui/transmutability/primitives/unit.current.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
diff --git a/tests/ui/transmutability/primitives/unit.next.stderr b/tests/ui/transmutability/primitives/unit.next.stderr
index 52b708d680e83..4bfb229832b3f 100644
--- a/tests/ui/transmutability/primitives/unit.next.stderr
+++ b/tests/ui/transmutability/primitives/unit.next.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
diff --git a/tests/ui/transmutability/primitives/unit.rs b/tests/ui/transmutability/primitives/unit.rs
index 44216950f5572..93b21e0b58684 100644
--- a/tests/ui/transmutability/primitives/unit.rs
+++ b/tests/ui/transmutability/primitives/unit.rs
@@ -9,11 +9,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume::ALIGNMENT
                 .and(Assume::LIFETIMES)
                 .and(Assume::SAFETY)
diff --git a/tests/ui/transmutability/references/accept_assume_lifetime_extension.rs b/tests/ui/transmutability/references/accept_assume_lifetime_extension.rs
index 3bdd7256791ec..edad02fc96d22 100644
--- a/tests/ui/transmutability/references/accept_assume_lifetime_extension.rs
+++ b/tests/ui/transmutability/references/accept_assume_lifetime_extension.rs
@@ -4,11 +4,11 @@
 
 #![feature(transmutability, core_intrinsics)]
 
-use std::mem::{Assume, BikeshedIntrinsicFrom};
+use std::mem::{Assume, TransmuteFrom};
 
 unsafe fn transmute<Src, Dst>(src: Src) -> Dst
 where
-    Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::LIFETIMES) }>,
+    Dst: TransmuteFrom<Src, { Assume::SAFETY.and(Assume::LIFETIMES) }>,
 {
     core::intrinsics::transmute_unchecked(src)
 }
@@ -82,7 +82,7 @@ mod hrtb {
 
     unsafe fn extend_hrtb<'a>(src: &'a u8) -> &'static u8
     where
-        for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8, { Assume::LIFETIMES }>,
+        for<'b> &'b u8: TransmuteFrom<&'a u8, { Assume::LIFETIMES }>,
     {
         core::intrinsics::transmute_unchecked(src)
     }
diff --git a/tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs b/tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs
index 559ee23a44606..5734575e90bed 100644
--- a/tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs
+++ b/tests/ui/transmutability/references/accept_unexercised_lifetime_extension.rs
@@ -4,11 +4,11 @@
 
 #![feature(transmutability, core_intrinsics)]
 
-use std::mem::{Assume, BikeshedIntrinsicFrom};
+use std::mem::{Assume, TransmuteFrom};
 
 unsafe fn transmute<Src, Dst>(src: Src) -> Dst
 where
-    Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>,
+    Dst: TransmuteFrom<Src, { Assume::SAFETY }>,
 {
     core::intrinsics::transmute_unchecked(src)
 }
diff --git a/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible-mut.rs b/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible-mut.rs
index ba2db755e3b10..92068ee0d4f20 100644
--- a/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible-mut.rs
+++ b/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible-mut.rs
@@ -2,11 +2,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: false,
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 4b2866dc4f067..1698021d5541a 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
@@ -10,7 +10,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
diff --git a/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible.rs b/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible.rs
index cd70c27828541..8e2da3518a961 100644
--- a/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible.rs
+++ b/tests/ui/transmutability/references/recursive-wrapper-types-bit-compatible.rs
@@ -2,11 +2,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: false,
diff --git a/tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.rs b/tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.rs
index 2f264e8339e9a..01b176cc3c126 100644
--- a/tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.rs
+++ b/tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.rs
@@ -2,11 +2,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: false,
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 2b7cab1660d11..dbd3e39b36556 100644
--- a/tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.stderr
+++ b/tests/ui/transmutability/references/recursive-wrapper-types-bit-incompatible.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
diff --git a/tests/ui/transmutability/references/recursive-wrapper-types.rs b/tests/ui/transmutability/references/recursive-wrapper-types.rs
index 28f4d6661cb0d..53dedeb6388f5 100644
--- a/tests/ui/transmutability/references/recursive-wrapper-types.rs
+++ b/tests/ui/transmutability/references/recursive-wrapper-types.rs
@@ -2,11 +2,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: false,
diff --git a/tests/ui/transmutability/references/reject_extension.rs b/tests/ui/transmutability/references/reject_extension.rs
index 161da5772e874..dd02e5c01c481 100644
--- a/tests/ui/transmutability/references/reject_extension.rs
+++ b/tests/ui/transmutability/references/reject_extension.rs
@@ -6,11 +6,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<
+        Dst: TransmuteFrom<
             Src,
             {
                 Assume {
diff --git a/tests/ui/transmutability/references/reject_extension.stderr b/tests/ui/transmutability/references/reject_extension.stderr
index 88dd0313e3c86..182106acf12cf 100644
--- a/tests/ui/transmutability/references/reject_extension.stderr
+++ b/tests/ui/transmutability/references/reject_extension.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<
+LL |           Dst: TransmuteFrom<
    |  ______________^
 LL | |             Src,
 LL | |             {
diff --git a/tests/ui/transmutability/references/reject_lifetime_extension.rs b/tests/ui/transmutability/references/reject_lifetime_extension.rs
index 79bb4e1e55694..ff9290c34af92 100644
--- a/tests/ui/transmutability/references/reject_lifetime_extension.rs
+++ b/tests/ui/transmutability/references/reject_lifetime_extension.rs
@@ -4,11 +4,11 @@
 
 #![feature(transmutability, core_intrinsics)]
 
-use std::mem::{Assume, BikeshedIntrinsicFrom};
+use std::mem::{Assume, TransmuteFrom};
 
 unsafe fn transmute<Src, Dst>(src: Src) -> Dst
 where
-    Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>,
+    Dst: TransmuteFrom<Src, { Assume::SAFETY }>,
 {
     core::intrinsics::transmute_unchecked(src)
 }
@@ -82,7 +82,7 @@ mod hrtb {
 
     unsafe fn extend_hrtb<'a>(src: &'a u8) -> &'static u8
     where
-        for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8>,
+        for<'b> &'b u8: TransmuteFrom<&'a u8>,
     {
         core::intrinsics::transmute_unchecked(src)
     }
diff --git a/tests/ui/transmutability/references/reject_lifetime_extension.stderr b/tests/ui/transmutability/references/reject_lifetime_extension.stderr
index df1b81f26d2ba..a597041c6cac2 100644
--- a/tests/ui/transmutability/references/reject_lifetime_extension.stderr
+++ b/tests/ui/transmutability/references/reject_lifetime_extension.stderr
@@ -70,8 +70,8 @@ LL |         unsafe { extend_hrtb(src) }
 note: due to current limitations in the borrow checker, this implies a `'static` lifetime
   --> $DIR/reject_lifetime_extension.rs:85:25
    |
-LL |         for<'b> &'b u8: BikeshedIntrinsicFrom<&'a u8>,
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         for<'b> &'b u8: TransmuteFrom<&'a u8>,
+   |                         ^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 8 previous errors
 
diff --git a/tests/ui/transmutability/references/u8-to-unit.rs b/tests/ui/transmutability/references/u8-to-unit.rs
index 017b73d959548..98deb6457cb07 100644
--- a/tests/ui/transmutability/references/u8-to-unit.rs
+++ b/tests/ui/transmutability/references/u8-to-unit.rs
@@ -2,11 +2,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: false,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/references/unit-to-itself.rs b/tests/ui/transmutability/references/unit-to-itself.rs
index 40aec8418fef6..789455c03ea17 100644
--- a/tests/ui/transmutability/references/unit-to-itself.rs
+++ b/tests/ui/transmutability/references/unit-to-itself.rs
@@ -2,11 +2,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: false,
diff --git a/tests/ui/transmutability/references/unit-to-u8.rs b/tests/ui/transmutability/references/unit-to-u8.rs
index 973d3206c127d..575a40e3622e6 100644
--- a/tests/ui/transmutability/references/unit-to-u8.rs
+++ b/tests/ui/transmutability/references/unit-to-u8.rs
@@ -2,11 +2,11 @@
 #![feature(transmutability)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/references/unit-to-u8.stderr b/tests/ui/transmutability/references/unit-to-u8.stderr
index 5d73dfdc8eb72..b5a79b1917fd9 100644
--- a/tests/ui/transmutability/references/unit-to-u8.stderr
+++ b/tests/ui/transmutability/references/unit-to-u8.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
diff --git a/tests/ui/transmutability/references/unsafecell.rs b/tests/ui/transmutability/references/unsafecell.rs
index a8a1f969fb493..4001f139770a5 100644
--- a/tests/ui/transmutability/references/unsafecell.rs
+++ b/tests/ui/transmutability/references/unsafecell.rs
@@ -5,11 +5,11 @@
 use std::cell::UnsafeCell;
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY }>
     {}
 }
 
diff --git a/tests/ui/transmutability/references/unsafecell.stderr b/tests/ui/transmutability/references/unsafecell.stderr
index 8bb323593554a..6664d8a7d6fbc 100644
--- a/tests/ui/transmutability/references/unsafecell.stderr
+++ b/tests/ui/transmutability/references/unsafecell.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_maybe_transmutable`
 LL |     pub fn is_maybe_transmutable<Src, Dst>()
    |            --------------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
 
 error[E0277]: `&UnsafeCell<u8>` cannot be safely transmuted into `&UnsafeCell<u8>`
   --> $DIR/unsafecell.rs:29:62
@@ -25,8 +25,8 @@ note: required by a bound in `is_maybe_transmutable`
 LL |     pub fn is_maybe_transmutable<Src, Dst>()
    |            --------------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/transmutability/region-infer.rs b/tests/ui/transmutability/region-infer.rs
index 0632bc5317667..c164f35c44739 100644
--- a/tests/ui/transmutability/region-infer.rs
+++ b/tests/ui/transmutability/region-infer.rs
@@ -1,13 +1,13 @@
 #![feature(transmutability)]
 
-use std::mem::{Assume, BikeshedIntrinsicFrom};
+use std::mem::{Assume, TransmuteFrom};
 
 #[repr(C)]
 struct W<'a>(&'a ());
 
 fn test<'a>()
 where
-    W<'a>: BikeshedIntrinsicFrom<
+    W<'a>: TransmuteFrom<
             (),
             { Assume { alignment: true, lifetimes: true, safety: true, validity: true } },
         >,
diff --git a/tests/ui/transmutability/region-infer.stderr b/tests/ui/transmutability/region-infer.stderr
index 03c46823838d7..09ecf484bc893 100644
--- a/tests/ui/transmutability/region-infer.stderr
+++ b/tests/ui/transmutability/region-infer.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `test`
 LL |   fn test<'a>()
    |      ---- required by a bound in this function
 LL |   where
-LL |       W<'a>: BikeshedIntrinsicFrom<
+LL |       W<'a>: TransmuteFrom<
    |  ____________^
 LL | |             (),
 LL | |             { Assume { alignment: true, lifetimes: true, safety: true, validity: true } },
diff --git a/tests/ui/transmutability/safety/assume/should_accept_if_dst_has_safety_invariant.rs b/tests/ui/transmutability/safety/assume/should_accept_if_dst_has_safety_invariant.rs
index cb3c1cdf46cb6..0113049f51e53 100644
--- a/tests/ui/transmutability/safety/assume/should_accept_if_dst_has_safety_invariant.rs
+++ b/tests/ui/transmutability/safety/assume/should_accept_if_dst_has_safety_invariant.rs
@@ -8,11 +8,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY }>
     {}
 }
 
diff --git a/tests/ui/transmutability/safety/assume/should_accept_if_ref_src_has_safety_invariant.rs b/tests/ui/transmutability/safety/assume/should_accept_if_ref_src_has_safety_invariant.rs
index b12c4a10d12b7..eca7a06559d21 100644
--- a/tests/ui/transmutability/safety/assume/should_accept_if_ref_src_has_safety_invariant.rs
+++ b/tests/ui/transmutability/safety/assume/should_accept_if_ref_src_has_safety_invariant.rs
@@ -8,11 +8,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY }>
     {}
 }
 
diff --git a/tests/ui/transmutability/safety/assume/should_accept_if_src_has_safety_invariant.rs b/tests/ui/transmutability/safety/assume/should_accept_if_src_has_safety_invariant.rs
index ff01462ffec51..46e84b48044f5 100644
--- a/tests/ui/transmutability/safety/assume/should_accept_if_src_has_safety_invariant.rs
+++ b/tests/ui/transmutability/safety/assume/should_accept_if_src_has_safety_invariant.rs
@@ -8,11 +8,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY }>
     {}
 }
 
diff --git a/tests/ui/transmutability/safety/should_accept_if_src_has_safety_invariant.rs b/tests/ui/transmutability/safety/should_accept_if_src_has_safety_invariant.rs
index d516e9a7da584..aaba6febde4e8 100644
--- a/tests/ui/transmutability/safety/should_accept_if_src_has_safety_invariant.rs
+++ b/tests/ui/transmutability/safety/should_accept_if_src_has_safety_invariant.rs
@@ -8,11 +8,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src> // safety is NOT assumed
+        Dst: TransmuteFrom<Src> // safety is NOT assumed
     {}
 }
 
diff --git a/tests/ui/transmutability/safety/should_reject_if_dst_has_safety_invariant.rs b/tests/ui/transmutability/safety/should_reject_if_dst_has_safety_invariant.rs
index 4f0aee3154850..6f8e383db1f0b 100644
--- a/tests/ui/transmutability/safety/should_reject_if_dst_has_safety_invariant.rs
+++ b/tests/ui/transmutability/safety/should_reject_if_dst_has_safety_invariant.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src> // safety is NOT assumed
+        Dst: TransmuteFrom<Src> // safety is NOT assumed
     {}
 }
 
diff --git a/tests/ui/transmutability/safety/should_reject_if_dst_has_safety_invariant.stderr b/tests/ui/transmutability/safety/should_reject_if_dst_has_safety_invariant.stderr
index 2339c2683267b..6445b1e146ede 100644
--- a/tests/ui/transmutability/safety/should_reject_if_dst_has_safety_invariant.stderr
+++ b/tests/ui/transmutability/safety/should_reject_if_dst_has_safety_invariant.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src> // safety is NOT assumed
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src> // safety is NOT assumed
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/transmutability/safety/should_reject_if_ref_src_has_safety_invariant.rs b/tests/ui/transmutability/safety/should_reject_if_ref_src_has_safety_invariant.rs
index 126059dd7b7d7..16d163d5420b3 100644
--- a/tests/ui/transmutability/safety/should_reject_if_ref_src_has_safety_invariant.rs
+++ b/tests/ui/transmutability/safety/should_reject_if_ref_src_has_safety_invariant.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::BikeshedIntrinsicFrom;
+    use std::mem::TransmuteFrom;
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src> // safety is NOT assumed
+        Dst: TransmuteFrom<Src> // safety is NOT assumed
     {}
 }
 
diff --git a/tests/ui/transmutability/safety/should_reject_if_ref_src_has_safety_invariant.stderr b/tests/ui/transmutability/safety/should_reject_if_ref_src_has_safety_invariant.stderr
index 99feebe92118e..38ef829f06438 100644
--- a/tests/ui/transmutability/safety/should_reject_if_ref_src_has_safety_invariant.stderr
+++ b/tests/ui/transmutability/safety/should_reject_if_ref_src_has_safety_invariant.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src> // safety is NOT assumed
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src> // safety is NOT assumed
+   |              ^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/transmutability/structs/repr/should_handle_align.rs b/tests/ui/transmutability/structs/repr/should_handle_align.rs
index 0c207766045c1..03065298b50e0 100644
--- a/tests/ui/transmutability/structs/repr/should_handle_align.rs
+++ b/tests/ui/transmutability/structs/repr/should_handle_align.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/structs/repr/should_handle_all.rs b/tests/ui/transmutability/structs/repr/should_handle_all.rs
index 52c24eecf1246..e5ca37e68ec6b 100644
--- a/tests/ui/transmutability/structs/repr/should_handle_all.rs
+++ b/tests/ui/transmutability/structs/repr/should_handle_all.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/structs/repr/should_handle_packed.rs b/tests/ui/transmutability/structs/repr/should_handle_packed.rs
index 4af32d6e84e56..c9be32d7b2a2d 100644
--- a/tests/ui/transmutability/structs/repr/should_handle_packed.rs
+++ b/tests/ui/transmutability/structs/repr/should_handle_packed.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.rs b/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.rs
index 4c285a616b3d9..8d291054365f9 100644
--- a/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.rs
+++ b/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.rs
@@ -7,11 +7,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src>,
+        Dst: TransmuteFrom<Src>,
     {
     }
 }
diff --git a/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.stderr b/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.stderr
index 7fb051f66250e..bdf2d3b6a58f8 100644
--- a/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.stderr
+++ b/tests/ui/transmutability/structs/repr/transmute_infinitely_recursive_type.stderr
@@ -12,7 +12,7 @@ LL |     struct ExplicitlyPadded(Box<ExplicitlyPadded>);
 error[E0391]: cycle detected when computing layout of `should_pad_explicitly_packed_field::ExplicitlyPadded`
    |
    = note: ...which immediately requires computing layout of `should_pad_explicitly_packed_field::ExplicitlyPadded` again
-   = note: cycle used when evaluating trait selection obligation `(): core::mem::transmutability::BikeshedIntrinsicFrom<should_pad_explicitly_packed_field::ExplicitlyPadded, core::mem::transmutability::Assume { alignment: false, lifetimes: false, safety: false, validity: false }>`
+   = note: cycle used when evaluating trait selection obligation `(): core::mem::transmutability::TransmuteFrom<should_pad_explicitly_packed_field::ExplicitlyPadded, core::mem::transmutability::Assume { alignment: false, lifetimes: false, safety: false, validity: false }>`
    = 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 2 previous errors
diff --git a/tests/ui/transmutability/structs/should_order_fields_correctly.rs b/tests/ui/transmutability/structs/should_order_fields_correctly.rs
index 3675e4330ecc8..aa9ca39eff241 100644
--- a/tests/ui/transmutability/structs/should_order_fields_correctly.rs
+++ b/tests/ui/transmutability/structs/should_order_fields_correctly.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume::ALIGNMENT
                 .and(Assume::LIFETIMES)
                 .and(Assume::SAFETY)
diff --git a/tests/ui/transmutability/transmute-padding-ice.rs b/tests/ui/transmutability/transmute-padding-ice.rs
index f5935a0009e77..133241c89cbf5 100644
--- a/tests/ui/transmutability/transmute-padding-ice.rs
+++ b/tests/ui/transmutability/transmute-padding-ice.rs
@@ -9,11 +9,11 @@
 use std::mem::size_of;
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<
+        Dst: TransmuteFrom<
             Src,
             { Assume { alignment: true, lifetimes: true, safety: true, validity: true } },
         >,
diff --git a/tests/ui/transmutability/uninhabited.rs b/tests/ui/transmutability/uninhabited.rs
index 7524922c16a7e..74f7a1a2e898f 100644
--- a/tests/ui/transmutability/uninhabited.rs
+++ b/tests/ui/transmutability/uninhabited.rs
@@ -3,11 +3,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/uninhabited.stderr b/tests/ui/transmutability/uninhabited.stderr
index 88a98c798fc3d..3fa02f0867ccb 100644
--- a/tests/ui/transmutability/uninhabited.stderr
+++ b/tests/ui/transmutability/uninhabited.stderr
@@ -34,7 +34,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -56,7 +56,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -78,7 +78,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
@@ -100,7 +100,7 @@ note: required by a bound in `is_maybe_transmutable`
 LL |       pub fn is_maybe_transmutable<Src, Dst>()
    |              --------------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume {
 LL | |                 alignment: true,
diff --git a/tests/ui/transmutability/unions/boolish.rs b/tests/ui/transmutability/unions/boolish.rs
index c829f83149e36..838643defd5dd 100644
--- a/tests/ui/transmutability/unions/boolish.rs
+++ b/tests/ui/transmutability/unions/boolish.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY }>
     {}
 }
 
diff --git a/tests/ui/transmutability/unions/repr/should_handle_align.rs b/tests/ui/transmutability/unions/repr/should_handle_align.rs
index ba4e904e16197..0605651bd7bb1 100644
--- a/tests/ui/transmutability/unions/repr/should_handle_align.rs
+++ b/tests/ui/transmutability/unions/repr/should_handle_align.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/unions/repr/should_handle_all.rs b/tests/ui/transmutability/unions/repr/should_handle_all.rs
index 85d48dd9b7ff1..8505c7f9123ee 100644
--- a/tests/ui/transmutability/unions/repr/should_handle_all.rs
+++ b/tests/ui/transmutability/unions/repr/should_handle_all.rs
@@ -5,11 +5,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/unions/repr/should_handle_packed.rs b/tests/ui/transmutability/unions/repr/should_handle_packed.rs
index fc06eba4353b2..5e9851ab0c984 100644
--- a/tests/ui/transmutability/unions/repr/should_handle_packed.rs
+++ b/tests/ui/transmutability/unions/repr/should_handle_packed.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume {
                 alignment: true,
                 lifetimes: true,
diff --git a/tests/ui/transmutability/unions/should_pad_variants.rs b/tests/ui/transmutability/unions/should_pad_variants.rs
index 1e4d2db8f74c2..986c7fafb8552 100644
--- a/tests/ui/transmutability/unions/should_pad_variants.rs
+++ b/tests/ui/transmutability/unions/should_pad_variants.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, {
+        Dst: TransmuteFrom<Src, {
             Assume::ALIGNMENT
                 .and(Assume::LIFETIMES)
                 .and(Assume::SAFETY)
diff --git a/tests/ui/transmutability/unions/should_pad_variants.stderr b/tests/ui/transmutability/unions/should_pad_variants.stderr
index da4294bdbce8c..bb26281c2f0ba 100644
--- a/tests/ui/transmutability/unions/should_pad_variants.stderr
+++ b/tests/ui/transmutability/unions/should_pad_variants.stderr
@@ -10,7 +10,7 @@ note: required by a bound in `is_transmutable`
 LL |       pub fn is_transmutable<Src, Dst>()
    |              --------------- required by a bound in this function
 LL |       where
-LL |           Dst: BikeshedIntrinsicFrom<Src, {
+LL |           Dst: TransmuteFrom<Src, {
    |  ______________^
 LL | |             Assume::ALIGNMENT
 LL | |                 .and(Assume::LIFETIMES)
diff --git a/tests/ui/transmutability/unions/should_permit_intersecting_if_validity_is_assumed.rs b/tests/ui/transmutability/unions/should_permit_intersecting_if_validity_is_assumed.rs
index 7efe9ac70f169..359ba51543981 100644
--- a/tests/ui/transmutability/unions/should_permit_intersecting_if_validity_is_assumed.rs
+++ b/tests/ui/transmutability/unions/should_permit_intersecting_if_validity_is_assumed.rs
@@ -7,11 +7,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
     {}
 }
 
diff --git a/tests/ui/transmutability/unions/should_reject_contraction.rs b/tests/ui/transmutability/unions/should_reject_contraction.rs
index 62a0ee929192f..87398328fc7dd 100644
--- a/tests/ui/transmutability/unions/should_reject_contraction.rs
+++ b/tests/ui/transmutability/unions/should_reject_contraction.rs
@@ -5,11 +5,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY }>
     {}
 }
 
diff --git a/tests/ui/transmutability/unions/should_reject_contraction.stderr b/tests/ui/transmutability/unions/should_reject_contraction.stderr
index 20eaa3a6b095c..ea68de14efc01 100644
--- a/tests/ui/transmutability/unions/should_reject_contraction.stderr
+++ b/tests/ui/transmutability/unions/should_reject_contraction.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/transmutability/unions/should_reject_disjoint.rs b/tests/ui/transmutability/unions/should_reject_disjoint.rs
index 732f92e81606b..0427e3c44a240 100644
--- a/tests/ui/transmutability/unions/should_reject_disjoint.rs
+++ b/tests/ui/transmutability/unions/should_reject_disjoint.rs
@@ -5,11 +5,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_maybe_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
     {}
 }
 
diff --git a/tests/ui/transmutability/unions/should_reject_disjoint.stderr b/tests/ui/transmutability/unions/should_reject_disjoint.stderr
index ea47797c97056..d55abbe081776 100644
--- a/tests/ui/transmutability/unions/should_reject_disjoint.stderr
+++ b/tests/ui/transmutability/unions/should_reject_disjoint.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_maybe_transmutable`
 LL |     pub fn is_maybe_transmutable<Src, Dst>()
    |            --------------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
 
 error[E0277]: `B` cannot be safely transmuted into `A`
   --> $DIR/should_reject_disjoint.rs:33:40
@@ -25,8 +25,8 @@ note: required by a bound in `is_maybe_transmutable`
 LL |     pub fn is_maybe_transmutable<Src, Dst>()
    |            --------------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY.and(Assume::VALIDITY) }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_maybe_transmutable`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/transmutability/unions/should_reject_intersecting.rs b/tests/ui/transmutability/unions/should_reject_intersecting.rs
index 752a606c861a6..9b3b18919f529 100644
--- a/tests/ui/transmutability/unions/should_reject_intersecting.rs
+++ b/tests/ui/transmutability/unions/should_reject_intersecting.rs
@@ -6,11 +6,11 @@
 #![allow(dead_code, incomplete_features, non_camel_case_types)]
 
 mod assert {
-    use std::mem::{Assume, BikeshedIntrinsicFrom};
+    use std::mem::{Assume, TransmuteFrom};
 
     pub fn is_transmutable<Src, Dst>()
     where
-        Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
+        Dst: TransmuteFrom<Src, { Assume::SAFETY }>
         // validity is NOT assumed -----^^^^^^^^^^^^^^^^^^
     {}
 }
diff --git a/tests/ui/transmutability/unions/should_reject_intersecting.stderr b/tests/ui/transmutability/unions/should_reject_intersecting.stderr
index 79dec659d9db6..522681d7d1578 100644
--- a/tests/ui/transmutability/unions/should_reject_intersecting.stderr
+++ b/tests/ui/transmutability/unions/should_reject_intersecting.stderr
@@ -10,8 +10,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error[E0277]: `B` cannot be safely transmuted into `A`
   --> $DIR/should_reject_intersecting.rs:36:34
@@ -25,8 +25,8 @@ note: required by a bound in `is_transmutable`
 LL |     pub fn is_transmutable<Src, Dst>()
    |            --------------- required by a bound in this function
 LL |     where
-LL |         Dst: BikeshedIntrinsicFrom<Src, { Assume::SAFETY }>
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
+LL |         Dst: TransmuteFrom<Src, { Assume::SAFETY }>
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_transmutable`
 
 error: aborting due to 2 previous errors
 

From c3000ad3baf4c135abc5740c09f726a8862c2ac3 Mon Sep 17 00:00:00 2001
From: jdonszelmann <jonabent@gmail.com>
Date: Thu, 22 Aug 2024 19:48:39 +0200
Subject: [PATCH 662/685] add repr to the allowlist for naked functions, and
 test that it works

---
 compiler/rustc_passes/src/check_attr.rs |  1 +
 tests/codegen/naked-fn/aligned.rs       | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+)
 create mode 100644 tests/codegen/naked-fn/aligned.rs

diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index c93fb5c23b1c4..be2b01309c59e 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -516,6 +516,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             sym::no_mangle,
             sym::naked,
             sym::instruction_set,
+            sym::repr,
             // code generation
             sym::cold,
             sym::target_feature,
diff --git a/tests/codegen/naked-fn/aligned.rs b/tests/codegen/naked-fn/aligned.rs
new file mode 100644
index 0000000000000..d5faac44836fe
--- /dev/null
+++ b/tests/codegen/naked-fn/aligned.rs
@@ -0,0 +1,20 @@
+//@ compile-flags: -C no-prepopulate-passes -Copt-level=0
+//@ needs-asm-support
+//@ ignore-arm no "ret" mnemonic
+
+#![crate_type = "lib"]
+#![feature(naked_functions, fn_align)]
+use std::arch::asm;
+
+// CHECK: Function Attrs: naked
+// CHECK-NEXT: define{{.*}}void @naked_empty()
+// CHECK: align 16
+#[repr(align(16))]
+#[no_mangle]
+#[naked]
+pub unsafe extern "C" fn naked_empty() {
+    // CHECK-NEXT: start:
+    // CHECK-NEXT: call void asm
+    // CHECK-NEXT: unreachable
+    asm!("ret", options(noreturn));
+}

From a507ec644c95c2251f41620d65ea254ee66b865d Mon Sep 17 00:00:00 2001
From: jdonszelmann <jonabent@gmail.com>
Date: Tue, 27 Aug 2024 16:46:39 +0200
Subject: [PATCH 663/685] add uitest for naked functions and the repr attr on
 functions

---
 tests/ui/asm/naked-with-invalid-repr-attr.rs  | 48 ++++++++++++
 .../asm/naked-with-invalid-repr-attr.stderr   | 77 +++++++++++++++++++
 2 files changed, 125 insertions(+)
 create mode 100644 tests/ui/asm/naked-with-invalid-repr-attr.rs
 create mode 100644 tests/ui/asm/naked-with-invalid-repr-attr.stderr

diff --git a/tests/ui/asm/naked-with-invalid-repr-attr.rs b/tests/ui/asm/naked-with-invalid-repr-attr.rs
new file mode 100644
index 0000000000000..687fe1ad73db1
--- /dev/null
+++ b/tests/ui/asm/naked-with-invalid-repr-attr.rs
@@ -0,0 +1,48 @@
+//@ needs-asm-support
+#![feature(naked_functions)]
+#![feature(fn_align)]
+#![crate_type = "lib"]
+use std::arch::asm;
+
+#[repr(C)]
+//~^ ERROR attribute should be applied to a struct, enum, or union [E0517]
+#[naked]
+extern "C" fn example1() {
+    //~^ NOTE not a struct, enum, or union
+    unsafe { asm!("", options(noreturn)) }
+}
+
+#[repr(transparent)]
+//~^ ERROR attribute should be applied to a struct, enum, or union [E0517]
+#[naked]
+extern "C" fn example2() {
+    //~^ NOTE not a struct, enum, or union
+    unsafe { asm!("", options(noreturn)) }
+}
+
+#[repr(align(16), C)]
+//~^ ERROR attribute should be applied to a struct, enum, or union [E0517]
+#[naked]
+extern "C" fn example3() {
+    //~^ NOTE not a struct, enum, or union
+    unsafe { asm!("", options(noreturn)) }
+}
+
+// note: two errors because of packed and C
+#[repr(C, packed)]
+//~^ ERROR attribute should be applied to a struct or union [E0517]
+//~| ERROR attribute should be applied to a struct, enum, or union [E0517]
+#[naked]
+extern "C" fn example4() {
+    //~^ NOTE not a struct, enum, or union
+    //~| NOTE not a struct or union
+    unsafe { asm!("", options(noreturn)) }
+}
+
+#[repr(u8)]
+//~^ ERROR attribute should be applied to an enum [E0517]
+#[naked]
+extern "C" fn example5() {
+    //~^ NOTE not an enum
+    unsafe { asm!("", options(noreturn)) }
+}
diff --git a/tests/ui/asm/naked-with-invalid-repr-attr.stderr b/tests/ui/asm/naked-with-invalid-repr-attr.stderr
new file mode 100644
index 0000000000000..3740f17a9dc32
--- /dev/null
+++ b/tests/ui/asm/naked-with-invalid-repr-attr.stderr
@@ -0,0 +1,77 @@
+error[E0517]: attribute should be applied to a struct, enum, or union
+  --> $DIR/naked-with-invalid-repr-attr.rs:7:8
+   |
+LL |   #[repr(C)]
+   |          ^
+...
+LL | / extern "C" fn example1() {
+LL | |
+LL | |     unsafe { asm!("", options(noreturn)) }
+LL | | }
+   | |_- not a struct, enum, or union
+
+error[E0517]: attribute should be applied to a struct, enum, or union
+  --> $DIR/naked-with-invalid-repr-attr.rs:15:8
+   |
+LL |   #[repr(transparent)]
+   |          ^^^^^^^^^^^
+...
+LL | / extern "C" fn example2() {
+LL | |
+LL | |     unsafe { asm!("", options(noreturn)) }
+LL | | }
+   | |_- not a struct, enum, or union
+
+error[E0517]: attribute should be applied to a struct, enum, or union
+  --> $DIR/naked-with-invalid-repr-attr.rs:23:19
+   |
+LL |   #[repr(align(16), C)]
+   |                     ^
+...
+LL | / extern "C" fn example3() {
+LL | |
+LL | |     unsafe { asm!("", options(noreturn)) }
+LL | | }
+   | |_- not a struct, enum, or union
+
+error[E0517]: attribute should be applied to a struct, enum, or union
+  --> $DIR/naked-with-invalid-repr-attr.rs:32:8
+   |
+LL |   #[repr(C, packed)]
+   |          ^
+...
+LL | / extern "C" fn example4() {
+LL | |
+LL | |
+LL | |     unsafe { asm!("", options(noreturn)) }
+LL | | }
+   | |_- not a struct, enum, or union
+
+error[E0517]: attribute should be applied to a struct or union
+  --> $DIR/naked-with-invalid-repr-attr.rs:32:11
+   |
+LL |   #[repr(C, packed)]
+   |             ^^^^^^
+...
+LL | / extern "C" fn example4() {
+LL | |
+LL | |
+LL | |     unsafe { asm!("", options(noreturn)) }
+LL | | }
+   | |_- not a struct or union
+
+error[E0517]: attribute should be applied to an enum
+  --> $DIR/naked-with-invalid-repr-attr.rs:42:8
+   |
+LL |   #[repr(u8)]
+   |          ^^
+...
+LL | / extern "C" fn example5() {
+LL | |
+LL | |     unsafe { asm!("", options(noreturn)) }
+LL | | }
+   | |_- not an enum
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0517`.

From 169b2f0e6dfd534a21372e0c9f1f4357149f112a Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Wed, 21 Aug 2024 22:22:18 -0700
Subject: [PATCH 664/685] library: Stabilize new_uninit for Box, Rc, and Arc

A partial stabilization that only affects:
- AllocType<T>::new_uninit
- AllocType<T>::assume_init
- AllocType<[T]>::new_uninit_slice
- AllocType<[T]>::assume_init
where "AllocType" is Box, Rc, or Arc
---
 library/alloc/src/boxed.rs    | 43 +++++++++++++----------------------
 library/alloc/src/lib.rs      |  1 -
 library/alloc/src/rc.rs       | 26 +++++++--------------
 library/alloc/src/sync.rs     | 26 +++++++--------------
 library/alloc/tests/lib.rs    |  1 -
 library/proc_macro/src/lib.rs |  1 -
 library/std/src/lib.rs        |  1 -
 7 files changed, 32 insertions(+), 67 deletions(-)

diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index caaf37f0465ed..38b1766c17440 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -262,8 +262,6 @@ impl<T> Box<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
-    ///
     /// let mut five = Box::<u32>::new_uninit();
     ///
     /// let five = unsafe {
@@ -276,7 +274,7 @@ impl<T> Box<T> {
     /// assert_eq!(*five, 5)
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     #[inline]
     pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
@@ -292,7 +290,6 @@ impl<T> Box<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(new_zeroed_alloc)]
     ///
     /// let zero = Box::<u32>::new_zeroed();
@@ -350,7 +347,7 @@ impl<T> Box<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// let mut five = Box::<u32>::try_new_uninit()?;
     ///
@@ -380,7 +377,7 @@ impl<T> Box<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// let zero = Box::<u32>::try_new_zeroed()?;
     /// let zero = unsafe { zero.assume_init() };
@@ -460,7 +457,7 @@ impl<T, A: Allocator> Box<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::alloc::System;
     ///
@@ -498,7 +495,7 @@ impl<T, A: Allocator> Box<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::alloc::System;
     ///
@@ -538,7 +535,7 @@ impl<T, A: Allocator> Box<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::alloc::System;
     ///
@@ -576,7 +573,7 @@ impl<T, A: Allocator> Box<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::alloc::System;
     ///
@@ -654,8 +651,6 @@ impl<T> Box<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
-    ///
     /// let mut values = Box::<[u32]>::new_uninit_slice(3);
     ///
     /// let values = unsafe {
@@ -670,7 +665,7 @@ impl<T> Box<[T]> {
     /// assert_eq!(*values, [1, 2, 3])
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
         unsafe { RawVec::with_capacity(len).into_box(len) }
@@ -686,7 +681,6 @@ impl<T> Box<[T]> {
     ///
     /// ```
     /// #![feature(new_zeroed_alloc)]
-    /// #![feature(new_uninit)]
     ///
     /// let values = Box::<[u32]>::new_zeroed_slice(3);
     /// let values = unsafe { values.assume_init() };
@@ -708,7 +702,7 @@ impl<T> Box<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// let mut values = Box::<[u32]>::try_new_uninit_slice(3)?;
     /// let values = unsafe {
@@ -746,7 +740,7 @@ impl<T> Box<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// let values = Box::<[u32]>::try_new_zeroed_slice(3)?;
     /// let values = unsafe { values.assume_init() };
@@ -778,7 +772,7 @@ impl<T, A: Allocator> Box<[T], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::alloc::System;
     ///
@@ -812,7 +806,7 @@ impl<T, A: Allocator> Box<[T], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::alloc::System;
     ///
@@ -837,7 +831,7 @@ impl<T, A: Allocator> Box<[T], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::alloc::System;
     ///
@@ -880,7 +874,7 @@ impl<T, A: Allocator> Box<[T], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::alloc::System;
     ///
@@ -927,8 +921,6 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
-    ///
     /// let mut five = Box::<u32>::new_uninit();
     ///
     /// let five: Box<u32> = unsafe {
@@ -940,7 +932,7 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
     ///
     /// assert_eq!(*five, 5)
     /// ```
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub unsafe fn assume_init(self) -> Box<T, A> {
         let (raw, alloc) = Box::into_raw_with_allocator(self);
@@ -958,7 +950,6 @@ impl<T, A: Allocator> Box<mem::MaybeUninit<T>, A> {
     ///
     /// ```
     /// #![feature(box_uninit_write)]
-    /// #![feature(new_uninit)]
     ///
     /// let big_box = Box::<[usize; 1024]>::new_uninit();
     ///
@@ -1001,8 +992,6 @@ impl<T, A: Allocator> Box<[mem::MaybeUninit<T>], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
-    ///
     /// let mut values = Box::<[u32]>::new_uninit_slice(3);
     ///
     /// let values = unsafe {
@@ -1016,7 +1005,7 @@ impl<T, A: Allocator> Box<[mem::MaybeUninit<T>], A> {
     ///
     /// assert_eq!(*values, [1, 2, 3])
     /// ```
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub unsafe fn assume_init(self) -> Box<[T], A> {
         let (raw, alloc) = Box::into_raw_with_allocator(self);
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index 5e4b08df6cb55..c459a8da820f6 100644
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -93,7 +93,6 @@
 // tidy-alphabetical-start
 #![cfg_attr(not(no_global_oom_handling), feature(const_alloc_error))]
 #![cfg_attr(not(no_global_oom_handling), feature(const_btree_len))]
-#![cfg_attr(test, feature(new_uninit))]
 #![feature(alloc_layout_extra)]
 #![feature(allocator_api)]
 #![feature(array_chunks)]
diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index f153aa6d3be9a..1b31a78394eca 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -503,7 +503,6 @@ impl<T> Rc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::rc::Rc;
@@ -518,7 +517,7 @@ impl<T> Rc<T> {
     /// assert_eq!(*five, 5)
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_uninit() -> Rc<mem::MaybeUninit<T>> {
         unsafe {
@@ -540,7 +539,6 @@ impl<T> Rc<T> {
     ///
     /// ```
     /// #![feature(new_zeroed_alloc)]
-    /// #![feature(new_uninit)]
     ///
     /// use std::rc::Rc;
     ///
@@ -594,7 +592,7 @@ impl<T> Rc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::rc::Rc;
@@ -630,7 +628,7 @@ impl<T> Rc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::rc::Rc;
     ///
@@ -692,7 +690,6 @@ impl<T, A: Allocator> Rc<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     /// #![feature(allocator_api)]
     ///
@@ -736,7 +733,6 @@ impl<T, A: Allocator> Rc<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(allocator_api)]
     ///
     /// use std::rc::Rc;
@@ -799,7 +795,7 @@ impl<T, A: Allocator> Rc<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::rc::Rc;
@@ -843,7 +839,7 @@ impl<T, A: Allocator> Rc<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(allocator_api, new_uninit)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::rc::Rc;
     /// use std::alloc::System;
@@ -967,7 +963,6 @@ impl<T> Rc<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::rc::Rc;
@@ -985,7 +980,7 @@ impl<T> Rc<[T]> {
     /// assert_eq!(*values, [1, 2, 3])
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_uninit_slice(len: usize) -> Rc<[mem::MaybeUninit<T>]> {
         unsafe { Rc::from_ptr(Rc::allocate_for_slice(len)) }
@@ -1000,7 +995,6 @@ impl<T> Rc<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(new_zeroed_alloc)]
     ///
     /// use std::rc::Rc;
@@ -1035,7 +1029,6 @@ impl<T, A: Allocator> Rc<[T], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     /// #![feature(allocator_api)]
     ///
@@ -1072,7 +1065,6 @@ impl<T, A: Allocator> Rc<[T], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(allocator_api)]
     ///
     /// use std::rc::Rc;
@@ -1122,7 +1114,6 @@ impl<T, A: Allocator> Rc<mem::MaybeUninit<T>, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::rc::Rc;
@@ -1136,7 +1127,7 @@ impl<T, A: Allocator> Rc<mem::MaybeUninit<T>, A> {
     ///
     /// assert_eq!(*five, 5)
     /// ```
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub unsafe fn assume_init(self) -> Rc<T, A> {
         let (ptr, alloc) = Rc::into_inner_with_allocator(self);
@@ -1160,7 +1151,6 @@ impl<T, A: Allocator> Rc<[mem::MaybeUninit<T>], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::rc::Rc;
@@ -1177,7 +1167,7 @@ impl<T, A: Allocator> Rc<[mem::MaybeUninit<T>], A> {
     ///
     /// assert_eq!(*values, [1, 2, 3])
     /// ```
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[inline]
     pub unsafe fn assume_init(self) -> Rc<[T], A> {
         let (ptr, alloc) = Rc::into_inner_with_allocator(self);
diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index 4a3522f1a641b..aac768eb0535a 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -505,7 +505,6 @@ impl<T> Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::sync::Arc;
@@ -521,7 +520,7 @@ impl<T> Arc<T> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_uninit() -> Arc<mem::MaybeUninit<T>> {
         unsafe {
@@ -543,7 +542,6 @@ impl<T> Arc<T> {
     ///
     /// ```
     /// #![feature(new_zeroed_alloc)]
-    /// #![feature(new_uninit)]
     ///
     /// use std::sync::Arc;
     ///
@@ -614,7 +612,7 @@ impl<T> Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit, allocator_api)]
+    /// #![feature(allocator_api)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::sync::Arc;
@@ -650,7 +648,7 @@ impl<T> Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit, allocator_api)]
+    /// #![feature( allocator_api)]
     ///
     /// use std::sync::Arc;
     ///
@@ -711,7 +709,6 @@ impl<T, A: Allocator> Arc<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     /// #![feature(allocator_api)]
     ///
@@ -755,7 +752,6 @@ impl<T, A: Allocator> Arc<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(allocator_api)]
     ///
     /// use std::sync::Arc;
@@ -845,7 +841,7 @@ impl<T, A: Allocator> Arc<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit, allocator_api)]
+    /// #![feature(allocator_api)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::sync::Arc;
@@ -889,7 +885,7 @@ impl<T, A: Allocator> Arc<T, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit, allocator_api)]
+    /// #![feature(allocator_api)]
     ///
     /// use std::sync::Arc;
     /// use std::alloc::System;
@@ -1101,7 +1097,6 @@ impl<T> Arc<[T]> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::sync::Arc;
@@ -1120,7 +1115,7 @@ impl<T> Arc<[T]> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[must_use]
     pub fn new_uninit_slice(len: usize) -> Arc<[mem::MaybeUninit<T>]> {
         unsafe { Arc::from_ptr(Arc::allocate_for_slice(len)) }
@@ -1136,7 +1131,6 @@ impl<T> Arc<[T]> {
     ///
     /// ```
     /// #![feature(new_zeroed_alloc)]
-    /// #![feature(new_uninit)]
     ///
     /// use std::sync::Arc;
     ///
@@ -1172,7 +1166,6 @@ impl<T, A: Allocator> Arc<[T], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     /// #![feature(allocator_api)]
     ///
@@ -1208,7 +1201,6 @@ impl<T, A: Allocator> Arc<[T], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(allocator_api)]
     ///
     /// use std::sync::Arc;
@@ -1257,7 +1249,6 @@ impl<T, A: Allocator> Arc<mem::MaybeUninit<T>, A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::sync::Arc;
@@ -1271,7 +1262,7 @@ impl<T, A: Allocator> Arc<mem::MaybeUninit<T>, A> {
     ///
     /// assert_eq!(*five, 5)
     /// ```
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[must_use = "`self` will be dropped if the result is not used"]
     #[inline]
     pub unsafe fn assume_init(self) -> Arc<T, A> {
@@ -1296,7 +1287,6 @@ impl<T, A: Allocator> Arc<[mem::MaybeUninit<T>], A> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(new_uninit)]
     /// #![feature(get_mut_unchecked)]
     ///
     /// use std::sync::Arc;
@@ -1313,7 +1303,7 @@ impl<T, A: Allocator> Arc<[mem::MaybeUninit<T>], A> {
     ///
     /// assert_eq!(*values, [1, 2, 3])
     /// ```
-    #[unstable(feature = "new_uninit", issue = "63291")]
+    #[stable(feature = "new_uninit", since = "CURRENT_RUSTC_VERSION")]
     #[must_use = "`self` will be dropped if the result is not used"]
     #[inline]
     pub unsafe fn assume_init(self) -> Arc<[T], A> {
diff --git a/library/alloc/tests/lib.rs b/library/alloc/tests/lib.rs
index 3d4add6fae452..c5c6a122cfec8 100644
--- a/library/alloc/tests/lib.rs
+++ b/library/alloc/tests/lib.rs
@@ -15,7 +15,6 @@
 #![feature(exact_size_is_empty)]
 #![feature(linked_list_cursors)]
 #![feature(map_try_insert)]
-#![feature(new_uninit)]
 #![feature(pattern)]
 #![feature(trusted_len)]
 #![feature(try_reserve_kind)]
diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index c271ac1870624..72b53c60f7439 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -28,7 +28,6 @@
 #![feature(decl_macro)]
 #![feature(maybe_uninit_write_slice)]
 #![feature(negative_impls)]
-#![feature(new_uninit)]
 #![feature(panic_can_unwind)]
 #![feature(restricted_std)]
 #![feature(rustc_attrs)]
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index f65e9bc8d8b5a..bea8eda261968 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -362,7 +362,6 @@
 #![feature(allocator_api)]
 #![feature(get_mut_unchecked)]
 #![feature(map_try_insert)]
-#![feature(new_uninit)]
 #![feature(new_zeroed_alloc)]
 #![feature(slice_concat_trait)]
 #![feature(thin_box)]

From 2535a0f7762141f0f826a94464fac2a4ae23b58b Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Wed, 21 Aug 2024 22:54:38 -0700
Subject: [PATCH 665/685] compiler: Remove feature(new_uninit)

---
 compiler/rustc_arena/src/lib.rs  | 1 -
 compiler/rustc_index/src/lib.rs  | 2 +-
 compiler/rustc_middle/src/lib.rs | 1 -
 compiler/rustc_span/src/lib.rs   | 1 -
 4 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/compiler/rustc_arena/src/lib.rs b/compiler/rustc_arena/src/lib.rs
index 8493354014734..260c9fe44ba80 100644
--- a/compiler/rustc_arena/src/lib.rs
+++ b/compiler/rustc_arena/src/lib.rs
@@ -21,7 +21,6 @@
 #![feature(decl_macro)]
 #![feature(dropck_eyepatch)]
 #![feature(maybe_uninit_slice)]
-#![feature(new_uninit)]
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
 #![feature(strict_provenance)]
diff --git a/compiler/rustc_index/src/lib.rs b/compiler/rustc_index/src/lib.rs
index b9d2a43206b1e..c25a742a89af1 100644
--- a/compiler/rustc_index/src/lib.rs
+++ b/compiler/rustc_index/src/lib.rs
@@ -1,7 +1,7 @@
 // tidy-alphabetical-start
 #![cfg_attr(all(feature = "nightly", test), feature(stmt_expr_attributes))]
 #![cfg_attr(feature = "nightly", allow(internal_features))]
-#![cfg_attr(feature = "nightly", feature(extend_one, new_uninit, step_trait, test))]
+#![cfg_attr(feature = "nightly", feature(extend_one, step_trait, test))]
 #![cfg_attr(feature = "nightly", feature(new_zeroed_alloc))]
 // tidy-alphabetical-end
 
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index 6886562d9b76d..2813c7751a58d 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -53,7 +53,6 @@
 #![feature(min_specialization)]
 #![feature(negative_impls)]
 #![feature(never_type)]
-#![feature(new_uninit)]
 #![feature(ptr_alignment_type)]
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index 35fe28c5d425b..7b020f11cdda0 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -26,7 +26,6 @@
 #![feature(let_chains)]
 #![feature(min_specialization)]
 #![feature(negative_impls)]
-#![feature(new_uninit)]
 #![feature(read_buf)]
 #![feature(round_char_boundary)]
 #![feature(rustc_attrs)]

From 605d9cf3b5f77f3f46d333347b21ab18697b75c6 Mon Sep 17 00:00:00 2001
From: Jubilee Young <workingjubilee@gmail.com>
Date: Wed, 21 Aug 2024 23:52:39 -0700
Subject: [PATCH 666/685] miri: Remove feature(new_uninit)

---
 src/tools/miri/tests/fail/data_race/alloc_read_race.rs  | 1 -
 src/tools/miri/tests/fail/data_race/alloc_write_race.rs | 1 -
 src/tools/miri/tests/fail/weak_memory/weak_uninit.rs    | 1 -
 src/tools/miri/tests/pass/rc.rs                         | 1 -
 src/tools/miri/tests/pass/slices.rs                     | 1 -
 5 files changed, 5 deletions(-)

diff --git a/src/tools/miri/tests/fail/data_race/alloc_read_race.rs b/src/tools/miri/tests/fail/data_race/alloc_read_race.rs
index c85c0ebe24451..312b7ba05d31c 100644
--- a/src/tools/miri/tests/fail/data_race/alloc_read_race.rs
+++ b/src/tools/miri/tests/fail/data_race/alloc_read_race.rs
@@ -1,7 +1,6 @@
 //@compile-flags: -Zmiri-disable-weak-memory-emulation -Zmiri-preemption-rate=0 -Zmiri-disable-stacked-borrows
 // Avoid accidental synchronization via address reuse inside `thread::spawn`.
 //@compile-flags: -Zmiri-address-reuse-cross-thread-rate=0
-#![feature(new_uninit)]
 
 use std::mem::MaybeUninit;
 use std::ptr::null_mut;
diff --git a/src/tools/miri/tests/fail/data_race/alloc_write_race.rs b/src/tools/miri/tests/fail/data_race/alloc_write_race.rs
index 9e2a430dd94f5..f1f308b37e7bf 100644
--- a/src/tools/miri/tests/fail/data_race/alloc_write_race.rs
+++ b/src/tools/miri/tests/fail/data_race/alloc_write_race.rs
@@ -1,7 +1,6 @@
 //@compile-flags: -Zmiri-disable-weak-memory-emulation -Zmiri-preemption-rate=0 -Zmiri-disable-stacked-borrows
 // Avoid accidental synchronization via address reuse inside `thread::spawn`.
 //@compile-flags: -Zmiri-address-reuse-cross-thread-rate=0
-#![feature(new_uninit)]
 
 use std::ptr::null_mut;
 use std::sync::atomic::{AtomicPtr, Ordering};
diff --git a/src/tools/miri/tests/fail/weak_memory/weak_uninit.rs b/src/tools/miri/tests/fail/weak_memory/weak_uninit.rs
index 54bea6c6908e3..79c97a5b75273 100644
--- a/src/tools/miri/tests/fail/weak_memory/weak_uninit.rs
+++ b/src/tools/miri/tests/fail/weak_memory/weak_uninit.rs
@@ -6,7 +6,6 @@
 // run multiple times until one try returns true.
 // Spurious failure is possible, if you are really unlucky with
 // the RNG and always read the latest value from the store buffer.
-#![feature(new_uninit)]
 
 use std::sync::atomic::*;
 use std::thread::spawn;
diff --git a/src/tools/miri/tests/pass/rc.rs b/src/tools/miri/tests/pass/rc.rs
index b1470dabc26bd..ce01e611b2ced 100644
--- a/src/tools/miri/tests/pass/rc.rs
+++ b/src/tools/miri/tests/pass/rc.rs
@@ -1,7 +1,6 @@
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
 //@compile-flags: -Zmiri-strict-provenance
-#![feature(new_uninit)]
 #![feature(get_mut_unchecked)]
 #![allow(ambiguous_wide_pointer_comparisons)]
 
diff --git a/src/tools/miri/tests/pass/slices.rs b/src/tools/miri/tests/pass/slices.rs
index 0b9805681b494..459d04d6761c1 100644
--- a/src/tools/miri/tests/pass/slices.rs
+++ b/src/tools/miri/tests/pass/slices.rs
@@ -1,7 +1,6 @@
 //@revisions: stack tree
 //@[tree]compile-flags: -Zmiri-tree-borrows
 //@compile-flags: -Zmiri-strict-provenance
-#![feature(new_uninit)]
 #![feature(slice_as_chunks)]
 #![feature(slice_partition_dedup)]
 #![feature(layout_for_ptr)]

From e17be955bbd5c0fa6e95805a2cb96946262cd75b Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Tue, 27 Aug 2024 19:29:52 +0200
Subject: [PATCH 667/685] interpret: add missing alignment check in raw_eq

---
 compiler/rustc_const_eval/src/interpret/intrinsics.rs | 10 +++++-----
 tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs     |  8 ++++++++
 tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr |  8 +++++++-
 3 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index aef39b9af2f1f..bedc56de0da25 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -684,19 +684,19 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         assert!(layout.is_sized());
 
         let get_bytes = |this: &InterpCx<'tcx, M>,
-                         op: &OpTy<'tcx, <M as Machine<'tcx>>::Provenance>,
-                         size|
+                         op: &OpTy<'tcx, <M as Machine<'tcx>>::Provenance>|
          -> InterpResult<'tcx, &[u8]> {
             let ptr = this.read_pointer(op)?;
-            let Some(alloc_ref) = self.get_ptr_alloc(ptr, size)? else {
+            this.check_ptr_align(ptr, layout.align.abi)?;
+            let Some(alloc_ref) = self.get_ptr_alloc(ptr, layout.size)? else {
                 // zero-sized access
                 return Ok(&[]);
             };
             alloc_ref.get_bytes_strip_provenance()
         };
 
-        let lhs_bytes = get_bytes(self, lhs, layout.size)?;
-        let rhs_bytes = get_bytes(self, rhs, layout.size)?;
+        let lhs_bytes = get_bytes(self, lhs)?;
+        let rhs_bytes = get_bytes(self, rhs)?;
         Ok(Scalar::from_bool(lhs_bytes == rhs_bytes))
     }
 }
diff --git a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs
index ab46fd796c535..99f98c3f27ada 100644
--- a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs
+++ b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.rs
@@ -13,5 +13,13 @@ const RAW_EQ_PTR: bool = unsafe {
 //~| unable to turn pointer into integer
 };
 
+const RAW_EQ_NOT_ALIGNED: bool = unsafe {
+    let arr = [0u8; 4];
+    let aref = &*arr.as_ptr().cast::<i32>();
+    std::intrinsics::raw_eq(aref, aref)
+//~^ ERROR evaluation of constant value failed
+//~| alignment
+};
+
 pub fn main() {
 }
diff --git a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr
index af16c2bc64a9d..bedfc8283ea45 100644
--- a/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr
+++ b/tests/ui/intrinsics/intrinsic-raw_eq-const-bad.stderr
@@ -13,6 +13,12 @@ LL |     std::intrinsics::raw_eq(&(&0), &(&1))
    = 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 2 previous errors
+error[E0080]: evaluation of constant value failed
+  --> $DIR/intrinsic-raw_eq-const-bad.rs:19:5
+   |
+LL |     std::intrinsics::raw_eq(aref, aref)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ accessing memory with alignment 1, but alignment 4 is required
+
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0080`.

From 0d6c9152fa8cfaf4b430beef643565ede7de1067 Mon Sep 17 00:00:00 2001
From: Noa <coolreader18@gmail.com>
Date: Tue, 27 Aug 2024 15:56:05 -0500
Subject: [PATCH 668/685] Fix Pin::set bounds regression

---
 library/core/src/pin.rs | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 780e476f531f4..65f6bfb7ee176 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1370,7 +1370,15 @@ impl<Ptr: Deref> Pin<Ptr> {
         // SAFETY: see documentation on this function
         unsafe { Pin::new_unchecked(&*self.__pointer) }
     }
+}
 
+// These methods being in a `Ptr: DerefMut` impl block concerns semver stability.
+// Currently, calling e.g. `.set()` on a `Pin<&T>` sees that `Ptr: DerefMut`
+// doesn't hold, and goes to check for a `.set()` method on `T`. But, if the
+// `where Ptr: DerefMut` bound is moved to the method, rustc sees the impl block
+// as a valid candidate, and doesn't go on to check other candidates when it
+// sees that the bound on the method.
+impl<Ptr: DerefMut> Pin<Ptr> {
     /// Gets a mutable reference to the pinned value this `Pin<Ptr>` points to.
     ///
     /// This is a generic method to go from `&mut Pin<Pointer<T>>` to `Pin<&mut T>`.
@@ -1402,10 +1410,7 @@ impl<Ptr: Deref> Pin<Ptr> {
     /// ```
     #[stable(feature = "pin", since = "1.33.0")]
     #[inline(always)]
-    pub fn as_mut(&mut self) -> Pin<&mut Ptr::Target>
-    where
-        Ptr: DerefMut,
-    {
+    pub fn as_mut(&mut self) -> Pin<&mut Ptr::Target> {
         // SAFETY: see documentation on this function
         unsafe { Pin::new_unchecked(&mut *self.__pointer) }
     }
@@ -1420,10 +1425,7 @@ impl<Ptr: Deref> Pin<Ptr> {
     #[unstable(feature = "pin_deref_mut", issue = "86918")]
     #[must_use = "`self` will be dropped if the result is not used"]
     #[inline(always)]
-    pub fn as_deref_mut(self: Pin<&mut Pin<Ptr>>) -> Pin<&mut Ptr::Target>
-    where
-        Ptr: DerefMut,
-    {
+    pub fn as_deref_mut(self: Pin<&mut Pin<Ptr>>) -> Pin<&mut Ptr::Target> {
         // SAFETY: What we're asserting here is that going from
         //
         //     Pin<&mut Pin<Ptr>>
@@ -1475,12 +1477,13 @@ impl<Ptr: Deref> Pin<Ptr> {
     #[inline(always)]
     pub fn set(&mut self, value: Ptr::Target)
     where
-        Ptr: DerefMut,
         Ptr::Target: Sized,
     {
         *(self.__pointer) = value;
     }
+}
 
+impl<Ptr: Deref> Pin<Ptr> {
     /// Unwraps this `Pin<Ptr>`, returning the underlying `Ptr`.
     ///
     /// # Safety

From c11d46f045815a346533f36914876a5c01a9f658 Mon Sep 17 00:00:00 2001
From: Matthew Giordano <mgiordan@cs.washington.edu>
Date: Tue, 27 Aug 2024 17:38:51 -0700
Subject: [PATCH 669/685] Add fmt::Debug to sync::Weak<T, A>

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

diff --git a/library/alloc/src/sync.rs b/library/alloc/src/sync.rs
index 4a3522f1a641b..1948d3e10c53e 100644
--- a/library/alloc/src/sync.rs
+++ b/library/alloc/src/sync.rs
@@ -335,7 +335,7 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized, A: Allocator> CoerceUnsized<Weak<U, A>> f
 impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T> {}
 
 #[stable(feature = "arc_weak", since = "1.4.0")]
-impl<T: ?Sized> fmt::Debug for Weak<T> {
+impl<T: ?Sized, A: Allocator> fmt::Debug for Weak<T, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "(Weak)")
     }

From 7eb4cfeaced28d49952e4ef54f8fe02258125854 Mon Sep 17 00:00:00 2001
From: Luca Versari <veluca@google.com>
Date: Mon, 24 Jun 2024 17:17:18 +0200
Subject: [PATCH 670/685] Implement RFC 3525.

---
 .../rustc_codegen_ssa/src/codegen_attrs.rs    | 125 ++++++++++++++++--
 compiler/rustc_feature/src/unstable.rs        |   2 +
 compiler/rustc_hir/src/def.rs                 |  35 +++++
 compiler/rustc_hir_typeck/src/coercion.rs     |   2 +
 .../src/rmeta/decoder/cstore_impl.rs          |   1 +
 compiler/rustc_metadata/src/rmeta/encoder.rs  |   3 +
 compiler/rustc_metadata/src/rmeta/mod.rs      |   3 +-
 .../src/middle/codegen_fn_attrs.rs            |   8 +-
 compiler/rustc_middle/src/query/mod.rs        |   7 +-
 compiler/rustc_middle/src/ty/parameterized.rs |   1 +
 compiler/rustc_mir_build/messages.ftl         |  16 +++
 .../rustc_mir_build/src/check_unsafety.rs     |  46 ++++++-
 compiler/rustc_mir_build/src/errors.rs        |  35 +++++
 compiler/rustc_passes/messages.ftl            |   4 +
 compiler/rustc_passes/src/check_attr.rs       |  33 ++++-
 compiler/rustc_passes/src/errors.rs           |   9 ++
 compiler/rustc_span/src/symbol.rs             |   1 +
 .../traits/fulfillment_errors.rs              |   2 +
 .../src/traits/select/candidate_assembly.rs   |   2 +
 .../struct-target-features.md                 |   7 +
 tests/assembly/struct-target-features.rs      |  37 ++++++
 .../feature-gate-struct-target-features.rs    |   4 +
 ...feature-gate-struct-target-features.stderr |  10 ++
 .../target-feature/struct-target-features.rs  |  98 ++++++++++++++
 .../struct-target-features.stderr             |  47 +++++++
 25 files changed, 511 insertions(+), 27 deletions(-)
 create mode 100644 src/doc/unstable-book/src/language-features/struct-target-features.md
 create mode 100644 tests/assembly/struct-target-features.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-struct-target-features.rs
 create mode 100644 tests/ui/feature-gates/feature-gate-struct-target-features.stderr
 create mode 100644 tests/ui/target-feature/struct-target-features.rs
 create mode 100644 tests/ui/target-feature/struct-target-features.stderr

diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 4ab20c154ccd0..209750d6ba612 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -1,5 +1,6 @@
 use rustc_ast::{ast, attr, MetaItemKind, NestedMetaItem};
 use rustc_attr::{list_contains_name, InlineAttr, InstructionSetAttr, OptimizeAttr};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::codes::*;
 use rustc_errors::{struct_span_code_err, DiagMessage, SubdiagMessage};
 use rustc_hir as hir;
@@ -8,7 +9,7 @@ use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE};
 use rustc_hir::weak_lang_items::WEAK_LANG_ITEMS;
 use rustc_hir::{lang_items, LangItem};
 use rustc_middle::middle::codegen_fn_attrs::{
-    CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry,
+    CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry, TargetFeature,
 };
 use rustc_middle::mir::mono::Linkage;
 use rustc_middle::query::Providers;
@@ -17,6 +18,7 @@ use rustc_session::lint;
 use rustc_session::parse::feature_err;
 use rustc_span::symbol::Ident;
 use rustc_span::{sym, Span};
+use rustc_target::abi::VariantIdx;
 use rustc_target::spec::{abi, SanitizerSet};
 
 use crate::errors;
@@ -78,6 +80,13 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
     let mut link_ordinal_span = None;
     let mut no_sanitize_span = None;
 
+    let fn_sig_outer = || {
+        use DefKind::*;
+
+        let def_kind = tcx.def_kind(did);
+        if let Fn | AssocFn | Variant | Ctor(..) = def_kind { Some(tcx.fn_sig(did)) } else { None }
+    };
+
     for attr in attrs.iter() {
         // In some cases, attribute are only valid on functions, but it's the `check_attr`
         // pass that check that they aren't used anywhere else, rather this module.
@@ -85,16 +94,12 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         // functions (such as calling `fn_sig`, which ICEs if given a non-function). We also
         // report a delayed bug, just in case `check_attr` isn't doing its job.
         let fn_sig = || {
-            use DefKind::*;
-
-            let def_kind = tcx.def_kind(did);
-            if let Fn | AssocFn | Variant | Ctor(..) = def_kind {
-                Some(tcx.fn_sig(did))
-            } else {
+            let sig = fn_sig_outer();
+            if sig.is_none() {
                 tcx.dcx()
                     .span_delayed_bug(attr.span, "this attribute can only be applied to functions");
-                None
             }
+            sig
         };
 
         let Some(Ident { name, .. }) = attr.ident() else {
@@ -613,7 +618,93 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         }
     }
 
-    // If a function uses #[target_feature] it can't be inlined into general
+    if let Some(sig) = fn_sig_outer() {
+        // Collect target features from types reachable from arguments.
+        // We define a type as "reachable" if:
+        //  - it is a function argument
+        //  - it is a field of a reachable struct
+        //  - there is a reachable reference to it
+        // FIXME(struct_target_features): we may want to cache the result of this computation.
+        let mut visited_types = FxHashSet::default();
+        let mut reachable_types: Vec<_> = sig.skip_binder().inputs().skip_binder().to_owned();
+        let mut additional_tf = vec![];
+
+        while let Some(ty) = reachable_types.pop() {
+            if visited_types.contains(&ty) {
+                continue;
+            }
+            visited_types.insert(ty);
+            match ty.kind() {
+                ty::Alias(..) => {
+                    if let Ok(t) =
+                        tcx.try_normalize_erasing_regions(tcx.param_env(did.to_def_id()), ty)
+                    {
+                        reachable_types.push(t)
+                    }
+                }
+
+                ty::Ref(_, inner, _) => reachable_types.push(*inner),
+                ty::Tuple(tys) => reachable_types.extend(tys.iter()),
+                ty::Adt(adt_def, args) => {
+                    additional_tf.extend_from_slice(tcx.struct_target_features(adt_def.did()));
+                    // This only recurses into structs as i.e. an Option<TargetFeature> is an ADT
+                    // that doesn't actually always contain a TargetFeature.
+                    if adt_def.is_struct() {
+                        reachable_types.extend(
+                            adt_def
+                                .variant(VariantIdx::from_usize(0))
+                                .fields
+                                .iter()
+                                .map(|field| field.ty(tcx, args)),
+                        );
+                    }
+                }
+                ty::Bool
+                | ty::Char
+                | ty::Int(..)
+                | ty::Uint(..)
+                | ty::Float(..)
+                | ty::Foreign(..)
+                | ty::Str
+                | ty::Array(..)
+                | ty::Pat(..)
+                | ty::Slice(..)
+                | ty::RawPtr(..)
+                | ty::FnDef(..)
+                | ty::FnPtr(..)
+                | ty::Dynamic(..)
+                | ty::Closure(..)
+                | ty::CoroutineClosure(..)
+                | ty::Coroutine(..)
+                | ty::CoroutineWitness(..)
+                | ty::Never
+                | ty::Param(..)
+                | ty::Bound(..)
+                | ty::Placeholder(..)
+                | ty::Infer(..)
+                | ty::Error(..) => (),
+            }
+        }
+
+        // FIXME(struct_target_features): is this really necessary?
+        if !additional_tf.is_empty() && sig.skip_binder().abi() != abi::Abi::Rust {
+            tcx.dcx().span_err(
+                tcx.hir().span(tcx.local_def_id_to_hir_id(did)),
+                "cannot use a struct with target features in a function with non-Rust ABI",
+            );
+        }
+        if !additional_tf.is_empty() && codegen_fn_attrs.inline == InlineAttr::Always {
+            tcx.dcx().span_err(
+                tcx.hir().span(tcx.local_def_id_to_hir_id(did)),
+                "cannot use a struct with target features in a #[inline(always)] function",
+            );
+        }
+        codegen_fn_attrs
+            .target_features
+            .extend(additional_tf.iter().map(|tf| TargetFeature { implied: true, ..*tf }));
+    }
+
+    // If a function uses non-default target_features it can't be inlined into general
     // purpose functions as they wouldn't have the right target features
     // enabled. For that reason we also forbid #[inline(always)] as it can't be
     // respected.
@@ -758,6 +849,20 @@ fn check_link_name_xor_ordinal(
     }
 }
 
+fn struct_target_features(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &[TargetFeature] {
+    let mut features = vec![];
+    let supported_features = tcx.supported_target_features(LOCAL_CRATE);
+    for attr in tcx.get_attrs(def_id, sym::target_feature) {
+        from_target_feature(tcx, attr, supported_features, &mut features);
+    }
+    tcx.arena.alloc_slice(&features)
+}
+
 pub fn provide(providers: &mut Providers) {
-    *providers = Providers { codegen_fn_attrs, should_inherit_track_caller, ..*providers };
+    *providers = Providers {
+        codegen_fn_attrs,
+        should_inherit_track_caller,
+        struct_target_features,
+        ..*providers
+    };
 }
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index 4524458023d7f..279d02e877731 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -594,6 +594,8 @@ declare_features! (
     (unstable, strict_provenance, "1.61.0", Some(95228)),
     /// Allows string patterns to dereference values to match them.
     (unstable, string_deref_patterns, "1.67.0", Some(87121)),
+    /// Allows structs to carry target_feature information.
+    (incomplete, struct_target_features, "CURRENT_RUSTC_VERSION", Some(129107)),
     /// Allows the use of `#[target_feature]` on safe functions.
     (unstable, target_feature_11, "1.45.0", Some(69098)),
     /// Allows using `#[thread_local]` on `static` items.
diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
index b329432d1e1c0..36e29d2dcb2cc 100644
--- a/compiler/rustc_hir/src/def.rs
+++ b/compiler/rustc_hir/src/def.rs
@@ -326,6 +326,41 @@ impl DefKind {
             | DefKind::ExternCrate => false,
         }
     }
+
+    /// Whether `query struct_target_features` should be used with this definition.
+    pub fn has_struct_target_features(self) -> bool {
+        match self {
+            DefKind::Struct | DefKind::Union | DefKind::Enum => true,
+            DefKind::Fn
+            | DefKind::AssocFn
+            | DefKind::Ctor(..)
+            | DefKind::Closure
+            | DefKind::Static { .. }
+            | DefKind::Mod
+            | DefKind::Variant
+            | DefKind::Trait
+            | DefKind::TyAlias
+            | DefKind::ForeignTy
+            | DefKind::TraitAlias
+            | DefKind::AssocTy
+            | DefKind::Const
+            | DefKind::AssocConst
+            | DefKind::Macro(..)
+            | DefKind::Use
+            | DefKind::ForeignMod
+            | DefKind::OpaqueTy
+            | DefKind::Impl { .. }
+            | DefKind::Field
+            | DefKind::TyParam
+            | DefKind::ConstParam
+            | DefKind::LifetimeParam
+            | DefKind::AnonConst
+            | DefKind::InlineConst
+            | DefKind::SyntheticCoroutineBody
+            | DefKind::GlobalAsm
+            | DefKind::ExternCrate => false,
+        }
+    }
 }
 
 /// The resolution of a path or export.
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index dabc5a8939783..54ddff9886922 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -850,6 +850,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                     }
 
                     // Safe `#[target_feature]` functions are not assignable to safe fn pointers (RFC 2396).
+                    // FIXME(struct_target_features): should this be true also for functions that inherit
+                    // target features from structs?
 
                     if b_hdr.safety == hir::Safety::Safe
                         && !self.tcx.codegen_fn_attrs(def_id).target_features.is_empty()
diff --git a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
index 46039f6e5f67c..27625f791082d 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
@@ -224,6 +224,7 @@ provide! { tcx, def_id, other, cdata,
     variances_of => { table }
     fn_sig => { table }
     codegen_fn_attrs => { table }
+    struct_target_features => { table }
     impl_trait_header => { table }
     const_param_default => { table }
     object_lifetime_default => { table }
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index 9c93726ca37f5..fbcfbd3befa94 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1392,6 +1392,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             if def_kind.has_codegen_attrs() {
                 record!(self.tables.codegen_fn_attrs[def_id] <- self.tcx.codegen_fn_attrs(def_id));
             }
+            if def_kind.has_struct_target_features() {
+                record_array!(self.tables.struct_target_features[def_id] <- self.tcx.struct_target_features(def_id));
+            }
             if should_encode_visibility(def_kind) {
                 let vis =
                     self.tcx.local_visibility(local_id).map_id(|def_id| def_id.local_def_index);
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
index c1b77172983fb..aec728d42624d 100644
--- a/compiler/rustc_metadata/src/rmeta/mod.rs
+++ b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -19,7 +19,7 @@ use rustc_macros::{
     Decodable, Encodable, MetadataDecodable, MetadataEncodable, TyDecodable, TyEncodable,
 };
 use rustc_middle::metadata::ModChild;
-use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
+use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrs, TargetFeature};
 use rustc_middle::middle::debugger_visualizer::DebuggerVisualizerFile;
 use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
 use rustc_middle::middle::lib_features::FeatureStability;
@@ -427,6 +427,7 @@ define_tables! {
     variances_of: Table<DefIndex, LazyArray<ty::Variance>>,
     fn_sig: Table<DefIndex, LazyValue<ty::EarlyBinder<'static, ty::PolyFnSig<'static>>>>,
     codegen_fn_attrs: Table<DefIndex, LazyValue<CodegenFnAttrs>>,
+    struct_target_features: Table<DefIndex, LazyArray<TargetFeature>>,
     impl_trait_header: Table<DefIndex, LazyValue<ty::ImplTraitHeader<'static>>>,
     const_param_default: Table<DefIndex, LazyValue<ty::EarlyBinder<'static, rustc_middle::ty::Const<'static>>>>,
     object_lifetime_default: Table<DefIndex, LazyValue<ObjectLifetimeDefault>>,
diff --git a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
index b7d290e58d22b..c098a73959230 100644
--- a/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
+++ b/compiler/rustc_middle/src/middle/codegen_fn_attrs.rs
@@ -26,8 +26,8 @@ pub struct CodegenFnAttrs {
     /// be set when `link_name` is set. This is for foreign items with the
     /// "raw-dylib" kind.
     pub link_ordinal: Option<u16>,
-    /// The `#[target_feature(enable = "...")]` attribute and the enabled
-    /// features (only enabled features are supported right now).
+    /// All the target features that are enabled for this function. Some features might be enabled
+    /// implicitly.
     pub target_features: Vec<TargetFeature>,
     /// The `#[linkage = "..."]` attribute on Rust-defined items and the value we found.
     pub linkage: Option<Linkage>,
@@ -55,8 +55,8 @@ pub struct CodegenFnAttrs {
 pub struct TargetFeature {
     /// The name of the target feature (e.g. "avx")
     pub name: Symbol,
-    /// The feature is implied by another feature, rather than explicitly added by the
-    /// `#[target_feature]` attribute
+    /// The feature is implied by another feature or by an argument, rather than explicitly
+    /// added by the `#[target_feature]` attribute
     pub implied: bool,
 }
 
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index c785b235f618b..6434bd0d7bfe5 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -47,7 +47,7 @@ use {rustc_ast as ast, rustc_attr as attr, rustc_hir as hir};
 use crate::infer::canonical::{self, Canonical};
 use crate::lint::LintExpectation;
 use crate::metadata::ModChild;
-use crate::middle::codegen_fn_attrs::CodegenFnAttrs;
+use crate::middle::codegen_fn_attrs::{CodegenFnAttrs, TargetFeature};
 use crate::middle::debugger_visualizer::DebuggerVisualizerFile;
 use crate::middle::exported_symbols::{ExportedSymbol, SymbolExportInfo};
 use crate::middle::lib_features::LibFeatures;
@@ -1245,6 +1245,11 @@ rustc_queries! {
         feedable
     }
 
+    query struct_target_features(def_id: DefId) -> &'tcx [TargetFeature] {
+        separate_provide_extern
+        desc { |tcx| "computing target features for struct `{}`", tcx.def_path_str(def_id) }
+    }
+
     query asm_target_features(def_id: DefId) -> &'tcx FxIndexSet<Symbol> {
         desc { |tcx| "computing target features for inline asm of `{}`", tcx.def_path_str(def_id) }
     }
diff --git a/compiler/rustc_middle/src/ty/parameterized.rs b/compiler/rustc_middle/src/ty/parameterized.rs
index 7e1255f606c35..be611e19b49a7 100644
--- a/compiler/rustc_middle/src/ty/parameterized.rs
+++ b/compiler/rustc_middle/src/ty/parameterized.rs
@@ -59,6 +59,7 @@ trivially_parameterized_over_tcx! {
     std::string::String,
     crate::metadata::ModChild,
     crate::middle::codegen_fn_attrs::CodegenFnAttrs,
+    crate::middle::codegen_fn_attrs::TargetFeature,
     crate::middle::debugger_visualizer::DebuggerVisualizerFile,
     crate::middle::exported_symbols::SymbolExportInfo,
     crate::middle::lib_features::FeatureStability,
diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index 7a10e627ccd89..a42e8ff0168b2 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -125,6 +125,17 @@ mir_build_initializing_type_with_requires_unsafe_unsafe_op_in_unsafe_fn_allowed
     .note = initializing a layout restricted type's field with a value outside the valid range is undefined behavior
     .label = initializing type with `rustc_layout_scalar_valid_range` attr
 
+mir_build_initializing_type_with_target_feature_requires_unsafe =
+    initializing type with `target_feature` attr is unsafe and requires unsafe block
+    .note = this struct can only be constructed if the corresponding `target_feature`s are available
+    .label = initializing type with `target_feature` attr
+
+mir_build_initializing_type_with_target_feature_requires_unsafe_unsafe_op_in_unsafe_fn_allowed =
+    initializing type with `target_feature` attr is unsafe and requires unsafe function or block
+    .note = this struct can only be constructed if the corresponding `target_feature`s are available
+    .label = initializing type with `target_feature` attr
+
+
 mir_build_inline_assembly_requires_unsafe =
     use of inline assembly is unsafe and requires unsafe block
     .note = inline assembly is entirely unchecked and can cause undefined behavior
@@ -387,6 +398,11 @@ mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_requires_unsafe =
     .note = initializing a layout restricted type's field with a value outside the valid range is undefined behavior
     .label = initializing type with `rustc_layout_scalar_valid_range` attr
 
+mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_target_feature_requires_unsafe =
+    initializing type with `target_feature` attr is unsafe and requires unsafe block
+    .note = this struct can only be constructed if the corresponding `target_feature`s are available
+    .label = initializing type with `target_feature` attr
+
 mir_build_unsafe_op_in_unsafe_fn_inline_assembly_requires_unsafe =
     use of inline assembly is unsafe and requires unsafe block
     .note = inline assembly is entirely unchecked and can cause undefined behavior
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index b6cf7a40ecd98..60cd49b88b43d 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -461,14 +461,18 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                     };
                     self.requires_unsafe(expr.span, CallToUnsafeFunction(func_id));
                 } else if let &ty::FnDef(func_did, _) = self.thir[fun].ty.kind() {
-                    // If the called function has target features the calling function hasn't,
+                    // If the called function has explicit target features the calling function hasn't,
                     // the call requires `unsafe`. Don't check this on wasm
                     // targets, though. For more information on wasm see the
                     // is_like_wasm check in hir_analysis/src/collect.rs
+                    // Implicit target features are OK because they are either a consequence of some
+                    // explicit target feature (which is checked to be present in the caller) or
+                    // come from a witness argument.
                     let callee_features = &self.tcx.codegen_fn_attrs(func_did).target_features;
                     if !self.tcx.sess.target.options.is_like_wasm
                         && !callee_features.iter().all(|feature| {
-                            self.body_target_features.iter().any(|f| f.name == feature.name)
+                            feature.implied
+                                || self.body_target_features.iter().any(|f| f.name == feature.name)
                         })
                     {
                         let missing: Vec<_> = callee_features
@@ -542,10 +546,16 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                 user_ty: _,
                 fields: _,
                 base: _,
-            }) => match self.tcx.layout_scalar_valid_range(adt_def.did()) {
-                (Bound::Unbounded, Bound::Unbounded) => {}
-                _ => self.requires_unsafe(expr.span, InitializingTypeWith),
-            },
+            }) => {
+                match self.tcx.layout_scalar_valid_range(adt_def.did()) {
+                    (Bound::Unbounded, Bound::Unbounded) => {}
+                    _ => self.requires_unsafe(expr.span, InitializingTypeWith),
+                }
+                if !self.tcx.struct_target_features(adt_def.did()).is_empty() {
+                    self.requires_unsafe(expr.span, ConstructingTargetFeaturesType)
+                }
+            }
+
             ExprKind::Closure(box ClosureExpr {
                 closure_id,
                 args: _,
@@ -647,6 +657,7 @@ enum UnsafeOpKind {
     CallToUnsafeFunction(Option<DefId>),
     UseOfInlineAssembly,
     InitializingTypeWith,
+    ConstructingTargetFeaturesType,
     UseOfMutableStatic,
     UseOfExternStatic,
     DerefOfRawPointer,
@@ -728,6 +739,15 @@ impl UnsafeOpKind {
                     unsafe_not_inherited_note,
                 },
             ),
+            ConstructingTargetFeaturesType => tcx.emit_node_span_lint(
+                UNSAFE_OP_IN_UNSAFE_FN,
+                hir_id,
+                span,
+                UnsafeOpInUnsafeFnInitializingTypeWithTargetFeatureRequiresUnsafe {
+                    span,
+                    unsafe_not_inherited_note,
+                },
+            ),
             UseOfMutableStatic => tcx.emit_node_span_lint(
                 UNSAFE_OP_IN_UNSAFE_FN,
                 hir_id,
@@ -885,6 +905,20 @@ impl UnsafeOpKind {
                     unsafe_not_inherited_note,
                 });
             }
+            ConstructingTargetFeaturesType if unsafe_op_in_unsafe_fn_allowed => {
+                dcx.emit_err(
+                    InitializingTypeWithTargetFeatureRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
+                        span,
+                        unsafe_not_inherited_note,
+                    },
+                );
+            }
+            ConstructingTargetFeaturesType => {
+                dcx.emit_err(InitializingTypeWithTargetFeatureRequiresUnsafe {
+                    span,
+                    unsafe_not_inherited_note,
+                });
+            }
             UseOfMutableStatic if unsafe_op_in_unsafe_fn_allowed => {
                 dcx.emit_err(UseOfMutableStaticRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
                     span,
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index 7f9eefd1d52e3..e7d6239aa9bf6 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -86,6 +86,16 @@ pub(crate) struct UnsafeOpInUnsafeFnInitializingTypeWithRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_target_feature_requires_unsafe, code = E0133)]
+#[note]
+pub(crate) struct UnsafeOpInUnsafeFnInitializingTypeWithTargetFeatureRequiresUnsafe {
+    #[label]
+    pub(crate) span: Span,
+    #[subdiagnostic]
+    pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedLintNote>,
+}
+
 #[derive(LintDiagnostic)]
 #[diag(mir_build_unsafe_op_in_unsafe_fn_mutable_static_requires_unsafe, code = E0133)]
 #[note]
@@ -250,6 +260,17 @@ pub(crate) struct InitializingTypeWithRequiresUnsafe {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
 }
 
+#[derive(Diagnostic)]
+#[diag(mir_build_initializing_type_with_target_feature_requires_unsafe, code = E0133)]
+#[note]
+pub(crate) struct InitializingTypeWithTargetFeatureRequiresUnsafe {
+    #[primary_span]
+    #[label]
+    pub(crate) span: Span,
+    #[subdiagnostic]
+    pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
+}
+
 #[derive(Diagnostic)]
 #[diag(
     mir_build_initializing_type_with_requires_unsafe_unsafe_op_in_unsafe_fn_allowed,
@@ -264,6 +285,20 @@ pub(crate) struct InitializingTypeWithRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
     pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
 }
 
+#[derive(Diagnostic)]
+#[diag(
+    mir_build_initializing_type_with_target_feature_requires_unsafe_unsafe_op_in_unsafe_fn_allowed,
+    code = E0133
+)]
+#[note]
+pub(crate) struct InitializingTypeWithTargetFeatureRequiresUnsafeUnsafeOpInUnsafeFnAllowed {
+    #[primary_span]
+    #[label]
+    pub(crate) span: Span,
+    #[subdiagnostic]
+    pub(crate) unsafe_not_inherited_note: Option<UnsafeNotInheritedNote>,
+}
+
 #[derive(Diagnostic)]
 #[diag(mir_build_mutable_static_requires_unsafe, code = E0133)]
 #[note]
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index e7f208d5ad544..38450fc288a1f 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -672,6 +672,10 @@ passes_should_be_applied_to_fn =
         *[false] not a function definition
     }
 
+passes_should_be_applied_to_fn_or_unit_struct =
+    attribute should be applied to a function definition or unit struct
+    .label = not a function definition or a unit struct
+
 passes_should_be_applied_to_static =
     attribute should be applied to a static
     .label = not a static
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index d1dac9ca6daff..9b3de24e1a632 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -746,12 +746,35 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             Target::Field | Target::Arm | Target::MacroDef => {
                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "target_feature");
             }
+            Target::Struct if self.tcx.features().struct_target_features => {
+                let ty = self.tcx.hir_node(hir_id).expect_item();
+                match ty.kind {
+                    ItemKind::Struct(data, _) => {
+                        if data.fields().len() != 0 {
+                            self.dcx().emit_err(errors::AttrShouldBeAppliedToFnOrUnitStruct {
+                                attr_span: attr.span,
+                                defn_span: span,
+                            });
+                        }
+                    }
+                    _ => {
+                        panic!("Target::Struct for a non-struct");
+                    }
+                }
+            }
             _ => {
-                self.dcx().emit_err(errors::AttrShouldBeAppliedToFn {
-                    attr_span: attr.span,
-                    defn_span: span,
-                    on_crate: hir_id == CRATE_HIR_ID,
-                });
+                if self.tcx.features().struct_target_features {
+                    self.dcx().emit_err(errors::AttrShouldBeAppliedToFnOrUnitStruct {
+                        attr_span: attr.span,
+                        defn_span: span,
+                    });
+                } else {
+                    self.dcx().emit_err(errors::AttrShouldBeAppliedToFn {
+                        attr_span: attr.span,
+                        defn_span: span,
+                        on_crate: hir_id == CRATE_HIR_ID,
+                    });
+                }
             }
         }
     }
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 1202351bdcd11..32db0823cf786 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -82,6 +82,15 @@ pub struct AttrShouldBeAppliedToFn {
     pub on_crate: bool,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_should_be_applied_to_fn_or_unit_struct)]
+pub struct AttrShouldBeAppliedToFnOrUnitStruct {
+    #[primary_span]
+    pub attr_span: Span,
+    #[label]
+    pub defn_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_should_be_applied_to_fn, code = E0739)]
 pub struct TrackedCallerWrongLocation {
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 2957105288bb3..c64fefd457ae2 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1852,6 +1852,7 @@ symbols! {
         stringify,
         struct_field_attributes,
         struct_inherit,
+        struct_target_features,
         struct_variant,
         structural_match,
         structural_peq,
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 9f0282319ec0a..def9d6e9a3110 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -438,6 +438,8 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         let is_target_feature_fn = if let ty::FnDef(def_id, _) =
                             *leaf_trait_ref.skip_binder().self_ty().kind()
                         {
+                            // FIXME(struct_target_features): should a function that inherits
+                            // target_features through arguments implement Fn traits?
                             !self.tcx.codegen_fn_attrs(def_id).target_features.is_empty()
                         } else {
                             false
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index cb8deeaedb66f..a21feec4b1a34 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -545,6 +545,8 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             // Provide an impl for suitable functions, rejecting `#[target_feature]` functions (RFC 2396).
             ty::FnDef(def_id, args) => {
                 let tcx = self.tcx();
+                // FIXME(struct_target_features): should a function that inherits target_features
+                // through an argument implement Fn traits?
                 if tcx.fn_sig(def_id).skip_binder().is_fn_trait_compatible()
                     && tcx.codegen_fn_attrs(def_id).target_features.is_empty()
                 {
diff --git a/src/doc/unstable-book/src/language-features/struct-target-features.md b/src/doc/unstable-book/src/language-features/struct-target-features.md
new file mode 100644
index 0000000000000..e814fe9007240
--- /dev/null
+++ b/src/doc/unstable-book/src/language-features/struct-target-features.md
@@ -0,0 +1,7 @@
+# `struct_target_features`
+
+The tracking issue for this feature is: [#129107]
+
+[#129107]: https://github.com/rust-lang/rust/issues/129107
+
+------------------------
diff --git a/tests/assembly/struct-target-features.rs b/tests/assembly/struct-target-features.rs
new file mode 100644
index 0000000000000..cc86fbaa84064
--- /dev/null
+++ b/tests/assembly/struct-target-features.rs
@@ -0,0 +1,37 @@
+//@ compile-flags: -O
+//@ assembly-output: emit-asm
+//@ only-x86_64
+
+#![crate_type = "lib"]
+#![feature(struct_target_features)]
+
+// Check that a struct_target_features type causes the compiler to effectively inline intrinsics.
+
+use std::arch::x86_64::*;
+
+#[target_feature(enable = "avx")]
+struct Avx {}
+
+#[target_feature(enable = "fma")]
+struct Fma {}
+
+pub fn add_simple(_: Avx, v: __m256) -> __m256 {
+    // CHECK-NOT: call
+    // CHECK: vaddps
+    unsafe { _mm256_add_ps(v, v) }
+}
+
+pub fn add_complex_type(_: (&Avx, ()), v: __m256) -> __m256 {
+    // CHECK-NOT: call
+    // CHECK: vaddps
+    unsafe { _mm256_add_ps(v, v) }
+}
+
+pub fn add_fma_combined(_: (&Avx, &Fma), v: __m256) -> (__m256, __m256) {
+    // CHECK-NOT: call
+    // CHECK-DAG: vaddps
+    let r1 = unsafe { _mm256_add_ps(v, v) };
+    // CHECK-DAG: vfmadd213ps
+    let r2 = unsafe { _mm256_fmadd_ps(v, v, v) };
+    (r1, r2)
+}
diff --git a/tests/ui/feature-gates/feature-gate-struct-target-features.rs b/tests/ui/feature-gates/feature-gate-struct-target-features.rs
new file mode 100644
index 0000000000000..854948811469b
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-struct-target-features.rs
@@ -0,0 +1,4 @@
+#[target_feature(enable = "avx")] //~ ERROR attribute should be applied to a function definition
+struct Avx {}
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-struct-target-features.stderr b/tests/ui/feature-gates/feature-gate-struct-target-features.stderr
new file mode 100644
index 0000000000000..1e18d3ee1e18d
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-struct-target-features.stderr
@@ -0,0 +1,10 @@
+error: attribute should be applied to a function definition
+  --> $DIR/feature-gate-struct-target-features.rs:1:1
+   |
+LL | #[target_feature(enable = "avx")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | struct Avx {}
+   | ------------- not a function definition
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/target-feature/struct-target-features.rs b/tests/ui/target-feature/struct-target-features.rs
new file mode 100644
index 0000000000000..feb479b6dc816
--- /dev/null
+++ b/tests/ui/target-feature/struct-target-features.rs
@@ -0,0 +1,98 @@
+//@ only-x86_64
+#![feature(struct_target_features)]
+//~^ WARNING the feature `struct_target_features` is incomplete and may not be safe to use and/or cause compiler crashes
+#![feature(target_feature_11)]
+
+use std::arch::x86_64::*;
+
+#[target_feature(enable = "avx")]
+//~^ ERROR attribute should be applied to a function definition or unit struct
+struct Invalid(u32);
+
+#[target_feature(enable = "avx")]
+struct Avx {}
+
+#[target_feature(enable = "sse")]
+struct Sse();
+
+#[target_feature(enable = "avx")]
+fn avx() {}
+
+trait TFAssociatedType {
+    type Assoc;
+}
+
+impl TFAssociatedType for () {
+    type Assoc = Avx;
+}
+
+fn avx_self(_: <() as TFAssociatedType>::Assoc) {
+    avx();
+}
+
+fn avx_avx(_: Avx) {
+    avx();
+}
+
+extern "C" fn bad_fun(_: Avx) {}
+//~^ ERROR cannot use a struct with target features in a function with non-Rust ABI
+
+#[inline(always)]
+//~^ ERROR cannot use `#[inline(always)]` with `#[target_feature]`
+fn inline_fun(_: Avx) {}
+//~^ ERROR cannot use a struct with target features in a #[inline(always)] function
+
+trait Simd {
+    fn do_something(&self);
+}
+
+impl Simd for Avx {
+    fn do_something(&self) {
+        unsafe {
+            println!("{:?}", _mm256_setzero_ps());
+        }
+    }
+}
+
+impl Simd for Sse {
+    fn do_something(&self) {
+        unsafe {
+            println!("{:?}", _mm_setzero_ps());
+        }
+    }
+}
+
+struct WithAvx {
+    #[allow(dead_code)]
+    avx: Avx,
+}
+
+impl Simd for WithAvx {
+    fn do_something(&self) {
+        unsafe {
+            println!("{:?}", _mm256_setzero_ps());
+        }
+    }
+}
+
+#[inline(never)]
+fn dosomething<S: Simd>(simd: &S) {
+    simd.do_something();
+}
+
+fn avxfn(_: &Avx) {}
+
+fn main() {
+    Avx {};
+    //~^ ERROR initializing type with `target_feature` attr is unsafe and requires unsafe function or block [E0133]
+
+    if is_x86_feature_detected!("avx") {
+        let avx = unsafe { Avx {} };
+        avxfn(&avx);
+        dosomething(&avx);
+        dosomething(&WithAvx { avx });
+    }
+    if is_x86_feature_detected!("sse") {
+        dosomething(&unsafe { Sse {} })
+    }
+}
diff --git a/tests/ui/target-feature/struct-target-features.stderr b/tests/ui/target-feature/struct-target-features.stderr
new file mode 100644
index 0000000000000..5ef863f504ee1
--- /dev/null
+++ b/tests/ui/target-feature/struct-target-features.stderr
@@ -0,0 +1,47 @@
+warning: the feature `struct_target_features` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/struct-target-features.rs:2:12
+   |
+LL | #![feature(struct_target_features)]
+   |            ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #129107 <https://github.com/rust-lang/rust/issues/129107> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+error: attribute should be applied to a function definition or unit struct
+  --> $DIR/struct-target-features.rs:8:1
+   |
+LL | #[target_feature(enable = "avx")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |
+LL | struct Invalid(u32);
+   | -------------------- not a function definition or a unit struct
+
+error: cannot use a struct with target features in a function with non-Rust ABI
+  --> $DIR/struct-target-features.rs:37:1
+   |
+LL | extern "C" fn bad_fun(_: Avx) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: cannot use a struct with target features in a #[inline(always)] function
+  --> $DIR/struct-target-features.rs:42:1
+   |
+LL | fn inline_fun(_: Avx) {}
+   | ^^^^^^^^^^^^^^^^^^^^^
+
+error: cannot use `#[inline(always)]` with `#[target_feature]`
+  --> $DIR/struct-target-features.rs:40:1
+   |
+LL | #[inline(always)]
+   | ^^^^^^^^^^^^^^^^^
+
+error[E0133]: initializing type with `target_feature` attr is unsafe and requires unsafe function or block
+  --> $DIR/struct-target-features.rs:86:5
+   |
+LL |     Avx {};
+   |     ^^^^^^ initializing type with `target_feature` attr
+   |
+   = note: this struct can only be constructed if the corresponding `target_feature`s are available
+
+error: aborting due to 5 previous errors; 1 warning emitted
+
+For more information about this error, try `rustc --explain E0133`.

From 0589dc75d314152de3ddf095ff2fc774c4a2d9c1 Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Wed, 28 Aug 2024 12:06:28 +0200
Subject: [PATCH 671/685] copysign with sign being a NaN is non-portable

---
 library/std/src/f128.rs | 11 ++++++++---
 library/std/src/f16.rs  | 11 ++++++++---
 library/std/src/f32.rs  | 11 ++++++++---
 library/std/src/f64.rs  | 11 ++++++++---
 4 files changed, 32 insertions(+), 12 deletions(-)

diff --git a/library/std/src/f128.rs b/library/std/src/f128.rs
index 506d708d0d2eb..b436fe9929c36 100644
--- a/library/std/src/f128.rs
+++ b/library/std/src/f128.rs
@@ -250,9 +250,14 @@ impl f128 {
     ///
     /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise equal to `-self`.
     /// If `self` is a NaN, then a NaN with the same payload as `self` and the sign bit of `sign` is
-    /// returned. Note, however, that conserving the sign bit on NaN across arithmetical operations
-    /// is not generally guaranteed. See [specification of NaN bit
-    /// patterns](primitive@f32#nan-bit-patterns) for more info.
+    /// returned.
+    ///
+    /// If `sign` is a NaN, then this operation will still carry over its sign into the result. Note
+    /// that IEEE 754 doesn't assign any meaning to the sign bit in case of a NaN, and as Rust
+    /// doesn't guarantee that the bit pattern of NaNs are conserved over arithmetic operations, the
+    /// result of `copysign` with `sign` being a NaN might produce an unexpected or non-portable
+    /// result. See the [specification of NaN bit patterns](primitive@f32#nan-bit-patterns) for more
+    /// info.
     ///
     /// # Examples
     ///
diff --git a/library/std/src/f16.rs b/library/std/src/f16.rs
index 033a3d4500932..b2cd5fae9d04a 100644
--- a/library/std/src/f16.rs
+++ b/library/std/src/f16.rs
@@ -249,9 +249,14 @@ impl f16 {
     ///
     /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise equal to `-self`.
     /// If `self` is a NaN, then a NaN with the same payload as `self` and the sign bit of `sign` is
-    /// returned. Note, however, that conserving the sign bit on NaN across arithmetical operations
-    /// is not generally guaranteed. See [specification of NaN bit
-    /// patterns](primitive@f32#nan-bit-patterns) for more info.
+    /// returned.
+    ///
+    /// If `sign` is a NaN, then this operation will still carry over its sign into the result. Note
+    /// that IEEE 754 doesn't assign any meaning to the sign bit in case of a NaN, and as Rust
+    /// doesn't guarantee that the bit pattern of NaNs are conserved over arithmetic operations, the
+    /// result of `copysign` with `sign` being a NaN might produce an unexpected or non-portable
+    /// result. See the [specification of NaN bit patterns](primitive@f32#nan-bit-patterns) for more
+    /// info.
     ///
     /// # Examples
     ///
diff --git a/library/std/src/f32.rs b/library/std/src/f32.rs
index 35c2a77b5338d..cafbe9761da19 100644
--- a/library/std/src/f32.rs
+++ b/library/std/src/f32.rs
@@ -228,9 +228,14 @@ impl f32 {
     ///
     /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise equal to `-self`.
     /// If `self` is a NaN, then a NaN with the same payload as `self` and the sign bit of `sign` is
-    /// returned. Note, however, that conserving the sign bit on NaN across arithmetical operations
-    /// is not generally guaranteed. See [specification of NaN bit
-    /// patterns](primitive@f32#nan-bit-patterns) for more info.
+    /// returned.
+    ///
+    /// If `sign` is a NaN, then this operation will still carry over its sign into the result. Note
+    /// that IEEE 754 doesn't assign any meaning to the sign bit in case of a NaN, and as Rust
+    /// doesn't guarantee that the bit pattern of NaNs are conserved over arithmetic operations, the
+    /// result of `copysign` with `sign` being a NaN might produce an unexpected or non-portable
+    /// result. See the [specification of NaN bit patterns](primitive@f32#nan-bit-patterns) for more
+    /// info.
     ///
     /// # Examples
     ///
diff --git a/library/std/src/f64.rs b/library/std/src/f64.rs
index c177f74a97e15..fba283e3a44bc 100644
--- a/library/std/src/f64.rs
+++ b/library/std/src/f64.rs
@@ -228,9 +228,14 @@ impl f64 {
     ///
     /// Equal to `self` if the sign of `self` and `sign` are the same, otherwise equal to `-self`.
     /// If `self` is a NaN, then a NaN with the same payload as `self` and the sign bit of `sign` is
-    /// returned. Note, however, that conserving the sign bit on NaN across arithmetical operations
-    /// is not generally guaranteed. See [specification of NaN bit
-    /// patterns](primitive@f32#nan-bit-patterns) for more info.
+    /// returned.
+    ///
+    /// If `sign` is a NaN, then this operation will still carry over its sign into the result. Note
+    /// that IEEE 754 doesn't assign any meaning to the sign bit in case of a NaN, and as Rust
+    /// doesn't guarantee that the bit pattern of NaNs are conserved over arithmetic operations, the
+    /// result of `copysign` with `sign` being a NaN might produce an unexpected or non-portable
+    /// result. See the [specification of NaN bit patterns](primitive@f32#nan-bit-patterns) for more
+    /// info.
     ///
     /// # Examples
     ///

From ddcb073c53db68500e31874529595e6c7658b670 Mon Sep 17 00:00:00 2001
From: Orion Gonzalez <ardi@ardis.dev>
Date: Tue, 27 Aug 2024 18:28:59 +0200
Subject: [PATCH 672/685] replace is_some() -> unwrap with if let

---
 compiler/rustc_driver_impl/src/lib.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 2b7dc040f6411..540523aa7b450 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -463,12 +463,8 @@ fn run_compiler(
             linker.link(sess, codegen_backend)?
         }
 
-        if sess.opts.unstable_opts.print_fuel.is_some() {
-            eprintln!(
-                "Fuel used by {}: {}",
-                sess.opts.unstable_opts.print_fuel.as_ref().unwrap(),
-                sess.print_fuel.load(Ordering::SeqCst)
-            );
+        if let Some(fuel) = sess.opts.unstable_opts.print_fuel.as_deref() {
+            eprintln!("Fuel used by {}: {}", fuel, sess.print_fuel.load(Ordering::SeqCst));
         }
 
         Ok(())

From b218623ea030885e88730413c61e3d47ed2905da Mon Sep 17 00:00:00 2001
From: Orion Gonzalez <ardi@ardis.dev>
Date: Tue, 27 Aug 2024 18:46:44 +0200
Subject: [PATCH 673/685] cleanup make_input

---
 compiler/rustc_driver_impl/src/lib.rs | 45 ++++++++++++++++-----------
 1 file changed, 26 insertions(+), 19 deletions(-)

diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 540523aa7b450..76bff6a87f32d 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -481,36 +481,43 @@ fn make_output(matches: &getopts::Matches) -> (Option<PathBuf>, Option<OutFileNa
     (odir, ofile)
 }
 
-// Extract input (string or file and optional path) from matches.
+/// Extract input (string or file and optional path) from matches.
+/// This handles reading from stdin if `-` is provided.
 fn make_input(
     early_dcx: &EarlyDiagCtxt,
     free_matches: &[String],
 ) -> Result<Option<Input>, ErrorGuaranteed> {
-    let [ifile] = free_matches else { return Ok(None) };
-    if ifile == "-" {
-        let mut src = String::new();
-        if io::stdin().read_to_string(&mut src).is_err() {
-            // Immediately stop compilation if there was an issue reading
-            // the input (for example if the input stream is not UTF-8).
-            let reported =
-                early_dcx.early_err("couldn't read from stdin, as it did not contain valid UTF-8");
-            return Err(reported);
-        }
-        if let Ok(path) = env::var("UNSTABLE_RUSTDOC_TEST_PATH") {
+    let [input_file] = free_matches else { return Ok(None) };
+
+    if input_file != "-" {
+        // Normal `Input::File`
+        return Ok(Some(Input::File(PathBuf::from(input_file))));
+    }
+
+    // read from stdin as `Input::Str`
+    let mut input = String::new();
+    if io::stdin().read_to_string(&mut input).is_err() {
+        // Immediately stop compilation if there was an issue reading
+        // the input (for example if the input stream is not UTF-8).
+        let reported =
+            early_dcx.early_err("couldn't read from stdin, as it did not contain valid UTF-8");
+        return Err(reported);
+    }
+
+    let name = match env::var("UNSTABLE_RUSTDOC_TEST_PATH") {
+        Ok(path) => {
             let line = env::var("UNSTABLE_RUSTDOC_TEST_LINE").expect(
                 "when UNSTABLE_RUSTDOC_TEST_PATH is set \
                                     UNSTABLE_RUSTDOC_TEST_LINE also needs to be set",
             );
             let line = isize::from_str_radix(&line, 10)
                 .expect("UNSTABLE_RUSTDOC_TEST_LINE needs to be an number");
-            let file_name = FileName::doc_test_source_code(PathBuf::from(path), line);
-            Ok(Some(Input::Str { name: file_name, input: src }))
-        } else {
-            Ok(Some(Input::Str { name: FileName::anon_source_code(&src), input: src }))
+            FileName::doc_test_source_code(PathBuf::from(path), line)
         }
-    } else {
-        Ok(Some(Input::File(PathBuf::from(ifile))))
-    }
+        Err(_) => FileName::anon_source_code(&input),
+    };
+
+    Ok(Some(Input::Str { name, input }))
 }
 
 /// Whether to stop or continue compilation.

From a007d349a1ccd6f998049e3acbf99e0df17a5c49 Mon Sep 17 00:00:00 2001
From: Orion Gonzalez <ardi@ardis.dev>
Date: Tue, 27 Aug 2024 20:04:47 +0200
Subject: [PATCH 674/685] clarify a few things

---
 compiler/rustc_driver_impl/src/lib.rs | 12 ++++++++----
 compiler/rustc_session/src/config.rs  |  1 +
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 76bff6a87f32d..f77551475366c 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -391,13 +391,17 @@ fn run_compiler(
 
         let linker = compiler.enter(|queries| {
             let early_exit = || early_exit().map(|_| None);
+
+            // Parse the crate root source code (doesn't parse submodules yet)
+            // Everything else is parsed during macro expansion.
             queries.parse()?;
 
-            if let Some(ppm) = &sess.opts.pretty {
-                if ppm.needs_ast_map() {
+            // If pretty printing is requested: Figure out the representation, print it and exit
+            if let Some(pp_mode) = sess.opts.pretty {
+                if pp_mode.needs_ast_map() {
                     queries.global_ctxt()?.enter(|tcx| {
                         tcx.ensure().early_lint_checks(());
-                        pretty::print(sess, *ppm, pretty::PrintExtra::NeedsAstMap { tcx });
+                        pretty::print(sess, pp_mode, pretty::PrintExtra::NeedsAstMap { tcx });
                         Ok(())
                     })?;
 
@@ -408,7 +412,7 @@ fn run_compiler(
                     let krate = queries.parse()?;
                     pretty::print(
                         sess,
-                        *ppm,
+                        pp_mode,
                         pretty::PrintExtra::AfterParsing { krate: &*krate.borrow() },
                     );
                 }
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 95d171409d86d..4fb3702b05dc5 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -2893,6 +2893,7 @@ pub enum PpHirMode {
 }
 
 #[derive(Copy, Clone, PartialEq, Debug)]
+/// Pretty print mode
 pub enum PpMode {
     /// Options that print the source code, i.e.
     /// `-Zunpretty=normal` and `-Zunpretty=expanded`

From c35e01e48e4eb6850f20628dde49f1204c2242c8 Mon Sep 17 00:00:00 2001
From: Orion Gonzalez <ardi@ardis.dev>
Date: Tue, 27 Aug 2024 20:05:53 +0200
Subject: [PATCH 675/685] clarify what term can be

---
 compiler/rustc_parse/src/parser/item.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index 8775d792c3d2b..7bdcac454558a 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -49,7 +49,9 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses the contents of a module (inner attributes followed by module items).
-    /// We exit once we hit `term`
+    /// We exit once we hit `term` which can be either
+    /// - EOF (for files)
+    /// - `}` for mod items
     pub fn parse_mod(
         &mut self,
         term: &TokenKind,

From f61f34f4b8dbbcee2e0cb793d0f79ac04e4667b7 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 28 Aug 2024 22:01:10 +1000
Subject: [PATCH 676/685] coverage: `CodeRegion` is never stored in an arena

This might have been left over when coverage regions were stored in individual
MIR statements, instead of a separate table attached to the MIR body.
---
 compiler/rustc_middle/src/arena.rs    | 1 -
 compiler/rustc_middle/src/ty/codec.rs | 1 -
 2 files changed, 2 deletions(-)

diff --git a/compiler/rustc_middle/src/arena.rs b/compiler/rustc_middle/src/arena.rs
index 37c10b14054c5..7050a06b8dc22 100644
--- a/compiler/rustc_middle/src/arena.rs
+++ b/compiler/rustc_middle/src/arena.rs
@@ -35,7 +35,6 @@ macro_rules! arena_types {
             )>,
             [] crate_for_resolver: rustc_data_structures::steal::Steal<(rustc_ast::Crate, rustc_ast::AttrVec)>,
             [] resolutions: rustc_middle::ty::ResolverGlobalCtxt,
-            [decode] code_region: rustc_middle::mir::coverage::CodeRegion,
             [] const_allocs: rustc_middle::mir::interpret::Allocation,
             [] region_scope_tree: rustc_middle::middle::region::ScopeTree,
             // Required for the incremental on-disk cache
diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs
index 401f6da6526aa..46203ee150f64 100644
--- a/compiler/rustc_middle/src/ty/codec.rs
+++ b/compiler/rustc_middle/src/ty/codec.rs
@@ -462,7 +462,6 @@ impl_decodable_via_ref! {
     &'tcx traits::ImplSource<'tcx, ()>,
     &'tcx mir::Body<'tcx>,
     &'tcx mir::BorrowCheckResult<'tcx>,
-    &'tcx mir::coverage::CodeRegion,
     &'tcx ty::List<ty::BoundVariableKind>,
     &'tcx ty::ListWithCachedTypeInfo<ty::Clause<'tcx>>,
     &'tcx ty::List<FieldIdx>,

From 5e162a8f484dcaeeb094d3f7ef5c60c0ec467626 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 28 Aug 2024 22:07:57 +1000
Subject: [PATCH 677/685] coverage: Simplify some debug logging

---
 compiler/rustc_mir_transform/src/coverage/mod.rs | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/compiler/rustc_mir_transform/src/coverage/mod.rs b/compiler/rustc_mir_transform/src/coverage/mod.rs
index 96ca3b43d5c2a..a3ba0deba26f1 100644
--- a/compiler/rustc_mir_transform/src/coverage/mod.rs
+++ b/compiler/rustc_mir_transform/src/coverage/mod.rs
@@ -362,19 +362,13 @@ fn inject_statement(mir_body: &mut mir::Body<'_>, counter_kind: CoverageKind, bb
 /// but it's hard to rule out entirely (especially in the presence of complex macros
 /// or other expansions), and if it does happen then skipping a span or function is
 /// better than an ICE or `llvm-cov` failure that the user might have no way to avoid.
+#[instrument(level = "debug", skip(source_map))]
 fn make_code_region(
     source_map: &SourceMap,
     file_name: Symbol,
     span: Span,
     body_span: Span,
 ) -> Option<CodeRegion> {
-    debug!(
-        "Called make_code_region(file_name={}, span={}, body_span={})",
-        file_name,
-        source_map.span_to_diagnostic_string(span),
-        source_map.span_to_diagnostic_string(body_span)
-    );
-
     let lo = span.lo();
     let hi = span.hi();
 

From 46e1b5b6dd4454b52566efa8ddfa800daa20f067 Mon Sep 17 00:00:00 2001
From: Zalathar <Zalathar@users.noreply.github.com>
Date: Wed, 28 Aug 2024 18:46:49 +1000
Subject: [PATCH 678/685] coverage: Rename `CodeRegion` to `SourceRegion`

LLVM uses the word "code" to refer to a particular kind of coverage mapping.
This unrelated usage of the word is confusing, and makes it harder to introduce
types whose names correspond to the LLVM classification of coverage kinds.
---
 .../src/coverageinfo/ffi.rs                   |  7 ++--
 .../src/coverageinfo/map_data.rs              | 12 +++---
 compiler/rustc_middle/src/mir/coverage.rs     |  6 +--
 compiler/rustc_middle/src/mir/pretty.rs       |  4 +-
 .../rustc_mir_transform/src/coverage/mod.rs   | 40 +++++++++----------
 5 files changed, 35 insertions(+), 34 deletions(-)

diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs
index cabdd310d1fc8..d7a4f105f3c41 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/ffi.rs
@@ -1,5 +1,5 @@
 use rustc_middle::mir::coverage::{
-    CodeRegion, ConditionInfo, CounterId, CovTerm, DecisionInfo, ExpressionId, MappingKind,
+    ConditionInfo, CounterId, CovTerm, DecisionInfo, ExpressionId, MappingKind, SourceRegion,
 };
 
 /// Must match the layout of `LLVMRustCounterKind`.
@@ -236,9 +236,10 @@ impl CounterMappingRegion {
     pub(crate) fn from_mapping(
         mapping_kind: &MappingKind,
         local_file_id: u32,
-        code_region: &CodeRegion,
+        source_region: &SourceRegion,
     ) -> Self {
-        let &CodeRegion { file_name: _, start_line, start_col, end_line, end_col } = code_region;
+        let &SourceRegion { file_name: _, start_line, start_col, end_line, end_col } =
+            source_region;
         match *mapping_kind {
             MappingKind::Code(term) => Self::code_region(
                 Counter::from_term(term),
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
index 44eafab6060b3..5ed640b840e76 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
@@ -2,8 +2,8 @@ use rustc_data_structures::captures::Captures;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_index::bit_set::BitSet;
 use rustc_middle::mir::coverage::{
-    CodeRegion, CounterId, CovTerm, Expression, ExpressionId, FunctionCoverageInfo, Mapping,
-    MappingKind, Op,
+    CounterId, CovTerm, Expression, ExpressionId, FunctionCoverageInfo, Mapping, MappingKind, Op,
+    SourceRegion,
 };
 use rustc_middle::ty::Instance;
 use rustc_span::Symbol;
@@ -201,7 +201,7 @@ impl<'tcx> FunctionCoverage<'tcx> {
 
     /// Returns an iterator over all filenames used by this function's mappings.
     pub(crate) fn all_file_names(&self) -> impl Iterator<Item = Symbol> + Captures<'_> {
-        self.function_coverage_info.mappings.iter().map(|mapping| mapping.code_region.file_name)
+        self.function_coverage_info.mappings.iter().map(|mapping| mapping.source_region.file_name)
     }
 
     /// Convert this function's coverage expression data into a form that can be
@@ -230,12 +230,12 @@ impl<'tcx> FunctionCoverage<'tcx> {
     /// that will be used by `mapgen` when preparing for FFI.
     pub(crate) fn counter_regions(
         &self,
-    ) -> impl Iterator<Item = (MappingKind, &CodeRegion)> + ExactSizeIterator {
+    ) -> impl Iterator<Item = (MappingKind, &SourceRegion)> + ExactSizeIterator {
         self.function_coverage_info.mappings.iter().map(move |mapping| {
-            let Mapping { kind, code_region } = mapping;
+            let Mapping { kind, source_region } = mapping;
             let kind =
                 kind.map_terms(|term| if self.is_zero_term(term) { CovTerm::Zero } else { term });
-            (kind, code_region)
+            (kind, source_region)
         })
     }
 
diff --git a/compiler/rustc_middle/src/mir/coverage.rs b/compiler/rustc_middle/src/mir/coverage.rs
index b11c523cfe964..bfe2a2c2cb3db 100644
--- a/compiler/rustc_middle/src/mir/coverage.rs
+++ b/compiler/rustc_middle/src/mir/coverage.rs
@@ -163,7 +163,7 @@ impl Debug for CoverageKind {
 
 #[derive(Clone, TyEncodable, TyDecodable, Hash, HashStable, PartialEq, Eq, PartialOrd, Ord)]
 #[derive(TypeFoldable, TypeVisitable)]
-pub struct CodeRegion {
+pub struct SourceRegion {
     pub file_name: Symbol,
     pub start_line: u32,
     pub start_col: u32,
@@ -171,7 +171,7 @@ pub struct CodeRegion {
     pub end_col: u32,
 }
 
-impl Debug for CodeRegion {
+impl Debug for SourceRegion {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         write!(
             fmt,
@@ -242,7 +242,7 @@ impl MappingKind {
 #[derive(TyEncodable, TyDecodable, Hash, HashStable, TypeFoldable, TypeVisitable)]
 pub struct Mapping {
     pub kind: MappingKind,
-    pub code_region: CodeRegion,
+    pub source_region: SourceRegion,
 }
 
 /// Stores per-function coverage information attached to a `mir::Body`,
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index efdc0c710ba7e..6785805c27df3 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -547,8 +547,8 @@ fn write_function_coverage_info(
     for (id, expression) in expressions.iter_enumerated() {
         writeln!(w, "{INDENT}coverage {id:?} => {expression:?};")?;
     }
-    for coverage::Mapping { kind, code_region } in mappings {
-        writeln!(w, "{INDENT}coverage {kind:?} => {code_region:?};")?;
+    for coverage::Mapping { kind, source_region } in mappings {
+        writeln!(w, "{INDENT}coverage {kind:?} => {source_region:?};")?;
     }
     writeln!(w)?;
 
diff --git a/compiler/rustc_mir_transform/src/coverage/mod.rs b/compiler/rustc_mir_transform/src/coverage/mod.rs
index a3ba0deba26f1..af0f1e38a754e 100644
--- a/compiler/rustc_mir_transform/src/coverage/mod.rs
+++ b/compiler/rustc_mir_transform/src/coverage/mod.rs
@@ -13,7 +13,7 @@ use rustc_hir::intravisit::{walk_expr, Visitor};
 use rustc_middle::hir::map::Map;
 use rustc_middle::hir::nested_filter;
 use rustc_middle::mir::coverage::{
-    CodeRegion, CoverageKind, DecisionInfo, FunctionCoverageInfo, Mapping, MappingKind,
+    CoverageKind, DecisionInfo, FunctionCoverageInfo, Mapping, MappingKind, SourceRegion,
 };
 use rustc_middle::mir::{
     self, BasicBlock, BasicBlockData, SourceInfo, Statement, StatementKind, Terminator,
@@ -159,7 +159,7 @@ fn create_mappings<'tcx>(
             .expect("all BCBs with spans were given counters")
             .as_term()
     };
-    let region_for_span = |span: Span| make_code_region(source_map, file_name, span, body_span);
+    let region_for_span = |span: Span| make_source_region(source_map, file_name, span, body_span);
 
     // Fully destructure the mappings struct to make sure we don't miss any kinds.
     let ExtractedMappings {
@@ -175,9 +175,9 @@ fn create_mappings<'tcx>(
     mappings.extend(code_mappings.iter().filter_map(
         // Ordinary code mappings are the simplest kind.
         |&mappings::CodeMapping { span, bcb }| {
-            let code_region = region_for_span(span)?;
+            let source_region = region_for_span(span)?;
             let kind = MappingKind::Code(term_for_bcb(bcb));
-            Some(Mapping { kind, code_region })
+            Some(Mapping { kind, source_region })
         },
     ));
 
@@ -186,29 +186,29 @@ fn create_mappings<'tcx>(
             let true_term = term_for_bcb(true_bcb);
             let false_term = term_for_bcb(false_bcb);
             let kind = MappingKind::Branch { true_term, false_term };
-            let code_region = region_for_span(span)?;
-            Some(Mapping { kind, code_region })
+            let source_region = region_for_span(span)?;
+            Some(Mapping { kind, source_region })
         },
     ));
 
     mappings.extend(mcdc_branches.iter().filter_map(
         |&mappings::MCDCBranch { span, true_bcb, false_bcb, condition_info, decision_depth: _ }| {
-            let code_region = region_for_span(span)?;
+            let source_region = region_for_span(span)?;
             let true_term = term_for_bcb(true_bcb);
             let false_term = term_for_bcb(false_bcb);
             let kind = match condition_info {
                 Some(mcdc_params) => MappingKind::MCDCBranch { true_term, false_term, mcdc_params },
                 None => MappingKind::Branch { true_term, false_term },
             };
-            Some(Mapping { kind, code_region })
+            Some(Mapping { kind, source_region })
         },
     ));
 
     mappings.extend(mcdc_decisions.iter().filter_map(
         |&mappings::MCDCDecision { span, bitmap_idx, num_conditions, .. }| {
-            let code_region = region_for_span(span)?;
+            let source_region = region_for_span(span)?;
             let kind = MappingKind::MCDCDecision(DecisionInfo { bitmap_idx, num_conditions });
-            Some(Mapping { kind, code_region })
+            Some(Mapping { kind, source_region })
         },
     ));
 
@@ -363,12 +363,12 @@ fn inject_statement(mir_body: &mut mir::Body<'_>, counter_kind: CoverageKind, bb
 /// or other expansions), and if it does happen then skipping a span or function is
 /// better than an ICE or `llvm-cov` failure that the user might have no way to avoid.
 #[instrument(level = "debug", skip(source_map))]
-fn make_code_region(
+fn make_source_region(
     source_map: &SourceMap,
     file_name: Symbol,
     span: Span,
     body_span: Span,
-) -> Option<CodeRegion> {
+) -> Option<SourceRegion> {
     let lo = span.lo();
     let hi = span.hi();
 
@@ -418,7 +418,7 @@ fn make_code_region(
     start_line = source_map.doctest_offset_line(&file.name, start_line);
     end_line = source_map.doctest_offset_line(&file.name, end_line);
 
-    check_code_region(CodeRegion {
+    check_source_region(SourceRegion {
         file_name,
         start_line: start_line as u32,
         start_col: start_col as u32,
@@ -427,12 +427,12 @@ fn make_code_region(
     })
 }
 
-/// If `llvm-cov` sees a code region that is improperly ordered (end < start),
+/// If `llvm-cov` sees a source region that is improperly ordered (end < start),
 /// it will immediately exit with a fatal error. To prevent that from happening,
 /// discard regions that are improperly ordered, or might be interpreted in a
 /// way that makes them improperly ordered.
-fn check_code_region(code_region: CodeRegion) -> Option<CodeRegion> {
-    let CodeRegion { file_name: _, start_line, start_col, end_line, end_col } = code_region;
+fn check_source_region(source_region: SourceRegion) -> Option<SourceRegion> {
+    let SourceRegion { file_name: _, start_line, start_col, end_line, end_col } = source_region;
 
     // Line/column coordinates are supposed to be 1-based. If we ever emit
     // coordinates of 0, `llvm-cov` might misinterpret them.
@@ -445,17 +445,17 @@ fn check_code_region(code_region: CodeRegion) -> Option<CodeRegion> {
     let is_ordered = (start_line, start_col) <= (end_line, end_col);
 
     if all_nonzero && end_col_has_high_bit_unset && is_ordered {
-        Some(code_region)
+        Some(source_region)
     } else {
         debug!(
-            ?code_region,
+            ?source_region,
             ?all_nonzero,
             ?end_col_has_high_bit_unset,
             ?is_ordered,
-            "Skipping code region that would be misinterpreted or rejected by LLVM"
+            "Skipping source region that would be misinterpreted or rejected by LLVM"
         );
         // If this happens in a debug build, ICE to make it easier to notice.
-        debug_assert!(false, "Improper code region: {code_region:?}");
+        debug_assert!(false, "Improper source region: {source_region:?}");
         None
     }
 }

From 4e6cd0f8e748331807f51c28ac9dfb18f05fdaf9 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Wed, 28 Aug 2024 17:31:22 +0200
Subject: [PATCH 679/685] Fix path to run clippy on rustdoc

---
 src/bootstrap/src/core/build_steps/clippy.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bootstrap/src/core/build_steps/clippy.rs b/src/bootstrap/src/core/build_steps/clippy.rs
index 4ee9fbc314263..a2bb03cd5ac81 100644
--- a/src/bootstrap/src/core/build_steps/clippy.rs
+++ b/src/bootstrap/src/core/build_steps/clippy.rs
@@ -313,7 +313,7 @@ lint_any!(
     RemoteTestServer, "src/tools/remote-test-server", "remote-test-server";
     Rls, "src/tools/rls", "rls";
     RustAnalyzer, "src/tools/rust-analyzer", "rust-analyzer";
-    Rustdoc, "src/tools/rustdoc", "clippy";
+    Rustdoc, "src/librustdoc", "clippy";
     Rustfmt, "src/tools/rustfmt", "rustfmt";
     RustInstaller, "src/tools/rust-installer", "rust-installer";
     Tidy, "src/tools/tidy", "tidy";

From 19296ca23c08d2f272f1f0ccbafa94f6c00984c1 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Wed, 28 Aug 2024 10:58:35 -0400
Subject: [PATCH 680/685] Move 'tcx lifetime off of impl and onto methods

---
 compiler/rustc_metadata/src/rmeta/decoder.rs | 32 +++++++++++---------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index a13eac08c9fd2..7321e2c760cef 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -962,7 +962,7 @@ impl CrateRoot {
     }
 }
 
-impl<'a, 'tcx> CrateMetadataRef<'a> {
+impl<'a> CrateMetadataRef<'a> {
     fn missing(self, descr: &str, id: DefIndex) -> ! {
         bug!("missing `{descr}` for {:?}", self.local_def_id(id))
     }
@@ -1036,7 +1036,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
             .decode((self, sess))
     }
 
-    fn load_proc_macro(self, id: DefIndex, tcx: TyCtxt<'tcx>) -> SyntaxExtension {
+    fn load_proc_macro<'tcx>(self, id: DefIndex, tcx: TyCtxt<'tcx>) -> SyntaxExtension {
         let (name, kind, helper_attrs) = match *self.raw_proc_macro(id) {
             ProcMacro::CustomDerive { trait_name, attributes, client } => {
                 let helper_attrs =
@@ -1070,7 +1070,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         )
     }
 
-    fn get_explicit_item_bounds(
+    fn get_explicit_item_bounds<'tcx>(
         self,
         index: DefIndex,
         tcx: TyCtxt<'tcx>,
@@ -1084,7 +1084,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         ty::EarlyBinder::bind(&*output)
     }
 
-    fn get_explicit_item_super_predicates(
+    fn get_explicit_item_super_predicates<'tcx>(
         self,
         index: DefIndex,
         tcx: TyCtxt<'tcx>,
@@ -1141,7 +1141,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         )
     }
 
-    fn get_adt_def(self, item_id: DefIndex, tcx: TyCtxt<'tcx>) -> ty::AdtDef<'tcx> {
+    fn get_adt_def<'tcx>(self, item_id: DefIndex, tcx: TyCtxt<'tcx>) -> ty::AdtDef<'tcx> {
         let kind = self.def_kind(item_id);
         let did = self.local_def_id(item_id);
 
@@ -1225,12 +1225,12 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
     /// Iterates over the stability implications in the given crate (when a `#[unstable]` attribute
     /// has an `implied_by` meta item, then the mapping from the implied feature to the actual
     /// feature is a stability implication).
-    fn get_stability_implications(self, tcx: TyCtxt<'tcx>) -> &'tcx [(Symbol, Symbol)] {
+    fn get_stability_implications<'tcx>(self, tcx: TyCtxt<'tcx>) -> &'tcx [(Symbol, Symbol)] {
         tcx.arena.alloc_from_iter(self.root.stability_implications.decode(self))
     }
 
     /// Iterates over the lang items in the given crate.
-    fn get_lang_items(self, tcx: TyCtxt<'tcx>) -> &'tcx [(DefId, LangItem)] {
+    fn get_lang_items<'tcx>(self, tcx: TyCtxt<'tcx>) -> &'tcx [(DefId, LangItem)] {
         tcx.arena.alloc_from_iter(
             self.root
                 .lang_items
@@ -1239,7 +1239,11 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         )
     }
 
-    fn get_stripped_cfg_items(self, cnum: CrateNum, tcx: TyCtxt<'tcx>) -> &'tcx [StrippedCfgItem] {
+    fn get_stripped_cfg_items<'tcx>(
+        self,
+        cnum: CrateNum,
+        tcx: TyCtxt<'tcx>,
+    ) -> &'tcx [StrippedCfgItem] {
         let item_names = self
             .root
             .stripped_cfg_items
@@ -1412,7 +1416,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
             .decode((self, sess))
     }
 
-    fn get_inherent_implementations_for_type(
+    fn get_inherent_implementations_for_type<'tcx>(
         self,
         tcx: TyCtxt<'tcx>,
         id: DefIndex,
@@ -1439,7 +1443,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         })
     }
 
-    fn get_incoherent_impls(self, tcx: TyCtxt<'tcx>, simp: SimplifiedType) -> &'tcx [DefId] {
+    fn get_incoherent_impls<'tcx>(self, tcx: TyCtxt<'tcx>, simp: SimplifiedType) -> &'tcx [DefId] {
         if let Some(impls) = self.cdata.incoherent_impls.get(&simp) {
             tcx.arena.alloc_from_iter(impls.decode(self).map(|idx| self.local_def_id(idx)))
         } else {
@@ -1447,7 +1451,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         }
     }
 
-    fn get_implementations_of_trait(
+    fn get_implementations_of_trait<'tcx>(
         self,
         tcx: TyCtxt<'tcx>,
         trait_def_id: DefId,
@@ -1491,7 +1495,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         self.root.foreign_modules.decode((self, sess))
     }
 
-    fn get_dylib_dependency_formats(
+    fn get_dylib_dependency_formats<'tcx>(
         self,
         tcx: TyCtxt<'tcx>,
     ) -> &'tcx [(CrateNum, LinkagePreference)] {
@@ -1503,11 +1507,11 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
         )
     }
 
-    fn get_missing_lang_items(self, tcx: TyCtxt<'tcx>) -> &'tcx [LangItem] {
+    fn get_missing_lang_items<'tcx>(self, tcx: TyCtxt<'tcx>) -> &'tcx [LangItem] {
         tcx.arena.alloc_from_iter(self.root.lang_items_missing.decode(self))
     }
 
-    fn exported_symbols(
+    fn exported_symbols<'tcx>(
         self,
         tcx: TyCtxt<'tcx>,
     ) -> &'tcx [(ExportedSymbol<'tcx>, SymbolExportInfo)] {

From 7c4cc9fb79bce08262be968fc02ca7e01aa2a743 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Wed, 28 Aug 2024 10:10:39 -0700
Subject: [PATCH 681/685] Update reference

---
 src/doc/reference | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/doc/reference b/src/doc/reference
index f0f6155220ca3..0668397076da3 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit f0f6155220ca307881f185e44d0c325c5af75ad2
+Subproject commit 0668397076da350c404dadcf07b6cbc433ad3743

From 39148351bd919d16920b00e0bd70203b73db53bb Mon Sep 17 00:00:00 2001
From: Ding Xiang Fei <dingxiangfei2009@protonmail.ch>
Date: Fri, 23 Aug 2024 21:07:18 +0800
Subject: [PATCH 682/685] derive(SmartPointer): assume pointee from the single
 generic and better error messages

---
 .../src/deriving/smart_ptr.rs                 | 75 ++++++++++++-------
 .../deriving-smart-pointer-expanded.rs        |  6 ++
 .../deriving-smart-pointer-expanded.stdout    | 15 ++++
 .../ui/deriving/deriving-smart-pointer-neg.rs | 24 ++++--
 .../deriving-smart-pointer-neg.stderr         | 32 +++++---
 5 files changed, 108 insertions(+), 44 deletions(-)

diff --git a/compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs b/compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs
index 7eb1f17a59ce3..b3695d5fb4986 100644
--- a/compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/smart_ptr.rs
@@ -11,7 +11,6 @@ use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_span::symbol::{sym, Ident};
 use rustc_span::{Span, Symbol};
-use smallvec::{smallvec, SmallVec};
 use thin_vec::{thin_vec, ThinVec};
 
 macro_rules! path {
@@ -68,43 +67,63 @@ pub fn expand_deriving_smart_ptr(
     };
 
     // Convert generic parameters (from the struct) into generic args.
-    let mut pointee_param = None;
-    let mut multiple_pointee_diag: SmallVec<[_; 2]> = smallvec![];
-    let self_params = generics
+    let self_params: Vec<_> = generics
         .params
         .iter()
-        .enumerate()
-        .map(|(idx, p)| match p.kind {
+        .map(|p| match p.kind {
             GenericParamKind::Lifetime => GenericArg::Lifetime(cx.lifetime(p.span(), p.ident)),
-            GenericParamKind::Type { .. } => {
-                if p.attrs().iter().any(|attr| attr.has_name(sym::pointee)) {
-                    if pointee_param.is_some() {
-                        multiple_pointee_diag.push(cx.dcx().struct_span_err(
-                            p.span(),
-                            "`SmartPointer` can only admit one type as pointee",
-                        ));
-                    } else {
-                        pointee_param = Some(idx);
-                    }
-                }
-                GenericArg::Type(cx.ty_ident(p.span(), p.ident))
-            }
+            GenericParamKind::Type { .. } => GenericArg::Type(cx.ty_ident(p.span(), p.ident)),
             GenericParamKind::Const { .. } => GenericArg::Const(cx.const_ident(p.span(), p.ident)),
         })
-        .collect::<Vec<_>>();
-    let Some(pointee_param_idx) = pointee_param else {
+        .collect();
+    let type_params: Vec<_> = generics
+        .params
+        .iter()
+        .enumerate()
+        .filter_map(|(idx, p)| {
+            if let GenericParamKind::Type { .. } = p.kind {
+                Some((idx, p.span(), p.attrs().iter().any(|attr| attr.has_name(sym::pointee))))
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    let pointee_param_idx = if type_params.is_empty() {
+        // `#[derive(SmartPointer)]` requires at least one generic type on the target `struct`
         cx.dcx().struct_span_err(
             span,
-            "At least one generic type should be designated as `#[pointee]` in order to derive `SmartPointer` traits",
+            "`SmartPointer` can only be derived on `struct`s that are generic over at least one type",
         ).emit();
         return;
-    };
-    if !multiple_pointee_diag.is_empty() {
-        for diag in multiple_pointee_diag {
-            diag.emit();
+    } else if type_params.len() == 1 {
+        // Regardless of the only type param being designed as `#[pointee]` or not, we can just use it as such
+        type_params[0].0
+    } else {
+        let mut pointees = type_params
+            .iter()
+            .filter_map(|&(idx, span, is_pointee)| is_pointee.then_some((idx, span)))
+            .fuse();
+        match (pointees.next(), pointees.next()) {
+            (Some((idx, _span)), None) => idx,
+            (None, _) => {
+                cx.dcx().struct_span_err(
+                    span,
+                    "exactly one generic type parameter must be marked as #[pointee] to derive SmartPointer traits",
+                ).emit();
+                return;
+            }
+            (Some((_, one)), Some((_, another))) => {
+                cx.dcx()
+                    .struct_span_err(
+                        vec![one, another],
+                        "only one type parameter can be marked as `#[pointee]` when deriving SmartPointer traits",
+                    )
+                    .emit();
+                return;
+            }
         }
-        return;
-    }
+    };
 
     // Create the type of `self`.
     let path = cx.path_all(span, false, vec![name_ident], self_params.clone());
diff --git a/tests/ui/deriving/deriving-smart-pointer-expanded.rs b/tests/ui/deriving/deriving-smart-pointer-expanded.rs
index b78258c25290e..e48ad3dd4bc6c 100644
--- a/tests/ui/deriving/deriving-smart-pointer-expanded.rs
+++ b/tests/ui/deriving/deriving-smart-pointer-expanded.rs
@@ -20,3 +20,9 @@ where
     data: &'a mut T,
     x: core::marker::PhantomData<X>,
 }
+
+#[derive(SmartPointer)]
+#[repr(transparent)]
+struct MyPointerWithoutPointee<'a, T: ?Sized> {
+    ptr: &'a T,
+}
diff --git a/tests/ui/deriving/deriving-smart-pointer-expanded.stdout b/tests/ui/deriving/deriving-smart-pointer-expanded.stdout
index 3c7e719818042..68ef17f2b0547 100644
--- a/tests/ui/deriving/deriving-smart-pointer-expanded.stdout
+++ b/tests/ui/deriving/deriving-smart-pointer-expanded.stdout
@@ -42,3 +42,18 @@ impl<'a, Y, Z: MyTrait<T> + MyTrait<__S>, T: ?Sized + MyTrait<T> +
     MyTrait<__S>> ::core::ops::CoerceUnsized<MyPointer2<'a, Y, Z, __S, X>> for
     MyPointer2<'a, Y, Z, T, X> where Y: MyTrait<T>, Y: MyTrait<__S> {
 }
+
+#[repr(transparent)]
+struct MyPointerWithoutPointee<'a, T: ?Sized> {
+    ptr: &'a T,
+}
+#[automatically_derived]
+impl<'a, T: ?Sized + ::core::marker::Unsize<__S>, __S: ?Sized>
+    ::core::ops::DispatchFromDyn<MyPointerWithoutPointee<'a, __S>> for
+    MyPointerWithoutPointee<'a, T> {
+}
+#[automatically_derived]
+impl<'a, T: ?Sized + ::core::marker::Unsize<__S>, __S: ?Sized>
+    ::core::ops::CoerceUnsized<MyPointerWithoutPointee<'a, __S>> for
+    MyPointerWithoutPointee<'a, T> {
+}
diff --git a/tests/ui/deriving/deriving-smart-pointer-neg.rs b/tests/ui/deriving/deriving-smart-pointer-neg.rs
index 04f52a154fe42..f02fb56130fa7 100644
--- a/tests/ui/deriving/deriving-smart-pointer-neg.rs
+++ b/tests/ui/deriving/deriving-smart-pointer-neg.rs
@@ -9,13 +9,6 @@ enum NotStruct<'a, T: ?Sized> {
     Variant(&'a T),
 }
 
-#[derive(SmartPointer)]
-//~^ ERROR: At least one generic type should be designated as `#[pointee]` in order to derive `SmartPointer` traits
-#[repr(transparent)]
-struct NoPointee<'a, T: ?Sized> {
-    ptr: &'a T,
-}
-
 #[derive(SmartPointer)]
 //~^ ERROR: `SmartPointer` can only be derived on `struct`s with at least one field
 #[repr(transparent)]
@@ -30,6 +23,23 @@ struct NoFieldUnit<'a, #[pointee] T: ?Sized>();
 //~^ ERROR: lifetime parameter `'a` is never used
 //~| ERROR: type parameter `T` is never used
 
+#[derive(SmartPointer)]
+//~^ ERROR: `SmartPointer` can only be derived on `struct`s that are generic over at least one type
+#[repr(transparent)]
+struct NoGeneric<'a>(&'a u8);
+
+#[derive(SmartPointer)]
+//~^ ERROR: exactly one generic type parameter must be marked as #[pointee] to derive SmartPointer traits
+#[repr(transparent)]
+struct AmbiguousPointee<'a, T1: ?Sized, T2: ?Sized> {
+    a: (&'a T1, &'a T2),
+}
+
+#[derive(SmartPointer)]
+#[repr(transparent)]
+struct TooManyPointees<'a, #[pointee] A: ?Sized, #[pointee] B: ?Sized>((&'a A, &'a B));
+//~^ ERROR: only one type parameter can be marked as `#[pointee]` when deriving SmartPointer traits
+
 #[derive(SmartPointer)]
 //~^ ERROR: `SmartPointer` can only be derived on `struct`s with `#[repr(transparent)]`
 struct NotTransparent<'a, #[pointee] T: ?Sized> {
diff --git a/tests/ui/deriving/deriving-smart-pointer-neg.stderr b/tests/ui/deriving/deriving-smart-pointer-neg.stderr
index 8b0f91d41fb88..e7c2afc8b00c7 100644
--- a/tests/ui/deriving/deriving-smart-pointer-neg.stderr
+++ b/tests/ui/deriving/deriving-smart-pointer-neg.stderr
@@ -6,7 +6,7 @@ LL | #[derive(SmartPointer)]
    |
    = note: this error originates in the derive macro `SmartPointer` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: At least one generic type should be designated as `#[pointee]` in order to derive `SmartPointer` traits
+error: `SmartPointer` can only be derived on `struct`s with at least one field
   --> $DIR/deriving-smart-pointer-neg.rs:12:10
    |
 LL | #[derive(SmartPointer)]
@@ -22,7 +22,7 @@ LL | #[derive(SmartPointer)]
    |
    = note: this error originates in the derive macro `SmartPointer` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: `SmartPointer` can only be derived on `struct`s with at least one field
+error: `SmartPointer` can only be derived on `struct`s that are generic over at least one type
   --> $DIR/deriving-smart-pointer-neg.rs:26:10
    |
 LL | #[derive(SmartPointer)]
@@ -30,8 +30,22 @@ LL | #[derive(SmartPointer)]
    |
    = note: this error originates in the derive macro `SmartPointer` (in Nightly builds, run with -Z macro-backtrace for more info)
 
+error: exactly one generic type parameter must be marked as #[pointee] to derive SmartPointer traits
+  --> $DIR/deriving-smart-pointer-neg.rs:31:10
+   |
+LL | #[derive(SmartPointer)]
+   |          ^^^^^^^^^^^^
+   |
+   = note: this error originates in the derive macro `SmartPointer` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: only one type parameter can be marked as `#[pointee]` when deriving SmartPointer traits
+  --> $DIR/deriving-smart-pointer-neg.rs:40:39
+   |
+LL | struct TooManyPointees<'a, #[pointee] A: ?Sized, #[pointee] B: ?Sized>((&'a A, &'a B));
+   |                                       ^                     ^
+
 error: `SmartPointer` can only be derived on `struct`s with `#[repr(transparent)]`
-  --> $DIR/deriving-smart-pointer-neg.rs:33:10
+  --> $DIR/deriving-smart-pointer-neg.rs:43:10
    |
 LL | #[derive(SmartPointer)]
    |          ^^^^^^^^^^^^
@@ -39,13 +53,13 @@ LL | #[derive(SmartPointer)]
    = note: this error originates in the derive macro `SmartPointer` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `derive(SmartPointer)` requires T to be marked `?Sized`
-  --> $DIR/deriving-smart-pointer-neg.rs:41:36
+  --> $DIR/deriving-smart-pointer-neg.rs:51:36
    |
 LL | struct NoMaybeSized<'a, #[pointee] T> {
    |                                    ^
 
 error[E0392]: lifetime parameter `'a` is never used
-  --> $DIR/deriving-smart-pointer-neg.rs:22:16
+  --> $DIR/deriving-smart-pointer-neg.rs:15:16
    |
 LL | struct NoField<'a, #[pointee] T: ?Sized> {}
    |                ^^ unused lifetime parameter
@@ -53,7 +67,7 @@ LL | struct NoField<'a, #[pointee] T: ?Sized> {}
    = help: consider removing `'a`, referring to it in a field, or using a marker such as `PhantomData`
 
 error[E0392]: type parameter `T` is never used
-  --> $DIR/deriving-smart-pointer-neg.rs:22:31
+  --> $DIR/deriving-smart-pointer-neg.rs:15:31
    |
 LL | struct NoField<'a, #[pointee] T: ?Sized> {}
    |                               ^ unused type parameter
@@ -61,7 +75,7 @@ LL | struct NoField<'a, #[pointee] T: ?Sized> {}
    = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
 
 error[E0392]: lifetime parameter `'a` is never used
-  --> $DIR/deriving-smart-pointer-neg.rs:29:20
+  --> $DIR/deriving-smart-pointer-neg.rs:22:20
    |
 LL | struct NoFieldUnit<'a, #[pointee] T: ?Sized>();
    |                    ^^ unused lifetime parameter
@@ -69,13 +83,13 @@ LL | struct NoFieldUnit<'a, #[pointee] T: ?Sized>();
    = help: consider removing `'a`, referring to it in a field, or using a marker such as `PhantomData`
 
 error[E0392]: type parameter `T` is never used
-  --> $DIR/deriving-smart-pointer-neg.rs:29:35
+  --> $DIR/deriving-smart-pointer-neg.rs:22:35
    |
 LL | struct NoFieldUnit<'a, #[pointee] T: ?Sized>();
    |                                   ^ unused type parameter
    |
    = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
 
-error: aborting due to 10 previous errors
+error: aborting due to 12 previous errors
 
 For more information about this error, try `rustc --explain E0392`.

From b013a3ddf0060b62ee8050e241f80d024c48cc59 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Esteban=20K=C3=BCber?= <esteban@kuber.com.ar>
Date: Wed, 21 Aug 2024 03:17:47 +0000
Subject: [PATCH 683/685] Emit specific message for `time<0.3.35` inference
 failure

```
error[E0282]: type annotations needed for `Box<_>`
  --> ~/.cargo/registry/src/index.crates.io-6f17d22bba15001f/time-0.3.34/src/format_description/parse/mod.rs:83:9
   |
83 |     let items = format_items
   |         ^^^^^
...
86 |     Ok(items.into())
   |              ---- type must be known at this point
   |
   = note: this is an inference error on crate `time` caused by a change in Rust 1.80.0; update `time` to version `>=0.3.35`
```

Partially address #127343.
---
 compiler/rustc_span/src/symbol.rs             |  1 +
 compiler/rustc_trait_selection/messages.ftl   |  2 +
 .../error_reporting/infer/need_type_info.rs   | 46 ++++++++++++++++++-
 compiler/rustc_trait_selection/src/errors.rs  |  2 +
 compiler/rustc_trait_selection/src/lib.rs     |  1 +
 ...d-time-version-format_description-parse.rs |  8 ++++
 ...me-version-format_description-parse.stderr | 11 +++++
 7 files changed, 69 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/inference/detect-old-time-version-format_description-parse.rs
 create mode 100644 tests/ui/inference/detect-old-time-version-format_description-parse.stderr

diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 2957105288bb3..7a544d7c8375b 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1896,6 +1896,7 @@ symbols! {
         three_way_compare,
         thumb2,
         thumb_mode: "thumb-mode",
+        time,
         tmm_reg,
         to_owned_method,
         to_string,
diff --git a/compiler/rustc_trait_selection/messages.ftl b/compiler/rustc_trait_selection/messages.ftl
index 137850f31d31e..3ddd23924b5f4 100644
--- a/compiler/rustc_trait_selection/messages.ftl
+++ b/compiler/rustc_trait_selection/messages.ftl
@@ -446,6 +446,8 @@ trait_selection_type_annotations_needed = {$source_kind ->
 }
     .label = type must be known at this point
 
+trait_selection_type_annotations_needed_error_time = this is an inference error on crate `time` caused by an API change in Rust 1.80.0; update `time` to version `>=0.3.35` by calling `cargo update`
+
 trait_selection_types_declared_different = these two types are declared with different lifetimes...
 
 trait_selection_unable_to_construct_constant_value = unable to construct a constant value for the unevaluated constant {$unevaluated}
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index 173671059ca93..53f013ac153b1 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -6,7 +6,7 @@ use rustc_errors::codes::*;
 use rustc_errors::{Diag, IntoDiagArg};
 use rustc_hir as hir;
 use rustc_hir::def::{CtorOf, DefKind, Namespace, Res};
-use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::def_id::{DefId, LocalDefId, LOCAL_CRATE};
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{Body, Closure, Expr, ExprKind, FnRetTy, HirId, LetStmt, LocalSource};
 use rustc_middle::bug;
@@ -18,7 +18,7 @@ use rustc_middle::ty::{
     TypeFoldable, TypeFolder, TypeSuperFoldable, TypeckResults,
 };
 use rustc_span::symbol::{sym, Ident};
-use rustc_span::{BytePos, Span, DUMMY_SP};
+use rustc_span::{BytePos, FileName, Span, DUMMY_SP};
 
 use crate::error_reporting::TypeErrCtxt;
 use crate::errors::{
@@ -384,6 +384,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 bad_label,
                 was_written: false,
                 path: Default::default(),
+                time_version: false,
             }),
             TypeAnnotationNeeded::E0283 => self.dcx().create_err(AmbiguousImpl {
                 span,
@@ -577,6 +578,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 }
             }
         }
+
+        let time_version =
+            self.detect_old_time_crate_version(failure_span, &kind, &mut infer_subdiags);
+
         match error_code {
             TypeAnnotationNeeded::E0282 => self.dcx().create_err(AnnotationRequired {
                 span,
@@ -588,6 +593,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 bad_label: None,
                 was_written: path.is_some(),
                 path: path.unwrap_or_default(),
+                time_version,
             }),
             TypeAnnotationNeeded::E0283 => self.dcx().create_err(AmbiguousImpl {
                 span,
@@ -613,6 +619,42 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             }),
         }
     }
+
+    /// Detect the inference regression on crate `time` <= 0.3.35 and emit a more targeted error.
+    /// <https://github.com/rust-lang/rust/issues/127343>
+    // FIXME: we should figure out a more generic version of doing this, ideally in cargo itself.
+    fn detect_old_time_crate_version(
+        &self,
+        span: Option<Span>,
+        kind: &InferSourceKind<'_>,
+        // We will clear the non-actionable suggestion from the error to reduce noise.
+        infer_subdiags: &mut Vec<SourceKindSubdiag<'_>>,
+    ) -> bool {
+        // FIXME(#129461): We are time-boxing this code in the compiler. It'll start failing
+        // compilation once we promote 1.89 to beta, which will happen in 9 months from now.
+        #[cfg(not(version("1.89")))]
+        const fn version_check() {}
+        #[cfg(version("1.89"))]
+        const fn version_check() {
+            panic!("remove this check as presumably the ecosystem has moved from needing it");
+        }
+        const { version_check() };
+        // Only relevant when building the `time` crate.
+        if self.infcx.tcx.crate_name(LOCAL_CRATE) == sym::time
+            && let Some(span) = span
+            && let InferSourceKind::LetBinding { pattern_name, .. } = kind
+            && let Some(name) = pattern_name
+            && name.as_str() == "items"
+            && let FileName::Real(file) = self.infcx.tcx.sess.source_map().span_to_filename(span)
+        {
+            let path = file.local_path_if_available().to_string_lossy();
+            if path.contains("format_description") && path.contains("parse") {
+                infer_subdiags.clear();
+                return true;
+            }
+        }
+        false
+    }
 }
 
 #[derive(Debug)]
diff --git a/compiler/rustc_trait_selection/src/errors.rs b/compiler/rustc_trait_selection/src/errors.rs
index 5384084f6d7c3..ebaec0b905936 100644
--- a/compiler/rustc_trait_selection/src/errors.rs
+++ b/compiler/rustc_trait_selection/src/errors.rs
@@ -205,6 +205,8 @@ pub struct AnnotationRequired<'a> {
     #[note(trait_selection_full_type_written)]
     pub was_written: bool,
     pub path: PathBuf,
+    #[note(trait_selection_type_annotations_needed_error_time)]
+    pub time_version: bool,
 }
 
 // Copy of `AnnotationRequired` for E0283
diff --git a/compiler/rustc_trait_selection/src/lib.rs b/compiler/rustc_trait_selection/src/lib.rs
index 1bd6626693675..c98d6c5f1dfd2 100644
--- a/compiler/rustc_trait_selection/src/lib.rs
+++ b/compiler/rustc_trait_selection/src/lib.rs
@@ -19,6 +19,7 @@
 #![feature(assert_matches)]
 #![feature(associated_type_defaults)]
 #![feature(box_patterns)]
+#![feature(cfg_version)]
 #![feature(control_flow_enum)]
 #![feature(extract_if)]
 #![feature(if_let_guard)]
diff --git a/tests/ui/inference/detect-old-time-version-format_description-parse.rs b/tests/ui/inference/detect-old-time-version-format_description-parse.rs
new file mode 100644
index 0000000000000..453a795e7686b
--- /dev/null
+++ b/tests/ui/inference/detect-old-time-version-format_description-parse.rs
@@ -0,0 +1,8 @@
+#![crate_name = "time"]
+
+fn main() {
+    let items = Box::new(vec![]); //~ ERROR E0282
+    //~^ NOTE type must be known at this point
+    //~| NOTE this is an inference error on crate `time` caused by an API change in Rust 1.80.0; update `time` to version `>=0.3.35`
+    items.into();
+}
diff --git a/tests/ui/inference/detect-old-time-version-format_description-parse.stderr b/tests/ui/inference/detect-old-time-version-format_description-parse.stderr
new file mode 100644
index 0000000000000..2949a5dcfec9c
--- /dev/null
+++ b/tests/ui/inference/detect-old-time-version-format_description-parse.stderr
@@ -0,0 +1,11 @@
+error[E0282]: type annotations needed for `Box<Vec<_>>`
+  --> $DIR/detect-old-time-version-format_description-parse.rs:4:9
+   |
+LL |     let items = Box::new(vec![]);
+   |         ^^^^^   ---------------- type must be known at this point
+   |
+   = note: this is an inference error on crate `time` caused by an API change in Rust 1.80.0; update `time` to version `>=0.3.35` by calling `cargo update`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0282`.

From d8129a1c0163c0561cf113208ada9771ed133f1f Mon Sep 17 00:00:00 2001
From: Nicole LeGare <legaren@immunant.com>
Date: Wed, 28 Aug 2024 16:15:36 -0700
Subject: [PATCH 684/685] Correct trusty targets to be tier 3

---
 .../rustc_target/src/spec/targets/aarch64_unknown_trusty.rs     | 2 +-
 compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs
index 1525faf9b7e1d..9fd7c24649896 100644
--- a/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs
+++ b/compiler/rustc_target/src/spec/targets/aarch64_unknown_trusty.rs
@@ -7,7 +7,7 @@ pub fn target() -> Target {
         llvm_target: "aarch64-unknown-unknown-musl".into(),
         metadata: crate::spec::TargetMetadata {
             description: Some("ARM64 Trusty".into()),
-            tier: Some(2),
+            tier: Some(3),
             host_tools: Some(false),
             std: Some(false),
         },
diff --git a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
index ae73de5e64dc5..889cc20156979 100644
--- a/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
+++ b/compiler/rustc_target/src/spec/targets/armv7_unknown_trusty.rs
@@ -8,7 +8,7 @@ pub fn target() -> Target {
         llvm_target: "armv7-unknown-unknown-gnueabi".into(),
         metadata: crate::spec::TargetMetadata {
             description: Some("Armv7-A Trusty".into()),
-            tier: Some(2),
+            tier: Some(3),
             host_tools: Some(false),
             std: Some(false),
         },

From 555414e6839f60b0c2103b63991f2bf5dfa0b4c6 Mon Sep 17 00:00:00 2001
From: Amjad Alsharafi <26300843+Amjad50@users.noreply.github.com>
Date: Thu, 29 Aug 2024 08:38:19 +0800
Subject: [PATCH 685/685] Update `compiler_builtins` to `0.1.123`

Signed-off-by: Amjad Alsharafi <26300843+Amjad50@users.noreply.github.com>
---
 library/Cargo.lock       | 4 ++--
 library/alloc/Cargo.toml | 2 +-
 library/std/Cargo.toml   | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/library/Cargo.lock b/library/Cargo.lock
index aa22181a4639a..54ad052c52322 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -58,9 +58,9 @@ dependencies = [
 
 [[package]]
 name = "compiler_builtins"
-version = "0.1.121"
+version = "0.1.123"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce956e6dc07082ec481f0935a51e83b343f8ca51be560452c0ebf830d0bdf5a5"
+checksum = "b47fcbecb558bdad78c7d3a998523c60a50dd6cd046d5fe74163e309e878fff7"
 dependencies = [
  "cc",
  "rustc-std-workspace-core",
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index a39a0a6ce0ea2..4365bcc4ad022 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -10,7 +10,7 @@ edition = "2021"
 
 [dependencies]
 core = { path = "../core" }
-compiler_builtins = { version = "0.1.121", features = ['rustc-dep-of-std'] }
+compiler_builtins = { version = "0.1.123", features = ['rustc-dep-of-std'] }
 
 [dev-dependencies]
 rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 334c75df2315a..5f0144922ca69 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -17,7 +17,7 @@ cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
 panic_unwind = { path = "../panic_unwind", optional = true }
 panic_abort = { path = "../panic_abort" }
 core = { path = "../core", public = true }
-compiler_builtins = { version = "0.1.121" }
+compiler_builtins = { version = "0.1.123" }
 profiler_builtins = { path = "../profiler_builtins", optional = true }
 unwind = { path = "../unwind" }
 hashbrown = { version = "0.14", default-features = false, features = [